File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/cache.tar
Back
__pycache__/__init__.cpython-310.pyc 0000644 00000003735 15030004302 0013207 0 ustar 00 o �h� � @ s� d Z ddlmZ ddlmZmZmZmZ ddlm Z m Z ddl m Z g d�Z dZG dd � d e �Ze� Ze ee�Zd d � Zej�e� d S ) a Caching framework. This package defines set of cache backends that all conform to a simple API. In a nutshell, a cache is a set of values -- which can be any object that may be pickled -- identified by string keys. For the complete API, see the abstract BaseCache class in django.core.cache.backends.base. Client code should use the `cache` variable defined here to access the default cache backend and look up non-default cache backends in the `caches` dict-like object. See docs/topics/cache.txt for information on the public API. � )�signals)� BaseCache�CacheKeyWarning�InvalidCacheBackendError�InvalidCacheKey)�BaseConnectionHandler�ConnectionProxy)� import_string)�cache�caches�DEFAULT_CACHE_ALIASr r r r �defaultc @ s e Zd ZdZeZdd� ZdS )� CacheHandler�CACHESc C sf | j | �� }|�d�}|�dd�}zt|�}W n ty- } z td||f �|�d }~ww |||�S )N�BACKEND�LOCATION� z Could not find backend '%s': %s)�settings�copy�popr � ImportErrorr )�self�alias�params�backend�location� backend_cls�e� r �M/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/__init__.py�create_connection* s ���� z CacheHandler.create_connectionN)�__name__� __module__� __qualname__� settings_namer �exception_classr r r r r r & s r c K s t �� d S )N)r � close_all)�kwargsr r r � close_caches< s r( N)�__doc__� django.corer � django.core.cache.backends.baser r r r �django.utils.connectionr r �django.utils.module_loadingr �__all__r r r r r( �request_finished�connectr r r r �<module> s __pycache__/utils.cpython-310.pyc 0000644 00000001101 15030004302 0012571 0 ustar 00 o �h� � @ s d dl mZ dZddd�ZdS )� )�md5ztemplate.cache.%s.%sNc C sH t dd�}|d ur |D ]}|�t|��� � |�d� q t| |�� f S )NF)�usedforsecurity� :)r �update�str�encode� TEMPLATE_FRAGMENT_KEY_TEMPLATE� hexdigest)� fragment_name�vary_on�hasher�arg� r �J/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/utils.py�make_template_fragment_key s r )N)�django.utils.cryptor r r r r r r �<module> s backends/dummy.py 0000644 00000002023 15030004302 0010003 0 ustar 00 "Dummy cache backend" from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache class DummyCache(BaseCache): def __init__(self, host, *args, **kwargs): super().__init__(*args, **kwargs) def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): self.make_and_validate_key(key, version=version) return True def get(self, key, default=None, version=None): self.make_and_validate_key(key, version=version) return default def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): self.make_and_validate_key(key, version=version) def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): self.make_and_validate_key(key, version=version) return False def delete(self, key, version=None): self.make_and_validate_key(key, version=version) return False def has_key(self, key, version=None): self.make_and_validate_key(key, version=version) return False def clear(self): pass backends/base.py 0000644 00000033623 15030004302 0007574 0 ustar 00 "Base Cache class." import time import warnings from asgiref.sync import sync_to_async from django.core.exceptions import ImproperlyConfigured from django.utils.module_loading import import_string class InvalidCacheBackendError(ImproperlyConfigured): pass class CacheKeyWarning(RuntimeWarning): pass class InvalidCacheKey(ValueError): pass # Stub class to ensure not passing in a `timeout` argument results in # the default timeout DEFAULT_TIMEOUT = object() # Memcached does not accept keys longer than this. MEMCACHE_MAX_KEY_LENGTH = 250 def default_key_func(key, key_prefix, version): """ Default function to generate keys. Construct the key used by all other methods. By default, prepend the `key_prefix`. KEY_FUNCTION can be used to specify an alternate function with custom key making behavior. """ return "%s:%s:%s" % (key_prefix, version, key) def get_key_func(key_func): """ Function to decide which key function to use. Default to ``default_key_func``. """ if key_func is not None: if callable(key_func): return key_func else: return import_string(key_func) return default_key_func class BaseCache: _missing_key = object() def __init__(self, params): timeout = params.get("timeout", params.get("TIMEOUT", 300)) if timeout is not None: try: timeout = int(timeout) except (ValueError, TypeError): timeout = 300 self.default_timeout = timeout options = params.get("OPTIONS", {}) max_entries = params.get("max_entries", options.get("MAX_ENTRIES", 300)) try: self._max_entries = int(max_entries) except (ValueError, TypeError): self._max_entries = 300 cull_frequency = params.get("cull_frequency", options.get("CULL_FREQUENCY", 3)) try: self._cull_frequency = int(cull_frequency) except (ValueError, TypeError): self._cull_frequency = 3 self.key_prefix = params.get("KEY_PREFIX", "") self.version = params.get("VERSION", 1) self.key_func = get_key_func(params.get("KEY_FUNCTION")) def get_backend_timeout(self, timeout=DEFAULT_TIMEOUT): """ Return the timeout value usable by this backend based upon the provided timeout. """ if timeout == DEFAULT_TIMEOUT: timeout = self.default_timeout elif timeout == 0: # ticket 21147 - avoid time.time() related precision issues timeout = -1 return None if timeout is None else time.time() + timeout def make_key(self, key, version=None): """ Construct the key used by all other methods. By default, use the key_func to generate a key (which, by default, prepends the `key_prefix' and 'version'). A different key function can be provided at the time of cache construction; alternatively, you can subclass the cache backend to provide custom key making behavior. """ if version is None: version = self.version return self.key_func(key, self.key_prefix, version) def validate_key(self, key): """ Warn about keys that would not be portable to the memcached backend. This encourages (but does not force) writing backend-portable cache code. """ for warning in memcache_key_warnings(key): warnings.warn(warning, CacheKeyWarning) def make_and_validate_key(self, key, version=None): """Helper to make and validate keys.""" key = self.make_key(key, version=version) self.validate_key(key) return key def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): """ Set a value in the cache if the key does not already exist. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. Return True if the value was stored, False otherwise. """ raise NotImplementedError( "subclasses of BaseCache must provide an add() method" ) async def aadd(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): return await sync_to_async(self.add, thread_sensitive=True)( key, value, timeout, version ) def get(self, key, default=None, version=None): """ Fetch a given key from the cache. If the key does not exist, return default, which itself defaults to None. """ raise NotImplementedError("subclasses of BaseCache must provide a get() method") async def aget(self, key, default=None, version=None): return await sync_to_async(self.get, thread_sensitive=True)( key, default, version ) def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): """ Set a value in the cache. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. """ raise NotImplementedError("subclasses of BaseCache must provide a set() method") async def aset(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): return await sync_to_async(self.set, thread_sensitive=True)( key, value, timeout, version ) def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): """ Update the key's expiry time using timeout. Return True if successful or False if the key does not exist. """ raise NotImplementedError( "subclasses of BaseCache must provide a touch() method" ) async def atouch(self, key, timeout=DEFAULT_TIMEOUT, version=None): return await sync_to_async(self.touch, thread_sensitive=True)( key, timeout, version ) def delete(self, key, version=None): """ Delete a key from the cache and return whether it succeeded, failing silently. """ raise NotImplementedError( "subclasses of BaseCache must provide a delete() method" ) async def adelete(self, key, version=None): return await sync_to_async(self.delete, thread_sensitive=True)(key, version) def get_many(self, keys, version=None): """ Fetch a bunch of keys from the cache. For certain backends (memcached, pgsql) this can be *much* faster when fetching multiple values. Return a dict mapping each key in keys to its value. If the given key is missing, it will be missing from the response dict. """ d = {} for k in keys: val = self.get(k, self._missing_key, version=version) if val is not self._missing_key: d[k] = val return d async def aget_many(self, keys, version=None): """See get_many().""" d = {} for k in keys: val = await self.aget(k, self._missing_key, version=version) if val is not self._missing_key: d[k] = val return d def get_or_set(self, key, default, timeout=DEFAULT_TIMEOUT, version=None): """ Fetch a given key from the cache. If the key does not exist, add the key and set it to the default value. The default value can also be any callable. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. Return the value of the key stored or retrieved. """ val = self.get(key, self._missing_key, version=version) if val is self._missing_key: if callable(default): default = default() self.add(key, default, timeout=timeout, version=version) # Fetch the value again to avoid a race condition if another caller # added a value between the first get() and the add() above. return self.get(key, default, version=version) return val async def aget_or_set(self, key, default, timeout=DEFAULT_TIMEOUT, version=None): """See get_or_set().""" val = await self.aget(key, self._missing_key, version=version) if val is self._missing_key: if callable(default): default = default() await self.aadd(key, default, timeout=timeout, version=version) # Fetch the value again to avoid a race condition if another caller # added a value between the first aget() and the aadd() above. return await self.aget(key, default, version=version) return val def has_key(self, key, version=None): """ Return True if the key is in the cache and has not expired. """ return ( self.get(key, self._missing_key, version=version) is not self._missing_key ) async def ahas_key(self, key, version=None): return ( await self.aget(key, self._missing_key, version=version) is not self._missing_key ) def incr(self, key, delta=1, version=None): """ Add delta to value in the cache. If the key does not exist, raise a ValueError exception. """ value = self.get(key, self._missing_key, version=version) if value is self._missing_key: raise ValueError("Key '%s' not found" % key) new_value = value + delta self.set(key, new_value, version=version) return new_value async def aincr(self, key, delta=1, version=None): """See incr().""" value = await self.aget(key, self._missing_key, version=version) if value is self._missing_key: raise ValueError("Key '%s' not found" % key) new_value = value + delta await self.aset(key, new_value, version=version) return new_value def decr(self, key, delta=1, version=None): """ Subtract delta from value in the cache. If the key does not exist, raise a ValueError exception. """ return self.incr(key, -delta, version=version) async def adecr(self, key, delta=1, version=None): return await self.aincr(key, -delta, version=version) def __contains__(self, key): """ Return True if the key is in the cache and has not expired. """ # This is a separate method, rather than just a copy of has_key(), # so that it always has the same functionality as has_key(), even # if a subclass overrides it. return self.has_key(key) def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None): """ Set a bunch of values in the cache at once from a dict of key/value pairs. For certain backends (memcached), this is much more efficient than calling set() multiple times. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. On backends that support it, return a list of keys that failed insertion, or an empty list if all keys were inserted successfully. """ for key, value in data.items(): self.set(key, value, timeout=timeout, version=version) return [] async def aset_many(self, data, timeout=DEFAULT_TIMEOUT, version=None): for key, value in data.items(): await self.aset(key, value, timeout=timeout, version=version) return [] def delete_many(self, keys, version=None): """ Delete a bunch of values in the cache at once. For certain backends (memcached), this is much more efficient than calling delete() multiple times. """ for key in keys: self.delete(key, version=version) async def adelete_many(self, keys, version=None): for key in keys: await self.adelete(key, version=version) def clear(self): """Remove *all* values from the cache at once.""" raise NotImplementedError( "subclasses of BaseCache must provide a clear() method" ) async def aclear(self): return await sync_to_async(self.clear, thread_sensitive=True)() def incr_version(self, key, delta=1, version=None): """ Add delta to the cache version for the supplied key. Return the new version. """ if version is None: version = self.version value = self.get(key, self._missing_key, version=version) if value is self._missing_key: raise ValueError("Key '%s' not found" % key) self.set(key, value, version=version + delta) self.delete(key, version=version) return version + delta async def aincr_version(self, key, delta=1, version=None): """See incr_version().""" if version is None: version = self.version value = await self.aget(key, self._missing_key, version=version) if value is self._missing_key: raise ValueError("Key '%s' not found" % key) await self.aset(key, value, version=version + delta) await self.adelete(key, version=version) return version + delta def decr_version(self, key, delta=1, version=None): """ Subtract delta from the cache version for the supplied key. Return the new version. """ return self.incr_version(key, -delta, version) async def adecr_version(self, key, delta=1, version=None): return await self.aincr_version(key, -delta, version) def close(self, **kwargs): """Close the cache connection""" pass async def aclose(self, **kwargs): pass def memcache_key_warnings(key): if len(key) > MEMCACHE_MAX_KEY_LENGTH: yield ( "Cache key will cause errors if used with memcached: %r " "(longer than %s)" % (key, MEMCACHE_MAX_KEY_LENGTH) ) for char in key: if ord(char) < 33 or ord(char) == 127: yield ( "Cache key contains characters that will cause errors if " "used with memcached: %r" % key ) break backends/redis.py 0000644 00000017364 15030004302 0007774 0 ustar 00 """Redis cache backend.""" import pickle import random import re from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache from django.utils.functional import cached_property from django.utils.module_loading import import_string class RedisSerializer: def __init__(self, protocol=None): self.protocol = pickle.HIGHEST_PROTOCOL if protocol is None else protocol def dumps(self, obj): # Only skip pickling for integers, a int subclasses as bool should be # pickled. if type(obj) is int: return obj return pickle.dumps(obj, self.protocol) def loads(self, data): try: return int(data) except ValueError: return pickle.loads(data) class RedisCacheClient: def __init__( self, servers, serializer=None, pool_class=None, parser_class=None, **options, ): import redis self._lib = redis self._servers = servers self._pools = {} self._client = self._lib.Redis if isinstance(pool_class, str): pool_class = import_string(pool_class) self._pool_class = pool_class or self._lib.ConnectionPool if isinstance(serializer, str): serializer = import_string(serializer) if callable(serializer): serializer = serializer() self._serializer = serializer or RedisSerializer() if isinstance(parser_class, str): parser_class = import_string(parser_class) parser_class = parser_class or self._lib.connection.DefaultParser self._pool_options = {"parser_class": parser_class, **options} def _get_connection_pool_index(self, write): # Write to the first server. Read from other servers if there are more, # otherwise read from the first server. if write or len(self._servers) == 1: return 0 return random.randint(1, len(self._servers) - 1) def _get_connection_pool(self, write): index = self._get_connection_pool_index(write) if index not in self._pools: self._pools[index] = self._pool_class.from_url( self._servers[index], **self._pool_options, ) return self._pools[index] def get_client(self, key=None, *, write=False): # key is used so that the method signature remains the same and custom # cache client can be implemented which might require the key to select # the server, e.g. sharding. pool = self._get_connection_pool(write) return self._client(connection_pool=pool) def add(self, key, value, timeout): client = self.get_client(key, write=True) value = self._serializer.dumps(value) if timeout == 0: if ret := bool(client.set(key, value, nx=True)): client.delete(key) return ret else: return bool(client.set(key, value, ex=timeout, nx=True)) def get(self, key, default): client = self.get_client(key) value = client.get(key) return default if value is None else self._serializer.loads(value) def set(self, key, value, timeout): client = self.get_client(key, write=True) value = self._serializer.dumps(value) if timeout == 0: client.delete(key) else: client.set(key, value, ex=timeout) def touch(self, key, timeout): client = self.get_client(key, write=True) if timeout is None: return bool(client.persist(key)) else: return bool(client.expire(key, timeout)) def delete(self, key): client = self.get_client(key, write=True) return bool(client.delete(key)) def get_many(self, keys): client = self.get_client(None) ret = client.mget(keys) return { k: self._serializer.loads(v) for k, v in zip(keys, ret) if v is not None } def has_key(self, key): client = self.get_client(key) return bool(client.exists(key)) def incr(self, key, delta): client = self.get_client(key, write=True) if not client.exists(key): raise ValueError("Key '%s' not found." % key) return client.incr(key, delta) def set_many(self, data, timeout): client = self.get_client(None, write=True) pipeline = client.pipeline() pipeline.mset({k: self._serializer.dumps(v) for k, v in data.items()}) if timeout is not None: # Setting timeout for each key as redis does not support timeout # with mset(). for key in data: pipeline.expire(key, timeout) pipeline.execute() def delete_many(self, keys): client = self.get_client(None, write=True) client.delete(*keys) def clear(self): client = self.get_client(None, write=True) return bool(client.flushdb()) class RedisCache(BaseCache): def __init__(self, server, params): super().__init__(params) if isinstance(server, str): self._servers = re.split("[;,]", server) else: self._servers = server self._class = RedisCacheClient self._options = params.get("OPTIONS", {}) @cached_property def _cache(self): return self._class(self._servers, **self._options) def get_backend_timeout(self, timeout=DEFAULT_TIMEOUT): if timeout == DEFAULT_TIMEOUT: timeout = self.default_timeout # The key will be made persistent if None used as a timeout. # Non-positive values will cause the key to be deleted. return None if timeout is None else max(0, int(timeout)) def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.add(key, value, self.get_backend_timeout(timeout)) def get(self, key, default=None, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.get(key, default) def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) self._cache.set(key, value, self.get_backend_timeout(timeout)) def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.touch(key, self.get_backend_timeout(timeout)) def delete(self, key, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.delete(key) def get_many(self, keys, version=None): key_map = { self.make_and_validate_key(key, version=version): key for key in keys } ret = self._cache.get_many(key_map.keys()) return {key_map[k]: v for k, v in ret.items()} def has_key(self, key, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.has_key(key) def incr(self, key, delta=1, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.incr(key, delta) def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None): if not data: return [] safe_data = {} for key, value in data.items(): key = self.make_and_validate_key(key, version=version) safe_data[key] = value self._cache.set_many(safe_data, self.get_backend_timeout(timeout)) return [] def delete_many(self, keys, version=None): if not keys: return safe_keys = [self.make_and_validate_key(key, version=version) for key in keys] self._cache.delete_many(safe_keys) def clear(self): return self._cache.clear() backends/db.py 0000644 00000026154 15030004302 0007250 0 ustar 00 "Database cache backend." import base64 import pickle from datetime import datetime, timezone from django.conf import settings from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache from django.db import DatabaseError, connections, models, router, transaction from django.utils.timezone import now as tz_now class Options: """A class that will quack like a Django model _meta class. This allows cache operations to be controlled by the router """ def __init__(self, table): self.db_table = table self.app_label = "django_cache" self.model_name = "cacheentry" self.verbose_name = "cache entry" self.verbose_name_plural = "cache entries" self.object_name = "CacheEntry" self.abstract = False self.managed = True self.proxy = False self.swapped = False class BaseDatabaseCache(BaseCache): def __init__(self, table, params): super().__init__(params) self._table = table class CacheEntry: _meta = Options(table) self.cache_model_class = CacheEntry class DatabaseCache(BaseDatabaseCache): # This class uses cursors provided by the database connection. This means # it reads expiration values as aware or naive datetimes, depending on the # value of USE_TZ and whether the database supports time zones. The ORM's # conversion and adaptation infrastructure is then used to avoid comparing # aware and naive datetimes accidentally. pickle_protocol = pickle.HIGHEST_PROTOCOL def get(self, key, default=None, version=None): return self.get_many([key], version).get(key, default) def get_many(self, keys, version=None): if not keys: return {} key_map = { self.make_and_validate_key(key, version=version): key for key in keys } db = router.db_for_read(self.cache_model_class) connection = connections[db] quote_name = connection.ops.quote_name table = quote_name(self._table) with connection.cursor() as cursor: cursor.execute( "SELECT %s, %s, %s FROM %s WHERE %s IN (%s)" % ( quote_name("cache_key"), quote_name("value"), quote_name("expires"), table, quote_name("cache_key"), ", ".join(["%s"] * len(key_map)), ), list(key_map), ) rows = cursor.fetchall() result = {} expired_keys = [] expression = models.Expression(output_field=models.DateTimeField()) converters = connection.ops.get_db_converters( expression ) + expression.get_db_converters(connection) for key, value, expires in rows: for converter in converters: expires = converter(expires, expression, connection) if expires < tz_now(): expired_keys.append(key) else: value = connection.ops.process_clob(value) value = pickle.loads(base64.b64decode(value.encode())) result[key_map.get(key)] = value self._base_delete_many(expired_keys) return result def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) self._base_set("set", key, value, timeout) def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) return self._base_set("add", key, value, timeout) def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) return self._base_set("touch", key, None, timeout) def _base_set(self, mode, key, value, timeout=DEFAULT_TIMEOUT): timeout = self.get_backend_timeout(timeout) db = router.db_for_write(self.cache_model_class) connection = connections[db] quote_name = connection.ops.quote_name table = quote_name(self._table) with connection.cursor() as cursor: cursor.execute("SELECT COUNT(*) FROM %s" % table) num = cursor.fetchone()[0] now = tz_now() now = now.replace(microsecond=0) if timeout is None: exp = datetime.max else: tz = timezone.utc if settings.USE_TZ else None exp = datetime.fromtimestamp(timeout, tz=tz) exp = exp.replace(microsecond=0) if num > self._max_entries: self._cull(db, cursor, now, num) pickled = pickle.dumps(value, self.pickle_protocol) # The DB column is expecting a string, so make sure the value is a # string, not bytes. Refs #19274. b64encoded = base64.b64encode(pickled).decode("latin1") try: # Note: typecasting for datetimes is needed by some 3rd party # database backends. All core backends work without typecasting, # so be careful about changes here - test suite will NOT pick # regressions. with transaction.atomic(using=db): cursor.execute( "SELECT %s, %s FROM %s WHERE %s = %%s" % ( quote_name("cache_key"), quote_name("expires"), table, quote_name("cache_key"), ), [key], ) result = cursor.fetchone() if result: current_expires = result[1] expression = models.Expression( output_field=models.DateTimeField() ) for converter in connection.ops.get_db_converters( expression ) + expression.get_db_converters(connection): current_expires = converter( current_expires, expression, connection ) exp = connection.ops.adapt_datetimefield_value(exp) if result and mode == "touch": cursor.execute( "UPDATE %s SET %s = %%s WHERE %s = %%s" % (table, quote_name("expires"), quote_name("cache_key")), [exp, key], ) elif result and ( mode == "set" or (mode == "add" and current_expires < now) ): cursor.execute( "UPDATE %s SET %s = %%s, %s = %%s WHERE %s = %%s" % ( table, quote_name("value"), quote_name("expires"), quote_name("cache_key"), ), [b64encoded, exp, key], ) elif mode != "touch": cursor.execute( "INSERT INTO %s (%s, %s, %s) VALUES (%%s, %%s, %%s)" % ( table, quote_name("cache_key"), quote_name("value"), quote_name("expires"), ), [key, b64encoded, exp], ) else: return False # touch failed. except DatabaseError: # To be threadsafe, updates/inserts are allowed to fail silently return False else: return True def delete(self, key, version=None): key = self.make_and_validate_key(key, version=version) return self._base_delete_many([key]) def delete_many(self, keys, version=None): keys = [self.make_and_validate_key(key, version=version) for key in keys] self._base_delete_many(keys) def _base_delete_many(self, keys): if not keys: return False db = router.db_for_write(self.cache_model_class) connection = connections[db] quote_name = connection.ops.quote_name table = quote_name(self._table) with connection.cursor() as cursor: cursor.execute( "DELETE FROM %s WHERE %s IN (%s)" % ( table, quote_name("cache_key"), ", ".join(["%s"] * len(keys)), ), keys, ) return bool(cursor.rowcount) def has_key(self, key, version=None): key = self.make_and_validate_key(key, version=version) db = router.db_for_read(self.cache_model_class) connection = connections[db] quote_name = connection.ops.quote_name now = tz_now().replace(microsecond=0, tzinfo=None) with connection.cursor() as cursor: cursor.execute( "SELECT %s FROM %s WHERE %s = %%s and %s > %%s" % ( quote_name("cache_key"), quote_name(self._table), quote_name("cache_key"), quote_name("expires"), ), [key, connection.ops.adapt_datetimefield_value(now)], ) return cursor.fetchone() is not None def _cull(self, db, cursor, now, num): if self._cull_frequency == 0: self.clear() else: connection = connections[db] table = connection.ops.quote_name(self._table) cursor.execute( "DELETE FROM %s WHERE %s < %%s" % ( table, connection.ops.quote_name("expires"), ), [connection.ops.adapt_datetimefield_value(now)], ) deleted_count = cursor.rowcount remaining_num = num - deleted_count if remaining_num > self._max_entries: cull_num = remaining_num // self._cull_frequency cursor.execute( connection.ops.cache_key_culling_sql() % table, [cull_num] ) last_cache_key = cursor.fetchone() if last_cache_key: cursor.execute( "DELETE FROM %s WHERE %s < %%s" % ( table, connection.ops.quote_name("cache_key"), ), [last_cache_key[0]], ) def clear(self): db = router.db_for_write(self.cache_model_class) connection = connections[db] table = connection.ops.quote_name(self._table) with connection.cursor() as cursor: cursor.execute("DELETE FROM %s" % table) backends/__pycache__/memcached.cpython-310.pyc 0000644 00000015123 15030004302 0015122 0 ustar 00 o �h� � @ sl d Z ddlZddlZddlmZmZmZmZ ddlm Z G dd� de�Z G dd� de �Z G d d � d e �Z dS ) zMemcached cache backend� N)�DEFAULT_TIMEOUT� BaseCache�InvalidCacheKey�memcache_key_warnings)�cached_propertyc s� e Zd Z� fdd�Zedd� �Zedd� �Zefdd�Z ed fd d �Z d#d d �Z ed fdd�Z ed fdd�Z d$dd�Zd$dd�Zdd� Zd%dd�Zed fdd �Zd$d d �Zd d � Zd!d"� Z� ZS )&�BaseMemcachedCachec sT t � �|� t|t�rt�d|�| _n|| _|| _|| _|j | _ |� d�p&i | _ d S )Nz[;,]�OPTIONS) �super�__init__� isinstance�str�re�split�_servers� LibraryValueNotFoundException�_lib�Client�_class�get�_options)�self�server�params�library�value_not_found_exception�� __class__� �W/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/memcached.pyr s zBaseMemcachedCache.__init__c C s | j S �N)r �r r r r �client_servers s z!BaseMemcachedCache.client_serversc C s | j | jfi | j��S )zQ Implement transparent thread-safe access to a memcached client. )r r! r r r r r �_cache# s zBaseMemcachedCache._cachec C sJ |t kr| j}|du r dS t|�dkrd}|dkr!|tt�� �7 }t|�S )z� Memcached deals with long (> 30 days) timeouts in a special way. Call this function to obtain a safe value for your timeout. Nr ���i �' )r �default_timeout�int�time)r �timeoutr r r �get_backend_timeout* s z&BaseMemcachedCache.get_backend_timeoutNc C s$ | j ||d�}| j�||| �|��S �N��version)�make_and_validate_keyr" �addr( �r �key�valuer' r+ r r r r- E s zBaseMemcachedCache.addc C s | j ||d�}| j�||�S r) )r, r" r )r r/ �defaultr+ r r r r I s zBaseMemcachedCache.getc C s8 | j ||d�}| j�||| �|��s| j�|� d S d S r) )r, r" �setr( �deleter. r r r r2 M s �zBaseMemcachedCache.setc C s& | j ||d�}t| j�|| �|���S r) )r, �boolr" �touchr( �r r/ r' r+ r r r r5 T s zBaseMemcachedCache.touchc C s | j ||d�}t| j�|��S r) )r, r4 r" r3 )r r/ r+ r r r r3 X s zBaseMemcachedCache.deletec s: ��fdd�|D �� �j �� �� �}� fdd�|�� D �S )Nc s i | ] }� j |�d �|�qS �r* �r, ��.0r/ �r r+ r r � <dictcomp>] s �z/BaseMemcachedCache.get_many.<locals>.<dictcomp>c s i | ] \}}� | |�qS r r )r: �k�v)�key_mapr r r< a � )r" � get_multi�keys�items)r rB r+ �retr )r? r r+ r �get_many\ s �zBaseMemcachedCache.get_manyc K � | j �� d S r )r" �disconnect_all�r �kwargsr r r �closec s zBaseMemcachedCache.close� c C sl | j ||d�}z|dk r| j�|| �}n| j�||�}W n | jy) d }Y nw |d u r4td| ��|S )Nr* r zKey '%s' not found)r, r" �decr�incrr � ValueError)r r/ �deltar+ �valr r r rM g s �� zBaseMemcachedCache.incrc s^ i }i � |� � D ]\}}| j||d�}|||< |� |< q| j�|| �|��}� fdd�|D �S )Nr* c s g | ]}� | �qS r r )r: r= �� original_keysr r � <listcomp>� s z/BaseMemcachedCache.set_many.<locals>.<listcomp>)rC r, r" � set_multir( ) r �datar' r+ � safe_datar/ r0 �safe_key� failed_keysr rQ r �set_manyx s �zBaseMemcachedCache.set_manyc s$ � �fdd�|D �}� j �|� d S )Nc s g | ] }� j |�d ��qS r7 r8 r9 r; r r rS � r@ z2BaseMemcachedCache.delete_many.<locals>.<listcomp>)r" � delete_multi)r rB r+ r r; r � delete_many� s z BaseMemcachedCache.delete_manyc C rF r )r" � flush_allr r r r �clear� s zBaseMemcachedCache.clearc C s t |�D ]}t|��d S r )r r )r r/ �warningr r r � validate_key� s �z BaseMemcachedCache.validate_key)NNr )rK N)�__name__� __module__� __qualname__r �propertyr! r r" r r( r- r r2 r5 r3 rE rJ rM rY r[ r] r_ � __classcell__r r r r r s& r c sB e Zd ZdZ� fdd�Zedd� �Zedfdd�Zd d � Z � Z S ) � PyLibMCCachez2An implementation of a cache binding using pylibmcc s" dd l }t� j||||jd� d S )Nr �r r )�pylibmcr r �NotFound)r r r rg r r r r � s �zPyLibMCCache.__init__c C s4 g }| j D ]}|�|�d�r|dd � n|� q|S )Nzunix:� )r �append� startswith)r �outputr r r r r! � s "zPyLibMCCache.client_serversNc C s6 | j ||d�}|dkr| j�|�S | j�|| �|��S )Nr* r )r, r" r3 r5 r( r6 r r r r5 � s zPyLibMCCache.touchc K s d S r r rH r r r rJ � s zPyLibMCCache.close) r` ra rb �__doc__r rc r! r r5 rJ rd r r r r re � s re c s e Zd ZdZ� fdd�Z� ZS )�PyMemcacheCachez6An implementation of a cache binding using pymemcache.c sB dd l }t� j|||td� | jj| _dd|jjd�| j �| _ d S )Nr rf TF)�allow_unicode_keys�default_noreply�serde) �pymemcache.serder r �KeyErrorr � HashClientr rq � pickle_serder )r r r � pymemcacher r r r � s � � �zPyMemcacheCache.__init__)r` ra rb rm r rd r r r r rn � s rn ) rm r r& � django.core.cache.backends.baser r r r �django.utils.functionalr r re rn r r r r �<module> s backends/__pycache__/__init__.cpython-310.pyc 0000644 00000000263 15030004302 0014752 0 ustar 00 o �h � @ s d S )N� r r r �V/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/__init__.py�<module> s backends/__pycache__/dummy.cpython-310.pyc 0000644 00000003214 15030004302 0014345 0 ustar 00 o �h � @ s( d Z ddlmZmZ G dd� de�ZdS )zDummy cache backend� )�DEFAULT_TIMEOUT� BaseCachec sl e Zd Z� fdd�Zedfdd�Zddd�Zedfdd �Zedfd d �Zdd d �Z ddd�Z dd� Z � Z S )� DummyCachec s t � j|i |�� d S �N)�super�__init__)�self�host�args�kwargs�� __class__� �S/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/dummy.pyr s zDummyCache.__init__Nc C s | j ||d� dS )N��versionT��make_and_validate_key�r �key�value�timeoutr r r r �add � zDummyCache.addc C s | j ||d� |S �Nr r )r r �defaultr r r r �get r zDummyCache.getc C s | j ||d� d S r r r r r r �set s zDummyCache.setc C s | j ||d� dS �Nr Fr )r r r r r r r �touch r zDummyCache.touchc C � | j ||d� dS r r �r r r r r r �delete r zDummyCache.deletec C r r r r! r r r �has_key r zDummyCache.has_keyc C s d S r r )r r r r �clear! s zDummyCache.clear)NNr ) �__name__� __module__� __qualname__r r r r r r r" r# r$ � __classcell__r r r r r s r N)�__doc__� django.core.cache.backends.baser r r r r r r �<module> s backends/__pycache__/filebased.cpython-310.pyc 0000644 00000013425 15030004302 0015135 0 ustar 00 o �h� � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z m Z ddl m Z ddl mZ ddlmZ G dd� de �ZdS ) zFile-based cache backend� N)�DEFAULT_TIMEOUT� BaseCache)�locks)�file_move_safe)�md5c s� e Zd ZdZejZ� fdd�Zedfdd�Z d!dd�Z d d � Z edfd d �Z edfd d�Z d"dd�Zdd� Zd"dd�Zdd� Zdd� Zd"dd�Zdd � Zd d � Zd d � Z� ZS )#�FileBasedCachez.djcachec s& t � �|� tj�|�| _| �� d S �N)�super�__init__�os�path�abspath�_dir� _createdir)�self�dir�params�� __class__� �W/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/filebased.pyr s zFileBasedCache.__init__Nc C s$ | � ||�rdS | �||||� dS �NFT)�has_key�set)r �key�value�timeout�versionr r r �add s zFileBasedCache.addc C s� | � ||�}z1t|d��!}| �|�s$t�t�|�� ��W d � W S W d � W |S 1 s0w Y W |S tyA Y |S w )N�rb) � _key_to_file�open� _is_expired�pickle�loads�zlib� decompress�read�FileNotFoundError)r r �defaultr �fname�fr r r �get s � �� ��zFileBasedCache.getc C s< | � |�}|�t�|| j�� |�t�t�|| j��� d S r )�get_backend_timeout�writer# �dumps�pickle_protocolr% �compress)r �filer r �expiryr r r �_write_content) s z FileBasedCache._write_contentc C s� | � � | �||�}| �� tj| jd�\}}d}z1t|d��} | �| ||� W d � n1 s1w Y t||dd� d}W |sIt � |� d S d S |sSt � |� w w )N)r F�wbT)�allow_overwrite) r r �_cull�tempfile�mkstempr r! r4 r r �remove) r r r r r r* �fd�tmp_path�renamedr+ r r r r . s �� �zFileBasedCache.setc C s� z\t | �||�d��H}z@t�|tj� | �|�r'W t�|� W d � W dS t�t � |� � ��}|� d� | � |||� W t�|� W d � W dS t�|� w 1 sUw Y W d S tyf Y dS w )Nzr+bFr T)r! r r �lock�LOCK_EXr" �unlockr# r$ r% r& r' �seekr4 r( )r r r r r+ �previous_valuer r r �touch= s& � � � �zFileBasedCache.touchc C s | � | �||��S r )�_deleter �r r r r r r �deleteN s zFileBasedCache.deletec C sB |� | j�r tj�|�sdS zt�|� W dS ty Y dS w r )� startswithr r r �existsr: r( �r r* r r r rD Q s ��zFileBasedCache._deletec C s` | � ||�}z t|d��}| �|� W d � W S 1 s w Y W d S ty/ Y dS w )Nr F)r r! r" r( )r r r r* r+ r r r r [ s (� �zFileBasedCache.has_keyc C s^ | � � }t|�}|| jk rdS | jdkr| �� S t�|t|| j ��}|D ]}| �|� q%dS )z� Remove random cache entries if max_entries is reached at a ratio of num_entries / cull_frequency. A value of 0 for CULL_FREQUENCY means that the entire cache will be purged. Nr ) �_list_cache_files�len� _max_entries�_cull_frequency�clear�random�sample�intrD )r �filelist� num_entriesr* r r r r7 c s �zFileBasedCache._cullc C s: t �d�}zt j| jddd� W t �|� d S t �|� w )N�? i� T)�exist_ok)r �umask�makedirsr )r � old_umaskr r r r t s zFileBasedCache._createdirc C s: | j ||d�}tj�| jd�t|�� dd��� | jg��S )z� Convert a key into a cache file path. Basically this is the root cache path joined with the md5sum of the key and a suffix. )r � F)�usedforsecurity) �make_and_validate_keyr r �joinr r �encode� hexdigest� cache_suffixrE r r r r } s ���zFileBasedCache._key_to_filec C s | � � D ]}| �|� qdS )z- Remove all the cache files. N)rJ rD rI r r r rN � s �zFileBasedCache.clearc C sV zt �|�}W n ty d}Y nw |dur)|t�� k r)|�� | �|j� dS dS )zL Take an open cache file `f` and delete it if it's expired. r NTF)r# �load�EOFError�time�closerD �name)r r+ �expr r r r" � s � zFileBasedCache._is_expiredc s" � fdd�t �� jd� j �D �S )z� Get a list of paths to all the cache files. These are all the files in the root cache dir that end on the cache_suffix. c s g | ] }t j�� j|��qS r )r r r\ r )�.0r* �r r r � <listcomp>� s ��z4FileBasedCache._list_cache_files.<locals>.<listcomp>z*%s)�glob�glob1r r_ rg r rg r rJ � s �z FileBasedCache._list_cache_files)NNr )�__name__� __module__� __qualname__r_ r# �HIGHEST_PROTOCOLr0 r r r r, r4 r rC rF rD r r7 r r rN r" rJ � __classcell__r r r r r s$ r )�__doc__ri r r# rO r8 rb r% � django.core.cache.backends.baser r �django.core.filesr �django.core.files.mover �django.utils.cryptor r r r r r �<module> s backends/__pycache__/locmem.cpython-310.pyc 0000644 00000010232 15030004302 0014464 0 ustar 00 o �h� � @ s\ d Z ddlZddlZddlmZ ddlmZ ddlmZm Z i Z i Z i Z G dd� de �Z dS )z$Thread-safe in-memory cache backend.� N)� OrderedDict)�Lock)�DEFAULT_TIMEOUT� BaseCachec s� e Zd ZejZ� fdd�Zedfdd�Zd dd�Z efdd �Z edfd d �Z edfd d �Z d dd�Z d dd�Zdd� Zdd� Zdd� Zd dd�Zdd � Z� ZS ) � LocMemCachec s> t � �|� t�|t� �| _t�|i �| _t�|t� �| _ d S �N) �super�__init__�_caches� setdefaultr �_cache� _expire_info�_locksr �_lock)�self�name�params�� __class__� �T/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/locmem.pyr s zLocMemCache.__init__Nc C st | j ||d�}t�|| j�}| j� | �|�r'| �|||� W d � dS W d � dS 1 s3w Y d S )N��versionTF)�make_and_validate_key�pickle�dumps�pickle_protocolr � _has_expired�_set�r �key�value�timeoutr �pickledr r r �add s �$�zLocMemCache.addc C s~ | j ||d�}| j�( | �|�r | �|� |W d � S | j| }| jj|dd� W d � n1 s5w Y t�|�S )Nr F��last)r r r �_deleter � move_to_endr �loads)r r �defaultr r# r r r �get" s � � zLocMemCache.getc C sF t | j�| jkr | �� || j|< | jj|dd� | �|�| j|< d S )NFr% )�lenr � _max_entries�_cullr( �get_backend_timeoutr )r r r! r" r r r r , s zLocMemCache._setc C sV | j ||d�}t�|| j�}| j� | �|||� W d � d S 1 s$w Y d S �Nr )r r r r r r r r r r �set3 s "�zLocMemCache.setc C sh | j ||d�}| j� | �|�r W d � dS | �|�| j|< W d � dS 1 s-w Y d S �Nr FT)r r r r/ r )r r r" r r r r �touch9 s �$�zLocMemCache.touch� c C s� | j ||d�}| j�; | �|�r| �|� td| ��| j| }t�|�}|| }t�|| j �}|| j|< | jj |dd� W d � |S 1 sHw Y |S )Nr zKey '%s' not foundFr% ) r r r r' � ValueErrorr r r) r r r( )r r �deltar r# r! � new_valuer r r �incrA s � � zLocMemCache.incrc C sb | j ||d�}| j� | �|�r | �|� W d � dS W d � dS 1 s*w Y d S r2 )r r r r' �r r r r r r �has_keyO s �$�zLocMemCache.has_keyc C s" | j �|d�}|d uo|t�� kS )N���)r r+ �time)r r �expr r r r W s zLocMemCache._has_expiredc C sZ | j dkr| j�� | j�� d S t| j�| j }t|�D ] }| j�� \}}| j|= q d S )Nr )�_cull_frequencyr �clearr r, �range�popitem)r �count�ir �_r r r r. [ s �zLocMemCache._cullc C s, z | j |= | j|= W dS ty Y dS w )NFT)r r �KeyError)r r r r r r' e s ��zLocMemCache._deletec C sB | j ||d�}| j� | �|�W d � S 1 sw Y d S r0 )r r r' r9 r r r �deletem s $�zLocMemCache.deletec C s@ | j � | j�� | j�� W d � d S 1 sw Y d S r )r r r? r )r r r r r? r s "�zLocMemCache.clear)NN)r4 Nr )�__name__� __module__� __qualname__r �HIGHEST_PROTOCOLr r r r$ r+ r r1 r3 r8 r: r r. r' rF r? � __classcell__r r r r r s r )�__doc__r r< � collectionsr � threadingr � django.core.cache.backends.baser r r r r r r r r r �<module> s backends/__pycache__/base.cpython-310.pyc 0000644 00000031454 15030004302 0014133 0 ustar 00 o �h�7 � @ s� d Z ddlZddlZddlmZ ddlmZ ddlmZ G dd� de�Z G dd � d e �Z G d d � d e �Z e� Zd Zd d� Zdd� ZG dd� d�Zdd� ZdS )zBase Cache class.� N)� sync_to_async)�ImproperlyConfigured)� import_stringc @ � e Zd ZdS )�InvalidCacheBackendErrorN��__name__� __module__� __qualname__� r r �R/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/base.pyr � r c @ r )�CacheKeyWarningNr r r r r r r r c @ r )�InvalidCacheKeyNr r r r r r r r � c C s d||| f S )z� Default function to generate keys. Construct the key used by all other methods. By default, prepend the `key_prefix`. KEY_FUNCTION can be used to specify an alternate function with custom key making behavior. z%s:%s:%sr )�key� key_prefix�versionr r r �default_key_func s r c C s | durt | �r | S t| �S tS )z] Function to decide which key function to use. Default to ``default_key_func``. N)�callabler r )�key_funcr r r � get_key_func* s r c @ s� e Zd Ze� Zdd� Zefdd�ZdOdd�Zdd � Z dOd d �Z edfd d �Z edfdd�Z dPdd�Z dPdd�Zedfdd�Zedfdd�Zedfdd�Zedfdd�ZdOd d �ZdOd d �ZdOd d!�ZdOd"d#�Zedfd$d%�Zedfd&d'�ZdOd(d)�ZdOd*d+�ZdQd-d.�ZdQd/d0�Z dQd1d2�Z dQd3d4�Z d5d6� Z edfd7d8�Z edfd9d:�Z!dOd;d<�Z"dOd=d>�Z#d?d@� Z$dAdB� Z%dQdCdD�Z&dQdEdF�Z'dQdGdH�Z(dQdIdJ�Z)dKdL� Z*dMdN� Z+dS )R� BaseCachec C s |� d|� dd��}|d ur"zt|�}W n ttfy! d}Y nw || _|� di �}|� d|� dd��}zt|�| _W n ttfyJ d| _Y nw |� d|� dd ��}zt|�| _W n ttfyj d | _Y nw |� d d �| _|� d d �| _t |� d��| _ d S )N�timeout�TIMEOUTi, �OPTIONS� max_entries� MAX_ENTRIES�cull_frequency�CULL_FREQUENCY� � KEY_PREFIX� �VERSION� � KEY_FUNCTION) �get�int� ValueError� TypeError�default_timeout� _max_entries�_cull_frequencyr r r r )�self�paramsr �optionsr r r r r �__init__; s0 � � �zBaseCache.__init__c C s4 |t kr| j}n|dkrd}|du rdS t�� | S )zj Return the timeout value usable by this backend based upon the provided timeout. r ���N)�DEFAULT_TIMEOUTr* �time)r- r r r r �get_backend_timeoutU s z BaseCache.get_backend_timeoutNc C s |du r| j }| �|| j|�S )ap Construct the key used by all other methods. By default, use the key_func to generate a key (which, by default, prepends the `key_prefix' and 'version'). A different key function can be provided at the time of cache construction; alternatively, you can subclass the cache backend to provide custom key making behavior. N)r r r �r- r r r r r �make_keya s zBaseCache.make_keyc C s t |�D ]}t�|t� qdS )z� Warn about keys that would not be portable to the memcached backend. This encourages (but does not force) writing backend-portable cache code. N)�memcache_key_warnings�warnings�warnr )r- r �warningr r r � validate_keyn s �zBaseCache.validate_keyc C s | j ||d�}| �|� |S )z!Helper to make and validate keys.�r )r6 r; r5 r r r �make_and_validate_keyw s z BaseCache.make_and_validate_keyc C � t d��)z� Set a value in the cache if the key does not already exist. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. Return True if the value was stored, False otherwise. z4subclasses of BaseCache must provide an add() method��NotImplementedError�r- r �valuer r r r r �add} s �z BaseCache.addc � � �t | jdd�||||�I d H S �NT)�thread_sensitive)r rC rA r r r �aadd� � � �zBaseCache.aaddc C r> )z� Fetch a given key from the cache. If the key does not exist, return default, which itself defaults to None. z3subclasses of BaseCache must provide a get() methodr? �r- r �defaultr r r r r& � � z BaseCache.getc � � �t | jdd�|||�I d H S rE )r r& rI r r r �aget� � � �zBaseCache.agetc C r> )z� Set a value in the cache. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. z3subclasses of BaseCache must provide a set() methodr? rA r r r �set� rK z BaseCache.setc � rD rE )r rO rA r r r �aset� rH zBaseCache.asetc C r> )z� Update the key's expiry time using timeout. Return True if successful or False if the key does not exist. z5subclasses of BaseCache must provide a touch() methodr? �r- r r r r r r �touch� � �zBaseCache.touchc � rL rE )r rR rQ r r r �atouch� rN zBaseCache.atouchc C r> )zh Delete a key from the cache and return whether it succeeded, failing silently. z6subclasses of BaseCache must provide a delete() methodr? r5 r r r �delete� rS zBaseCache.deletec � s �t | jdd�||�I d H S rE )r rU r5 r r r �adelete� s �zBaseCache.adeletec C s6 i }|D ]}| j || j|d�}|| jur|||< q|S )a. Fetch a bunch of keys from the cache. For certain backends (memcached, pgsql) this can be *much* faster when fetching multiple values. Return a dict mapping each key in keys to its value. If the given key is missing, it will be missing from the response dict. r< �r& � _missing_key�r- �keysr �d�k�valr r r �get_many� s �zBaseCache.get_manyc � s> �i }|D ]}| j || j|d�I dH }|| jur |||< q|S )zSee get_many().r< N�rM rX rY r r r � aget_many� s � �zBaseCache.aget_manyc C sP | j || j|d�}|| ju r&t|�r|� }| j||||d� | j |||d�S |S )aU Fetch a given key from the cache. If the key does not exist, add the key and set it to the default value. The default value can also be any callable. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. Return the value of the key stored or retrieved. r< �r r )r& rX r rC �r- r rJ r r r] r r r � get_or_set� s zBaseCache.get_or_setc � sd �| j || j|d�I dH }|| ju r0t|�r|� }| j||||d�I dH | j |||d�I dH S |S )zSee get_or_set().r< Nra )rM rX r rG rb r r r � aget_or_set� s � zBaseCache.aget_or_setc C s | j || j|d�| juS )�M Return True if the key is in the cache and has not expired. r< rW r5 r r r �has_key� s �zBaseCache.has_keyc � s �| j || j|d�I d H | juS �Nr< r_ r5 r r r �ahas_key� s ���zBaseCache.ahas_keyr$ c C sD | j || j|d�}|| ju rtd| ��|| }| j|||d� |S )zs Add delta to value in the cache. If the key does not exist, raise a ValueError exception. r< �Key '%s' not found)r& rX r( rO �r- r �deltar rB � new_valuer r r �incr s zBaseCache.incrc � sR �| j || j|d�I dH }|| ju rtd| ��|| }| j|||d�I dH |S )z See incr().r< Nri )rM rX r( rP rj r r r �aincr s � zBaseCache.aincrc C s | j || |d�S )zz Subtract delta from value in the cache. If the key does not exist, raise a ValueError exception. r< )rm �r- r rk r r r r �decr s zBaseCache.decrc � s �| j || |d�I d H S rg )rn ro r r r �adecr! s �zBaseCache.adecrc C s | � |�S )re )rf )r- r r r r � __contains__$ s zBaseCache.__contains__c C s( |� � D ] \}}| j||||d� qg S )a� Set a bunch of values in the cache at once from a dict of key/value pairs. For certain backends (memcached), this is much more efficient than calling set() multiple times. If timeout is given, use that timeout for the key; otherwise use the default cache timeout. On backends that support it, return a list of keys that failed insertion, or an empty list if all keys were inserted successfully. ra )�itemsrO �r- �datar r r rB r r r �set_many- s zBaseCache.set_manyc � s0 �|� � D ]\}}| j||||d�I d H qg S )Nra )rs rP rt r r r � aset_many= s �zBaseCache.aset_manyc C s |D ] }| j ||d� qdS )z� Delete a bunch of values in the cache at once. For certain backends (memcached), this is much more efficient than calling delete() multiple times. r< N)rU �r- rZ r r r r r � delete_manyB s �zBaseCache.delete_manyc � s$ �|D ] }| j ||d�I d H qd S rg )rV rx r r r � adelete_manyK s ��zBaseCache.adelete_manyc C r> )z+Remove *all* values from the cache at once.z5subclasses of BaseCache must provide a clear() methodr? �r- r r r �clearO s �zBaseCache.clearc � s �t | jdd�� I d H S rE )r r| r{ r r r �aclearU � �zBaseCache.aclearc C s` |du r| j }| j|| j|d�}|| ju rtd| ��| j|||| d� | j||d� || S )zf Add delta to the cache version for the supplied key. Return the new version. Nr< ri )r r& rX r( rO rU �r- r rk r rB r r r � incr_versionX s zBaseCache.incr_versionc � st �|du r| j }| j|| j|d�I dH }|| ju r td| ��| j|||| d�I dH | j||d�I dH || S )zSee incr_version().Nr< ri )r rM rX r( rP rV r r r r � aincr_versionh s � zBaseCache.aincr_versionc C s | � || |�S )zm Subtract delta from the cache version for the supplied key. Return the new version. )r� ro r r r � decr_versionu s zBaseCache.decr_versionc � s �| � || |�I d H S �N)r� ro r r r � adecr_version| r~ zBaseCache.adecr_versionc K s dS )zClose the cache connectionNr �r- �kwargsr r r �close s zBaseCache.closec � s �d S r� r r� r r r �aclose� s �zBaseCache.acloser� )NN)r$ N),r r r �objectrX r0 r2 r4 r6 r; r= rC rG r& rM rO rP rR rT rU rV r^ r` rc rd rf rh rm rn rp rq rr rv rw ry rz r| r} r� r� r� r� r� r� r r r r r 8 sP r c c sR � t | �tkrd| tf V | D ]}t|�dk s t|�dkr&d| V d S qd S )NzGCache key will cause errors if used with memcached: %r (longer than %s)�! � zOCache key contains characters that will cause errors if used with memcached: %r)�len�MEMCACHE_MAX_KEY_LENGTH�ord)r �charr r r r7 � s � ������r7 )�__doc__r3 r8 � asgiref.syncr �django.core.exceptionsr �django.utils.module_loadingr r �RuntimeWarningr r( r r� r2 r� r r r r7 r r r r �<module> s" Q backends/__pycache__/db.cpython-310.pyc 0000644 00000017413 15030004302 0013605 0 ustar 00 o �hl, � @ s� d Z ddlZddlZddlmZmZ ddlmZ ddlmZm Z ddl m Z m Z m Z mZmZ ddlmZ G dd � d �ZG d d � d e �ZG d d � d e�ZdS )zDatabase cache backend.� N)�datetime�timezone)�settings)�DEFAULT_TIMEOUT� BaseCache)� DatabaseError� connections�models�router� transaction)�nowc @ s e Zd ZdZdd� ZdS )�Optionsz~A class that will quack like a Django model _meta class. This allows cache operations to be controlled by the router c C s@ || _ d| _d| _d| _d| _d| _d| _d| _d| _d| _ d S )N� django_cache� cacheentryz cache entryz cache entries� CacheEntryFT) �db_table� app_label� model_name� verbose_name�verbose_name_plural� object_name�abstract�managed�proxy�swapped)�self�table� r �P/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/db.py�__init__ s zOptions.__init__N)�__name__� __module__� __qualname__�__doc__r r r r r r s r c s e Zd Z� fdd�Z� ZS )�BaseDatabaseCachec s. t � �|� � | _G � fdd�d�}|| _d S )Nc s e Zd Ze� �ZdS )z.BaseDatabaseCache.__init__.<locals>.CacheEntryN)r r! r" r �_metar �r r r r $ s r )�superr �_table�cache_model_class)r r �paramsr �� __class__r& r r s zBaseDatabaseCache.__init__)r r! r" r � __classcell__r r r+ r r$ s r$ c @ s� e Zd ZejZddd�Zddd�Zedfdd�Z edfdd �Z edfd d �Z efd d �Z ddd�Z ddd�Zdd� Zddd�Zdd� Zdd� ZdS ) � DatabaseCacheNc C s | � |g|��||�S �N)�get_many�get)r �key�default�versionr r r r1 3 s zDatabaseCache.getc sX |si S � �fdd�|D �}t �� j�}t| }|jj}|� j�}|�� �,}|�d|d�|d�|d�||d�d� dgt |� �f t |�� |� � } W d � n1 sTw Y i } g } t jt �� d �} |j�| �| �|� } | D ]2\}}}| D ]}||| |�}qy|t� k r�| �|� qr|j�|�}t�t�|�� ��}|| |�|�< qr� �| � | S ) Nc s i | ] }� j |�d �|�qS ��r4 ��make_and_validate_key��.0r2 �r r4 r r � <dictcomp>: s �z*DatabaseCache.get_many.<locals>.<dictcomp>z*SELECT %s, %s, %s FROM %s WHERE %s IN (%s)� cache_key�value�expires�, �%s�� output_field)r � db_for_readr) r �ops� quote_namer( �cursor�execute�join�len�list�fetchallr � Expression� DateTimeField�get_db_converters�tz_now�append� process_clob�pickle�loads�base64� b64decode�encoder1 �_base_delete_many)r �keysr4 �key_map�db� connectionrF r rG �rows�result� expired_keys� expression� convertersr2 r> r? � converterr r; r r0 6 sT � �� � ��� zDatabaseCache.get_manyc C s" | j ||d�}| �d|||� d S )Nr6 �set�r8 � _base_set�r r2 r> �timeoutr4 r r r rc d s zDatabaseCache.setc C s | j ||d�}| �d|||�S )Nr6 �addrd rf r r r rh h � zDatabaseCache.addc C s | j ||d�}| �d|d |�S )Nr6 �touchrd )r r2 rg r4 r r r rj l ri zDatabaseCache.touchc C s� | � |�}t�| j�}t| }|jj}|| j�}|�� ��*} | � d| � | � � d } t � } | j dd�} |d u r<t j} ntjrBtjnd } t j|| d�} | j dd�} | | jkr^| �|| | | � t�|| j�}t�|��d�}z�t j |d��� | � d|d�|d �||d�f |g� | � � }|r�|d }t j t � � d �}|j�!|�|�!|� D ]}||||�}q�|j�"| �} |r�|d kr�| � d ||d �|d�f | |g� nO|r�|dks�|dkr�|| k r�| � d||d�|d �|d�f || |g� n+|d k�r | � d||d�|d�|d �f ||| g� n W d � W W d � dS W d � n 1 �s&w Y W n t#�y= Y W d � dS w W d � dS 1 �sKw Y d S )NzSELECT COUNT(*) FROM %sr )� microsecond)�tz�latin1)�usingz$SELECT %s, %s FROM %s WHERE %s = %%sr= r? � rB rj z%UPDATE %s SET %s = %%s WHERE %s = %%src rh z/UPDATE %s SET %s = %%s, %s = %%s WHERE %s = %%sr> z2INSERT INTO %s (%s, %s, %s) VALUES (%%s, %%s, %%s)FT)$�get_backend_timeoutr � db_for_writer) r rE rF r( rG rH �fetchonerP �replacer �maxr �USE_TZr �utc� fromtimestamp� _max_entries�_cullrS �dumps�pickle_protocolrU � b64encode�decoder �atomicr rM rN rO �adapt_datetimefield_valuer )r �moder2 r> rg r[ r\ rF r rG �numr �exprl �pickled� b64encodedr^ �current_expiresr` rb r r r re p s� ��� ���� ����� ��� ��� �:�P&�zDatabaseCache._base_setc C s | j ||d�}| �|g�S )Nr6 )r8 rX )r r2 r4 r r r �delete� s zDatabaseCache.deletec s" � �fdd�|D �}� � |� d S )Nc s g | ] }� j |�d ��qS r5 r7 r9 r; r r � <listcomp>� s z-DatabaseCache.delete_many.<locals>.<listcomp>)rX )r rY r4 r r; r � delete_many� s zDatabaseCache.delete_manyc C s� |sdS t �| j�}t| }|jj}|| j�}|�� �"}|�d||d�d� dgt |� �f |� t |j �W d � S 1 s@w Y d S )NFz DELETE FROM %s WHERE %s IN (%s)r= r@ rA ) r rq r) r rE rF r( rG rH rI rJ �bool�rowcount)r rY r[ r\ rF r rG r r r rX � s$ ��� $�z DatabaseCache._base_delete_manyc C s� | j ||d�}t�| j�}t| }|jj}t� jdd d�}|� � �)}|� d|d�|| j �|d�|d�f ||j� |�g� |� � d uW d � S 1 sMw Y d S )Nr6 r )rk �tzinfoz-SELECT %s FROM %s WHERE %s = %%s and %s > %%sr= r? )r8 r rD r) r rE rF rP rs rG rH r( r rr )r r2 r4 r[ r\ rF r rG r r r �has_key� s$ ��� $�zDatabaseCache.has_keyc C s� | j dkr | �� d S t| }|j�| j�}|�d||j�d�f |j�|�g� |j}|| }|| j kr_|| j } |�|j� � | | g� |� � } | ra|�d||j�d�f | d g� d S d S d S )Nr z DELETE FROM %s WHERE %s < %%sr? r= ) �_cull_frequency�clearr rE rF r( rH r r� rx �cache_key_culling_sqlrr ) r r[ rG r r� r\ r � deleted_count� remaining_num�cull_num�last_cache_keyr r r ry s> �� � � ����zDatabaseCache._cullc C s^ t �| j�}t| }|j�| j�}|�� �}|�d| � W d � d S 1 s(w Y d S )NzDELETE FROM %s) r rq r) r rE rF r( rG rH )r r[ r\ r rG r r r r� s "�zDatabaseCache.clear)NNr/ )r r! r" rS �HIGHEST_PROTOCOLr{ r1 r0 r rc rh rj re r� r� rX r� ry r� r r r r r. * s . ] r. )r# rU rS r r � django.confr � django.core.cache.backends.baser r � django.dbr r r r r �django.utils.timezoner rP r r$ r. r r r r �<module> s backends/__pycache__/redis.cpython-310.pyc 0000644 00000020716 15030004302 0014326 0 ustar 00 o �h� � @ st d Z ddlZddlZddlZddlmZmZ ddlmZ ddl m Z G dd� d�Z G dd � d �Z G d d � d e�Z dS ) zRedis cache backend.� N)�DEFAULT_TIMEOUT� BaseCache)�cached_property)� import_stringc @ s& e Zd Zddd�Zdd� Zdd� ZdS ) �RedisSerializerNc C s |d u r t j| _d S || _d S �N)�pickle�HIGHEST_PROTOCOL�protocol)�selfr � r �S/usr/local/CyberCP/lib/python3.10/site-packages/django/core/cache/backends/redis.py�__init__ s zRedisSerializer.__init__c C s t |�tu r|S t�|| j�S r )�type�intr �dumpsr )r �objr r r r s zRedisSerializer.dumpsc C s( zt |�W S ty t�|� Y S w r )r � ValueErrorr �loads)r �datar r r r s �zRedisSerializer.loadsr )�__name__� __module__� __qualname__r r r r r r r r s r c @ s� e Zd Z d"dd�Zdd� Zdd� Zd#dd �d d �Zd d � Zdd� Zdd� Z dd� Z dd� Z dd� Z dd� Z dd� Zd d � Zd d � Zd d!� ZdS )$�RedisCacheClientNc K s� dd l }|| _|| _i | _| jj| _t|t�rt|�}|p | jj | _ t|t�r+t|�}t |�r2|� }|p6t � | _ t|t�rAt|�}|pG| jjj}d|i|�| _d S )Nr � parser_class)�redis�_lib�_servers�_pools�Redis�_client� isinstance�strr �ConnectionPool� _pool_class�callabler � _serializer� connection� DefaultParser� _pool_options)r �servers� serializer� pool_classr �optionsr r r r r s" zRedisCacheClient.__init__c C s, |s t | j�dkr dS t�dt | j�d �S )N� r )�lenr �random�randint)r �writer r r �_get_connection_pool_index? s z+RedisCacheClient._get_connection_pool_indexc C s@ | � |�}|| jvr| jj| j| fi | j��| j|< | j| S r )r3 r r$ �from_urlr r) )r r2 �indexr r r �_get_connection_poolF s � � z%RedisCacheClient._get_connection_poolF�r2 c C s | � |�}| j|d�S )N)�connection_pool)r6 r )r �keyr2 �poolr r r � get_clientO s zRedisCacheClient.get_clientc C s^ | j |dd�}| j�|�}|dkr$t|j||dd�� }r"|�|� |S t|j|||dd��S )NTr7 r )�nx)�exr< )r; r& r �bool�set�delete)r r9 �value�timeout�client�retr r r �addV s zRedisCacheClient.addc C s, | � |�}|�|�}|d u r|S | j�|�S r )r; �getr& r )r r9 �defaultrC rA r r r rF a s zRedisCacheClient.getc C sD | j |dd�}| j�|�}|dkr|�|� d S |j|||d� d S )NTr7 r )r= )r; r& r r@ r? )r r9 rA rB rC r r r r? f s zRedisCacheClient.setc C s4 | j |dd�}|d u rt|�|��S t|�||��S �NTr7 )r; r> �persist�expire)r r9 rB rC r r r �touchn s zRedisCacheClient.touchc C s | j |dd�}t|�|��S rH )r; r> r@ �r r9 rC r r r r@ u � zRedisCacheClient.deletec s, � � d �}|�|�}� fdd�t||�D �S )Nc s& i | ]\}}|d ur|� j �|��qS r )r& r ��.0�k�v�r r r � <dictcomp>| s z-RedisCacheClient.get_many.<locals>.<dictcomp>)r; �mget�zip)r �keysrC rD r rR r �get_manyy s �zRedisCacheClient.get_manyc C s | � |�}t|�|��S r )r; r> �existsrL r r r �has_key� s zRedisCacheClient.has_keyc C s0 | j |dd�}|�|�std| ��|�||�S )NTr7 zKey '%s' not found.)r; rX r �incr)r r9 �deltarC r r r rZ � s zRedisCacheClient.incrc s\ � j d dd�}|�� }|�� fdd�|�� D �� |d ur(|D ]}|�||� q |�� d S )NTr7 c s i | ] \}}|� j �|��qS r )r& r rN rR r r rS � s z-RedisCacheClient.set_many.<locals>.<dictcomp>)r; �pipeline�mset�itemsrJ �execute)r r rB rC r\ r9 r rR r �set_many� s zRedisCacheClient.set_manyc C s | j d dd�}|j|� d S rH )r; r@ )r rV rC r r r � delete_many� rM z RedisCacheClient.delete_manyc C s | j d dd�}t|�� �S rH )r; r> �flushdb)r rC r r r �clear� � zRedisCacheClient.clear)NNNr )r r r r r3 r6 r; rE rF r? rK r@ rW rY rZ r` ra rc r r r r r s& � r c s� e Zd Z� fdd�Zedd� �Zefdd�Zedfdd �Zd d d �Z edfd d �Z edfdd�Z d dd�Z d dd�Z d dd�Zd!dd�Zedfdd�Zd dd �Zd d � Z� ZS )"� RedisCachec sD t � �|� t|t�rt�d|�| _n|| _t| _|� di �| _ d S )Nz[;,]�OPTIONS) �superr r! r" �re�splitr r �_classrF �_options)r �server�params�� __class__r r r � s zRedisCache.__init__c C s | j | jfi | j��S r )rj r rk rR r r r �_cache� s zRedisCache._cachec C s( |t kr| j}|d u r d S tdt|��S )Nr )r �default_timeout�maxr )r rB r r r �get_backend_timeout� s z RedisCache.get_backend_timeoutNc C s$ | j ||d�}| j�||| �|��S �N��version)�make_and_validate_keyrp rE rs �r r9 rA rB rv r r r rE � s zRedisCache.addc C � | j ||d�}| j�||�S rt )rw rp rF )r r9 rG rv r r r rF � rM zRedisCache.getc C s( | j ||d�}| j�||| �|�� d S rt )rw rp r? rs rx r r r r? � s zRedisCache.setc C s" | j ||d�}| j�|| �|��S rt )rw rp rK rs )r r9 rB rv r r r rK � s zRedisCache.touchc C � | j ||d�}| j�|�S rt )rw rp r@ �r r9 rv r r r r@ � rd zRedisCache.deletec s: ��fdd�|D �� �j �� �� �}� fdd�|�� D �S )Nc s i | ] }� j |�d �|�qS �ru �rw �rO r9 �r rv r r rS � s �z'RedisCache.get_many.<locals>.<dictcomp>c s i | ] \}}� | |�qS r r rN )�key_mapr r rS � � )rp rW rV r^ )r rV rv rD r )r� r rv r rW � s �zRedisCache.get_manyc C rz rt )rw rp rY r{ r r r rY � rd zRedisCache.has_keyr. c C ry rt )rw rp rZ )r r9 r[ rv r r r rZ � rM zRedisCache.incrc C sL |sg S i }|� � D ]\}}| j||d�}|||< q | j�|| �|�� g S rt )r^ rw rp r` rs )r r rB rv � safe_datar9 rA r r r r` � s zRedisCache.set_manyc s, |sd S � �fdd�|D �}� j �|� d S )Nc s g | ] }� j |�d ��qS r| r} r~ r r r � <listcomp>� r� z*RedisCache.delete_many.<locals>.<listcomp>)rp ra )r rV rv � safe_keysr r r ra � s zRedisCache.delete_manyc C s | j �� S r )rp rc rR r r r rc � s zRedisCache.clear)NNr )r. N)r r r r r rp r rs rE rF r? rK r@ rW rY rZ r` ra rc � __classcell__r r rn r re � s re )�__doc__r r0 rh � django.core.cache.backends.baser r �django.utils.functionalr �django.utils.module_loadingr r r re r r r r �<module> s backends/memcached.py 0000644 00000015220 15030004302 0010561 0 ustar 00 "Memcached cache backend" import re import time from django.core.cache.backends.base import ( DEFAULT_TIMEOUT, BaseCache, InvalidCacheKey, memcache_key_warnings, ) from django.utils.functional import cached_property class BaseMemcachedCache(BaseCache): def __init__(self, server, params, library, value_not_found_exception): super().__init__(params) if isinstance(server, str): self._servers = re.split("[;,]", server) else: self._servers = server # Exception type raised by the underlying client library for a # nonexistent key. self.LibraryValueNotFoundException = value_not_found_exception self._lib = library self._class = library.Client self._options = params.get("OPTIONS") or {} @property def client_servers(self): return self._servers @cached_property def _cache(self): """ Implement transparent thread-safe access to a memcached client. """ return self._class(self.client_servers, **self._options) def get_backend_timeout(self, timeout=DEFAULT_TIMEOUT): """ Memcached deals with long (> 30 days) timeouts in a special way. Call this function to obtain a safe value for your timeout. """ if timeout == DEFAULT_TIMEOUT: timeout = self.default_timeout if timeout is None: # Using 0 in memcache sets a non-expiring timeout. return 0 elif int(timeout) == 0: # Other cache backends treat 0 as set-and-expire. To achieve this # in memcache backends, a negative timeout must be passed. timeout = -1 if timeout > 2592000: # 60*60*24*30, 30 days # See https://github.com/memcached/memcached/wiki/Programming#expiration # "Expiration times can be set from 0, meaning "never expire", to # 30 days. Any time higher than 30 days is interpreted as a Unix # timestamp date. If you want to expire an object on January 1st of # next year, this is how you do that." # # This means that we have to switch to absolute timestamps. timeout += int(time.time()) return int(timeout) def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.add(key, value, self.get_backend_timeout(timeout)) def get(self, key, default=None, version=None): key = self.make_and_validate_key(key, version=version) return self._cache.get(key, default) def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) if not self._cache.set(key, value, self.get_backend_timeout(timeout)): # Make sure the key doesn't keep its old value in case of failure # to set (memcached's 1MB limit). self._cache.delete(key) def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) return bool(self._cache.touch(key, self.get_backend_timeout(timeout))) def delete(self, key, version=None): key = self.make_and_validate_key(key, version=version) return bool(self._cache.delete(key)) def get_many(self, keys, version=None): key_map = { self.make_and_validate_key(key, version=version): key for key in keys } ret = self._cache.get_multi(key_map.keys()) return {key_map[k]: v for k, v in ret.items()} def close(self, **kwargs): # Many clients don't clean up connections properly. self._cache.disconnect_all() def incr(self, key, delta=1, version=None): key = self.make_and_validate_key(key, version=version) try: # Memcached doesn't support negative delta. if delta < 0: val = self._cache.decr(key, -delta) else: val = self._cache.incr(key, delta) # Normalize an exception raised by the underlying client library to # ValueError in the event of a nonexistent key when calling # incr()/decr(). except self.LibraryValueNotFoundException: val = None if val is None: raise ValueError("Key '%s' not found" % key) return val def set_many(self, data, timeout=DEFAULT_TIMEOUT, version=None): safe_data = {} original_keys = {} for key, value in data.items(): safe_key = self.make_and_validate_key(key, version=version) safe_data[safe_key] = value original_keys[safe_key] = key failed_keys = self._cache.set_multi( safe_data, self.get_backend_timeout(timeout) ) return [original_keys[k] for k in failed_keys] def delete_many(self, keys, version=None): keys = [self.make_and_validate_key(key, version=version) for key in keys] self._cache.delete_multi(keys) def clear(self): self._cache.flush_all() def validate_key(self, key): for warning in memcache_key_warnings(key): raise InvalidCacheKey(warning) class PyLibMCCache(BaseMemcachedCache): "An implementation of a cache binding using pylibmc" def __init__(self, server, params): import pylibmc super().__init__( server, params, library=pylibmc, value_not_found_exception=pylibmc.NotFound ) @property def client_servers(self): output = [] for server in self._servers: output.append(server[5:] if server.startswith("unix:") else server) return output def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) if timeout == 0: return self._cache.delete(key) return self._cache.touch(key, self.get_backend_timeout(timeout)) def close(self, **kwargs): # libmemcached manages its own connections. Don't call disconnect_all() # as it resets the failover state and creates unnecessary reconnects. pass class PyMemcacheCache(BaseMemcachedCache): """An implementation of a cache binding using pymemcache.""" def __init__(self, server, params): import pymemcache.serde super().__init__( server, params, library=pymemcache, value_not_found_exception=KeyError ) self._class = self._lib.HashClient self._options = { "allow_unicode_keys": True, "default_noreply": False, "serde": pymemcache.serde.pickle_serde, **self._options, } backends/filebased.py 0000644 00000013250 15030004302 0010572 0 ustar 00 "File-based cache backend" import glob import os import pickle import random import tempfile import time import zlib from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache from django.core.files import locks from django.core.files.move import file_move_safe from django.utils.crypto import md5 class FileBasedCache(BaseCache): cache_suffix = ".djcache" pickle_protocol = pickle.HIGHEST_PROTOCOL def __init__(self, dir, params): super().__init__(params) self._dir = os.path.abspath(dir) self._createdir() def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): if self.has_key(key, version): return False self.set(key, value, timeout, version) return True def get(self, key, default=None, version=None): fname = self._key_to_file(key, version) try: with open(fname, "rb") as f: if not self._is_expired(f): return pickle.loads(zlib.decompress(f.read())) except FileNotFoundError: pass return default def _write_content(self, file, timeout, value): expiry = self.get_backend_timeout(timeout) file.write(pickle.dumps(expiry, self.pickle_protocol)) file.write(zlib.compress(pickle.dumps(value, self.pickle_protocol))) def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): self._createdir() # Cache dir can be deleted at any time. fname = self._key_to_file(key, version) self._cull() # make some room if necessary fd, tmp_path = tempfile.mkstemp(dir=self._dir) renamed = False try: with open(fd, "wb") as f: self._write_content(f, timeout, value) file_move_safe(tmp_path, fname, allow_overwrite=True) renamed = True finally: if not renamed: os.remove(tmp_path) def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): try: with open(self._key_to_file(key, version), "r+b") as f: try: locks.lock(f, locks.LOCK_EX) if self._is_expired(f): return False else: previous_value = pickle.loads(zlib.decompress(f.read())) f.seek(0) self._write_content(f, timeout, previous_value) return True finally: locks.unlock(f) except FileNotFoundError: return False def delete(self, key, version=None): return self._delete(self._key_to_file(key, version)) def _delete(self, fname): if not fname.startswith(self._dir) or not os.path.exists(fname): return False try: os.remove(fname) except FileNotFoundError: # The file may have been removed by another process. return False return True def has_key(self, key, version=None): fname = self._key_to_file(key, version) try: with open(fname, "rb") as f: return not self._is_expired(f) except FileNotFoundError: return False def _cull(self): """ Remove random cache entries if max_entries is reached at a ratio of num_entries / cull_frequency. A value of 0 for CULL_FREQUENCY means that the entire cache will be purged. """ filelist = self._list_cache_files() num_entries = len(filelist) if num_entries < self._max_entries: return # return early if no culling is required if self._cull_frequency == 0: return self.clear() # Clear the cache when CULL_FREQUENCY = 0 # Delete a random selection of entries filelist = random.sample(filelist, int(num_entries / self._cull_frequency)) for fname in filelist: self._delete(fname) def _createdir(self): # Set the umask because os.makedirs() doesn't apply the "mode" argument # to intermediate-level directories. old_umask = os.umask(0o077) try: os.makedirs(self._dir, 0o700, exist_ok=True) finally: os.umask(old_umask) def _key_to_file(self, key, version=None): """ Convert a key into a cache file path. Basically this is the root cache path joined with the md5sum of the key and a suffix. """ key = self.make_and_validate_key(key, version=version) return os.path.join( self._dir, "".join( [ md5(key.encode(), usedforsecurity=False).hexdigest(), self.cache_suffix, ] ), ) def clear(self): """ Remove all the cache files. """ for fname in self._list_cache_files(): self._delete(fname) def _is_expired(self, f): """ Take an open cache file `f` and delete it if it's expired. """ try: exp = pickle.load(f) except EOFError: exp = 0 # An empty file is considered expired. if exp is not None and exp < time.time(): f.close() # On Windows a file has to be closed before deleting self._delete(f.name) return True return False def _list_cache_files(self): """ Get a list of paths to all the cache files. These are all the files in the root cache dir that end on the cache_suffix. """ return [ os.path.join(self._dir, fname) for fname in glob.glob1(self._dir, "*%s" % self.cache_suffix) ] backends/__init__.py 0000644 00000000000 15030004302 0010400 0 ustar 00 backends/locmem.py 0000644 00000007703 15030004302 0010136 0 ustar 00 "Thread-safe in-memory cache backend." import pickle import time from collections import OrderedDict from threading import Lock from django.core.cache.backends.base import DEFAULT_TIMEOUT, BaseCache # Global in-memory store of cache data. Keyed by name, to provide # multiple named local memory caches. _caches = {} _expire_info = {} _locks = {} class LocMemCache(BaseCache): pickle_protocol = pickle.HIGHEST_PROTOCOL def __init__(self, name, params): super().__init__(params) self._cache = _caches.setdefault(name, OrderedDict()) self._expire_info = _expire_info.setdefault(name, {}) self._lock = _locks.setdefault(name, Lock()) def add(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) pickled = pickle.dumps(value, self.pickle_protocol) with self._lock: if self._has_expired(key): self._set(key, pickled, timeout) return True return False def get(self, key, default=None, version=None): key = self.make_and_validate_key(key, version=version) with self._lock: if self._has_expired(key): self._delete(key) return default pickled = self._cache[key] self._cache.move_to_end(key, last=False) return pickle.loads(pickled) def _set(self, key, value, timeout=DEFAULT_TIMEOUT): if len(self._cache) >= self._max_entries: self._cull() self._cache[key] = value self._cache.move_to_end(key, last=False) self._expire_info[key] = self.get_backend_timeout(timeout) def set(self, key, value, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) pickled = pickle.dumps(value, self.pickle_protocol) with self._lock: self._set(key, pickled, timeout) def touch(self, key, timeout=DEFAULT_TIMEOUT, version=None): key = self.make_and_validate_key(key, version=version) with self._lock: if self._has_expired(key): return False self._expire_info[key] = self.get_backend_timeout(timeout) return True def incr(self, key, delta=1, version=None): key = self.make_and_validate_key(key, version=version) with self._lock: if self._has_expired(key): self._delete(key) raise ValueError("Key '%s' not found" % key) pickled = self._cache[key] value = pickle.loads(pickled) new_value = value + delta pickled = pickle.dumps(new_value, self.pickle_protocol) self._cache[key] = pickled self._cache.move_to_end(key, last=False) return new_value def has_key(self, key, version=None): key = self.make_and_validate_key(key, version=version) with self._lock: if self._has_expired(key): self._delete(key) return False return True def _has_expired(self, key): exp = self._expire_info.get(key, -1) return exp is not None and exp <= time.time() def _cull(self): if self._cull_frequency == 0: self._cache.clear() self._expire_info.clear() else: count = len(self._cache) // self._cull_frequency for i in range(count): key, _ = self._cache.popitem() del self._expire_info[key] def _delete(self, key): try: del self._cache[key] del self._expire_info[key] except KeyError: return False return True def delete(self, key, version=None): key = self.make_and_validate_key(key, version=version) with self._lock: return self._delete(key) def clear(self): with self._lock: self._cache.clear() self._expire_info.clear() __init__.py 0000644 00000003610 15030004302 0006640 0 ustar 00 """ Caching framework. This package defines set of cache backends that all conform to a simple API. In a nutshell, a cache is a set of values -- which can be any object that may be pickled -- identified by string keys. For the complete API, see the abstract BaseCache class in django.core.cache.backends.base. Client code should use the `cache` variable defined here to access the default cache backend and look up non-default cache backends in the `caches` dict-like object. See docs/topics/cache.txt for information on the public API. """ from django.core import signals from django.core.cache.backends.base import ( BaseCache, CacheKeyWarning, InvalidCacheBackendError, InvalidCacheKey, ) from django.utils.connection import BaseConnectionHandler, ConnectionProxy from django.utils.module_loading import import_string __all__ = [ "cache", "caches", "DEFAULT_CACHE_ALIAS", "InvalidCacheBackendError", "CacheKeyWarning", "BaseCache", "InvalidCacheKey", ] DEFAULT_CACHE_ALIAS = "default" class CacheHandler(BaseConnectionHandler): settings_name = "CACHES" exception_class = InvalidCacheBackendError def create_connection(self, alias): params = self.settings[alias].copy() backend = params.pop("BACKEND") location = params.pop("LOCATION", "") try: backend_cls = import_string(backend) except ImportError as e: raise InvalidCacheBackendError( "Could not find backend '%s': %s" % (backend, e) ) from e return backend_cls(location, params) caches = CacheHandler() cache = ConnectionProxy(caches, DEFAULT_CACHE_ALIAS) def close_caches(**kwargs): # Some caches need to do a cleanup at the end of a request cycle. If not # implemented in a particular backend cache.close() is a no-op. caches.close_all() signals.request_finished.connect(close_caches) utils.py 0000644 00000000631 15030004302 0006241 0 ustar 00 from django.utils.crypto import md5 TEMPLATE_FRAGMENT_KEY_TEMPLATE = "template.cache.%s.%s" def make_template_fragment_key(fragment_name, vary_on=None): hasher = md5(usedforsecurity=False) if vary_on is not None: for arg in vary_on: hasher.update(str(arg).encode()) hasher.update(b":") return TEMPLATE_FRAGMENT_KEY_TEMPLATE % (fragment_name, hasher.hexdigest())
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings