U
|
Þ=®dí6 ã @ s d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z
|
ddl m Z ddl mZ ddlmZ e
|
jrddlZddlmZ G dd d ejZd
|
Zd e ed ¡ e ejd d > ejd B d ¡ ZG dd dZ G dd dZ G dd de Z G dd de Z dS )a The optional bytecode cache system. This is useful if you have very
|
complex template situations and the compilation of all those templates
|
slows down your application too much.
|
|
Situations where this is useful are often forking web applications that
|
are initialized on the first request.
|
é N)Úsha1)ÚBytesIO)ÚCodeTypeé )Ú Environmentc @ s8 e Zd ZeedddZdeeeje ddddZ dS ) Ú_MemcachedClient)ÚkeyÚreturnc C s d S ©N© )Úselfr r r úEd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\jinja2/bccache.pyÚget s z_MemcachedClient.getN)r ÚvalueÚtimeoutr c C s d S r
|
r )r r r r r r r Úset s z_MemcachedClient.set)N)
|
Ú__name__Ú
|
__module__Ú __qualname__ÚstrÚbytesr ÚtÚOptionalÚintr r r r r r s r é s j2é é c @ sx e Zd ZdZdeeddddZdddd Zejdd
|
d d Z ej
|
e dd
|
d dZ e ddddZ e dddZdS )ÚBucketau Buckets are used to store the bytecode for one template. It's created
|
and initialized by the bytecode cache and passed to the loading functions.
|
|
The buckets get an internal checksum from the cache assigned and use this
|
to automatically reject outdated cache material. Individual bytecode
|
cache subclasses don't have to care about cache invalidation.
|
r N)Ú environmentr Úchecksumr c C s || _ || _|| _| ¡ d S r
|
)r r r Úreset)r r r r r r r Ú__init__5 s zBucket.__init__©r c C s
|
d| _ dS )z)Resets the bucket (unloads the bytecode).N)Úcode©r r r r r ; s z Bucket.reset)Úfr c
|
C s| | tt¡}|tkr"| ¡ dS t |¡}| j|krB| ¡ dS zt |¡| _W n$ t t
|
t fk
|
rv | ¡ Y dS X dS )z/Loads bytecode from a file or file like object.N) ÚreadÚlenÚbc_magicr ÚpickleÚloadr Úmarshalr# ÚEOFErrorÚ
|
ValueErrorÚ TypeError)r r% Úmagicr r r r Ú load_bytecode? s
|
|
zBucket.load_bytecodec C s> | j dkrtd| t¡ t | j|d¡ t | j |¡ dS )z;Dump the bytecode into the file or file like object passed.Nzcan't write empty bucketr )r# r. Úwriter( r) Údumpr r+ )r r% r r r Úwrite_bytecodeR s
|
|
|
zBucket.write_bytecode)Ústringr c C s | t|¡ dS )zLoad bytecode from bytes.N)r0 r )r r4 r r r Úbytecode_from_stringZ s zBucket.bytecode_from_stringc C s t }| |¡ | ¡ S )z Return the bytecode as bytes.)r r3 Úgetvalue)r Úoutr r r Úbytecode_to_string^ s
|
zBucket.bytecode_to_string)r r r Ú__doc__r r! r r ÚBinaryIOr0 ÚIOr r3 r5 r8 r r r r r , s r c @ s e Zd ZdZeddddZeddddZddd d
|
Zdee j
|
e j e ed d d Z eedddZ dee j
|
e eedddZeddddZdS )Ú BytecodeCacheaÞ To implement your own bytecode cache you have to subclass this class
|
and override :meth:`load_bytecode` and :meth:`dump_bytecode`. Both of
|
these methods are passed a :class:`~jinja2.bccache.Bucket`.
|
|
A very basic bytecode cache that saves the bytecode on the file system::
|
|
from os import path
|
|
class MyCache(BytecodeCache):
|
|
def __init__(self, directory):
|
self.directory = directory
|
|
def load_bytecode(self, bucket):
|
filename = path.join(self.directory, bucket.key)
|
if path.exists(filename):
|
with open(filename, 'rb') as f:
|
bucket.load_bytecode(f)
|
|
def dump_bytecode(self, bucket):
|
filename = path.join(self.directory, bucket.key)
|
with open(filename, 'wb') as f:
|
bucket.write_bytecode(f)
|
|
A more advanced version of a filesystem based bytecode cache is part of
|
Jinja.
|
N©Úbucketr c C s
|
t dS )z¹Subclasses have to override this method to load bytecode into a
|
bucket. If they are not able to find code in the cache for the
|
bucket, it must not do anything.
|
N©ÚNotImplementedError©r r> r r r r0 s zBytecodeCache.load_bytecodec C s
|
t dS )zÀSubclasses have to override this method to write the bytecode
|
from a bucket back to the cache. If it unable to do so it must not
|
fail silently but raise an exception.
|
Nr? rA r r r Ú dump_bytecode s zBytecodeCache.dump_bytecoder" c C s dS )zºClears the cache. This method is not used by Jinja but should be
|
implemented to allow applications to clear the bytecode cache used
|
by a particular environment.
|
Nr r$ r r r Úclear s zBytecodeCache.clear)ÚnameÚfilenamer c C s2 t | d¡}|dk r*| d| ¡ ¡ | ¡ S )z3Returns the unique hash key for this template name.úutf-8Nú|)r ÚencodeÚupdateÚ hexdigest)r rD rE Úhashr r r Ú get_cache_key s zBytecodeCache.get_cache_key)Úsourcer c C s t | d¡ ¡ S )z"Returns a checksum for the source.rF )r rH rJ )r rM r r r Úget_source_checksum¡ s z!BytecodeCache.get_source_checksumr )r rD rE rM r c C s0 | ||¡}| |¡}t|||}| |¡ |S )zwReturn a cache bucket for the given template. All arguments are
|
mandatory but filename may be `None`.
|
)rL rN r r0 )r r rD rE rM r r r> r r r Ú
|
get_bucket¥ s
|
|
|
|
zBytecodeCache.get_bucketc C s | |¡ dS )z Put the bucket into the cache.N)rB rA r r r Ú
|
set_bucketµ s zBytecodeCache.set_bucket)N)r r r r9 r r0 rB rC r r r ÚUnionrL rN rO rP r r r r r< e s$ ÿ þ ú r< c @ sv e Zd ZdZdeje eddddZeddd Ze ed
|
d d Z
|
e dd
|
d dZ e dd
|
ddZ ddddZ dS )ÚFileSystemBytecodeCacheaï A bytecode cache that stores bytecode on the filesystem. It accepts
|
two arguments: The directory where the cache items are stored and a
|
pattern string that is used to build the filename.
|
|
If no directory is specified a default cache directory is selected. On
|
Windows the user's temp directory is used, on UNIX systems a directory
|
is created for the user in the system temp directory.
|
|
The pattern can be used to have multiple separate caches operate on the
|
same directory. The default pattern is ``'__jinja2_%s.cache'``. ``%s``
|
is replaced with the cache key.
|
|
>>> bcc = FileSystemBytecodeCache('/tmp/jinja_cache', '%s.cache')
|
|
This bytecode cache supports clearing of the cache using the clear method.
|
Nú__jinja2_%s.cache)Ú directoryÚpatternr c C s |d kr| ¡ }|| _|| _d S r
|
)Ú_get_default_cache_dirrT rU )r rT rU r r r r! Ì s z FileSystemBytecodeCache.__init__r" c
|
C s^ dddd}t ¡ }tjdkr$|S ttds4| dt ¡ }tj ||¡}zt |t j
|
¡ W n0 t k
|
r } z|j t j kr W 5 d }~X Y nX zNt |t j
|
¡ t |¡}|jt ¡ ksÚt |j¡rÚt |j¡t j
|
krà| W n4 t k
|
r } z|j t j kr W 5 d }~X Y nX t |¡}|jt ¡ ksTt |j¡rTt |j¡t j
|
krZ| |S )Nz te.NoReturnr" c S s t dd S )NzJCannot determine safe temp directory. You need to explicitly provide one.)Ú RuntimeErrorr r r r Ú _unsafe_dirÕ s ÿzCFileSystemBytecodeCache._get_default_cache_dir.<locals>._unsafe_dirÚntÚgetuidz_jinja2-cache-)ÚtempfileÚ
|
gettempdirÚosrD ÚhasattrrZ ÚpathÚjoinÚmkdirÚstatÚS_IRWXUÚOSErrorÚerrnoÚEEXISTÚchmodÚlstatÚst_uidÚS_ISDIRÚst_modeÚS_IMODE)r rX ZtmpdirÚdirnameZ
|
actual_dirÚeZactual_dir_statr r r rV Ô sF
|
|
|
ÿ
|
þý
|
|
ÿ
|
þýz.FileSystemBytecodeCache._get_default_cache_dirr= c C s t j | j| j|jf ¡S r
|
)r] r_ r` rT rU r rA r r r Ú_get_cache_filename s z+FileSystemBytecodeCache._get_cache_filenamec
|
C sT | |¡}zt|d}W n tttfk
|
r4 Y d S X | | |¡ W 5 Q R X d S )NÚrb)ro ÚopenÚFileNotFoundErrorÚIsADirectoryErrorÚPermissionErrorr0 )r r> rE r% r r r r0 s
|
z%FileSystemBytecodeCache.load_bytecodec sÈ | |¡}tjdtj |¡tj |¡ddd d d fdd }z | ¡ W 5 Q R X W n tk
|
rz | Y nX zt j
|
|¡ W n4 t k
|
r¨ | Y n tk
|
r | Y nX d S )NÚwbz.tmpF)ÚmodeÚdirÚprefixÚsuffixÚdeleter" c s* zt j¡ W n tk
|
r$ Y nX d S r
|
)r] ÚremoverD rd r ©r% r r Ú remove_silent" s z<FileSystemBytecodeCache.dump_bytecode.<locals>.remove_silent) ro r[ ÚNamedTemporaryFiler] r_ rm Úbasenamer3 Ú BaseExceptionÚreplacerD rd )r r> rD r} r r| r rB s,
|
|
|
û
|
z%FileSystemBytecodeCache.dump_bytecodec C sb ddl m} t t | j¡| jd ¡}|D ]2}z|t j | j|¡ W q* t k
|
rZ Y q*X q*d S )Nr )r{ )Ú*)
|
r] r{ ÚfnmatchÚfilterÚlistdirrT rU r_ r` rd )r r{ ÚfilesrE r r r rC ; s z FileSystemBytecodeCache.clear)NrS )r r r r9 r r r r! rV r ro r0 rB rC r r r r rR º s ÿ þ /&rR c @ sL e Zd ZdZddeeje edddZ e
|
dd d
|
d Z e
|
dd d d Z dS )ÚMemcachedBytecodeCachea' This class implements a bytecode cache that uses a memcache cache for
|
storing the information. It does not enforce a specific memcache library
|
(tummy's memcache or cmemcache) but will accept any class that provides
|
the minimal interface required.
|
|
Libraries compatible with this class:
|
|
- `cachelib <https://github.com/pallets/cachelib>`_
|
- `python-memcached <https://pypi.org/project/python-memcached/>`_
|
|
(Unfortunately the django cache interface is not compatible because it
|
does not support storing binary data, only text. You can however pass
|
the underlying cache client to the bytecode cache which is available
|
as `django.core.cache.cache._client`.)
|
|
The minimal interface for the client passed to the constructor is this:
|
|
.. class:: MinimalClientInterface
|
|
.. method:: set(key, value[, timeout])
|
|
Stores the bytecode in the cache. `value` is a string and
|
`timeout` the timeout of the key. If timeout is not provided
|
a default timeout or no timeout should be assumed, if it's
|
provided it's an integer with the number of seconds the cache
|
item should exist.
|
|
.. method:: get(key)
|
|
Returns the value for the cache key. If the item does not
|
exist in the cache the return value must be `None`.
|
|
The other arguments to the constructor are the prefix for all keys that
|
is added before the actual cache key and the timeout for the bytecode in
|
the cache system. We recommend a high (or no) timeout.
|
|
This bytecode cache does not support clearing of used items in the cache.
|
The clear method is a no-operation function.
|
|
.. versionadded:: 2.7
|
Added support for ignoring memcache errors through the
|
`ignore_memcache_errors` parameter.
|
újinja2/bytecode/NTr ©Úclientrx r Úignore_memcache_errorsc C s || _ || _|| _|| _d S r
|
r )r r rx r r r r r r! v s z MemcachedBytecodeCache.__init__r= c C sD z| j | j|j ¡}W n tk
|
r4 | js0 Y n X | |¡ d S r
|
)r r rx r Ú Exceptionr r5 )r r> r# r r r r0 s z$MemcachedBytecodeCache.load_bytecodec C sf | j |j }| ¡ }z0| jd k r4| j ||| j¡ n| j ||¡ W n tk
|
r` | js\ Y nX d S r
|
)rx r r8 r r r r r )r r> r r r r r rB s
|
z$MemcachedBytecodeCache.dump_bytecode)r NT) r r r r9 r r r r Úboolr! r r0 rB r r r r r I s / ûû r ) r9 re r r+ r] r) rb Úsysr[ Útypingr Úhashlibr Úior Útypesr Ú TYPE_CHECKINGZtyping_extensionsÚter r ÚProtocolr Z
|
bc_versionÚdumpsÚ version_infor( r r< rR r r r r r Ú<module> s8
|
ÿ þÿ9U
|
