File: //home/arjun/projects/env/lib/python3.10/site-packages/redis/__pycache__/connection.cpython-310.pyc
o
$we\� �
@ s U d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZ d dl m
Z
d dl m Z m
Z
mZ d dlmZ d dlmZmZmZmZmZmZ d dlmZmZmZ dd lm Z m Z m Z m Z dd
l m!Z! dd l"m#Z#m$Z$ dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z- dd
l.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 e2r�d dl7Z7dZ8dZ9dZ:dZ;dZ<e=� Z>eee e e f e?d< e2r�e Z@ne Z@G dd� d�ZAG dd� d�ZBG dd� d�ZCG dd � d eC�ZDG d d � d eD�ZEG d d � d eC�ZFd!ZGd"d#� ZHeIeJeJeHeHeKeIeIeHd$� ZLd%d&� ZMG d'd(� d(�ZNG d)d*� d*eN�ZOdS )+� N)�abstractmethod)�chain)�Empty�Full� LifoQueue)�time)�Any�Callable�List�Optional�Type�Union)�parse_qs�unquote�urlparse� )�Encoder�_HiredisParser� _RESP2Parser� _RESP3Parser)� NoBackoff)�CredentialProvider�"UsernamePasswordCredentialProvider)�AuthenticationError�$AuthenticationWrongNumberOfArgsError�ChildDeadlockedError�ConnectionError� DataError�
RedisError�
ResponseError� TimeoutError)�Retry)�CRYPTOGRAPHY_AVAILABLE�HIREDIS_AVAILABLE�HIREDIS_PACK_AVAILABLE�
SSL_AVAILABLE�get_lib_version� str_if_bytes� *� $s
� � �
DefaultParserc @ s e Zd Zdefdd�ZdS )�HiredisRespSerializer�argsc G s� g }t |d t�rt|d �� �� �|dd� }nd|d v r.t|d �� �|dd� }z |�t�|�� W |S tyN t �
� \}}}t |�� |��w ��2Pack a series of arguments into the Redis protocolr r N� )
�
isinstance�str�tuple�encode�split�append�hiredis� pack_command� TypeError�sys�exc_infor �with_traceback)�selfr. �output�_�value� traceback� rC �I/home/arjun/projects/env/lib/python3.10/site-packages/redis/connection.py�pack: s " ��zHiredisRespSerializer.packN)�__name__�
__module__� __qualname__r
rE rC rC rC rD r- 9 s r- c @ s e Zd Zddd�Zdd� ZdS )�PythonRespSerializer�returnNc C s || _ || _d S �N)�_buffer_cutoffr5 )r> �
buffer_cutoffr5 rC rC rD �__init__L s
z PythonRespSerializer.__init__c G s g }t |d t�rt|d �� �� �|dd� }nd|d v r.t|d �� �|dd� }t�ttt|���� t f�}| j
}t | j|�D ]>}t|�}t|�|ksZ||ksZt |t �rtt�|t
t|��� t f�}|�|� |�|� t }qEt�|t
t|��� t |t f�}qE|�|� |S r/ )r2 r3 r4 r5 r6 � SYM_EMPTY�join�SYM_STAR�len�SYM_CRLFrL �map�
memoryview�
SYM_DOLLARr7 )r> r. r? �buffrM �arg�
arg_lengthrC rC rD rE P s< " ��
��
zPythonRespSerializer.pack�rJ N)rF rG rH rN rE rC rC rC rD rI K s
rI c * @ s� e Zd ZdZdddddedddedddde� ddddd dfd
ed ee d ee
d
ee
de de de de dededee dee dee dee de e
df deeg df dee dee d eeg df f&d d �Zd d � Zed!d"� �Zd#d$� Zd%d&� Zd'd(� Zd)d*� Zd+d,� Zd-d.� Zed/d0� �Zed1d2� �Zed3d4� �Z d5d6� Z d7d8� Z d9d:� Z d;d<� Z d=d>� Z!dMd@dA�Z"dBdC� Z#dNdDdE�Z$ dOd?ddF�dGdH�Z%dIdJ� Z&dKdL� Z'dS )P�AbstractConnectionz0Manages communication to and from a Redis serverr NF�utf-8�stricti zredis-pyr+ �db�password�socket_timeout�socket_connect_timeout�retry_on_timeout�encoding�encoding_errors�decode_responses�socket_read_size�health_check_interval� client_name�lib_name� lib_version�username�retry�redis_connect_func�credential_provider�protocol�command_packerc C s� |s|r |dur t d��t�� | _|| _|
| _|| _|| _|| _|| _ || _
|| _ |du r/|}|| _ || _
|tu r;g }|rB|�t� || _|sI|rb|du rUtt� d�| _nt�|�| _| j�|� ntt� d�| _| | _d| _|| _t||| �| _ d| _ | | _ | � |
� g | _ d| _!z-zt"|�}W n t#y� t$}Y n t%y� t&d��w W |dk s�|dkr�t&d ��|| _'n|dk s�|dkr�t&d ��|| _'w | �(|�| _)dS )
a2
Initialize a new Connection.
To specify a retry policy for specific errors, first set
`retry_on_error` to a list of the error/s to retry on, then set
`retry` to a valid `Retry` object.
To retry on TimeoutError, `retry_on_timeout` can also be set to `True`.
Nz�'username' and 'password' cannot be passed along with 'credential_provider'. Please provide only one of the following arguments:
1. 'password' and (optional) 'username'
2. 'credential_provider'r r ip zprotocol must be an integerr+ � z protocol must be either 2 or 3)*r �os�getpid�pidr^ rh ri rj rn r_ rk r` ra rb �SENTINELr7 r �retry_on_errorr! r rl �copy�deepcopy�update_supported_errorsrg �next_health_checkrm r �encoder�_sock�_socket_read_size�
set_parser�_connect_callbacksrL �intr: �DEFAULT_RESP_VERSION�
ValueErrorr ro �_construct_command_packer�_command_packer)r> r^ r_ r` ra rb rv rc rd re � parser_classrf rg rh ri rj rk rl rm rn ro rp �prC rC rD rN � sh �
���zAbstractConnection.__init__c C s, d� dd� | �� D ��}| jj� d|� d�S )N�,c S s g | ] \}}|� d |� ��qS )�=rC )�.0�k�vrC rC rD �
<listcomp>� s z/AbstractConnection.__repr__.<locals>.<listcomp>�<�>)rP � repr_pieces� __class__rF )r> � repr_argsrC rC rD �__repr__� s zAbstractConnection.__repr__c C � d S rK rC �r> rC rC rD r� � � z AbstractConnection.repr_piecesc C s$ z| � � W d S ty Y d S w rK )�
disconnect� Exceptionr� rC rC rD �__del__� s
�zAbstractConnection.__del__c C s& |d ur|S t r t� S t| j| jj�S rK )r$ r- rI rL r{ r5 )r> �packerrC rC rD r� � s
z,AbstractConnection._construct_command_packerc C s( t �|�}|| jvr| j�|� d S d S rK )�weakref�
WeakMethodr r7 )r> �callback�wmrC rC rD �_register_connect_callback� s
�z-AbstractConnection._register_connect_callbackc C s. z | j �t�|�� W d S ty Y d S w rK )r �remover� r� r� )r> r� rC rC rD � _deregister_connect_callback� s
�z/AbstractConnection._deregister_connect_callbackc C s || j d�| _dS )z�
Creates a new instance of parser_class with socket size:
_socket_read_size and assigns it to the parser for the connection
:param parser_class: The required parser class
)rf N)r} �_parser)r> r� rC rC rD r~ � s z AbstractConnection.set_parserc
s� � j rdS z� j�� fdd�� fdd��}W n tjy" td�� ty4 } zt� �|���d}~ww |� _ z� j du rC� �
� n� � � � W n t yU � � � � w dd� � j
D �� _
� j
D ] }|� }|rm|� � qbdS )z5Connects to the Redis server if not already connectedNc s � � � S rK )�_connectrC r� rC rD �<lambda> s z,AbstractConnection.connect.<locals>.<lambda>c s
� � | �S rK �r� )�errorr� rC rD r� s
z Timeout connecting to serverc S s g | ]}|� r|�qS rC rC )r� �refrC rC rD r� s z.AbstractConnection.connect.<locals>.<listcomp>)r| rl �call_with_retry�socket�timeoutr �OSErrorr �_error_messagerm �
on_connectr r� r )r> �sock�er� r� rC r� rD �connect s: ���
� �
��zAbstractConnection.connectc C r� rK rC r� rC rC rD r� & r� zAbstractConnection._connectc C r� rK rC r� rC rC rD � _host_error* r� z AbstractConnection._host_errorc C r� rK rC )r> � exceptionrC rC rD r� . r� z!AbstractConnection._error_messagec C st | j �| � | j }d}| js| js| jr"| jp t| j| j�}|�� }|r\| jdvr\t| j t �r?| �
t � |j | j _ | j �| � t
|�dkrKd|d g}| jd| jdg|�R � | �� }nq|r�| jdg|�R dd i� z| �� }W n ty� | jd|d
d d � | �� }Y nw t|�d kr�td
��n:| jdvr�t| j t �r�| �
t � |j | j _ | j �| � | �d| j� | �� }|�d�| jkr�|�d�| jkr�td��| jr�| �dd| j� t| �� �d kr�td��z| jr�| �ddd| j� | �� W n ty� Y nw z| j�r| �ddd| j� | �� W n
t�y Y nw | j�r6| �d| j� t| �� �d k�r8td��dS dS )z=Initialize the connection, authenticate and select a databaseN)r+ �2r �defaultr �HELLO�AUTH� check_healthF����r� �OKz Invalid Username or Passwords proto�protozInvalid RESP version�CLIENT�SETNAMEzError setting client name�SETINFOzLIB-NAMEzLIB-VER�SELECTzInvalid Database)r� r� rn rk r_ r �get_credentialsro r2 r r~ r �EXCEPTION_CLASSESrR � send_command�
read_responser r' r �getr rh ri r rj r^ )r> �parser� auth_args�
cred_provider�response�
auth_responserC rC rD r� 2 s� �
� �
� ����z AbstractConnection.on_connectc G sx | j �� | j}d| _|du rdS t�� | jkr*z|�tj� W n t y) Y nw z|�
� W dS t y; Y dS w )z!Disconnects from the Redis serverN) r� �
on_disconnectr| rr rs rt �shutdownr� � SHUT_RDWRr� �close)r> r. � conn_sockrC rC rD r� � s
� �z AbstractConnection.disconnectc C s* | j ddd� t| �� �dkrtd��dS )z Send PING, expect PONG in return�PINGFr� �PONGz#Bad response from PING health checkN)r� r' r� r r� rC rC rD �
_send_ping� s �z AbstractConnection._send_pingc C � | � � dS )z Function to call when PING failsNr� )r> r� rC rC rD � _ping_failed� � z AbstractConnection._ping_failedc C s0 | j rt� | jkr| j�| j| j� dS dS dS )z3Check the health of the connection with a PING/PONGN)rg r rz rl r� r� r� r� rC rC rD r� � s �z AbstractConnection.check_healthTc
C s� | j s| �� |r
| �� zt|t�r|g}|D ]}| j �|� qW dS tjy3 | �� t d�� t
yg } z)| �� t |j �dkrNd|j d }}n
|j d }|j d }t
d|� d|� d���d}~w tyr | �� � w ) z2Send an already packed command to the Redis serverzTimeout writing to socketr �UNKNOWNr �Error z while writing to socket. �.N)r| r� r� r2 r3 �sendallr� r� r� r r� rR r. r �
BaseException)r> �commandr� �itemr� �errno�errmsgrC rC rD �send_packed_command� s2
�
� �z&AbstractConnection.send_packed_commandc O s" | j | jj|� |�dd�d� dS )z+Pack and send a command to the Redis serverr� Tr� N)r� r� rE r� )r> r. �kwargsrC rC rD r� � s
�z AbstractConnection.send_commandc
C s` | j }|s | �� | �� }z| j�|�W S ty/ } z| �� td|� d|j� ���d}~ww )z8Poll the socket to see if there's data that can be read.�Error while reading from z: N) r| r� r� r� �can_readr� r� r r. )r> r� r� �
host_errorr� rC rC rD r� � s ��zAbstractConnection.can_read)�disconnect_on_error� push_requestc
C s� | � � }z| jdv rts| jj||d�}n| jj|d�}W n> tjy2 |r+| �� td|� ��� t yN } z|r?| �� t
d|� d|j � ���d}~w t y[ |rZ| �� � w | j
rft� | j
| _t|t�rpz|�~w |S )z0Read the response from a previously sent command)�3rq )�disable_decodingr� )r� zTimeout reading from r� z : N)r� ro r# r� r� r� r� r� r r� r r. r� rg r rz r2 r )r> r� r� r� r� r� r� rC rC rD r� � s> ���� �
z AbstractConnection.read_responsec G s | j j|� S )r0 )r� rE )r> r. rC rC rD r9 r� z AbstractConnection.pack_commandc C s� g }g }d}| j }|D ]B}| jj|� D ]9}t|�}||ks&||ks&t|t�r4|r0|�t�|�� d}g }||ks=t|t�rC|�|� q|�|� ||7 }qq |rX|�t�|�� |S )z.Pack multiple commands into the Redis protocolr ) rL r� rE rR r2 rU r7 rO rP ) r> �commandsr? �pieces�
buffer_lengthrM �cmd�chunk�chunklenrC rC rD �
pack_commands s. �
�z AbstractConnection.pack_commands�T)r )F)(rF rG rH �__doc__ru r, r& r� r r3 �float�boolr
r r r rN r� r r� r� r� r� r� r~ r� r� r� r� r� r� r� r� r� r� r� r� r� r9 r� rC rC rC rD r[ ~ s� ������� �
� �
�����
����
�Y
#
Z
� �. r[ c sL e Zd ZdZ d� fdd� Zd d
� Zd d � Zd
d� Zdd� Z� Z S )�
Connectionz4Manages TCP communication to and from a Redis server� localhost�� FNr c s< || _ t|�| _|| _|pi | _|| _t� jdi |�� d S �NrC )�hostr� �port�socket_keepalive�socket_keepalive_options� socket_type�superrN )r> r� r� r� r� r� r� �r� rC rD rN 7 s
zConnection.__init__c C s6 d| j fd| jfd| jfg}| jr|�d| jf� |S )Nr� r� r^ rh )r� r� r^ rh r7 �r> r� rC rC rD r� G s zConnection.repr_piecesc C s d}t �| j| j| jt j�D ]k}|\}}}}}d}zDt � |||�}|�t jt jd� | j rH|�t j
t j d� | j �
� D ] \} }
|�t j| |
� q;|�| j� |�|� |�| j� |W S tyy } z| }|duro|�� W Y d} ~ qd} ~ ww |dur�|�td��)z Create a TCP socket connectionNr z)socket.getaddrinfo returned an empty list)r� � getaddrinfor� r� r� � SOCK_STREAM�
setsockopt� IPPROTO_TCP� TCP_NODELAYr� �
SOL_SOCKET� SO_KEEPALIVEr� �items�
settimeoutra r� r` r� r� ) r> �err�res�family�socktyper� � canonname�socket_addressr� r� r� r@ rC rC rD r� M s4 �
��zConnection._connectc C s | j � d| j� �S )N�:)r� r� r� rC rC rD r� v s zConnection._host_errorc C s� | � � }t|j�dkr*z
d|� d|jd � d�W S ty) d|jd � � Y S w zd|jd � d|� d |jd � d�W S tyN d|jd � � Y S w )
Nr zError connecting to z. r r� zConnection Error: r� z connecting to �. )r� rR r. �AttributeError�r> r� r� rC rC rD r� y s&
� ���� �zConnection._error_message)r� r� FNr �
rF rG rH r� rN r� r� r� r� �
__classcell__rC rC r� rD r� 4 s �)r� c sF e Zd ZdZ d � fdd� Z� fdd�Z� ZS )
�
SSLConnectionz�Manages SSL connections to and from the Redis server(s).
This class extends the Connection class, adding SSL functionality, and making
use of ssl.SSLContext (https://docs.python.org/3/library/ssl.html#ssl.SSLContext)
N�requiredFc
s� t std��|| _|| _|du rtj}n t|t�r1tjtjtj d�}||vr-td|� ���|| }|| _
|| _ || _ || _
|| _|| _| | _|
| _| | _| | _t� jdi |
�� dS )ae Constructor
Args:
ssl_keyfile: Path to an ssl private key. Defaults to None.
ssl_certfile: Path to an ssl certificate. Defaults to None.
ssl_cert_reqs: The string value for the SSLContext.verify_mode (none, optional, required). Defaults to "required".
ssl_ca_certs: The path to a file of concatenated CA certificates in PEM format. Defaults to None.
ssl_ca_data: Either an ASCII string of one or more PEM-encoded certificates or a bytes-like object of DER-encoded certificates.
ssl_check_hostname: If set, match the hostname during the SSL handshake. Defaults to False.
ssl_ca_path: The path to a directory containing several CA certificates in PEM format. Defaults to None.
ssl_password: Password for unlocking an encrypted private key. Defaults to None.
ssl_validate_ocsp: If set, perform a full ocsp validation (i.e not a stapled verification)
ssl_validate_ocsp_stapled: If set, perform a validation on a stapled ocsp response
ssl_ocsp_context: A fully initialized OpenSSL.SSL.Context object to be used in verifying the ssl_ocsp_expected_cert
ssl_ocsp_expected_cert: A PEM armoured string containing the expected certificate to be returned from the ocsp verification service.
Raises:
RedisError
z$Python wasn't built with SSL supportN)�none�optionalr z+Invalid SSL Certificate Requirements Flag: rC )r% r �keyfile�certfile�ssl� CERT_NONEr2 r3 �
CERT_OPTIONAL�
CERT_REQUIRED� cert_reqs�ca_certs�ca_data�ca_path�check_hostname�certificate_password�ssl_validate_ocsp�ssl_validate_ocsp_stapled�ssl_ocsp_context�ssl_ocsp_expected_certr� rN )r> � ssl_keyfile� ssl_certfile�
ssl_cert_reqs� ssl_ca_certs� ssl_ca_data�ssl_check_hostname� ssl_ca_path� ssl_passwordr" r# r$ r% r� � CERT_REQSr� rC rD rN � s6 $
��zSSLConnection.__init__c
s� t � �� }t�� }| j|_| j|_| js| jr"|j | j| j| j
d� | j dus1| j dus1| j
dur<|j| j | j | j
d� |j|| jd�}| jdu rQtdu rQtd��| jr[| jr[td��| jr�d dl}d
d lm} | jdu r�|j�|jj�}|� | j� |� | j� n| j}|� || j � |j� |t!�!� �}|�"� |�#| j| j$f� |�%� |�&� |S | jdu r�tr�d
d lm'} ||| j| j$| j �} | �(� r�|S t)d
��|S )z Wrap the socket with SSL support)r r r_ N)�cafile�capath�cadata)�server_hostnameTFz cryptography is not installed.zKEither an OCSP staple or pure OCSP connection must be validated - not both.r r )�ocsp_staple_verifier)� OCSPVerifierzocsp validation error)*r� r� r �create_default_contextr r � verify_moder r �load_cert_chainr! r r r �load_verify_locations� wrap_socketr� r" r" r r# �OpenSSL�ocspr3 r$ �SSL�Context�
SSLv23_METHOD�use_certificate_file�use_privatekey_file�set_ocsp_client_callbackr% r� r� � request_ocspr� r� � do_handshaker� r4 �is_validr )
r> r� �context�sslsockr: r3 �
staple_ctx�conr4 �or� rC rD r� � s^
�
� �
� zSSLConnection._connect) NNr NNFNNFFNN)rF rG rH r� rN r� r rC rC r� rD r � s �Br c sB e Zd ZdZd� fdd� Zdd� Zdd � Zd
d � Zd d
� Z� Z S )�UnixDomainSocketConnectionz4Manages UDS communication to and from a Redis server� Nc s" || _ || _t� jdi |�� d S r� )�pathr` r� rN )r> rL r` r� r� rC rD rN s z#UnixDomainSocketConnection.__init__c C s. d| j fd| jfg}| jr|�d| jf� |S )NrL r^ rh )rL r^ rh r7 r� rC rC rD r� # s z&UnixDomainSocketConnection.repr_piecesc C s8 t � t jt j�}|�| j� |�| j� |�| j� |S )z&Create a Unix domain socket connection)r� �AF_UNIXr� r ra r� rL r` )r> r� rC rC rD r� ) s
z#UnixDomainSocketConnection._connectc C s | j S rK )rL r� rC rC rD r� 1 s z&UnixDomainSocketConnection._host_errorc C sR | � � }t|j�dkrd|� d|jd � d�S d|jd � d|� d|jd � d�S )Nr z!Error connecting to unix socket: r
r r� r� z connecting to unix socket: )r� rR r. r rC rC rD r� 4 s ����z)UnixDomainSocketConnection._error_message)rK Nr rC rC r� rD rJ s rJ )�0�F�FALSE�N�NOc C s6 | d u s| dkr
d S t | t�r| �� tv rdS t| �S )NrK F)r2 r3 �upper�
FALSE_STRINGSr� )rA rC rC rD �to_boolF s
rU ) r^ r` ra r� rb rv �max_connectionsrg r+ c
C s� | � d�s| � d�s| � d�std��t| �} i }t| j��� D ]7\}}|rWt|�dkrWt|d �}t� |�}|rSz||�||< W q t
tfyR td|� d���w |||< q | j rbt| j �|d< | j rlt| j �|d < | j
d
kr�| jr{t| j�|d < t|d < |S | jr�t| j�|d
< | jr�t| j�|d< | jr�d|vr�ztt| j��dd��|d< W n ttfy� Y nw | j
dkr�t|d < |S )Nzredis://z rediss://zunix://zRRedis URL must specify one of the following schemes (redis://, rediss://, unix://)r zInvalid value for `z` in connection URL.rk r_ �unixrL �connection_classr� r� r^ �/rK �rediss)�
startswithr� r r �queryr rR r �URL_QUERY_ARGUMENT_PARSERSr� r: rk r_ �schemerL rJ �hostnamer� r� �replacer r )�urlr� �namerA r� rC rC rD � parse_url[ sZ ����
��
� �
rc c @ s� e Zd ZdZedd� �Zedfdee fdd�Z de
e
ffd d
�Z d&d d �Z d&d
d�Z
de
ddfdd�Zdefdd�Zd'dd�Zd(dd�Zdddefdd�Zd)d eddfd d �Zd&d d!�Zd*d$d%�ZdS )+�ConnectionPoola�
Create a connection pool. ``If max_connections`` is set, then this
object raises :py:class:`~redis.exceptions.ConnectionError` when the pool's
limit is reached.
By default, TCP connections are created unless ``connection_class``
is specified. Use class:`.UnixDomainSocketConnection` for
unix sockets.
Any additional keyword arguments are passed to the constructor of
``connection_class``.
c K s4 t |�}d|v r|d |d< |�|� | di |��S )a
Return a connection pool configured from the given URL.
For example::
redis://[[username]:[password]]@localhost:6379/0
rediss://[[username]:[password]]@localhost:6379/0
unix://[username@]/path/to/socket.sock?db=0[&password=password]
Three URL schemes are supported:
- `redis://` creates a TCP socket connection. See more at:
<https://www.iana.org/assignments/uri-schemes/prov/redis>
- `rediss://` creates a SSL wrapped TCP socket connection. See more at:
<https://www.iana.org/assignments/uri-schemes/prov/rediss>
- ``unix://``: creates a Unix Domain Socket connection.
The username, password, hostname, path and all querystring values
are passed through urllib.parse.unquote in order to replace any
percent-encoded values with their corresponding characters.
There are several ways to specify a database number. The first value
found will be used:
1. A ``db`` querystring option, e.g. redis://localhost?db=0
2. If using the redis:// or rediss:// schemes, the path argument
of the url, e.g. redis://localhost/0
3. A ``db`` keyword argument to this function.
If none of these options are specified, the default db=0 is used.
All querystring options are cast to their appropriate Python types.
Boolean arguments can be specified with string values "True"/"False"
or "Yes"/"No". Values that cannot be properly cast cause a
``ValueError`` to be raised. Once parsed, the querystring arguments
and keyword arguments are passed to the ``ConnectionPool``'s
class initializer. In the case of conflicting arguments, querystring
arguments always win.
rX NrC )rc �update)�clsra r� � url_optionsrC rC rD �from_url� s
)
zConnectionPool.from_urlNrV c K sJ |pd}t |t�r
|dk rtd��|| _|| _|| _t�� | _| � � d S )Nl r z,"max_connections" must be a positive integer)
r2 r� r� rX �connection_kwargsrV � threading�Lock�
_fork_lock�reset)r> rX rV ri rC rC rD rN � s
zConnectionPool.__init__rJ c C s( t | �j� dt| jdi | j���� d�S )Nr� r� rC )�typerF �reprrX ri r� rC rC rD r� � s ��zConnectionPool.__repr__c C s, t �� | _d| _g | _t� | _t�� | _ d S )Nr )
rj rk �_lock�_created_connections�_available_connections�set�_in_use_connectionsrr rs rt r� rC rC rD rm � s
zConnectionPool.resetc C sl | j t�� kr4| jjdd�}|st�z| j t�� kr&| �� W | j�� d S W | j�� d S | j�� w d S )N� )r� )rt rr rs rl �acquirer rm �release)r> �acquiredrC rC rD � _checkpid s #
��zConnectionPool._checkpid� command_namer� c O s� | � � | j�# z| j�� }W n
ty | �� }Y nw | j�|� W d � n1 s-w Y z.|�� z |� � r@t
d��W W |S t
t fy` |� � |�� |� � r\t
d��Y W |S w t
ym | �|� � w )z Get a connection from the poolN�Connection has data�Connection not ready)ry rp rr �pop�
IndexError�make_connectionrt �addr� r� r r� r� r� rw �r> rz �keys�options�
connectionrC rC rD �get_connection2 s8 � ��
���
�z ConnectionPool.get_connectionc C s, | j }t|�dd�|�dd�|�dd�d�S )z,Return an encoder based on encoding settingsrc r\ rd r] re F)rc rd re )ri r r� )r> r� rC rC rD � get_encoderS s
�zConnectionPool.get_encoderc C s4 | j | jkr
td��| j d7 _ | jdi | j��S )zCreate a new connectionzToo many connectionsr NrC )rq rV r rX ri r� rC rC rD r \ s z ConnectionPool.make_connectionr� c C s� | � � | j�; z| j�|� W n ty Y nw | �|�r&| j�|� n| jd8 _|� � W d � dS W d � dS 1 sEw Y dS )z(Releases the connection back to the poolr N)
ry rp rt r� �KeyError�owns_connectionrr r7 rq r� �r> r� rC rC rD rw c s �
� "�zConnectionPool.releasec C s |j | j kS rK )rt r� rC rC rD r� x s z ConnectionPool.owns_connectionT�inuse_connectionsc C s` | � � | j� |rt| j| j�}n| j}|D ]}|�� qW d � dS 1 s)w Y dS )z�
Disconnects connections in the pool
If ``inuse_connections`` is True, disconnect connections that are
current in use, potentially by other threads. Otherwise only disconnect
connections that are idle in the pool.
N)ry rp r rr rt r� )r> r� � connectionsr� rC rC rD r� { s �
�"�zConnectionPool.disconnectc C r� )z-Close the pool, disconnecting all connectionsNr� r� rC rC rD r� � r� zConnectionPool.closerl r! c C s8 | j �d|i� | jD ]}||_q | jD ]}||_qd S )Nrl )ri re rr rl rt )r> rl �connrC rC rD � set_retry� s
�zConnectionPool.set_retryrZ )rJ r� )r� r� rJ Nr� )rl r! rJ N)rF rG rH r� � classmethodrh r� r r� rN r3 r� rm ry r� r r� r rw r� r� r� r� r� rC rC rC rD rd � s(
2�
�
/!
rd c sR e Zd ZdZddeef� fdd� Zdd� Zdd � Zd
d � Z d d
� Z
dd� Z � Z S )�BlockingConnectionPoola
Thread-safe blocking connection pool::
>>> from redis.client import Redis
>>> client = Redis(connection_pool=BlockingConnectionPool())
It performs the same function as the default
:py:class:`~redis.ConnectionPool` implementation, in that,
it maintains a pool of reusable connections that can be shared by
multiple redis clients (safely across threads if required).
The difference is that, in the event that a client tries to get a
connection from the pool when all of connections are in use, rather than
raising a :py:class:`~redis.ConnectionError` (as the default
:py:class:`~redis.ConnectionPool` implementation does), it
makes the client wait ("blocks") for a specified number of seconds until
a connection becomes available.
Use ``max_connections`` to increase / decrease the pool size::
>>> pool = BlockingConnectionPool(max_connections=10)
Use ``timeout`` to tell it either how many seconds to wait for a connection
to become available, or to block forever:
>>> # Block forever.
>>> pool = BlockingConnectionPool(timeout=None)
>>> # Raise a ``ConnectionError`` after five seconds if a connection is
>>> # not available.
>>> pool = BlockingConnectionPool(timeout=5)
�2 � c s( || _ || _t� jd||d�|�� d S )N)rX rV rC )� queue_classr� r� rN )r> rV r� rX r� ri r� rC rD rN � s �
�z BlockingConnectionPool.__init__c C sJ | � | j�| _ z| j�d � W n ty Y nw qg | _t�� | _d S rK ) r� rV �pool�
put_nowaitr � _connectionsrr rs rt r� rC rC rD rm � s �� z BlockingConnectionPool.resetc C s" | j di | j��}| j�|� |S )zMake a fresh connection.NrC )rX ri r� r7 r� rC rC rD r � s z&BlockingConnectionPool.make_connectionc O s� | � � d}z | jjd| jd�}W n ty td��w |du r%| �� }z.|�� z |�� r3td��W W |S tt fyS |�
� |�� |�� rOtd��Y W |S w t y` | � |� � w )a7
Get a connection, blocking for ``self.timeout`` until a connection
is available from the pool.
If the connection returned is ``None`` then creates a new connection.
Because we use a last-in first-out queue, the existing connections
(having been returned to the pool after the initial ``None`` values
were added) will be returned before ``None`` values. This means we only
create new connections when we need to, i.e.: the actual number of
connections will only increase in response to demand.
NT)�blockr� zNo connection available.r{ r| )
ry r� r� r� r r r r� r� r� r� r� rw r� rC rC rD r� � s8
�� ���
�z%BlockingConnectionPool.get_connectionc C sR | � � | �|�s|�� | j�d� dS z | j�|� W dS ty( Y dS w )z)Releases the connection back to the pool.N)ry r� r� r� r� r r� rC rC rD rw s
�z BlockingConnectionPool.releasec C s | � � | jD ]}|�� qdS )z(Disconnects all connections in the pool.N)ry r� r� r� rC rC rD r� 4 s
�z!BlockingConnectionPool.disconnect)
rF rG rH r� r� r rN rm r r� rw r� r rC rC r� rD r� � s #�4r� )Prw rr r� r r; rj r� �abcr � itertoolsr �queuer r r r �typingr r r
r r r
� urllib.parser r r �_parsersr r r r �backoffr � credentialsr r �
exceptionsr r r r r r r r rl r! �utilsr" r# r$ r% r& r' r8 rQ rV rS rO r� �objectru �__annotations__r, r- rI r[ r� r rJ rT rU r� r� �listr] rc rd r� rC rC rC rD �<module> st
(
3 9[
( �
9