Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/dogpile/cache/backends/__pycache__/memcached.cpython-39.pyc
Ðазад
a t�h0T � @ s d Z ddlZddlZddlZddlZddlmZ ddlmZ ddlZddlm Z ddlm Z dd l m Z ej r�ddladdladdladdlandadadadad ZG d d � d �ZG d d� de �ZG dd� de�ZG dd� dee�ZG dd� dee�ZG dd� de�ZG dd� de�ZdS )zo Memcached Backends ------------------ Provides backends for talking to `memcached <http://memcached.org>`_. � N)�Any)�Mapping� )� CacheBackend��NO_VALUE� )�util)�GenericMemcachedBackend�MemcachedBackend�PylibmcBackend�PyMemcacheBackend�BMemcachedBackend� MemcachedLockc @ s4 e Zd ZdZd dd�Zddd�Zdd � Zd d � Zd S )r z(Simple distributed lock using memcached.r c C s$ || _ d| | _|| _t�� | _d S )N�_lock)� client_fn�key�timeout� threading�Lock�_mutex)�selfr r r � r ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/dogpile/cache/backends/memcached.py�__init__/ s zMemcachedLock.__init__Tc C s� | � � }d}| j�F |�| jd| j�r6W d � dS |sJW d � dS W d � n1 s^0 Y |d t�� d| d }t�|� |dk r |d7 }q d S )Nr � TFr g @� )r r �addr r �random�time�sleep)r �wait�client�iZ sleep_timer r r �acquire5 s . zMemcachedLock.acquirec C s | � � }|�| j�d uS �N)r �getr �r r" r r r �lockedD s zMemcachedLock.lockedc C s | � � }|�| j� d S r% )r �deleter r' r r r �releaseH s zMemcachedLock.releaseN)r )T)�__name__� __module__� __qualname__�__doc__r r$ r( r* r r r r r , s r c @ s� e Zd ZU dZi Zeeef ed< dZ dZ dd� Z dd� Z dd � Z d d � Zejd d � �Zedd� �Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zd d � ZdS ) r a� Base class for memcached backends. This base class accepts a number of paramters common to all backends. :param url: the string URL to connect to. Can be a single string or a list of strings. This is the only argument that's required. :param distributed_lock: boolean, when True, will use a memcached-lock as the dogpile lock (see :class:`.MemcachedLock`). Use this when multiple processes will be talking to the same memcached instance. When left at False, dogpile will coordinate on a regular threading mutex. :param lock_timeout: integer, number of seconds after acquiring a lock that memcached should expire it. This argument is only valid when ``distributed_lock`` is ``True``. .. versionadded:: 0.5.7 The :class:`.GenericMemachedBackend` uses a ``threading.local()`` object to store individual client objects per thread, as most modern memcached clients do not appear to be inherently threadsafe. In particular, ``threading.local()`` has the advantage over pylibmc's built-in thread pool in that it automatically discards objects associated with a particular thread when that thread ends. � set_argumentsNc C s8 | � � t�|d �| _|�dd�| _|�dd�| _d S )N�url�distributed_lockF� lock_timeoutr )�_importsr Zto_listr0 r& r1 r2 �r � argumentsr r r r x s z GenericMemcachedBackend.__init__c C s | j dkS �Nr )r2 �r r r r �has_lock_timeout� s z(GenericMemcachedBackend.has_lock_timeoutc C s t � �dS )z client library imports go here.N��NotImplementedErrorr7 r r r r3 � s z GenericMemcachedBackend._importsc C s t � �dS )z(Creation of a Client instance goes here.Nr9 r7 r r r �_create_client� s z&GenericMemcachedBackend._create_clientc s | � G � fdd�dt j�}|� S )Nc s e Zd Z� fdd�ZdS )z4GenericMemcachedBackend._clients.<locals>.ClientPoolc s � � � | _d S r% )r; � memcachedr7 ��backendr r r � s z=GenericMemcachedBackend._clients.<locals>.ClientPool.__init__N)r+ r, r- r r r= r r � ClientPool� s r? )r �local)r r? r r= r �_clients� s z GenericMemcachedBackend._clientsc C s | j jS )z�Return the memcached client. This uses a threading.local by default as it appears most modern memcached libs aren't inherently threadsafe. )rA r< r7 r r r r" � s z GenericMemcachedBackend.clientc s& � j r t� fdd�|� jd�S d S d S )Nc s � j S r% )r" r r7 r r �<lambda>� � z3GenericMemcachedBackend.get_mutex.<locals>.<lambda>)r )r1 r r2 �r r r r7 r � get_mutex� s �z!GenericMemcachedBackend.get_mutexc C s | j �|�}|d u rtS |S d S r% )r" r& r �r r �valuer r r r& � s zGenericMemcachedBackend.getc s( | j �|�� dd� � fdd�|D �D �S )Nc S s g | ]}|d u rt n|�qS r% r )�.0�valr r r � <listcomp>� s �z5GenericMemcachedBackend.get_multi.<locals>.<listcomp>c s g | ]}� � |t��qS r )r& r )rH r ��valuesr r rJ � rC )r" � get_multi�r �keysr rK r rM � s �z!GenericMemcachedBackend.get_multic C s | j j||fi | j�� d S r% )r" �setr/ rF r r r rP � s zGenericMemcachedBackend.setc C s, dd� |� � D �}| jj|fi | j�� d S )Nc S s i | ]\}}||�qS r r )rH r rG r r r � <dictcomp>� rC z5GenericMemcachedBackend.set_multi.<locals>.<dictcomp>)�itemsr" � set_multir/ )r �mappingr r r rS � s z!GenericMemcachedBackend.set_multic C s | j �|� d S r% )r" r) rD r r r r) � s z GenericMemcachedBackend.deletec C s | j �|� d S r% )r" � delete_multirN r r r rU � s z$GenericMemcachedBackend.delete_multi)r+ r, r- r. r/ r �strr �__annotations__� serializerZ deserializerr r8 r3 r; r Zmemoized_propertyrA �propertyr" rE r& rM rP rS r) rU r r r r r M s& r c s e Zd ZdZ� fdd�Z� ZS )� MemcacheArgsa� Mixin which provides support for the 'time' argument to set(), 'min_compress_len' to other methods. :param memcached_expire_time: integer, when present will be passed as the ``time`` parameter to the ``set`` method. This is used to set the memcached expiry time for a value. .. note:: This parameter is **different** from Dogpile's own ``expiration_time``, which is the number of seconds after which Dogpile will consider the value to be expired. When Dogpile considers a value to be expired, it **continues to use the value** until generation of a new value is complete, when using :meth:`.CacheRegion.get_or_create`. Therefore, if you are setting ``memcached_expire_time``, you'll want to make sure it is greater than ``expiration_time`` by at least enough seconds for new values to be generated, else the value won't be available during a regeneration, forcing all threads to wait for a regeneration each time a value expires. :param min_compress_len: Threshold length to kick in auto-compression of the value using the compressor c sT |� dd�| _i | _d|v r*|d | jd< d|v r@|d | jd< tt| ��|� d S )N�min_compress_lenr �memcached_expire_timer )r& r[ r/ �superrZ r r4 �� __class__r r r � s � zMemcacheArgs.__init__)r+ r, r- r. r � __classcell__r r r^ r rZ � s rZ c s0 e Zd ZdZ� fdd�Zdd� Zdd� Z� ZS )r a� A backend for the `pylibmc <http://sendapatch.se/projects/pylibmc/index.html>`_ memcached client. A configuration illustrating several of the optional arguments described in the pylibmc documentation:: from dogpile.cache import make_region region = make_region().configure( 'dogpile.cache.pylibmc', expiration_time = 3600, arguments = { 'url':["127.0.0.1"], 'binary':True, 'behaviors':{"tcp_nodelay": True,"ketama":True} } ) Arguments accepted here include those of :class:`.GenericMemcachedBackend`, as well as those below. :param binary: sets the ``binary`` flag understood by ``pylibmc.Client``. :param behaviors: a dictionary which will be passed to ``pylibmc.Client`` as the ``behaviors`` parameter. :param min_compress_len: Integer, will be passed as the ``min_compress_len`` parameter to the ``pylibmc.Client.set`` method. c s0 |� dd�| _|� di �| _tt| ��|� d S )N�binaryF� behaviors)r& ra rb r] r r r4 r^ r r r s zPylibmcBackend.__init__c C s dd l a d S r6 )�pylibmcr7 r r r r3 s zPylibmcBackend._importsc C s t j| j| j| jd�S )N)ra rb )rc �Clientr0 ra rb r7 r r r r; s �z PylibmcBackend._create_client�r+ r, r- r. r r3 r; r` r r r^ r r � s ! r c s0 e Zd ZdZ� fdd�Zdd� Zdd� Z� ZS )r aa A backend using the standard `Python-memcached <http://www.tummy.com/Community/software/ python-memcached/>`_ library. Example:: from dogpile.cache import make_region region = make_region().configure( 'dogpile.cache.memcached', expiration_time = 3600, arguments = { 'url':"127.0.0.1:11211" } ) :param dead_retry: Number of seconds memcached server is considered dead before it is tried again. Will be passed to ``memcache.Client`` as the ``dead_retry`` parameter. .. versionchanged:: 1.1.8 Moved the ``dead_retry`` argument which was erroneously added to "set_parameters" to be part of the Memcached connection arguments. :param socket_timeout: Timeout in seconds for every call to a server. Will be passed to ``memcache.Client`` as the ``socket_timeout`` parameter. .. versionchanged:: 1.1.8 Moved the ``socket_timeout`` argument which was erroneously added to "set_parameters" to be part of the Memcached connection arguments. c s0 |� dd�| _|� dd�| _tt| ��|� d S )N� dead_retry� �socket_timeoutr )r& rf rh r] r r r4 r^ r r r G s zMemcachedBackend.__init__c C s dd l a d S r6 )�memcacher7 r r r r3 L s zMemcachedBackend._importsc C s t j| j| j| jd�S )N)rf rh )ri rd r0 rf rh r7 r r r r; P s �z MemcachedBackend._create_clientre r r r^ r r # s # r c s8 e Zd ZdZ� fdd�Zdd� Zdd� Zdd � Z� ZS ) r ax A backend for the `python-binary-memcached <https://github.com/jaysonsantos/ python-binary-memcached>`_ memcached client. This is a pure Python memcached client which includes security features like SASL and SSL/TLS. SASL is a standard for adding authentication mechanisms to protocols in a way that is protocol independent. A typical configuration using username/password:: from dogpile.cache import make_region region = make_region().configure( 'dogpile.cache.bmemcached', expiration_time = 3600, arguments = { 'url':["127.0.0.1"], 'username':'scott', 'password':'tiger' } ) A typical configuration using tls_context:: import ssl from dogpile.cache import make_region ctx = ssl.create_default_context(cafile="/path/to/my-ca.pem") region = make_region().configure( 'dogpile.cache.bmemcached', expiration_time = 3600, arguments = { 'url':["127.0.0.1"], 'tls_context':ctx, } ) For advanced ways to configure TLS creating a more complex tls_context visit https://docs.python.org/3/library/ssl.html Arguments which can be passed to the ``arguments`` dictionary include: :param username: optional username, will be used for SASL authentication. :param password: optional password, will be used for SASL authentication. :param tls_context: optional TLS context, will be used for TLS connections. .. versionadded:: 1.0.2 c s> |� dd �| _|� dd �| _|� dd �| _tt| ��|� d S )N�username�password� tls_context)r& rj rk rl r] r r r4 r^ r r r � s zBMemcachedBackend.__init__c C s dd l a d S r6 )� bmemcachedr7 r r r r3 � s zBMemcachedBackend._importsc C s t j| j| j| j| jd�S )N)rj rk rl )rm rd r0 rj rk rl r7 r r r r; � s �z BMemcachedBackend._create_clientc C s |D ]}| � |� qdS )z<python-binary-memcached api does not implements delete_multiN)r) )r rO r r r r rU � s z BMemcachedBackend.delete_multi) r+ r, r- r. r r3 r; rU r` r r r^ r r X s : r c s0 e Zd ZdZ� fdd�Zdd� Zdd� Z� ZS )r aW A backend for the `pymemcache <https://github.com/pinterest/pymemcache>`_ memcached client. A comprehensive, fast, pure Python memcached client .. versionadded:: 1.1.2 pymemcache supports the following features: * Complete implementation of the memcached text protocol. * Configurable timeouts for socket connect and send/recv calls. * Access to the "noreply" flag, which can significantly increase the speed of writes. * Flexible, simple approach to serialization and deserialization. * The (optional) ability to treat network and memcached errors as cache misses. dogpile.cache uses the ``HashClient`` from pymemcache in order to reduce API differences when compared to other memcached client drivers. This allows the user to provide a single server or a list of memcached servers. Arguments which can be passed to the ``arguments`` dictionary include: :param tls_context: optional TLS context, will be used for TLS connections. A typical configuration using tls_context:: import ssl from dogpile.cache import make_region ctx = ssl.create_default_context(cafile="/path/to/my-ca.pem") region = make_region().configure( 'dogpile.cache.pymemcache', expiration_time = 3600, arguments = { 'url':["127.0.0.1"], 'tls_context':ctx, } ) .. seealso:: `<https://docs.python.org/3/library/ssl.html>`_ - additional TLS documentation. :param serde: optional "serde". Defaults to ``pymemcache.serde.pickle_serde``. :param default_noreply: defaults to False. When set to True this flag enables the pymemcache "noreply" feature. See the pymemcache documentation for further details. :param socket_keepalive: optional socket keepalive, will be used for TCP keepalive configuration. Use of this parameter requires pymemcache 3.5.0 or greater. This parameter accepts a `pymemcache.client.base.KeepAliveOpts <https://pymemcache.readthedocs.io/en/latest/apidoc/pymemcache.client.base.html#pymemcache.client.base.KeepaliveOpts>`_ object. A typical configuration using ``socket_keepalive``:: from pymemcache import KeepaliveOpts from dogpile.cache import make_region # Using the default keepalive configuration socket_keepalive = KeepaliveOpts() region = make_region().configure( 'dogpile.cache.pymemcache', expiration_time = 3600, arguments = { 'url':["127.0.0.1"], 'socket_keepalive': socket_keepalive } ) .. versionadded:: 1.1.4 - added support for ``socket_keepalive``. :param enable_retry_client: optional flag to enable retry client mechanisms to handle failure. Defaults to False. When set to ``True``, the :paramref:`.PyMemcacheBackend.retry_attempts` parameter must also be set, along with optional parameters :paramref:`.PyMemcacheBackend.retry_delay`. :paramref:`.PyMemcacheBackend.retry_for`, :paramref:`.PyMemcacheBackend.do_not_retry_for`. .. seealso:: `<https://pymemcache.readthedocs.io/en/latest/getting_started.html#using-the-built-in-retrying-mechanism>`_ - in the pymemcache documentation .. versionadded:: 1.1.4 :param retry_attempts: how many times to attempt an action with pymemcache's retrying wrapper before failing. Must be 1 or above. Defaults to None. .. versionadded:: 1.1.4 :param retry_delay: optional int|float, how many seconds to sleep between each attempt. Used by the retry wrapper. Defaults to None. .. versionadded:: 1.1.4 :param retry_for: optional None|tuple|set|list, what exceptions to allow retries for. Will allow retries for all exceptions if None. Example: ``(MemcacheClientError, MemcacheUnexpectedCloseError)`` Accepts any class that is a subclass of Exception. Defaults to None. .. versionadded:: 1.1.4 :param do_not_retry_for: optional None|tuple|set|list, what exceptions should be retried. Will not block retries for any Exception if None. Example: ``(IOError, MemcacheIllegalInputError)`` Accepts any class that is a subclass of Exception. Defaults to None. .. versionadded:: 1.1.4 :param hashclient_retry_attempts: Amount of times a client should be tried before it is marked dead and removed from the pool in the HashClient's internal mechanisms. .. versionadded:: 1.1.5 :param hashclient_retry_timeout: Time in seconds that should pass between retry attempts in the HashClient's internal mechanisms. .. versionadded:: 1.1.5 :param dead_timeout: Time in seconds before attempting to add a node back in the pool in the HashClient's internal mechanisms. .. versionadded:: 1.1.5 :param memcached_expire_time: integer, when present will be passed as the ``time`` parameter to the ``set`` method. This is used to set the memcached expiry time for a value. .. note:: This parameter is **different** from Dogpile's own ``expiration_time``, which is the number of seconds after which Dogpile will consider the value to be expired. When Dogpile considers a value to be expired, it **continues to use the value** until generation of a new value is complete, when using :meth:`.CacheRegion.get_or_create`. Therefore, if you are setting ``memcached_expire_time``, you'll want to make sure it is greater than ``expiration_time`` by at least enough seconds for new values to be generated, else the value won't be available during a regeneration, forcing all threads to wait for a regeneration each time a value expires. .. versionadded:: 1.3.3 c s t � �|� |�dtjj�| _|�dd�| _|�dd �| _|�dd �| _|�dd�| _ |�dd �| _ |�dd �| _ |�d d �| _ |�d d �| _ |�d d �| _|�d d�| _|�dd�| _| j d us�| j d us�| j d us�| j d ur�| j s�t�d� i | _d|v �r|d | jd< d S )N�serde�default_noreplyFrl �socket_keepalive�enable_retry_client�retry_attempts� retry_delay� retry_for�do_not_retry_for�hashclient_retry_attemptsr �hashclient_retry_timeoutr Zhashclient_dead_timeout�< z=enable_retry_client is not set; retry options will be ignoredr\ Zexpire)r] r r& � pymemcachern Z pickle_serdero rl rp rq rr rs rt ru rv rw � dead_timeout�warnings�warnr/ r4 r^ r r r P sB �������� zPyMemcacheBackend.__init__c C s dd l a d S r6 )ry r7 r r r r3 q s zPyMemcacheBackend._importsc C sz | j | j| j| j| j| jd�}| jd ur8|�d| ji� tj j j | j fi |��}| j rvtj jj|| j| j| j| jd�S |S )N)rn ro rl rr Z retry_timeoutrz rp )Zattemptsrs rt ru )rn ro rl rv rw rz rp �updatery r" �hashZ HashClientr0 rq ZretryingZRetryingClientrr rs rt ru )r �_kwargsr" r r r r; u s& � �z PyMemcacheBackend._create_clientre r r r^ r r � s % !r )r. r r r �typingr r r{ �apir r � r � TYPE_CHECKINGrm ri rc ry �__all__r r rZ r r r r r r r r �<module> s6 !|)15S
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка