U d @sddlZddlZddlZddlZddlZddlZddlZddlmZddl m Z m Z m Z ddl m Z ddlmZmZmZddlmZddlmZddlmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+zddl,Z,d Z-Wne.k rd Z-YnXe/ej0iZ1e-r\e2e,d rRde1e,j3<de1e,j4<n de1e,j5<e6e17Z8e*rddl9Z9ee9j:Z;e;edkZd Z?e=sd Z?dZ@dZAdZBdZCdZDeEZFdZGdZHdZIdZJGdddZKGdddZLGdd d ZMGd!d"d"eLZNGd#d$d$eLZOe*r2eOZPneNZPGd%d&d&ZQGd'd(d(eQZRGd)d*d*eQZSd+ZTd,d-ZUeVeWeWeUeUeXeVeVeUd. ZYd/d0ZZGd1d2d2Z[Gd3d4d4e[Z\dS)5N)chain)EmptyFull LifoQueue)time)parse_qsunquoteurlparse)Version) NoBackoff)AuthenticationError$AuthenticationWrongNumberOfArgsErrorBusyLoadingErrorChildDeadlockedErrorConnectionError DataErrorExecAbortErrorInvalidResponse ModuleErrorNoPermissionError NoScriptError ReadOnlyError RedisError ResponseError TimeoutError)Retry)CRYPTOGRAPHY_AVAILABLEHIREDIS_AVAILABLE str_if_bytesTFSSLWantReadErrorz0.1.3z0.1.4z1.0.0*$s zConnection closed by server.z:Error loading the extension. Please check the server logs.z5Error unloading module: no such module with that namez/Error unloading module: operation not possible.z[Error unloading module: the module exports one or more module-side data types, can't unloadc@s*eZdZdZddZddZd ddZd S) Encoderz=Encode strings to bytes-like and decode bytes-like to stringscCs||_||_||_dSNencodingencoding_errorsdecode_responses)selfr'r(r)r+4/tmp/pip-unpacked-wheel-f5h5_hbx/redis/connection.py__init__XszEncoder.__init__cCst|ttfr|St|tr&tdn@t|ttfrBt|}n$t|t sft |j }td|dt|t r||j |j }|S)z=Return a bytestring or bytes-like representation of the valuezNInvalid input of type: 'bool'. Convert to a bytes, string, int or float first.zInvalid input of type: 'z2'. Convert to a bytes, string, int or float first.) isinstancebytes memoryviewboolrintfloatreprencodestrtype__name__r'r()r*valuetypenamer+r+r,r5]s      zEncoder.encodeFcCs:|js |r6t|tr|}t|tr6||j|j}|S)z:Return a unicode string from the bytes-like representation)r)r.r0tobytesr/decoder'r()r*r9forcer+r+r,r<ts    zEncoder.decodeN)F)r8 __module__ __qualname____doc__r-r5r<r+r+r+r,r$Usr$c@sLeZdZdededededeeeeee ee ei e e e eeedZddZd S) BaseParserzmax number of clients reachedz(Client sent AUTH, but no password is setzinvalid passwordz,wrong number of arguments for 'auth' commandz,wrong number of arguments for 'AUTH' command)ZERRZ EXECABORTZLOADINGZNOSCRIPTZREADONLYZNOAUTHZNOPERMcCs\|dd}||jkrT|t|dd}|j|}t|trL||t}||St|S)zParse an error response rN)splitEXCEPTION_CLASSESlenr.dictgetr)r*responseZ error_codeZexception_classr+r+r, parse_errors    zBaseParser.parse_errorN)r8r>r?rr r MODULE_LOAD_ERRORrMODULE_EXPORTS_DATA_TYPES_ERRORNO_SUCH_MODULE_ERROR MODULE_UNLOAD_NOT_POSSIBLE_ERRORrrrrrrErJr+r+r+r,rA~s6rAc@sXeZdZddZeddZdedfddZd d Zd d Z d dZ ddZ ddZ dS) SocketBuffercCs,||_||_||_t|_d|_d|_dSNr)_socksocket_read_sizesocket_timeoutioBytesIO_buffer bytes_written bytes_read)r*socketrRrSr+r+r,r-s  zSocketBuffer.__init__cCs |j|jSr%)rWrXr*r+r+r,lengthszSocketBuffer.lengthNTc CsP|j}|j}|j}||jd}|tk }z z||r>|||j|} t | t rht | dkrht t || t | } |j| 7_|| 7}|dk r||krq>WWdStjk r|rtdYWjdStk r2} zBt| jd} |s| j| krWYW*dSt d| jW5d} ~ XYnXW5|rJ||jXdSNrTzTimeout reading from socketFz!Error while reading from socket: )rQrRrVseekrWSENTINEL settimeoutrSrecvr.r/rFrSERVER_CLOSED_CONNECTION_ERRORwriterYtimeoutrNONBLOCKING_EXCEPTIONS#NONBLOCKING_EXCEPTION_ERROR_NUMBERSrH __class__errnoargs) r*r[rdraise_on_timeoutsockrRbufmarkercustom_timeoutdataZ data_lengthexallowedr+r+r,_read_from_sockets<      &zSocketBuffer._read_from_socketcCst|jp|j|ddS)NFrdrj)r1r[rrr*rdr+r+r,can_readszSocketBuffer.can_readcCsn|d}||jkr"|||j|j|j|j|}|jt|7_|j|jkrb||ddS)Nr ) r[rrrVr^rXreadrFrWpurge)r*r[ror+r+r,rws   zSocketBuffer.readcCst|j}||j|}|tsB|||j|}q|jt|7_|j|jkrh| |ddS)Nrv) rVr^rXreadlineendswithSYM_CRLFrrrFrWrx)r*rlror+r+r,rys     zSocketBuffer.readlinecCs&|jd|jd|_d|_dSrP)rVr^truncaterWrXrZr+r+r,rxs  zSocketBuffer.purgecCs<z||jWntk r*YnXd|_d|_dSr%)rxrVclose ExceptionrQrZr+r+r,r} szSocketBuffer.close) r8r>r?r-propertyr[r_rrrurwryrxr}r+r+r+r,rOs  )rOc@sBeZdZdZddZddZddZdd Zd d Zdd dZ dS) PythonParserzPlain Python parsing classcCs||_d|_d|_d|_dSr%)rRencoderrQrVr*rRr+r+r,r-szPythonParser.__init__cCs&z |Wntk r YnXdSr% on_disconnectr~rZr+r+r,__del__$s zPythonParser.__del__cCs(|j|_t|j|j|j|_|j|_dS)zCalled when the socket connectsN)rQrOrRrSrVrr* connectionr+r+r, on_connect*szPythonParser.on_connectcCs*d|_|jdk r |jd|_d|_dS)z"Called when the socket disconnectsN)rQrVr}rrZr+r+r,r2s   zPythonParser.on_disconnectcCs|jo|j|Sr%)rVrurtr+r+r,ru:szPythonParser.can_readFcsj}|stt|dd|dd}}|dkrFtd||dkrx|jddd}|}t|trt||S|dkrnp|d krt|}n^|d krt|}|d krdSj |}n4|d krt|}|d krdSfd dt |D}t|t rdkrj |}|S)NrC)-+:r"r!zProtocol Error: rutf-8replace)errorsrrr"r]r!csg|]}jdqS)disable_decoding) read_response).0irr*r+r, esz.PythonParser.read_response..F) rVryrrbrr<rJr.r2rwranger/r)r*rrawbyterIerrorr[r+rr,r=s>      zPythonParser.read_responseN)F) r8r>r?r@r-rrrrurr+r+r+r,rsrc@sPeZdZdZddZddZddZdd Zd d Ze d fd dZ dddZ dS) HiredisParserz*Parser class for connections using HirediscCs$ts td||_tr t||_dS)NzHiredis is not installed)rrrRHIREDIS_USE_BYTE_BUFFER bytearrayrVrr+r+r,r-qs zHiredisParser.__init__cCs&z |Wntk r YnXdSr%rrZr+r+r,rys zHiredisParser.__del__cKsd|j|_|j|_t|jd}ts(t|d<|jjr<|jj |d<t rL|jj |d<t j f||_d|_dS)N)Z protocolError replyErrorrr'rF)rQrS_socket_timeoutrrJ HIREDIS_SUPPORTS_CALLABLE_ERRORSrrr)r' HIREDIS_SUPPORTS_ENCODING_ERRORSr(hiredisReader_reader_next_response)r*rkwargsr+r+r,rs   zHiredisParser.on_connectcCsd|_d|_d|_dS)NF)rQrrrZr+r+r,rszHiredisParser.on_disconnectcCs@|jstt|jdkr<|j|_|jdkr<|j|ddSdS)NFrsT)rrrbrgetsread_from_socketrtr+r+r,rus   zHiredisParser.can_readTc Cs>|j}|tk }zz|r"||trX|j|j}|dkrDtt|j |jd|n8|j |j }t |tr|t|dkrtt|j |WWdStjk r|rtdYWjdStk r }zBt|jd}|s|j|krWYW*dStd|jW5d}~XYnXW5|r8||jXdSr\)rQr_r`rr recv_intorVrrbrfeedrarRr.r/rFrYrdrrerfrHrgrhri) r*rdrjrkrnZbufflenbufferrprqr+r+r,rs4    &zHiredisParser.read_from_socketFcCs|jstt|jdk r(|j}d|_|S|r:|jd}n |j}|dkrr||rf|jd}qD|j}qDtst|tr| |j d}n4t|t r|rt|dtr| |dj d|d<t|tr|n$t|t r|rt|dtr|d|S)NFr) rrrbrrrrr.rrJrilist)r*rrIr+r+r,rsD       zHiredisParser.read_responseN)F) r8r>r?r@r-rrrrur_rrr+r+r+r,rns %rc@seZdZdZddddddddddeddded dddddfd d Zd d ZddZddZ ddZ ddZ ddZ ddZ ddZddZddZd d!Zd"d#Zd$d%Zd&d'Zd5d)d*Zd+d,Zd6d-d.Zd7d/d0Zd1d2Zd3d4ZdS)8 Connectionz4Manages TCP communication to and from a Redis server localhostirNFrstrictcCst|_||_t||_||_||_||_||_ ||_ |p>||_ ||_ |pNi|_ | |_| |_| tkrjg} | rx| t| |_| r|dkrttd|_n t||_|j| nttd|_||_d|_||_t| | ||_d|_||_ |!|g|_"d|_#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`. NrCrp)$osgetpidpidhostr2portdbusername client_namepasswordrSsocket_connect_timeoutsocket_keepalivesocket_keepalive_options socket_typeretry_on_timeoutr_appendrretry_on_errorrr retrycopydeepcopyupdate_supported_errorshealth_check_intervalnext_health_checkredis_connect_funcr$rrQ_socket_read_size set_parser_connect_callbacks_buffer_cutoff)r*rrrrrSrrrrrrr'r(r) parser_classrRrrrrrr+r+r,r-sB       zConnection.__init__cCs,ddd|D}|jjd|dS)N,cSsg|]\}}|d|qS)=r+)rkvr+r+r,rAsz'Connection.__repr__..<>)join repr_piecesrgr8)r*Z repr_argsr+r+r,__repr__@szConnection.__repr__cCs6d|jfd|jfd|jfg}|jr2|d|jf|S)Nrrrr)rrrrrr*piecesr+r+r,rDszConnection.repr_piecescCs&z |Wntk r YnXdSr%) disconnectr~rZr+r+r,rJs zConnection.__del__cCs|jt|dSr%)rrweakref WeakMethod)r*callbackr+r+r,register_connect_callbackPsz$Connection.register_connect_callbackcCs g|_dSr%)rrZr+r+r,clear_connect_callbacksSsz"Connection.clear_connect_callbackscCs||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 )rRN)r_parser)r*rr+r+r,rVszConnection.set_parserc sjr dSz"jfddfdd}WnLtjk rJtdYn0tk rx}zt|W5d}~XYnX|_z"j dkr n Wnt k r YnXj D]}|}|r|qdS)z5Connects to the Redis server if not already connectedNcsSr%)_connectr+rZr+r,dr#z$Connection.connect..cs |Sr%r)rrZr+r,rdr#zTimeout connecting to server)rQrcall_with_retryrYrdrOSErrorr_error_messagerrrrr)r*rkerefrr+rZr,connect^s.      zConnection.connectc Csd}t|j|j|jtjD]}|\}}}}}d}zt|||}|tjtjd|j r|tj tj d|j D]\} } |tj| | qv||j||||j|WStk r} z| }|dk r|W5d} ~ XYqXq|dk r|tddS)zCreate a TCP socket connectionNrCz)socket.getaddrinfo returned an empty list)rY getaddrinforrr SOCK_STREAM setsockopt IPPROTO_TCP TCP_NODELAYr SOL_SOCKET SO_KEEPALIVEritemsr`rrrSrr}) r*errresfamilysocktypeproto canonnameZsocket_addressrkrr_r+r+r,rs6     zConnection._connectc Cst|jdkrZz$d|jd|jd|jddWStk rVd|jdYSXnVz0d|jdd |jd|jd |jdd WStk rd|jdYSXdS) NrCzError connecting to :z. r.zConnection Error: Error z connecting to . )rFrirrAttributeErrorr* exceptionr+r+r,rs ,zConnection._error_messagecCs|j||js|jr|jr0|j|jp*df}n|jf}|jd|ddiz |}Wn.tk r|jd|jdd|}YnXt|dkrtd|j r|dd |j t|dkrt d |j r|d |j t|dkrt d d S)z=Initialize the connection, authenticate and select a databaseAUTH check_healthFrOKzInvalid Username or PasswordZCLIENTZSETNAMEzError setting client nameZSELECTzInvalid DatabaseN)r) rrrr send_commandrr rr rrr)r*Z auth_argsZ auth_responser+r+r,rs*    zConnection.on_connectcGs||j|jdkrdSt|jkrNz|jtjWnt k rLYnXz|j Wnt k rpYnXd|_dS)z!Disconnects from the Redis serverN) rrrQrrrshutdownrY SHUT_RDWRrr})r*rir+r+r,rs  zConnection.disconnectcCs*|jdddt|dkr&tddS)z Send PING, expect PONG in returnZPINGFrZPONGz#Bad response from PING health checkN)rrrrrZr+r+r, _send_pingszConnection._send_pingcCs |dS)z Function to call when PING failsNr)r*rr+r+r, _ping_failedszConnection._ping_failedcCs(|jr$t|jkr$|j|j|jdS)z3Check the health of the connection with a PING/PONGN)rrrrrrrrZr+r+r,rszConnection.check_healthTc Cs|js||r|z*t|tr,|g}|D]}|j|q0Wntjk rj|t dYnt k r}zV|t |j dkrd|j d}}n|j d}|j d}t d|d|dW5d}~XYntk r|YnXdS) z2Send an already packed command to the Redis serverzTimeout writing to socketrCUNKNOWNrrz while writing to socket. rN)rQrrr.r6sendallrYrdrrrrFrir BaseException)r*commandritemrrherrmsgr+r+r,send_packed_commands,    &zConnection.send_packed_commandcOs |j|j||ddddS)z+Pack and send a command to the Redis serverrTrN)r pack_commandrH)r*rirr+r+r,rs zConnection.send_commandc Csp|j}|s|z|j|WStk rj}z,|td|jd|jd|j W5d}~XYnXdS)z8Poll the socket to see if there's data that can be read.Error while reading from rz: N) rQrrrurrrrrri)r*rdrkrr+r+r,ru#szConnection.can_readc Csz|jd|j}Wntk r.d}YnXz|jj|d}Wntjk rn|td|Yn\t k r}z"|t d|d|j W5d}~XYnt k r|YnX|j rt|j |_t|tr||S)z0Read the response from a previously sent commandrrrzTimeout reading from rz : N)rrrrrrYrdrrrrrir rrrr.r)r*rZhosterrrIrr+r+r,r0s( & zConnection.read_responsec Gsg}t|dtr4t|d|dd}n(d|dkr\t|d|dd}tttt|t f}|j }t |j j|D]|}t|}t||ks||kst|t rt|tt|t f}||||t }qt|tt|t |t f}q|||S)z2Pack a series of arguments into the Redis protocolrrCN )r.r6tupler5rD SYM_EMPTYrSYM_STARrFr{rmaprr0 SYM_DOLLARr)r*rioutputZbuff buffer_cutoffargZ arg_lengthr+r+r,rJs@"      zConnection.pack_commandc Csg}g}d}|j}|D]~}|j|D]n}t|}||ksJ||ksJt|trb|t|d}g}||kstt|tr||q$||||7}q$q|r|t||S)z.Pack multiple commands into the Redis protocolr)rrrFr.r0rrr) r*commandsrrZ buffer_lengthrcmdchunkZchunklenr+r+r, pack_commandsws.   zConnection.pack_commands)T)r)F)r8r>r?r@r_ DefaultParserr-rrrrrrrrrrrrrrrrrurrrr+r+r+r,rsV F!)'  -rc s.eZdZdZd fdd ZfddZZS) 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) NrequiredFc  sts tdtjf| ||_||_|dkr6tj}n:t|t rptjtj tj d}||krhtd|||}||_ ||_ ||_||_||_||_| |_| |_| |_| |_dS)aeConstructor 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)noneoptionalr z+Invalid SSL Certificate Requirements Flag: ) ssl_availablersuperr-keyfilecertfilessl CERT_NONEr.r6 CERT_OPTIONAL CERT_REQUIRED cert_reqsca_certsca_dataca_pathcheck_hostnamecertificate_passwordssl_validate_ocspssl_validate_ocsp_stapledssl_ocsp_contextssl_ocsp_expected_cert)r*Z ssl_keyfileZ ssl_certfileZ ssl_cert_reqsZ ssl_ca_certsZ ssl_ca_datassl_check_hostnameZ ssl_ca_pathZ ssl_passwordr1r2r3r4rZ CERT_REQSrgr+r,r-s6$ zSSLConnection.__init__c st}t}|j|_|j|_|js.|jrD|j |j|j|j d|j dk sb|j dk sb|j dk rx|j|j |j |j d|j||jd}|jdkrtdkrtd|jr|jrtd|jr\d dl}d d lm}|jdkr|j|jj}||j||jn|j}|||j|j |t!!}|"|#|j|j$f|%|&|S|jdkrtrd d lm'}|||j|j$|j } | (r|St)d |S)z Wrap the socket with SSL support)r&r%rN)cafilecapathcadata)server_hostnameTFzcryptography is not installed.zKEither an OCSP staple or pure OCSP connection must be validated - not both.rrC)ocsp_staple_verifier) OCSPVerifierzocsp validation error)*r$rr'create_default_contextr/r+ verify_moder&r%load_cert_chainr0r,r.r-load_verify_locations wrap_socketrr1rrr2OpenSSLZocspr;r3ZSSLContextZ SSLv23_METHODZuse_certificate_fileZuse_privatekey_fileZset_ocsp_client_callbackr4rrYZ request_ocsprr do_handshakerr<Zis_validr) r*rkcontextsslsockrBr;Z staple_ctxconr<or6r+r,rsj        zSSLConnection._connect) NNr NNFNNFFNN)r8r>r?r@r-r __classcell__r+r+r6r,rsCrc@sNeZdZdddddddddeedddddfdd Zd d Zd d ZddZdS)UnixDomainSocketConnectionrrNrrFrcCst|_||_||_||_||_||_||_| |_ | t kr@g} | rN| t | |_ |j r|dkrrttd|_n t||_|j| nttd|_| |_d|_||_t||||_d|_| |_|| g|_d|_dS)aB Initialize a new UnixDomainSocketConnection. 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`. NrCrr)rrrpathrrrrrSrr_rrrrr rrrrrrrr$rrQrrrr)r*rKrrrrSr'r(r)rrrrRrrrrr+r+r,r-#s8    z#UnixDomainSocketConnection.__init__cCs.d|jfd|jfg}|jr*|d|jf|S)NrKrr)rKrrrrr+r+r,r_sz&UnixDomainSocketConnection.repr_piecescCs,ttjtj}||j||j|S)z&Create a Unix domain socket connection)rYAF_UNIXrr`rSrrK)r*rkr+r+r,res  z#UnixDomainSocketConnection._connectcCsRt|jdkr(d|jd|jddSd|jdd|jd|jddSdS)NrCz!Error connecting to unix socket: rrrrz connecting to unix socket: )rFrirKrr+r+r,rls$z)UnixDomainSocketConnection._error_message) r8r>r?r_rr-rrrr+r+r+r,rJ"s( <rJ)0FFALSENNOcCs6|dks|dkrdSt|tr.|tkr.dSt|S)NrF)r.r6upper FALSE_STRINGSr1)r9r+r+r,to_bool{s rT) rrSrrrrmax_connectionsrr5c Cst|}i}t|jD]v\}}|rt|dkrt|d}t|}|rz||||<Wqtt fk rt d|dYqXq|||<q|j rt|j |d<|j rt|j |d<|j dkr|j rt|j |d<t|d<n|j d kr||jrt|j|d <|jrt|j|d <|j rfd |krfztt|j d d|d <Wntt fk rdYnX|j dkrt|d<nt d|S)NrzInvalid value for `z` in connection URL.rrunixrKconnection_class)Zredisredissrrr/rrXzRRedis URL must specify one of the following schemes (redis://, rediss://, unix://))r rqueryrrFrURL_QUERY_ARGUMENT_PARSERSrH TypeError ValueErrorrrschemerKrJhostnamerr2rrr)urlrnamer9parserr+r+r, parse_urlsH        rcc@steZdZdZeddZedfddZddZd d Z d d Z d dZ ddZ ddZ ddZddZdddZdS)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``. cKs0t|}d|kr|d|d<|||f|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]:[password]]@/path/to/socket.sock?db=0 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. rW)rcupdate)clsr`rZ url_optionsr+r+r,from_urls )  zConnectionPool.from_urlNcKsJ|pd}t|tr|dkr"td||_||_||_t|_| dS)Nlrz,"max_connections" must be a positive integer) r.r2r]rWconnection_kwargsrU threadingLock _fork_lockreset)r*rWrUrhr+r+r,r-s zConnectionPool.__init__cCs$t|jdt|jf|jdS)Nrr)r7r8r4rWrhrZr+r+r,rs"zConnectionPool.__repr__cCs,t|_d|_g|_t|_t|_ dSrP) rirj_lock_created_connections_available_connectionsset_in_use_connectionsrrrrZr+r+r,rls   zConnectionPool.resetcCsP|jtkrL|jjdd}|s$tz|jtkr<|W5|jXdS)N)rd)rrrrkacquirerreleaserl)r*Zacquiredr+r+r, _checkpid0s# zConnectionPool._checkpidc Os||j>z|j}Wntk r:|}YnX|j|W5QRXzZ|z| rnt dWn8t t fk r| || rt dYnXWn t k r||YnX|S)zGet a connection from the poolConnection has dataConnection not ready)rurmropop IndexErrormake_connectionrqaddrrurrrr rtr* command_namekeysoptionsrr+r+r,get_connection_s*  zConnectionPool.get_connectioncCs,|j}t|dd|dd|dddS)z,Return an encoder based on encoding settingsr'rr(rr)Fr&)rhr$rH)r*rr+r+r, get_encoders    zConnectionPool.get_encodercCs0|j|jkrtd|jd7_|jf|jS)zCreate a new connectionzToo many connectionsrC)rnrUrrWrhrZr+r+r,rzs zConnectionPool.make_connectionc Cs||jhz|j|Wntk r4YnX||rN|j|n$|jd8_| W5QRdSW5QRXdS)z(Releases the connection back to the poolrCN) rurmrqremoveKeyErrorowns_connectionrorrnrrr+r+r,rts zConnectionPool.releasecCs |j|jkSr%)rrr+r+r,rszConnectionPool.owns_connectionTc CsJ||j2|r$t|j|j}n|j}|D] }|q.W5QRXdS)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)rurmrrorqr)r*Zinuse_connections connectionsrr+r+r,rszConnectionPool.disconnect)T)r8r>r?r@ classmethodrgrr-rrlrurrrzrtrrr+r+r+r,rds  1 /! rdcsReZdZdZddeeffdd ZddZdd Zd d Z d d Z 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(||_||_tjf||d|dS)N)rWrU) queue_classrdr$r-)r*rUrdrWrrhr6r+r,r-s zBlockingConnectionPool.__init__cCsN||j|_z|jdWqtk r6Yq:YqXqg|_t|_dSr%) rrUpool put_nowaitr _connectionsrrrrZr+r+r,rls  zBlockingConnectionPool.resetcCs|jf|j}|j||S)zMake a fresh connection.)rWrhrrrr+r+r,rzs z&BlockingConnectionPool.make_connectionc Os|d}z|jjd|jd}Wntk r>tdYnX|dkrP|}zZ|z|rltdWn8tt fk r| ||rtdYnXWn t k r| |YnX|S)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)blockrdzNo connection available.rvrw) rurrHrdrrrzrrurrr rtr|r+r+r,rs,   z%BlockingConnectionPool.get_connectioncCsT|||s*||jddSz|j|Wntk rNYnXdS)z)Releases the connection back to the pool.N)rurrrrrrr+r+r,rtBs  zBlockingConnectionPool.releasecCs ||jD] }|qdS)z(Disconnects all connections in the pool.N)rurrrr+r+r,rWs z!BlockingConnectionPool.disconnect) r8r>r?r@rrr-rlrzrrtrrIr+r+r6r,rs#4r)]rrhrTrrYrir itertoolsrqueuerrrr urllib.parserrr Zpackaging.versionr Z redis.backoffr Zredis.exceptionsr r rrrrrrrrrrrrrZ redis.retryrZ redis.utilsrrrr'r# ImportErrorBlockingIOError EWOULDBLOCKrfhasattrrSSLWantWriteErrorSSLErrorrr~rer __version__Zhiredis_versionrZHIREDIS_SUPPORTS_BYTE_BUFFERrrrrr{rrbobjectr_rKrMrNrLr$rArOrrrrrrJrSrTr2r3rr[rcrdrr+r+r+r,s    D            )'vS!V  4z