o Z>m?Z?m@Z@ddlAmBZBddlCmDZDddlEmFZFddlGmHZHmIZIddlJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRddlSmTZTddlUmVZVddlWmXZXmYZYddlZm[Z[m\Z\m]Z]m^Z^m_Z_dZ`dZadZbdZcdZdGd d!d!ejeZfefjgZheee^e_e]feid"<eXrCe]Zjne^ZjGd#d$d$eZkGd%d&d&eZleekelfZmGd'd(d(ZnGd)d*d*enZoGd+d,d,eoZpGd-d.d.ZqGd/d0d0enZrd1Zsd2eetfd3d4Zud5d6Zveewexexeueueweweuevevexd7 Zyeezed8e{ffeid9<Gd:d;d;edezd2e|fd?d@Z}edAdBdCZ~GdDdBdBZGdEdFdFeZdS)GN)abstractmethod)chain)MappingProxyType) AnyCallableIterableListMappingOptionalProtocolSetTupleType TypedDictTypeVarUnion) ParseResultparse_qsunquoteurlparse)DB_CLIENT_CONNECTION_POOL_NAMEDB_CLIENT_CONNECTION_STATEAttributeBuilderConnectionState get_pool_name) SSL_AVAILABLE) SSLContext TLSVersion VerifyFlags)TokenInterface) DriverInforesolve_driver_info)!AsyncAfterConnectionReleasedEventEventDispatcher)deprecated_argsformat_error_message) r')timeout)record_connection_closedrecord_connection_countrecord_connection_create_timerecord_connection_wait_timerecord_error_count)Retry) NoBackoff)DEFAULT_RESP_VERSION)CredentialProvider"UsernamePasswordCredentialProvider)AuthenticationError$AuthenticationWrongNumberOfArgsErrorConnectionError DataErrorMaxConnectionsError RedisError ResponseError TimeoutError) CloseReason) EncodableT)HIREDIS_AVAILABLE str_if_bytes) BaseParserEncoder_AsyncHiredisParser_AsyncRESP2Parser_AsyncRESP3Parser*$s  c@seZdZeZdS) _SentinelN)__name__ __module__ __qualname__objectsentinelrOrOW/root/parts/websockify/install/lib/python3.10/site-packages/redis/asyncio/connection.pyrIds rI DefaultParserc@eZdZdddZdS)ConnectCallbackProtocol connectionAbstractConnectioncCdSNrOselfrTrOrOrP__call__ssz ConnectCallbackProtocol.__call__NrTrUrJrKrLrZrOrOrOrPrSrrSc@rR)AsyncConnectCallbackProtocolrTrUcdSrWrOrXrOrOrPrZwsz%AsyncConnectCallbackProtocol.__call__Nr[r\rOrOrOrPr^vr]r^c1@s"eZdZdZdZeddgddddddd ed d d ed ddddddddedd ddde e e fde e de e de e dede eefde de dedeede de de e de e de e de ede e de ede ed eed!e ed"e e d#e ef.d$d%Zefd&efd'd(Zd)d*Zd+d,Zed-d.Ze d/d0Z!d1d2Z"d3d4Z#deed5dfd6d7Z$d8d9Z% :d~d;edZ&d?d@Z'dAdBZ(dCdDZ)edEdFZ*ed5e fdGdHZ+dIe,d5e fdJdKZ-dLdMZ.ddNdOZ/dd;ed5dfdPdQZ0   ddRedSe e1dTe e dUed5df dVdWZ2dXdYZ3dZd[Z4d\d]Z5d^e6e7d5dfd_d`Z8 :dd^e e7e e6e7fd;ed5dfdadbZ9dcedded5dfdedfZ:dgdhZ; dd:d didjedke e dledme efdndoZe7fdpdqZ?dre6e6e=d5e>e7fdsdtZ@dudvZAdwdxZBdyeCfdzd{ZDd|d}ZEdS)rUz0Manages communication to and from a Redis server)dbusername client_namelib_name lib_versioncredential_providerpasswordsocket_timeoutsocket_connect_timeoutredis_connect_funcretry_on_timeoutretry_on_errorhealth_check_intervalnext_health_checklast_active_atencoder ssl_contextprotocol_reader_writer_parser_connect_callbacks_buffer_cutoff_lock_socket_read_size__dict__rcrdzbUse 'driver_info' parameter instead. lib_name and lib_version will be removed in a future version.) args_to_warnreasonrNFutf-8strictir)r`rfrgrhrjrkencodingencoding_errorsdecode_responses parser_classsocket_read_sizerlrbrcrd driver_inforaretryri encoder_classrerqevent_dispatcherr`rfrgrhrjrkr~rrrrrlrbrrarrirrerqrcCs|s|r |dur td|durt|_n||_||_| |_t||||_||_||_||_ ||_ |dur7|}||_ ||_ |t urCg}|rV|t|tj|tj||_|s]|rt|sgttd|_nt||_|j|nttd|_| |_d|_|||| |_||_d|_d|_| |_ |!| g|_"d|_#d|_$d|_%zt&|}Wnt'yt(}Ynt)yt*dw|d ks|d krt*d ||_+dS) ag Initialize a new async Connection. Parameters ---------- driver_info : DriverInfo, optional Driver metadata for CLIENT SETINFO. If provided, lib_name and lib_version are ignored. If not provided, a DriverInfo will be created from lib_name and lib_version (or defaults if those are also None). lib_name : str, optional **Deprecated.** Use driver_info instead. Library name for CLIENT SETINFO. lib_version : str, optional **Deprecated.** Use driver_info instead. Library version for CLIENT SETINFO. 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'ripFzprotocol must be an integerrr'zprotocol must be either 2 or 3),r7r$_event_dispatcherr`rbr"rrerfrargrhrjSENTINELappendr;socketr)asynciorkr/r0rcopydeepcopyupdate_supported_errorsrlrmrorirrrsrx set_parserrurv_re_auth_token_should_reconnectint TypeErrorr1 ValueErrorr6rq)rYr`rfrgrhrjrkr~rrrrrlrbrcrdrrarrirrerqrprOrOrP__init__sj.          zAbstractConnection.__init__ _warningscCsRt|ddr'|jd|t|dz t|WdSty&YdSwdS)Nrszunclosed Connection )source)getattrwarnResourceWarningrget_running_loop_close RuntimeError)rYrrOrOrP__del__ s   zAbstractConnection.__del__cCs$|jr|jd|_|_dSdS)zR Internal method to silently close the connection without waiting N)rscloserrrYrOrOrPrs zAbstractConnection._closecCs8ddd|D}d|jjd|jjd|dS)N,css"|] \}}|d|VqdS)=NrO.0kvrOrOrP &s z.AbstractConnection.__repr__..<.(z)>)join repr_pieces __class__rKrJ)rY repr_argsrOrOrP__repr__%s zAbstractConnection.__repr__cCrVrWrOrrOrOrPr)zAbstractConnection.repr_piecescCs|jduo |jduSrW)rrrsrrOrOrP is_connected-szAbstractConnection.is_connectedcCs(t|}||jvr|j|dSdS)a^ Register a callback to be called when the connection is established either initially or reconnected. This allows listeners to issue commands that are ephemeral to the connection, for example pub/sub subscription or key tracking. The callback must be a _method_ and will be kept as a weak reference. N)weakref WeakMethodrur)rYcallbackwmrOrOrPregister_connect_callback1s  z,AbstractConnection.register_connect_callbackcCs.z |jt|WdStyYdSw)z De-register a previously registered callback. It will no-longer receive notifications on connection events. Calling this is not required when the listener goes away, since the callbacks are kept as weak methods. N)ruremoverrr)rYrrOrOrPderegister_connect_callback=s  z.AbstractConnection.deregister_connect_callbackreturncCs||jd|_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 )rN)rxrt)rYrrOrOrPrHszAbstractConnection.set_parsercs.jjfddfddddIdHdS)z5Connects to the Redis server if not already connectedcsjdddS)NTF) check_healthretry_socket_connect)connect_check_healthrOrrOrPUz,AbstractConnection.connect..csj||dSNerror failure_count disconnectrrrOrPrXrTwith_failure_countN)rcall_with_retryrrOrrPconnectPs   zAbstractConnection.connectTrrc sjrdSdfdd}z|r#jjfdd|ddIdHnIdHWnytjy4tjtjfybtd}t t d dt d dt d dt d d|d d IdH|t y}z't  |}t t d dt d dt d dt d d|d d IdH|d}~wty}zt ||d}~wwz"jsj|d IdHntjrIdHnWntyIdHwddjD_jD]}|}|}|rt|r|IdHqdS)Nrcs|j||dSrrractual_retry_attemptsrYrOrPfailure_callbackfszAAbstractConnection.connect_check_health..failure_callbackcSrW)_connectrOrrOrPrnz9AbstractConnection.connect_check_health..TrzTimeout connecting to serverhostportF)server_address server_portnetwork_peer_addressnetwork_peer_port error_typeretry_attempts is_internalrcSsg|]}|r|qSrOrO)rrefrOrOrP sz;AbstractConnection.connect_check_health..)rrrrrCancelledErrorrr)r;r.rOSErrorr6_error_message Exceptionrion_connect_check_healthiscoroutinefunctionr9rruinspect isawaitable) rYrrreexcrrtaskrOrrPr^s                  z'AbstractConnection.connect_check_healthcC d|_dS)NTrrrOrOrPmark_for_reconnect z%AbstractConnection.mark_for_reconnectcC|jSrWrrrOrOrPshould_reconnectz#AbstractConnection.should_reconnectcCr)NFrrrOrOrPreset_should_reconnectrz)AbstractConnection.reset_should_reconnectcr_rWrOrrOrOrPrszAbstractConnection._connectcCrVrWrOrrOrOrP _host_errorrzAbstractConnection._host_error exceptioncCst||SrW)r&r)rYrrOrOrPrz!AbstractConnection._error_messagecCrrW)rqrrOrOrP get_protocolrzAbstractConnection.get_protocolcs|jddIdHdS)z=Initialize the connection, authenticate and select a databaseTrN)rrrOrOrP on_connectszAbstractConnection.on_connectc s&|j||j}d}|js|js|jr&|jpt|j|j}|IdH}|r|jdvrt|jt rC| t |j |j_ |j|t |dkrOd|dg}|jd|jdg|RddiIdH|IdH}|d t|jkr|d t|jkrtd nq|r|jdg|RddiIdHz |IdH}Wnty|jd|d dd IdH|IdH}Ynwt|dkrtdn.|jdvrt|jt r| t |j |j_ |j||jd|j|d IdH|IdH}|jr|jdd|j|d IdHt|IdHdkrtdd}d}|jr1|jjr1|jddd|jj|d IdHd}|jrK|jjrK|jddd|jj|d IdHd}|jr[|jd|j|d IdHtt||gD]} z |IdHWqctyzYqcw|jrt|IdHdkrtddSdS)N)r2rdefaultrHELLOAUTHrFsprotoprotozInvalid RESP versionrrOKzInvalid Username or PasswordCLIENTSETNAMEzError setting client nameSETINFOzLIB-NAMETzLIB-VERSELECTzInvalid Database)rtrrerarfr3get_credentials_asyncrq isinstancerCrrDEXCEPTION_CLASSESlen send_command read_responsegetrr6r5r?r4rbrformatted_namerdr`rangesumr:) rYrparser auth_args cred_providerresponse auth_response lib_name_sentlib_version_sent_rOrOrPrs                   z*AbstractConnection.on_connect_check_healthnowaitrrhealth_check_failedc szet|j4IdHO|j||js% WdIdHWdSz#z|j|s6|jIdHWn t y@YnwWd|_ d|_nd|_ d|_wWdIdHn 1IdHs`wYWnt j ywt d|jdw|r|rt j}nt j}|dur||jkrtt|ddt|ddt|ddt|dd||dIdHt||dIdHdStt jdIdHdS)z!Disconnects from the Redis serverNz#Timed out closing connection after rr)rrrrrr) close_reasonr)r) async_timeoutrhrt on_disconnectrrrsr wait_closedrrrrr;r<HEALTHCHECK_FAILEDERRORr get_retriesr.rr*APPLICATION_CLOSE)rYrrrrrrOrOrPr9sd    (       zAbstractConnection.disconnectcs8|jdddIdHt|IdHdkrtddS)z Send PING, expect PONG in returnPINGFrNPONGz#Bad response from PING health check)rr?rr6rrOrOrP _send_pingqs zAbstractConnection._send_pingcs|j||ddIdHdS)z Function to call when PING failsT)rrrNr)rYrrrOrOrP _ping_failedwszAbstractConnection._ping_failedcsB|jrt|jkr|jj|j|jddIdHdSdSdS)z3Check the health of the connection with a PING/PONGTrN) rlrrtimermrrrrrrOrOrPr}s zAbstractConnection.check_healthcommandcs"|j||jIdHdSrW)rs writelinesdrain)rYr!rOrOrP_send_packed_commands z'AbstractConnection._send_packed_commandc sX|js |jddIdH|r|IdHz5t|tr |}t|tr(|g}|jr;t | ||jIdHWdS|j ||j IdHWdStjya|jddIdHtddty}z/|jddIdHt|jdkrd|jd}}n |jd}|jd}td |d |d |d}~wty|jddIdHw) NFrTrzTimeout writing to socketrUNKNOWNrzError z while writing to socket. r)rrrrstrencodebytesrgrwait_forr$rsr"r#r;rrrargsr6 BaseException)rYr!rrerr_noerrmsgrOrOrPsend_packed_commandsF        z&AbstractConnection.send_packed_commandr+kwargscs(|j|j||dddIdHdS)z+Pack and send a command to the Redis serverrTrN)r/ pack_commandr)rYr+r0rOrOrPrszAbstractConnection.send_commandc s^z |jIdHWSty.}z|jddIdH|}td|d|jd}~ww)z8Poll the socket to see if there's data that can be read.NTr%Error while reading from z: )rtcan_read_destructiverrrr6r+)rYr host_errorrOrOrPr3sz'AbstractConnection.can_read_destructive)disconnect_on_error push_requestdisable_decodingr)r5r6c s|dur|n|j}|}z}|durB|jdvrBt|4IdH|jj||dIdH}WdIdHn 1IdHs}t |}t ||ksd||ksdt|tr~t|tt|t f}||||t }qOt|tt|t |t f}qO|||S)z2Pack a series of arguments into the Redis protocolrrN )rfloatr'tupler(split SYM_EMPTYrSYM_STARrSYM_CRLFrvmapro memoryview SYM_DOLLARr)rYr+outputbuff buffer_cutoffarg arg_lengthrOrOrPr1s>"      zAbstractConnection.pack_commandcommandsc Csg}g}d}|j}|D]A}|j|D]9}t|}||ks%||ks%t|tr3|r/|t|d}g}||ksstriphasattrrrrr)rverify_flags_strrrrOrOrPparse_ssl_verify_flagsks r) r`rgrhrgrjmax_connectionsrlrrrr).URL_QUERY_ARGUMENT_PARSERSc@sJeZdZUeed<eed<eeed<eed<eed<eed<eed<dS) ConnectKwargsrarfconnection_classrrr`rN)rJrKrLr'__annotations__rrUrrOrOrOrPrs   rF)totalurlc Cs|t|}i}t|jD]7\}}|rDt|dkrDt|d}t|}|r@z||||<Wq tt fy?t d|dw|||<q |j rOt|j |d<|j rYt|j |d<|j dkrn|j rht|j |d<t|d<|S|j d vr|jr}t|j|d <|jrt|j|d <|j rd |vrztt|j d d|d <Wn tt fyYnw|j dkrt|d<|Sd}t d|d)NrzInvalid value for 'z' in connection URL.rarfunixrr)redisredissrrr`/rrzredis://, rediss://, unix://z5Redis URL must specify one of the following schemes ())rrqueryrxrrrrrrrarfschemerrhostnamerrrAttributeErrorr)rparsedr0name value_listrr  valid_schemesrOrOrP parse_urlsR      r_CPConnectionPool)boundc@s2eZdZdZedeededefddZe dfdee d e e fd d Z ehd Zd dZddZd:ddZdefddZedgdddd;ddZddZddZdd Zd!e fd"d#Zd!e fd$d%Zdra Create a connection pool. ``If max_connections`` is set, then this object raises :py:class:`~redis.ConnectionError` when the pool's limit is reached. By default, TCP connections are created unless ``connection_class`` is specified. Use :py:class:`~redis.UnixDomainSocketConnection` for unix sockets. :py:class:`~redis.SSLConnection` can be used for SSL enabled connections. Any additional keyword arguments are passed to the constructor of ``connection_class``. clsrrcKs t|}|||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: - `rediss://` creates a SSL wrapped TCP socket connection. See more at: - ``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. NrO)rupdate)rrr0 url_optionsrOrOrPfrom_urls+ zConnectionPool.from_urlNrrcKs|pd}t|tr |dkrtd||_||_||_g|_t|_|j dt |_ t |_|j dd|_|jdurAt|_dSdS)Nlrz,"max_connections" must be a positive integerrr)rrrrconnection_kwargsr_available_connectionsset_in_use_connectionsrrArrLockrwrr$)rYrrrrOrOrPr s   zConnectionPool.__init__>rfrarrec sRdfddjD}djjdjjdjjdjjd|d S) Nrcs,g|]\}}|d|jvrdn|qS)rz )SENSITIVE_REPR_KEYSrrrOrPr,sz+ConnectionPool.__repr__..rrz()>)rrrxrrKrJr)rY conn_kwargsrOrrPr*s zConnectionPool.__repr__cCst|dr@t|dr@t|j}t|j}|dks|dkr@t|}ddlm}|dkr3||tj| d|dkr@||tj | dg|_t |_dS)Nrrrr+ pool_nameconnection_statecounter) rrrrrredis.observability.recorderr+rIDLEUSEDrWeakSetrY idle_count in_use_countrsync_record_connection_countrOrOrPreset7s,    zConnectionPool.resetcCszLt|dr t|dsWdSt|j}t|j}|dks |dkrGt|}ddlm}|dkr7||tj| d|dkrJ||tj | dWdSWdSWdSt yVYdSw)zCClean up connection pool and record metrics when garbage collected.rrNrrr) rrrrrrr+rrrrrrOrOrPrVs6      zConnectionPool.__del__cCs|jp t|j|jkS)z;Return True if a connection can be retrieved from the pool.)rrrrrrOrOrPcan_get_connectionusz!ConnectionPool.can_get_connection*)Use get_connection() without args instead5.3.0rzr{versionc s"|j4IdH+t|jt|j}t}|}t|jt|j}||k}WdIdHn 1IdHs9wYt|} |rPt| t j ddIdHnt| t j ddIdHt| t j ddIdHz| |IdH|r~t |t|dIdH|WSty||IdHw)z(Get a connected connection from the poolNrrrconnection_poolduration_seconds)rwrrrr  monotonicget_available_connectionrr+rrrensure_connectionr,r,release) rY command_namekeysoptionsconnections_beforestart_time_createdrTconnections_after is_createdrrOrOrPget_connection|sR   (      zConnectionPool.get_connectioncCsTz|j}Wnty!t|j|jkrtdd|}Ynw|j||S)zCGet a connection from the pool, without making sure it is connectedzToo many connectionsN) rpop IndexErrorrrrr8make_connectionaddrXrOrOrPrs    z'ConnectionPool.get_available_connectioncCs.|j}|j|dd|dd|dddS)z,Return an encoder based on encoding settingsr~r|rr}rF)r~rr)rrrrrOrOrP get_encoders    zConnectionPool.get_encodercCs|jdi|jS)z=Create a new connection. Can be overridden by child classes.NrO)rrrrOrOrPrszConnectionPool.make_connectionrTc s~|IdHz|IdHrtddWdStttfy>|IdH|IdH|IdHr;tddYdSw)z8Ensure that the connection object is connected and validNzConnection has datazConnection not ready)rr3r6r;rrrXrOrOrPrs  z ConnectionPool.ensure_connectioncs~|j||r|IdH|j||jt|IdHt |}t |t j ddIdHt |t j ddIdHdS)z(Releases the connection back to the poolNrrr)rrrrrrrdispatch_asyncr#rr+rrr)rYrTrrOrOrPrs&    zConnectionPool.releaseTinuse_connectionscs\|r t|j|j}n|j}tjdd|DddiIdH}tdd|Dd}|r,|dS)z Disconnects connections in the pool If ``inuse_connections`` is True, disconnect connections that are current in use, potentially by other tasks. Otherwise only disconnect connections that are idle in the pool. css|]}|VqdSrWr)rrTrOrOrPr sz,ConnectionPool.disconnect..return_exceptionsTNcss|] }t|tr|VqdSrW)rr,)rrrOrOrPr s)rrrrgathernext)rYr connectionsresprrOrOrPrs  zConnectionPool.disconnectc sV|j4IdH|jD]}|q WdIdHdS1IdHs$wYdS)z< Mark all active connections for reconnect. N)rwrr)rYconnrOrOrP'update_active_connections_for_reconnects   .z6ConnectionPool.update_active_connections_for_reconnectcs|IdHdS)z-Close the pool, disconnecting all connectionsNrrrOrOrPacloseszConnectionPool.acloserr/cCs(|jD]}||_q|jD]}||_q dSrW)rrr)rYrrrOrOrP set_retrys  zConnectionPool.set_retryrTc sj4IdHBjD]'jfddfddIdHjfddfddIdHq jD]q7WdIdHdS1IdHsPwYdS)NcsddSrW)rrYrZrO)rrTrOrPr'sz1ConnectionPool.re_auth_callback..c |SrW_mockrrrOrPr* crrW)rrO)rrOrPr-rcrrWrr!rrOrPr-r")rwrrrrrVrUrO)rrYrTrPre_auth_callback#s      .zConnectionPool.re_auth_callbackrcsdS)z Dummy functions, needs to be passed as error callback to retry object. :param error: :return: NrO)rYrrOrOrPr 2szConnectionPool._mockcCsXt}t||t<|}|}tjj|t<tj j|t<t |j |ft |j |fgS)zD Returns a connection count (both idle and in use). ) rbuild_base_attributesrrrrrrrrrrr)rY attributesfree_connections_attributesin_use_connections_attributesrOrOrPget_connection_count:s   z#ConnectionPool.get_connection_countr\rWr])rr/rN)(rJrKrLr^ classmethodrrr'rrerUr rr frozensetrrrrr`rr%r rrrrrrrrrr r#r9r rr=dictr(rOrOrOrPrsH0    4    c s|eZdZdZddeejfdedee de e de ej ffdd Z ed gd d d dfdd Zde ffdd ZZS)BlockingConnectionPoola  A blocking connection pool:: >>> from redis.asyncio import Redis, BlockingConnectionPool >>> client = Redis.from_pool(BlockingConnectionPool()) It performs the same function as the default :py:class:`~redis.asyncio.ConnectionPool` implementation, in that, it maintains a pool of reusable connections that can be shared by multiple async redis clients. 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.asyncio.ConnectionPool` implementation does), it blocks the current `Task` 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) 2rr)r queue_classc s,tjd||d|t|_||_dS)N)rrrO)rkrr Condition _conditionr))rYrr)rr/rrlrOrPrrs  zBlockingConnectionPool.__init__rrrrNc svt}zi|j4IdHUt|j4IdH6|j|jIdHt|jt|j }t}t }t|jt|j }||k} WdIdHn 1IdHsSwYWdIdHn 1IdHshwYWnt j y} ztd| d} ~ wwz)||IdH| rt|t|dIdHtt|t|dIdH|WSty||IdHw)z@Gets a connection from the pool, blocking until one is availableNzNo connection available.r)rr)r rr1rr)r*rrrrrkrrr;r6rr,r-rr,r) rYrrrstart_time_acquiredrr rTr r errrlrOrPr sL    *(      z%BlockingConnectionPool.get_connectionrTc s^|j4IdHt|IdH|jWdIdHdS1IdHs(wYdS)z)Releases the connection back to the pool.N)r1rkrnotifyrXrlrOrPrs  .zBlockingConnectionPool.releaserW)rJrKrLr^rer LifoQueuerr r<rrUQueuerr%r rr~rOrOrlrPr,Ps,#*r,)rrenumrrsysr rcrabcr itertoolsrtypesrtypingrrrrr r r r r rrrr urllib.parserrrrobservability.attributesrrrrrutilsrrrrr auth.tokenr rr!r"eventr#r$r%r& version_infor)r$redis.asyncio.observability.recorderr*r+r,r-r.redis.asyncio.retryr/ redis.backoffr0redis.connectionr1redis.credentialsr2r3redis.exceptionsr4r5r6r7r8r9r:r;redis.observability.metricsr< redis.typingr= redis.utilsr>r?_parsersr@rArBrCrDr@rDrASYM_LFr?EnumrIrNrrrQrSr^rbrUrerrrrr`rrrr<rr'rMrrrrr,rOrOrOrPs    <       (  g9S] 5