o Ch @sUddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZddlmZmZmZmZmZmZmZmZddlmZmZmZddlmZmZmZm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'dd l(m)Z)dd l*m+Z+dd l,m-Z-m.Z.dd l/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlm?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGeArddlHZHndZHe@rddlIZIdZJdZKdZLdZMdZNeOZPeee&e'e%feQd<e@re%ZRne&ZRGdddZSGdddZTGdddZUGdddeUZVGdd d eVZWGd!d"d"eUZXGd#d$d$eWZYGd%d&d&eVZZd'Z[d(d)Z\e]e^e^e\e\e_e]e]e\e^d* Z`d+d,Zaed-d.d/ZbGd0d.d.ZcGd1d2d2ecZddS)3N)abstractmethod)chain)EmptyFull LifoQueue)AnyCallableDictListOptionalTypeTypeVarUnion)parse_qsunquoteurlparse) CacheEntryCacheEntryStatus CacheFactoryCacheFactoryInterfaceCacheInterfaceCacheKey)Encoder_HiredisParser _RESP2Parser _RESP3Parser)TokenInterface) NoBackoff)CredentialProvider"UsernamePasswordCredentialProvider)AfterConnectionReleasedEventEventDispatcher) AuthenticationError$AuthenticationWrongNumberOfArgsErrorChildDeadlockedErrorConnectionError DataErrorMaxConnectionsError RedisError ResponseError TimeoutError)Retry) CRYPTOGRAPHY_AVAILABLEHIREDIS_AVAILABLE SSL_AVAILABLEcompare_versionsdeprecated_args ensure_stringformat_error_messageget_lib_version str_if_bytes*$s  DefaultParserc@seZdZdefddZdS)HiredisRespSerializerargscGsg}t|dtrt|d|dd}nd|dvr.t|d|dd}z |t|W|StyNt \}}}t | |w2Pack a series of arguments into the Redis protocolrrN ) isinstancestrtupleencodesplitappendhiredis pack_command TypeErrorsysexc_infor'with_traceback)selfr<output_value tracebackrQb/var/www/html/myvaluetrips/my_value_trip_new/venv/lib/python3.10/site-packages/redis/connection.pypackMs"  zHiredisRespSerializer.packN)__name__ __module__ __qualname__r rSrQrQrQrRr;Lsr;c@seZdZdddZddZdS)PythonRespSerializerreturnNcCs||_||_dSN)_buffer_cutoffrC)rL buffer_cutoffrCrQrQrR__init___s zPythonRespSerializer.__init__c Gsg}t|dtrt|d|dd}nd|dvr.t|d|dd}tttt|t f}|j }t |j|D]>}t|}t||ksZ||ksZt|t rtt|t t|t f}||||t }qEt|t t|t |t f}qE|||Sr=)r@rArBrCrD SYM_EMPTYjoinSYM_STARlenSYM_CRLFrZmap memoryview SYM_DOLLARrE)rLr<rMbuffr[arg arg_lengthrQrQrRrScs<"      zPythonRespSerializer.packrXN)rTrUrVr\rSrQrQrQrRrW^s  rWc@seZdZeddZeddZeddZeddZed d Zed d Z ed dZ eddZ eddZ ed,ddZ eddZed-ddZe d.dddddZedd Zed!d"Zeed#eeeefeeefffd$d%Zed&efd'd(Zed)d*Zd+S)/ConnectionInterfacecCdSrYrQrLrQrQrR repr_pieceszConnectionInterface.repr_piecescCrjrYrQrLcallbackrQrQrRregister_connect_callbackrmz-ConnectionInterface.register_connect_callbackcCrjrYrQrnrQrQrRderegister_connect_callbackrmz/ConnectionInterface.deregister_connect_callbackcCrjrYrQrL parser_classrQrQrR set_parserrmzConnectionInterface.set_parsercCrjrYrQrkrQrQrR get_protocolrmz ConnectionInterface.get_protocolcCrjrYrQrkrQrQrRconnectrmzConnectionInterface.connectcCrjrYrQrkrQrQrR on_connectrmzConnectionInterface.on_connectcGrjrYrQrLr<rQrQrR disconnectrmzConnectionInterface.disconnectcCrjrYrQrkrQrQrR check_healthrmz ConnectionInterface.check_healthTcCrjrYrQrLcommandrzrQrQrRsend_packed_commandrmz'ConnectionInterface.send_packed_commandcOrjrYrQrLr<kwargsrQrQrR send_commandrmz ConnectionInterface.send_commandrcCrjrYrQrLtimeoutrQrQrRcan_readrmzConnectionInterface.can_readFdisconnect_on_error push_requestcCrjrYrQ)rLdisable_decodingrrrQrQrR read_responsesz!ConnectionInterface.read_responsecGrjrYrQrxrQrQrRrGrmz ConnectionInterface.pack_commandcCrjrYrQrLcommandsrQrQrR pack_commandsrmz!ConnectionInterface.pack_commandsrXcCrjrYrQrkrQrQrRhandshake_metadatasz&ConnectionInterface.handshake_metadatatokencCrjrYrQrLrrQrQrRset_re_auth_tokenrmz%ConnectionInterface.set_re_auth_tokencCrjrYrQrkrQrQrRre_authrmzConnectionInterface.re_authNTrF)rTrUrVrrlrprqrtrurvrwryrzr}rrrrGrpropertyrr bytesrArrrrrQrQrQrRrisT              *ric*@sVeZdZdZdddddedddeddddeddddd ddfd ed ee d ee d ee de de de de dededee dee dee dee de e dfdeegdfdeedeedeegdfdeef(ddZd d!Zed"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Z 0d`d1e d2e fd3d4Zed5d6Zed7d8Zd9d:Zd;d<Zdad1e fd=d>Z d?d@Z!dAdBZ"dCdDZ#dEdFZ$dadGdHZ%dIdJZ&dbdKdLZ' dcd0ddMdNdOZ(dPdQZ)dRdSZ*dTe ee ffdUdVZ+e,dTe e-e.e.fe-e e fffdWdXZ/e/j0dYe e-e.e.fe-e e fffdZdXZ/d[e1fd\d]Z2d^d_Z3dS)dAbstractConnectionz0Manages communication to and from a Redis serverrNFutf-8strictizredis-pyr9dbpasswordsocket_timeoutsocket_connect_timeoutretry_on_timeoutencodingencoding_errorsdecode_responsessocket_read_sizehealth_check_interval client_namelib_name lib_versionusernameretryredis_connect_funccredential_providerprotocolcommand_packerevent_dispatchercCs|s|r |dur td|durt|_n||_t|_||_| |_||_||_ ||_ ||_ ||_ ||_ |dur;|}||_||_|turGg}|rN|t||_|sU|rn|durattd|_nt||_|j|nttd|_| |_d|_||_t||| |_d|_d|_ | |_!|"| g|_#d|_$d|_%z-zt&|}Wnt'yt(}Yn t)yt*dwW|dks|dkrt*d ||_+n|dks|dkrt*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'rripzprotocol must be an integerr9zprotocol must be either 2 or 3).r'r"_event_dispatcherosgetpidpidrrrrrrrrrrSENTINELrEr+retry_on_errorr,rrcopydeepcopyupdate_supported_errorsrnext_health_checkrrencoderr_sock_socket_read_sizert_connect_callbacksrZ_re_auth_tokenintrHDEFAULT_RESP_VERSION ValueErrorr&r_construct_command_packer_command_packer)rLrrrrrrrrrrsrrrrrrrrrrrrprQrQrRr\sr         zAbstractConnection.__init__cCs8ddd|D}d|jjd|jjd|dS)N,cSg|] \}}|d|qS=rQ.0kvrQrQrR Fz/AbstractConnection.__repr__..<.(z)>)r^rl __class__rUrT)rL repr_argsrQrQrR__repr__Es zAbstractConnection.__repr__cCrjrYrQrkrQrQrRrlIrmzAbstractConnection.repr_piecescCs$z|WdStyYdSwrY)ry ExceptionrkrQrQrR__del__Ms  zAbstractConnection.__del__cCs&|dur|Str tSt|j|jjSrY)r.r;rWrZrrC)rLpackerrQrQrRrSs z,AbstractConnection._construct_command_packercCs(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 WeakMethodrrE)rLrowmrQrQrRrp[s  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)rremoverrrrnrQrQrRrqgs  z.AbstractConnection.deregister_connect_callbackcCs||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)r_parserrrrQrQrRrtrszAbstractConnection.set_parsercCs|jdddS)z5Connects to the Redis server if not already connectedTrzN)connect_check_healthrkrQrQrRrvzszAbstractConnection.connectTrzretry_socket_connectc sjrdSz|rjfddfdd}n}Wntjy)tdty;}zt |d}~ww|_zj durLj |dn Wn t y^ wddjD_jD] }|}|rv|qkdS)NcSrY)_connectrQrkrQrRz9AbstractConnection.connect_check_health..c |SrYryerrorrkrQrRr zTimeout connecting to serverrcSsg|]}|r|qSrQrQ)rrefrQrQrRrsz;AbstractConnection.connect_check_health..)rrcall_with_retryrsocketrr+OSErrorr&_error_messageron_connect_check_healthr)ryr)rLrzrsockerrorQrkrRr~s@    z'AbstractConnection.connect_check_healthcCrjrYrQrkrQrQrRrrmzAbstractConnection._connectcCrjrYrQrkrQrQrR _host_errorrmzAbstractConnection._host_errorcCst||SrY)r3r)rL exceptionrQrQrRrz!AbstractConnection._error_messagecCs|jdddS)NTr)rrkrQrQrRrwzAbstractConnection.on_connectcCs|j||j}d}|js|js|jr"|jpt|j|j}|}|r`|jdvr`t|jt r?| t |j |j_ |j|t |dkrKd|dg}|jd|jdg|Rdd i||_nv|r|jdg|Rdd iz|}Wnty|jd|d d d |}Ynwt|d krtd n?|jdvrt|jt r| t |j |j_ |j||jd|j|d ||_|jd|jkr|jd|jkrtd|jr|jdd|j|d t|d krtdz|jr|jddd|j|d |Wn tyYnwz|jr#|jddd|j|d |Wn ty.Ynw|jrI|jd|j|d t|d krKtddSdS)z=Initialize the connection, authenticate and select a databaseN)r92rdefaultrHELLOAUTHrzFrOKzInvalid Username or PasswordsprotoprotozInvalid RESP versionCLIENTSETNAMEzError setting client nameSETINFOzLIB-NAMEzLIB-VERSELECTzInvalid Database)rrwrrrr get_credentialsrr@rrtrEXCEPTION_CLASSESr`rrrr$r5r#getr&rrr*rr)rLrzparser auth_args cred_provider auth_responserQrQrRrs                   z*AbstractConnection.on_connect_check_healthc Gs||j|j}d|_|durdSt|jkr,z|tjWn t t fy+Ynwz| WdSt y=YdSw)z!Disconnects from the Redis serverN) r on_disconnectrrrrshutdownr SHUT_RDWRrrHclose)rLr< conn_sockrQrQrRry"s  zAbstractConnection.disconnectcCs*|jdddt|dkrtddS)z Send PING, expect PONG in returnPINGFrPONGz#Bad response from PING health checkN)rr5rr&rkrQrQrR _send_ping6szAbstractConnection._send_pingcC |dS)z Function to call when PING failsNrrLrrQrQrR _ping_failed< zAbstractConnection._ping_failedcCs2|jrt|jkr|j|j|jdSdSdS)z3Check the health of the connection with a PING/PONGN)rtime monotonicrrrr rrkrQrQrRrz@szAbstractConnection.check_healthc Cs|js |jdd|r|zt|tr|g}|D]}|j|qWd Stjy5|t dt yi}z)|t |j dkrPd|j d}}n |j d}|j d}t d|d|d d }~wtyt|w) z2Send an already packed command to the Redis serverFrzTimeout writing to socketrUNKNOWNrzError z while writing to socket. rN)rrrzr@rAsendallrrryr+rr`r<r& BaseException)rLr|rzitemrerrnoerrmsgrQrQrRr}Es2     z&AbstractConnection.send_packed_commandcOs"|j|jj||ddddS)z+Pack and send a command to the Redis serverrzTrN)r}rrSrr~rQrQrRrds   zAbstractConnection.send_commandc Cs`|j}|s ||}z|j|WSty/}z|td|d|jd}~ww)z8Poll the socket to see if there's data that can be read.Error while reading from z: N) rrvrrrrryr&r<)rLrr host_errorrrQrQrRrkszAbstractConnection.can_readrc Cs|}z|jdvr|jj||d}n|jj|d}Wn>tjy0|r)|td|tyL}z|r=|t d|d|j d}~wt yY|rX|w|j ret |j |_t|troz|~w|S)z0Read the response from a previously sent command)3r)rr)rzTimeout reading from rz : N)rrrrrrryr+rr&r<rrrrrr@r*)rLrrrrresponserrQrQrRrys:    z AbstractConnection.read_responsecG |jj|S)r>)rrSrxrQrQrRrGrzAbstractConnection.pack_commandc Csg}g}d}|j}|D]B}|jj|D]9}t|}||ks&||ks&t|tr4|r0|t|d}g}||ks=t|trC||q||||7}qq |rX|t||S)z.Pack multiple commands into the Redis protocolr) rZrrSr`r@rcrEr]r^) rLrrMpieces buffer_lengthr[cmdchunkchunklenrQrQrRrs.   z AbstractConnection.pack_commandsrXcC|jSrY)rrkrQrQrRruzAbstractConnection.get_protocolcCr#rY_handshake_metadatarkrQrQrRrsz%AbstractConnection.handshake_metadatarOcC ||_dSrYr%)rLrOrQrQrRrs rcCr'rY)rrrQrQrRr z$AbstractConnection.set_re_auth_tokencCs<|jdur|d|jd|j|d|_dSdSNroid)rrtry_get get_valuerrkrQrQrRrs   zAbstractConnection.re_auth)TTrrr)4rTrUrV__doc__rr:r4rr rAfloatboolrrrrr"r\rrrlrrrprqrtrvrrrrrwrryr rrzr}rrrrGrrurr rrsetterrrrrQrQrQrRrs      `    '  o   ,(( rcsDeZdZdZ     dfdd Zd d Zd d Zd dZZS) Connectionz4Manages TCP communication to and from a Redis server localhostFNrc s<||_t||_||_|pi|_||_tjdi|dSNrQ)hostrportsocket_keepalivesocket_keepalive_options socket_typesuperr\)rLr5r6r7r8r9rrrQrRr\s   zConnection.__init__cCs6d|jfd|jfd|jfg}|jr|d|jf|S)Nr5r6rr)r5r6rrrErLrrQrQrRrlszConnection.repr_piecesc Cs,d}t|j|j|jtjD]}}|\}}}}}d}zDt|||}|tjtjd|j rH|tj tj d|j D] \} } |tj| | q;||j||||j|WSty} z"| }|durz|tjWn ty|Ynw|WYd} ~ qd} ~ ww|dur|td)zCreate a TCP socket connectionNrz)socket.getaddrinfo returned an empty list)r getaddrinfor5r6r9 SOCK_STREAM setsockopt IPPROTO_TCP TCP_NODELAYr7 SOL_SOCKET SO_KEEPALIVEr8items settimeoutrrvrrrrr) rLerrresfamilysocktyper canonnamesocket_addressrrrrNrQrQrRrs>      zConnection._connectcCs|jd|jS)N:)r5r6rkrQrQrRr&szConnection._host_error)r2r3FNr rTrUrVr-r\rlrr __classcell__rQrQr;rRr1s-r1c@sDeZdZdZdZdZdededej fddZ d d Z d d Z d dZ ddZddZddZddZddZd?ddZddZd@dd Z !dAdd!d"d#d$Zd%d&Zd'd(Zed)eeeefeeefffd*d+Zd,d-Zd.d/Z ded)d0fd1d2Z!d3d4Z"d5e#eee$e#effd6d7Z%d8d9Z&d:e'fd;d<Z(d=d>Z)d0S)BCacheProxyConnectionsfooz7.4.0redisconncache pool_lockcCsht|_||_|jj|_|jj|_|jj|_|j|_||_||_ t |_ d|_ d|_||jdSrY)rrr_connrr5r6r _pool_lock_cache threadingRLock _cache_lock_current_command_cache_key_current_optionsrp_enable_tracking_callback)rLrQrRrSrQrQrRr\/s     zCacheProxyConnection.__init__cC |jSrY)rTrlrkrQrQrRrlBr(z CacheProxyConnection.repr_piecescC|j|dSrY)rTrprnrQrQrRrpErz.CacheProxyConnection.register_connect_callbackcCr^rY)rTrqrnrQrQrRrqHrz0CacheProxyConnection.deregister_connect_callbackcCr^rY)rTrtrrrQrQrRrtKrzCacheProxyConnection.set_parsercCs|j|jjdd}|dur|jjdd}|jjdd}|dur-|jjdd}|dus5|dur9tdt|}t|}||jksNt||jdkrRtddS)Nsserverserversversionversionz0Cannot retrieve information about server versionrziTo maximize compatibility with all Redis products, client-side caching is supported by Redis 7.4 or later) rTrvrrr&r2DEFAULT_SERVER_NAMEr0MIN_ALLOWED_VERSION)rL server_name server_verrQrQrRrvNs"  zCacheProxyConnection.connectcC|jdSrY)rTrwrkrQrQrRrwerzCacheProxyConnection.on_connectcGs@|j |jWdn1swY|jj|dSrY)rYrVflushrTryrxrQrQrRryhs zCacheProxyConnection.disconnectcCrerY)rTrzrkrQrQrRrzmrz!CacheProxyConnection.check_healthTcCr^rY)rTr}r{rQrQrRr}psz(CacheProxyConnection.send_packed_commandc Os||j)|jt|ddds)d|_|jj|i| WddSWdn1s3wY|ddurCt dt|dt |dd|_|jY|j|jr|j|j}|j |jkr|j |j r~|j jdd|j srWdn1swY WddS|jt|j|jtj|jdWdn1swY|jj|i|dS) NrrQ)r| redis_keyskeyszCannot create cache key.Tr) cache_key cache_valuestatusconnection_ref)_process_pending_invalidationsrYrV is_cachablerrZrTrrrrBrmrUrrsetrDUMMY_CACHE_VALUEr IN_PROGRESS)rLr<rentryrQrQrRrusH   z!CacheProxyConnection.send_commandrcC |j|SrY)rTrrrQrQrRr zCacheProxyConnection.can_readFrcCs@|j8|jdur4|j|jdur4|j|jjtjkr4t|j|jj }d|_|WdSWdn1s>wY|j j |||d}|jG|jdur^|WdS|durs|j |jg|WdS|j|j}|durtj |_||_ |j|d|_Wd|S1swY|S)N)rrr)rYrZrVrrlrrrrrrkrTrdelete_by_cache_keysVALIDrp)rLrrrrGr cache_entryrQrQrRrsJ     z"CacheProxyConnection.read_responsecGrrY)rTrGrxrQrQrRrGruz!CacheProxyConnection.pack_commandcCrtrY)rTrrrQrQrRrruz"CacheProxyConnection.pack_commandsrXcCs|jjSrY)rTrrkrQrQrRrsz'CacheProxyConnection.handshake_metadatacCrerY)rTrrkrQrQrRrrzCacheProxyConnection._connectcCrerY)rTrrkrQrQrRrrz CacheProxyConnection._host_errorNcCs(|ddd||j|jdS)NrTRACKINGON)rrrset_invalidation_push_handler_on_invalidation_callback)rLrQrQrQrRr\sz.CacheProxyConnection._enable_tracking_callbackcCs&|r|jjdd|sdSdS)NTri)rrTrrkrQrQrRrnsz3CacheProxyConnection._process_pending_invalidationsdatacCsd|j%|ddur|jn|j|dWddSWddS1s+wYdS)Nr)rYrVrfdelete_by_redis_keys)rLr}rQrQrRr|s  "z.CacheProxyConnection._on_invalidation_callbackcCr]rY)rTrurkrQrQrRrur(z!CacheProxyConnection.get_protocolrcCr^rY)rTrrrQrQrRrrz&CacheProxyConnection.set_re_auth_tokencCrerY)rTrrkrQrQrRrrzCacheProxyConnection.re_authrrr)*rTrUrVrqrbrarirrWrXr\rlrprqrtrvrwryrzr}rrrrGrrrr rrArrrr\rnr r r|rurrrrQrQrQrRrO*sL   0 -(" rOcsReZdZdZ              d fdd Zfdd Zd d ZZS) SSLConnectionzManages 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) NrequiredTFc ststd||_||_|durtj}nt|tr1tjtjtj d}||vr-td|||}||_ ||_ ||_ ||_ |j tjkrE|nd|_||_| |_| |_| |_| |_| |_||_tjdi|dS)aConstructor 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), or an ssl.VerifyMode. 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. ssl_min_version: The lowest supported SSL version. It affects the supported SSL versions of the SSLContext. None leaves the default provided by ssl module. ssl_ciphers: A string listing the ciphers that are allowed to be used. Defaults to None, which means that the default ciphers are used. See https://docs.python.org/3/library/ssl.html#ssl.SSLContext.set_ciphers for more information. Raises: RedisError z$Python wasn't built with SSL supportN)noneoptionalrz+Invalid SSL Certificate Requirements Flag: FrQ)r/r)keyfilecertfilessl CERT_NONEr@rA CERT_OPTIONAL CERT_REQUIRED cert_reqsca_certsca_dataca_pathcheck_hostnamecertificate_passwordssl_validate_ocspssl_validate_ocsp_stapledssl_ocsp_contextssl_ocsp_expected_certssl_min_version ssl_ciphersr:r\)rL ssl_keyfile ssl_certfile ssl_cert_reqs ssl_ca_certs ssl_ca_datassl_check_hostname ssl_ca_path ssl_passwordrrrrrrr CERT_REQSr;rQrRr\s<( zSSLConnection.__init__c s4t}z||WSttfy|w)zN Wrap the socket with SSL support, handling potential errors. )r:r_wrap_socket_with_sslrr)rrLrr;rQrRrPs  zSSLConnection._connectc Cst}|j|_|j|_|js|jr|j|j|j|jd|j dus,|j dus,|j dur7|j |j |j |j d|j dur@|j |_|jrI||j|jdurVtdurVtd|jr`|jr`td|j||jd}|jrd dl}d d lm}|jdur|j|jj}||j||jn|j}| ||j!|j"|t##}|$|%|j|j&f|'|(|S|jdurtrd d lm)}|||j|j&|j } | *r|St+d |S)z Wraps the socket with SSL support. Args: sock: The plain socket to wrap with SSL. Returns: An SSL wrapped socket. )rrrN)cafilecapathcadataTFzcryptography is not installed.zKEither an OCSP staple or pure OCSP connection must be validated - not both.)server_hostnamerr)ocsp_staple_verifier) OCSPVerifierzocsp validation error),rcreate_default_contextrr verify_moderrload_cert_chainrrrrload_verify_locationsrminimum_versionr set_ciphersrr-r)r wrap_socketr5OpenSSLocsprrSSLContext SSLv23_METHODuse_certificate_fileuse_privatekey_fileset_ocsp_client_callbackrr1r request_ocsprvr6 do_handshakerris_validr&) rLrcontextsslsockrr staple_ctxconrorQrQrRr[sd             z#SSLConnection._wrap_socket_with_ssl)NNrNNTNNFFNNNN)rTrUrVr-r\rrrNrQrQr;rRrs& J rcs:eZdZdZd fdd ZddZdd Zd d ZZS) UnixDomainSocketConnectionz4Manages UDS communication to and from a Redis serverNc s"tjdi|||_||_dSr4)r:r\pathr)rLrrrr;rQrRr\s z#UnixDomainSocketConnection.__init__cCs.d|jfd|jfg}|jr|d|jf|S)Nrrr)rrrrEr<rQrQrRrlsz&UnixDomainSocketConnection.repr_piecesc Cszttjtj}||jz||jWnty4z|tj Wn ty.Ynw| w||j |S)z&Create a Unix domain socket connection) rAF_UNIXr>rErrvrrrrrrrrQrQrRrs    z#UnixDomainSocketConnection._connectcCr#rY)rrkrQrQrRrr$z&UnixDomainSocketConnection._host_error)rNrMrQrQr;rRrs r)0FFALSENNOcCs6|dus|dkr dSt|tr|tvrdSt|S)NrF)r@rAupper FALSE_STRINGSr/)rOrQrQrRto_bools r) rrrr7rrmax_connectionsrrrc Cs|ds|ds|dstdt|}i}t|jD]7\}}|rWt|dkrWt|d}t |}|rSz||||<Wq t tfyRtd|dw|||<q |j rbt|j |d<|j rlt|j |d <|j d kr|jr{t|j|d <t|d <|S|jrt|j|d <|jrt|j|d<|jrd|vrztt|jdd|d<Wn ttfyYnw|j dkrt|d <|S)Nzredis://z rediss://zunix://zRRedis URL must specify one of the following schemes (redis://, rediss://, unix://)rzInvalid value for 'z' in connection URL.rrunixrconnection_classr5r6r/rrediss) startswithrrrqueryrDr`rURL_QUERY_ARGUMENT_PARSERSrrHrrschemerrhostnamer6rreplaceAttributeErrorr)urlrnamerOrrQrQrR parse_urlsZ    r_CPConnectionPool)boundc@seZdZdZedeededefddZe ddfde e d e e fd d Z defd d ZddZd4ddZd4ddZedgdddd5d6ddZdefddZd7ddZd8d!d"Zd dde fd#d$Zd9d&eddfd'd(Zd4d)d*Zd+eddfd,d-Zd.efd/d0Zd1e fd2d3Z!dS):ra 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. :py:class:`~redis.SSLConnection` can be used for SSL enabled connections. Any additional keyword arguments are passed to the constructor of ``connection_class``. clsrrXcKs4t|}d|vr|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: - `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. rNrQ)rupdate)rrr url_optionsrQrQrRfrom_url2s )  zConnectionPool.from_urlNr cache_factorycKs |pd}t|tr |dkrtd||_||_||_d|_||_|ds*|drc|ddvr5t d|jd}|durLt|t sHtd ||_n|jdurX|j |_n t |jd |_| dd| dd|jd d|_|jdurt|_t|_t|_|dS) Nlrz,"max_connections" must be a positive integer cache_configrRr)rrz4Client caching is only supported with RESP version 3z#Cache must implement CacheInterfacer)r@rrrconnection_kwargsrrR_cache_factoryrr)r get_cacherpoprr"rWrX _fork_lock_lockreset)rLrrrrrRrQrQrRr\cs>         zConnectionPool.__init__c CsNddd|jD}d|jjd|jjd|jjd|jjd|d S) NrcSrrrQrrQrQrRrrz+ConnectionPool.__repr__..rrz()>)r^rrDrrUrTr)rL conn_kwargsrQrQrRrszConnectionPool.__repr__cCs|jddS)z Returns: The RESP protocol version, or ``None`` if the protocol is not specified, in which case the server default will be used. rN)rrrkrQrQrRruszConnectionPool.get_protocolcCs"d|_g|_t|_t|_dS)Nr)_created_connections_available_connectionsrp_in_use_connectionsrrrrkrQrQrRrs zConnectionPool.resetcCsl|jtkr4|jjdd}|stz|jtkr&|W|jdSW|jdS|jwdS)N)r)rrrracquirer%rrelease)rLacquiredrQrQrR _checkpids# zConnectionPool._checkpid*)Use get_connection() without args instead5.3.0 args_to_warnreasonr`r1c Os||j#z|j}Wn ty|}Ynw|j|Wdn1s-wYz8|z| rE|j durIt dWW|SWW|St t t fyj||| rft dYW|Swtyw||w)zGet a connection from the poolNConnection has dataConnection not ready)rrrr IndexErrormake_connectionraddrvrrRr&r+rryrrrL command_namerhoptions connectionrQrQrRget_connections<      zConnectionPool.get_connectioncCs,|j}t|dd|dd|dddS)z,Return an encoder based on encoding settingsrrrrrF)rrr)rrr)rLrrQrQrR get_encoders    zConnectionPool.get_encoderricCs\|j|jkr td|jd7_|jdur%t|jdi|j|j|jS|jdi|jS)zCreate a new connectionzToo many connectionsrNrQ)rrr(rRrOrrrrkrQrQrRrs  zConnectionPool.make_connectionrc Cs||jCz|j|Wnty YWddSw||r5|j||j t |n |  WddSWddS1sMwYdS)z(Releases the connection back to the poolN) rrrrKeyErrorowns_connectionrrErdispatchr!ryrLrrQrQrRr(s$    "zConnectionPool.releasecCs |j|jkSrY)rrrQrQrRr@ruzConnectionPool.owns_connectionTinuse_connectionscCs`||j|rt|j|j}n|j}|D]}|qWddS1s)wYdS)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)rrrrrry)rLr connectionsrrQrQrRryCs "zConnectionPool.disconnectcCr )z-Close the pool, disconnecting all connectionsNrrkrQrQrRrWrzConnectionPool.closercCs8|jd|i|jD]}||_q |jD]}||_qdS)Nr)rrrrr)rLrrQrQrQrR set_retry[s   zConnectionPool.set_retryrcsj9jD]!jfddfddjfddfddqjD]q,WddS1s?wYdS)NcsddSr))rr+r,rQ)rQrrQrRrfsz1ConnectionPool.re_auth_callback..crrY_mockrrkrQrRrircrrY)rrQ)rQrQrRrlrcrrYr rrkrQrRrlr)rrrrrrrrQ)rQrLrrRre_auth_callbackbs     "zConnectionPool.re_auth_callbackrcsdS)z Dummy functions, needs to be passed as error callback to retry object. :param error: :return: NrQrrQrQrRr qszConnectionPool._mockrhrY)rXr1)rXri)rr1rXNr)"rTrUrVr- classmethodr rrArr1r rrr\rrurrr1rrrrrrr/ryrr,rrr r)r rQrQrQrRr#s>2 9  /"  csdeZdZdZddeeffdd ZddZdd Ze d gd d d dddZ ddZ ddZ 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) 2c s(||_||_tjd||d|dS)N)rrrQ) queue_classrr:r\)rLrrrrrr;rQrRr\s zBlockingConnectionPool.__init__cCsJ||j|_ z|jdWn tyYnwqg|_t|_dSrY) rrpool put_nowaitr _connectionsrrrrkrQrQrRrs  zBlockingConnectionPool.resetcCsL|jdurt|jdi|j|j|j}n |jdi|j}|j||S)zMake a fresh connection.NrQ)rRrOrrrrrErrQrQrRrs  z&BlockingConnectionPool.make_connectionrrrrNc Os|d}z |jjd|jd}Wn tytdw|dur%|}z/|z |r3tdWW|Stt t fyT| ||rPtdYW|Swt ya| |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)blockrzNo connection available.rr)rrrrrr&rrvrr+rryrrrrQrQrRrs8    z%BlockingConnectionPool.get_connectioncCsR|||s||jddSz |j|WdSty(YdSw)z)Releases the connection back to the pool.N)rrryrrrrrQrQrRrs   zBlockingConnectionPool.releasecCs ||jD]}|qdS)z(Disconnects all connections in the pool.N)rrryrrQrQrRrys  z!BlockingConnectionPool.disconnectrY)rTrUrVr-r1rr\rrr1rrryrNrQrQr;rRr zs"#  4r )errrrIrWrrabcr itertoolsrqueuerrrtypingrrr r r r r r urllib.parserrr redis.cacherrrrrr_parsersrrrr auth.tokenrbackoffr credentialsrr eventr!r" exceptionsr#r$r%r&r'r(r)r*r+rr,utilsr-r.r/r0r1r2r3r4r5rrFr_rdrar]robjectr__annotations__r:r;rWrirr1rOrrrrrr.listrrrrr rQrQrQrRs   (   , , 3QJW,#  9Y