U.js UddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZddlmZddlmZmZmZmZmZmZmZddlmZmZmZddlmZmZmZm Z m!Z!m"Z"d d l#m$Z$m%Z%m&Z&m'Z'd d l(m)Z)d d l*m+Z+m,Z,d d l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5d dl6m7Z7d dl8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@e:rddlAZAdZBdZCdZDdZEdZFeGZHeee&e'e%feId<e:re%ZJne&ZJGddZKGddZLGddZMGddeMZNGddeNZOGd d!eMZPGd"d#eOZQGd$d%eNZRd&ZSd'ZTeUeVeVeTeTeWeUeUeTeVd( ZXd)ZYGd*d+ZZGd,d-eZZ[y).N)abstractmethod)chain)EmptyFull LifoQueue)time)AnyCallableDictListOptionalTypeUnion)parse_qsunquoteurlparse) CacheEntryCacheEntryStatus CacheFactoryCacheFactoryInterfaceCacheInterfaceCacheKey)Encoder_HiredisParser _RESP2Parser _RESP3Parser) NoBackoff)CredentialProvider"UsernamePasswordCredentialProvider)AuthenticationError$AuthenticationWrongNumberOfArgsErrorChildDeadlockedErrorConnectionError DataError RedisError ResponseError TimeoutError)Retry)CRYPTOGRAPHY_AVAILABLEHIREDIS_AVAILABLE SSL_AVAILABLEcompare_versions ensure_stringformat_error_messageget_lib_version str_if_bytes*$s  DefaultParserceZdZdefdZy)HiredisRespSerializerargscg}t|dtr1t|djj |ddz}n)d|dvr"t|dj |ddz} |j t j||S#t$r3tj\}}}t|j|wxYw2Pack a series of arguments into the Redis protocolrrN ) isinstancestrtupleencodesplitappendhiredis pack_command TypeErrorsysexc_infor%with_traceback)selfr9output_value tracebacks RC:\xampp\htdocs\tradingbinance\backend\.venv\Lib\site-packages\redis/connection.pypackzHiredisRespSerializer.packEs d1gs #a)//12T!"X=D T!W_a)DH4D = MM'..t4 5   ="%,,. AuiE"11)< < =s 1$Br?r@rArB SYM_EMPTYjoinSYM_STARlenSYM_CRLFrYmap memoryview SYM_DOLLARrC)rJr9rKbuffrZarg arg_lengths rOrPzPythonRespSerializer.pack[sd d1gs #a)//12T!"X=D T!W_a)DH4D~~xSY)>)>)@(KL++ t{{D)CSJD M) -c:. ~~:s:'='='?J d# c" ~~"J..0   !*4  d r4returnN)rQrRrSr[rPrTr4rOrVrVVs +r4rVc:eZdZedZedZedZedZedZedZ edZ edZ edd Z ed Z edd Ze dd d ddZedZedZeedeeeefeeefffdZy)ConnectionInterfacecyrXrTrJs rO repr_pieceszConnectionInterface.repr_pieces r4cyrXrTrJcallbacks rOregister_connect_callbackz-ConnectionInterface.register_connect_callbackror4cyrXrTrqs rOderegister_connect_callbackz/ConnectionInterface.deregister_connect_callbackror4cyrXrTrJ parser_classs rO set_parserzConnectionInterface.set_parserror4cyrXrTrms rOconnectzConnectionInterface.connectror4cyrXrTrms rO on_connectzConnectionInterface.on_connectror4cyrXrTrJr9s rO disconnectzConnectionInterface.disconnectror4cyrXrTrms rO check_healthz ConnectionInterface.check_healthror4TcyrXrTrJcommandrs rOsend_packed_commandz'ConnectionInterface.send_packed_commandror4cyrXrTrJr9kwargss rO send_commandz ConnectionInterface.send_commandror4cyrXrTrJtimeouts rOcan_readzConnectionInterface.can_readror4Fdisconnect_on_error push_requestcyrXrT)rJdisable_decodingrrs rO read_responsez!ConnectionInterface.read_responses r4cyrXrTrs rOrEz ConnectionInterface.pack_commandror4cyrXrTrJcommandss rO pack_commandsz!ConnectionInterface.pack_commandsror4ricyrXrTrms rOhandshake_metadataz&ConnectionInterface.handshake_metadatas r4NTrF)rQrRrSrrnrsruryr{r}rrrrrrrErpropertyrr bytesr?rrTr4rOrkrksh                       !        E$ue|*AbstractConnectionz0Manages communication to and from a Redis serverrNFutf-8strictizredis-pyr5dbpasswordsocket_timeoutsocket_connect_timeoutretry_on_timeoutencodingencoding_errorsdecode_responsessocket_read_sizehealth_check_interval client_namelib_name lib_versionusernameretryredis_connect_funccredential_providerprotocolcommand_packerc|s|r | tdtj|_||_| |_||_||_||_||_ ||_ ||_ ||}||_ ||_ |turg}|r|jt ||_|s|rR|t%t'd|_nt+j,||_|j(j/|nt%t'd|_| |_d|_||_t7||| |_d|_d|_| |_|jA| g|_!d|_" tG|}|dks|dkDr tOd ||_(|jS||_*y#tH$r tJ}YDtL$r tOdwxYw#dks|dkDr tOd ||_(wxYw) 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 integerr5zprotocol must be either 2 or 3)+r%osgetpidpidrrrrrrrrrrSENTINELrCr(retry_on_errorr)rrcopydeepcopyupdate_supported_errorsrnext_health_checkrrencoderr_sock_socket_read_sizery_connect_callbacksrYintrFDEFAULT_RESP_VERSION ValueErrorr$r_construct_command_packer_command_packer)rJrrrrrrrrrrxrrrrrrrrrrrps rOr[zAbstractConnection.__init__s> &9&E+  99;&  &#6     , ! )%3 "&<# 0 X %N   ! !, /, N}"9;2 "]]51 JJ . .~ >y{A.DJ%:"!""4x:JK "& !1  %"$" H A 1uA%&FGGDM#==nM %$A A!"?@ @ A1uA%&FGGDMs$( F&&G 5G7G  GG,c dj|jDcgc] \}}|d|c}}}d|jjd|jjd|dScc}}w)N,=<.()>)r^rn __class__rRrQ)rJkv repr_argss rO__repr__zAbstractConnection.__repr__+spHHT5E5E5GH5GTQ1QCj5GHI 4>>,,-Qt~~/F/F.Gq SUVVIsA, cyrXrTrms rOrnzAbstractConnection.repr_pieces/ror4cD |jy#t$rYywxYwrX)r Exceptionrms rO__del__zAbstractConnection.__del__3s#  OO    s  c~||Str tSt|j|jj SrX)r+r8rVrYrrA)rJpackers rOrz,AbstractConnection._construct_command_packer9s6  M (* *'(;(;T\\=P=PQ Qr4ctj|}||jvr|jj|yy)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 WeakMethodrrC)rJrrwms rOrsz,AbstractConnection.register_connect_callbackAs;   ) T,, ,  # # * *2 . -r4c |jjtj|y#t$rYywxYw)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)rremoverrrrqs rOruz.AbstractConnection.deregister_connect_callbackMs8    # # * *7+=+=h+G H   s .1 ==c4||j|_y)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_parserrws rOryzAbstractConnection.set_parserXs $T5K5KL r4c<jry jjfdfd}|_ jjnjjDcgc] }|s |c}_ jD]}|}|s |y#tj$r t dt $r}tj|d}~wwxYw#t$rjwxYwcc}w)z5Connects to the Redis server if not already connectedNc$jSrX)_connectrmsrOz,AbstractConnection.connect..fs  r4c&j|SrXr)errorrJs rOrz,AbstractConnection.connect..fstu7Mr4zTimeout connecting to server)rrcall_with_retrysocketrr(OSErrorr$_error_messagerr}r&rr)rJsockerefrrs` rOr{zAbstractConnection.connect`s ::  :::--')MD  &&.!''-372I2I"S2I3SU32I"S**CuH+-~~ ?=> > :!$"5"5a"89 9 :  OO   #Ts."B3.C;6 DD3&C8C33C8;DcyrXrTrms rOrzAbstractConnection._connectror4cyrXrTrms rO _host_errorzAbstractConnection._host_errorror4c6t|j|SrX)r/r)rJ exceptions rOrz!AbstractConnection._error_messages#D$4$4$6 BBr4c|jj||j}d}|js|js |jr>|jxs t |j|j}|j }|r|jdvrt|jtrK|jt|j|j_ |jj|t|dk(rd|dg}|jd|jdg||j|_nB|rA|jdg|dd i |j}t%|d k7r t'd |jdvrt|jtrK|jt|j|j_ |jj||jd|j|j|_|j j)d|jk7r3|j j)d|jk7r t+d|j,rD|jdd|j,t%|jd k7r t+d |j.r.|jddd|j.|j |j2r.|jddd|j2|j|j4rD|jd|j4t%|jd k7r t+dyy#t"$r+|jd|d d |j}YcwxYw#t0$rYwxYw#t0$rYwxYw)z=Initialize the connection, authenticate and select a databaseN)r52rdefaultrHELLOAUTHrFrOKzInvalid Username or PasswordsprotoprotozInvalid RESP versionCLIENTSETNAMEzError setting client nameSETINFOzLIB-NAMEzLIB-VERSELECTzInvalid Database)rr}rrrr get_credentialsrr>rryrEXCEPTION_CLASSESr`rrrr"r1r!getr$rrr'rr)rJparser auth_args cred_provider auth_responses rOr}zAbstractConnection.on_connects] %  # # ((T5dmmT]]S &557I h6$,, 5 -171I1I . ''-9~"& ! 5 D  gt}}f Iy I&*&8&8&:D #  D  f Ey Eu E 5 $ 2 2 4 M*d2)*HII]]( *$,, 5 -171I1I . ''-   gt}} 5&*&8&8&:D #''++H5F++//8DMMI%&<==      h 43C3C DD..01T9%&ABB }}!!(Iz4==Q""$ !!(Iy$BRBRS""$ 77   h 0D..01T9%&899: a8 5 !!&)B-e!L $ 2 2 4  5J      s6%N%:O:O+%0OO O('O(+ O76O7cP|jj|j}d|_|ytj|j k(r |j tj |jy#ttf$rY#wxYw#t$rYywxYw)z!Disconnects from the Redis serverN) r on_disconnectrrrrshutdownr SHUT_RDWRrrFclose)rJr9 conn_socks rOrzAbstractConnection.disconnects ""$JJ     99;$(( " ""6#3#34  OO  Y'      s$B3BBB B%$B%cx|jddt|jdk7r tdy)z Send PING, expect PONG in returnPINGFrPONGz#Bad response from PING health checkN)rr1rr$rms rO _send_pingzAbstractConnection._send_pings< &u5 **, - 7!"GH H 8r4c$|jy)z Function to call when PING failsNr)rJrs rO _ping_failedzAbstractConnection._ping_failed  r4c|jrIt|jkDr1|jj |j |j yyy)z3Check the health of the connection with a PING/PONGN)rrrrrrrrms rOrzAbstractConnection.check_healthsA  % %$&43I3I*I JJ & &t8I8I J+J %r4TcN|js|j|r|j t|tr|g}|D]}|jj |y#t j$r|jtdt$ro}|jt|jdk(rd|jd}}n|jd}|jd}td|d|dd}~wt$r|jwxYw) z2Send an already packed command to the Redis serverzTimeout writing to socketrUNKNOWNrzError z while writing to socket. rN)rr{rr>r?sendallrrrr(rr`r9r$ BaseException)rJrritemrerrnoerrmsgs rOrz&AbstractConnection.send_packed_command szz LLN      '3'") ""4( ~~ < OO :; ; W OO 166{a )166!9vq !F5'1KF8ST"UV V  OO    s5A&&6D$A*DD$cx|j|jj||jddy)z+Pack and send a command to the Redis serverrTrN)rrrPr rs rOrzAbstractConnection.send_command*s9   %D % %t ,ND9 ! r4c|j}|s|j|j} |jj |S#t $r0}|j td|d|jd}~wwxYw)z8Poll the socket to see if there's data that can be read.Error while reading from z: N) rr{rrrrrr$r9)rJrr host_errorrs rOrzAbstractConnection.can_read1syzz LLN%%'  V<<((1 1 V OO !$=j\AFF8"TU U VsA B+A??Brc\|j} |jdvr$ts|jj ||}n|jj |}|jrt|jz|_t!|t"r ||S#t j $r!|r|jtd|t$r2}|r|jtd|d|jd}~wt$r|r|jwxYw#~wxYw)z0Read the response from a previously sent command)3r)rr)rzTimeout reading from r%z : N)rrr+rrrrrr(rr$r9rrrrr>r')rJrrrr&responsers rOrz AbstractConnection.read_response?s(%%'  }}(1B<<55%5L6 <<55GW5X&  % %%)Vd.H.H%HD " h . 5~~ E"!!6zlCD D "!!+J<3qvvhG  #!   s$ABD(;D%-D D%(D+c4|jj|S)r<)rrPrs rOrEzAbstractConnection.pack_commandms(t##(($//r4cg}g}d}|j}|D]}|jj|D]}t|}||kDs||kDst |t r*|r$|j tj|d}g}||kDst |t r|j |y|j |||z }|r$|j tj||S)z.Pack multiple commands into the Redis protocolr) rYrrPr`r>rcrCr]r^) rJrrKpieces buffer_lengthrZcmdchunkchunklens rOrz AbstractConnection.pack_commandsqs ++ C2--22C8u:!M1-/!%4 innV&<=$%MFm+z%/LMM%(MM%(!X-M!9&  MM)..0 1 r4ric|jSrX)rrms rO get_protocolzAbstractConnection.get_protocols }}r4c|jSrX_handshake_metadatarms rOrz%AbstractConnection.handshake_metadatas'''r4rMc||_yrXr4)rJrMs rOrz%AbstractConnection.handshake_metadatas #( r4rrr).rQrRrS__doc__rr6r0rr r?floatboolrr r rr[rrrnrrrsruryr{rrrr}rrrrrrrrrErr2rr rrsetterrTr4rOrrs6"&*.26!&'!&" %%&%)",%4%6"&"&;?<@"#7;-XN XN3-XN! XN !) XN  XNXNXNXNXN #XNc]XN3-XN c]!XN"3-#XN$S$Y%XN&%Xb$h%78'XN(&&89)XN*3-+XN,!"d(!34-XNtW   R / M!F    CX:t(I K >  V ,! ,\0<cjS(E$ue|*FHeYD !}}VXu= 2 2F4F4FJ((OOF$5$5v7J7JAN $ = = C C E1(:(:AqA!F ; ;< ^, 3 34 1 > ?IABB !#JJL !sD E55 F>FFc8|jd|jS)N:)r?r@rms rOrzConnection._host_errors))Adii[))r4) localhostiFNr rQrRrSr7r[rnrr __classcell__rs@rOr<r<s-: !% #  'CR*r4r<c"eZdZdZdZdZdededejfdZ dZ d Z d Z d Zd Zd ZdZdZd"dZdZd#dZ d$ddddZdZdZedeeeefeeefffdZdZdZ deddfdZ!dZ"d e#eee$e#effd!Z%y)%CacheProxyConnectionsfooz7.4.0redisconncache pool_lockctj|_||_|jj|_|jj |_|jj |_||_||_tj|_ d|_ d|_ |j|jyrX)rrr_connrr?r@ _pool_lock_cache threadingLock _cache_lock_current_command_cache_key_current_optionsrs_enable_tracking_callback)rJr`rarbs rOr[zCacheProxyConnection.__init__s 99; ZZ%% JJOO JJOO # $>>+*.' $ &&t'E'EFr4c6|jjSrX)rdrnrms rOrnz CacheProxyConnection.repr_piecesszz%%''r4c:|jj|yrX)rdrsrqs rOrsz.CacheProxyConnection.register_connect_callbacks ,,X6r4c:|jj|yrX)rdrurqs rOruz0CacheProxyConnection.deregister_connect_callbacks ..x8r4c:|jj|yrX)rdryrws rOryzCacheProxyConnection.set_parsers l+r4c |jj|jjjdd}|&|jjjdd}|jjjdd}|&|jjjdd}|| t dt |}t |}||j k7st||jdk(r t dy)Nsserverserversversionversionz0Cannot retrieve information about server versionrziTo maximize compatibility with all Redis products, client-side caching is supported by Redis 7.4 or later) rdr{rr r$r.DEFAULT_SERVER_NAMEr-MIN_ALLOWED_VERSION)rJ server_name server_vers rOr{zCacheProxyConnection.connects jj3377 4H  **77;;HdKKZZ2266z4H  66::9dKJ  !3!"TU U":. #K0  433 3 D,D,DEJ!{ Kr4c8|jjyrX)rdr}rms rOr}zCacheProxyConnection.on_connects r4c|j5|jjddd|jj|y#1swY#xYwrX)rirfflushrdrrs rOrzCacheProxyConnection.disconnects=    KK    t$ s A  Ac8|jjyrX)rdrrms rOrz!CacheProxyConnection.check_health#s !r4Tc:|jj|yrX)rdrrs rOrz(CacheProxyConnection.send_packed_command&s &&w/r4c |j|j5|jjt |dds-d|_|j j|i| dddy ddd|jd tdt |dt|jd|_|j5|jj|j r|jj|j }|j|j k7rf|j5|jjr7|jjd|jjr7ddd dddy|jjt!|j |j"t$j&|j ddd|j j|i|y#1swYxYw#1swYxYw#1swY?xYw) NrrT)r redis_keyskeyszCannot create cache key.Tr) cache_key cache_valuestatusconnection_ref)_process_pending_invalidationsrirf is_cachablerrjrdrr rr@rrerrsetrDUMMY_CACHE_VALUEr IN_PROGRESS)rJr9rentrys rOrz!CacheProxyConnection.send_command+s ++-   ;;**8DGPR+ST26/' ''88  U ::f  %78 8+3Gfjj.@(A+ '  {{t>>? (G(GH''4::5#22;;=!00>>D>Q$22;;=)  KKOO"== $ 6 6+77#'::  !6  00W 0) s9AHA0H8AH, H8&AH8H),H5 1H88Ic8|jj|SrX)rdrrs rOrzCacheProxyConnection.can_read[szz""7++r4Frc|j5|j|jj|j|jj|jjt j k7rKtj|jj|jjcdddSddd|jj|||}|j5|j |cdddS|1|jj|jg|cdddS|jj|j}|7t j|_||_ |jj|ddd|S#1swYxYw#1swY|SxYw)N)rrr)rirjrfr rrrrrrrdrdelete_by_cache_keysVALIDr)rJrrrr) cache_entrys rOrz"CacheProxyConnection.read_response^sr  //;KKOOD$C$CDPKKOOD$C$CDKK#//0}}KKOOD$C$CDPP  ::++- 3%,    ..6   00$2Q2Q1RS ++//$*I*IJK&%5%;%; "*2 '  ,!$I $$s%B3F/<F;)F;AF;/F8;Gc4|jj|SrX)rdrErs rOrEz!CacheProxyConnection.pack_commands&tzz&&--r4c8|jj|SrX)rdrrs rOrz"CacheProxyConnection.pack_commandsszz''11r4ric.|jjSrX)rdrrms rOrz'CacheProxyConnection.handshake_metadataszz,,,r4c8|jjyrX)rdrrms rOrzCacheProxyConnection._connects r4c8|jjyrX)rdrrms rOrz CacheProxyConnection._host_errors  r4Nc|jddd|j|jj|jy)NrTRACKINGON)rrrset_invalidation_push_handler_on_invalidation_callback)rJr`s rOrlz.CacheProxyConnection._enable_tracking_callbacks8 (J5  2243Q3QRr4c|jr.|jjd|jr-yy)NTr)rrdrrms rOrz3CacheProxyConnection._process_pending_invalidationss+mmo JJ $ $$ $ 7mmor4datac|j5|d|jjn|jj|ddddy#1swYyxYw)Nr)rirfrzdelete_by_redis_keys)rJrs rOrz.CacheProxyConnection._on_invalidation_callbacksF   Aw !!# 00a9   s ?AArrr)&rQrRrSrrurtrkrrgrhr[rnrsruryr{r}rrrrrrrErrrr rr?rrrrlrr r rrTr4rOr^r^s!!G!GG>> G$(79,. % "0 .1`, %'=APU'R.2-E$ue|*S9S3T.U:r4r^cPeZdZdZ dfd ZfdZdZxZS) 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) c ts td||_||_|tj }nWt |trGtj tjtjd}||vrtd|||}||_ ||_ ||_ ||_ ||_||_| |_| |_| |_| |_| |_||_t-|\di|y)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). 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)noneoptionalrequiredz+Invalid SSL Certificate Requirements Flag: rT)r,r&keyfilecertfilessl CERT_NONEr>r? CERT_OPTIONAL CERT_REQUIRED cert_reqsca_certsca_dataca_pathcheck_hostnamecertificate_passwordssl_validate_ocspssl_validate_ocsp_stapledssl_ocsp_contextssl_ocsp_expected_certssl_min_version ssl_ciphersrDr[)rJ ssl_keyfile ssl_certfile ssl_cert_reqs ssl_ca_certs ssl_ca_datassl_check_hostname ssl_ca_path ssl_passwordrrrrrrr CERT_REQSrs rOr[zSSLConnection.__init__sPCD D" $  MMM  s + ----I I- A-Q&m4M&$ " " 0$0!!2)B& 0&<#.& "6"r4ct|} |j|S#ttf$r|j wxYw)zN Wrap the socket with SSL support, handling potential errors. )rDr_wrap_socket_with_sslrr&r)rJrrs rOrzSSLConnection._connectsHw! --d3 3$  JJL  s "!Ac,tj}|j|_|j|_|j s |j r2|j|j |j |j|j|j |j2|j|j|j|j|j|j|_|jr|j!|j|j"durt$dur t'd|j(r|j"r t'd|j+||j,}|j(r+d dl}d d lm}|j4f|j6j9|j6j:}|j=|j |j?|j n |j4}|jA||jB|j6jE|tGjF}|jI|jK|j,|jLf|jO|jQ|S|j"durRt$rLd d lm)}|||j,|jL|j} | jUr|StWd |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_socketr?OpenSSLocsprrSSLContext SSLv23_METHODuse_certificate_fileuse_privatekey_fileset_ocsp_client_callbackrr<r request_ocspr{r@ do_handshakerris_validr$) rJrcontextsslsockrr staple_ctxconros rOrz#SSLConnection._wrap_socket_with_sslsu,,.!%!4!4"nn ==DLL  # # 22 $  MM %||'||'  ) )}}T\\$,, *     +&*&:&:G #       0 0 1  ! !T ).D.M=> >  ) )d.D.D  %%dDII%F  ) )  2$$,$[[001J1JK // >..t||<!22  / /$d&A&A  ++((V]]_EC     KKDII. /     LLNN  ! !T ).D *WdiiDMMJAzz|%&=>>r4)NNrNNFNNFFNNNN)rQrRrSr7r[rrr[r\s@rOrrsF  "'#F#P Mr4rc6eZdZdZdfd ZdZdZdZxZS)UnixDomainSocketConnectionz4Manages UDS communication to and from a Redis serverc @t|di|||_||_yr>)rDr[pathr)rJrrrrs rOr[z#UnixDomainSocketConnection.__init__Us" "6" ,r4cd|jfd|jfg}|jr|jd|jf|S)Nrrr)rrrrCrFs rOrnz&UnixDomainSocketConnection.repr_piecesZsB499%dgg7    MM=$*:*:; < r4cJtjtjtj}|j|j |j |j |j|j|S#t$r|jwxYw)z&Create a Unix domain socket connection) rAF_UNIXrIrPrr{rrrr)rJrs rOrz#UnixDomainSocketConnection._connect`sy}}V^^V-?-?@ 334  LL # ++,   JJL  s BB"c|jSrX)rrms rOrz&UnixDomainSocketConnection._host_errorms yyr4)NrZr\s@rOrrRs:-  r4r)0FFALSENNOcv||dk(ryt|tr|jtvryt |S)NrF)r>r?upper FALSE_STRINGSr9)rMs rOto_boolrts4 } %%++-="@ ;r4) rrrrArrmax_connectionsrrrcB|jds-|jds|jds tdt|}i}t|jj D]N\}}|s t |dkDst|d}tj|}|r ||||<J|||<P|jrt|j|d<|jrt|j|d <|jd k(r/|jrt|j|d <t|d <|S|j rt|j |d <|j"rt%|j"|d<|jr6d|vr2 t%t|jj'dd|d<|jdk(r t*|d <|S#ttf$rtd|dwxYw#t(tf$rYMwxYw)Nzredis://z rediss://zunix://zRRedis URL must specify one of the following schemes (redis://, rediss://, unix://)rzInvalid value for 'z' in connection URL.rrunixrconnection_classr?r@r/rrediss) startswithrrrqueryrOr`rURL_QUERY_ARGUMENT_PARSERSr rFrrschemerrhostnamer@rreplaceAttributeErrorr)urlrnamerMr s rO parse_urlrs z" >>+ & >>) $ 5  3-C F *002 e SZ!^E!H%E/33D9FW#)%=F4L %t 3 ||$S\\2z ||$S\\2z zzV 88$SXX.F6N%?!"& M! <<$S\\2F6N 88 ]F6N 88F* "7388#4#<# - `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. rrT)rupdate)clsrr url_optionss rOfrom_urlzConnectionPool.from_urls?R n  '.45G.HK* + k"}V}r4Nr cache_factoryc |xsd}t|tr|dkr td||_||_||_d|_||_|jds|jdr|jddvr td|jjd}|#t|ts td ||_nc|j |jj|_n7t|jjdj|_|jdd|jddtj|_|j#y) Nlrz,"max_connections" must be a positive integer cache_configrar)rr(z4Client caching is only supported with RESP version 3z#Cache must implement CacheInterface)r>rrrconnection_kwargsrra_cache_factoryr r&r get_cacherpoprgrh _fork_lockreset)rJrrrr ras rOr[zConnectionPool.__init__sM*2U/3/?Q3FKL L 0!2. +   04E4I4I'4R $$Z0@ !WXX**..w7E !%8$%JKK" &&2!%!4!4!>!>!@DJ!-..22>B"ikJ gt,nd3$..* r4ric dt|jdt|jdt|jdi|j dS)NrrrrrT)typerRrQreprrr rms rOrzConnectionPool.__repr__4sVT %%&aT (;(;'<*T**DT-C-CDEFb J r4c:|jjddS)z Returns: The RESP protocol version, or ``None`` if the protocol is not specified, in which case the server default will be used. rN)r r rms rOr2zConnectionPool.get_protocol:s %%))*d;;r4ctj|_d|_g|_t |_tj|_ y)Nr) rgrh_lock_created_connections_available_connectionsr_in_use_connectionsrrrrms rOrzConnectionPool.resetBs9^^% $%!&(##&5 99;r4cf|jtjk7rq|jj d}|st  |jtjk7r|j |jjyy#|jjwxYw)N)r)rrrracquirer#rrelease)rJacquireds rO _checkpidzConnectionPool._checkpidSsF 88ryy{ "..q.9H** *88ryy{*JJL'') #'')s 1BB0 command_namer<cd|j|j5 |jj}|j j|ddd j |jr|j td|S#t$r|j }YywxYw#1swYcxYw#ttf$r?|j|j|jr tdY|SwxYw#t$r|jwxYw)zGet a connection from the poolNConnection has dataConnection not ready)rrrr IndexErrormake_connectionraddr{rrar$rrrrrJr roptions connections rOget_connectionzConnectionPool.get_connections#  ZZ 4!88<<>   $ $ ( ( 4       B&&(TZZ-?)*?@@3 4!113  4Z"$W- B%%'""$&&()*@AA) B   LL $   sXB6BB6D.'CB30B62B33B66B?A D DDDD/c|j}t|jdd|jdd|jddS)z,Return an encoder based on encoding settingsrrrrrF)rrr)r rr )rJrs rO get_encoderzConnectionPool.get_encodersF''ZZ G4"JJ'8(C#ZZ(:EB  r4c:|j|jk\r td|xjdz c_|j;t |j di|j |j|jS|j di|j S)zCreate a new connectionzToo many connectionsrrT)rrr$rar^rr rrms rOr%zConnectionPool.make_connections  $ $(<(< <!"89 9 !!Q&! :: !'%%%?(>(>?TZZ %t$$>t'='=>>r4r)cv|j|j5 |jj||j |r|j j|n/|xjdzc_|j dddy dddy#t$rYqwxYw#1swYyxYw)z(Releases the connection back to the poolrN) rrrrKeyErrorowns_connectionrrCrrrJr)s rOrzConnectionPool.releases  ZZ ((// ; ##J/++22:> ))Q.)%%'!Z?Z  Zs.B/B AB/ B,)B/+B,,B//B8c4|j|jk(SrX)rr1s rOr0zConnectionPool.owns_connections~~))r4inuse_connectionsc|j|j5|r!t|j|j}n |j}|D]}|j  dddy#1swYyxYw)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)rrrrrr)rJr3 connectionsr)s rOrzConnectionPool.disconnects`  ZZ #//1I1I #99 ) %%'*ZZs AA..A7c$|jy)z-Close the pool, disconnecting all connectionsNrrms rOrzConnectionPool.closerr4c|jjd|i|jD] }||_ |jD] }||_ y)Nr)r rrrr)rJrr`s rO set_retryzConnectionPool.set_retrysI %%w&67//DDJ0,,DDJ-r4rh)rirk)r)r<riNr)rr)riN)rQrRrSr7 classmethodrr<r rrr[r?rr2rrr*rr,r%rr0r9rrr8rTr4rOrrs ..d$)-9= 0"#0 56 0d 3* <"-*^3\B W  ?**,*3*(D(D((r4rcJeZdZdZddeeffd ZdZdZdZ dZ d Z xZ 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 F||_||_t| d||d|y)N)rrrT) queue_classrrDr[)rJrrrr?r rs rOr[zBlockingConnectionPool.__init__s6'   -+   r4c|j|j|_ |jjd#t$rYnwxYwg|_t j|_yrX) r?rpool put_nowaitr _connectionsrrrrms rOrzBlockingConnectionPool.reset#sf$$T%9%9:   $$T*   99;s? A  A c|j(>?TZZJ/..H1G1GHJ   ,r4c |jd} |jjd|j}||j } |j |jr t d |S#t$r t dwxYw#t tf$r?|j|j|jr t dY|SwxYw#t$r|j|wxYw)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.r"r#) rrAr rrr$r%r{rrrrrr's rOr*z%BlockingConnectionPool.get_connectionFs   >T4<<HJ  --/J      B&&()*?@@)= >""<= = >($W- B%%'""$&&()*@AA) B   LL $  s6'A=C&B=BA C#C&"C##C&&Dc|j|j|s,|j|jj dy |jj |y#t $rYywxYw)z)Releases the connection back to the pool.N)rr0rrArBrr1s rOrzBlockingConnectionPool.releasezsj ##J/  ! ! # II  &   II  ,   sA++ A76A7cf|j|jD]}|jy)z(Disconnects all connections in the pool.N)rrCrr1s rOrz!BlockingConnectionPool.disconnects( ++J  ! ! #,r4) rQrRrSr7r<rr[rr%r*rrr[r\s@rOr;r;s6F#  0 2h*$r4r;)\rrrrrGrgrabcr itertoolsrqueuerrrrtypingr r r r r rr urllib.parserrr redis.cacherrrrrr_parsersrrrrbackoffr credentialsrr exceptionsr!r"r#r$r%r&r'r(rr)utilsr*r+r,r-r.r/r0r1rDr_rdrar]robjectr__annotations__r6r8rVrkrr<r^rrrrrr8listrrrr;rTr4rOrWs ((CCC44JIO            8E, nDEFF"M M$00fB B JJ),J)ZC*#C*LE:.E:PfJfR!3>/  # ! 6rkk\ b$^b$r4