Ë
|
|
çúhû ã óZ d dl Z d dlZd dlZd dlZd dlZd dlmZmZmZm Z m
|
Z
|
m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZ d dlmZmZm Z m Z d dl m Z m Z m!Z!m"Z" d dl#m$Z$ d dl%m&Z& d dl'm(Z( d dl)m*Z*m+Z+m,Z,m-Z- d d l.m/Z/m0Z0m1Z1m2Z2 d d
|
l3m4Z4 d d l5m6Z6m7Z7m8Z8m9Z9m:Z: d d l;m<Z<m=Z=m>Z>m?Z?m@Z@mAZA d d lBmCZCmDZDmEZE d dlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZN er eGr d dlOmPZPmQZQmRZR ndZPdZRdZQe
|
e eSeSf ge d f ZT edeE¬« ZU edeEeD« ZV edd¬« ZW edeeCeXf ¬« ZYerd dlZm[Z[ G d de« Z\ G d de« Z]ee\e]f Z^ G d de,e0e/e1« Z_e_Z` G d d e« Za G d d « Zb G d d!« Zc G d" d#e« Zd G d$ d%e« Zeeedeef ZfeeeeSegf d&f eeSef f Zhe eh Zi G d' d(e_« Zjy))é N)Ú TYPE_CHECKINGÚAnyÚ AsyncIteratorÚ AwaitableÚCallableÚDictÚIterableÚListÚMappingÚMutableMappingÚOptionalÚProtocolÚSetÚTupleÚTypeÚ TypedDictÚTypeVarÚUnionÚcast)Ú_RedisCallbacksÚ_RedisCallbacksRESP2Ú_RedisCallbacksRESP3Úbool_ok)Ú
|
ConnectionÚConnectionPoolÚ SSLConnectionÚUnixDomainSocketConnection©ÚLock)ÚRetry)Ú ExponentialWithJitterBackoff)ÚEMPTY_RESPONSEÚ NEVER_DECODEÚ AbstractRedisÚCaseInsensitiveDict)ÚAsyncCoreCommandsÚAsyncRedisModuleCommandsÚAsyncSentinelCommandsÚ list_or_args)ÚCredentialProvider)Ú(AfterPooledConnectionsInstantiationEventÚ'AfterPubSubConnectionInstantiationEventÚ'AfterSingleConnectionInstantiationEventÚ
|
ClientTypeÚEventDispatcher)ÚConnectionErrorÚExecAbortErrorÚ PubSubErrorÚ
|
RedisErrorÚ ResponseErrorÚ
|
WatchError)ÚChannelTÚ
|
EncodableTÚKeyT)Ú SSL_AVAILABLEÚ_set_info_loggerÚdeprecated_argsÚdeprecated_functionÚget_lib_versionÚsafe_strÚ str_if_bytesÚ truncate_text)Ú
|
TLSVersionÚ VerifyFlagsÚ
|
VerifyModeÚ_KeyT)ÚboundÚ_ArgTÚ_RedisTÚRedisÚ_NormalizeKeysT)ÚScriptc ó e Zd ZdefdZy)ÚResponseCallbackProtocolÚresponsec ó y ©N© ©ÚselfrM Úkwargss õg H:\项ç®\archive\æµè¯ç»\èæ¬\Change_password\venv_build\Lib\site-packages\redis/asyncio/client.pyÚ__call__z!ResponseCallbackProtocol.__call__d ó ó N©Ú__name__Ú
|
__module__Ú __qualname__r rU rP rW rT rL rL c s
|
Ø4 Ô4rW rL c ó e Zd ZdefdZy)Ú AsyncResponseCallbackProtocolrM c ó K y wrO rP rQ s rT rU z&AsyncResponseCallbackProtocol.__call__h ó è ø ùó NrX rP rW rT r] r] g s
|
Ø: sÔ:rW r] c O ó¬ e Zd ZU dZeeeef ef e d< e
|
d{dede de e fd« Z e
|
d ed d
|
ed d fd « Z ed gdd¬« dddddddddddddd e edd¬« d¬« dddddddddd ddddddd e« ddddd dd 'd ed!ed"eeef d#e e d$e e d%e e d&e e d'e eeeeef f d
|
e e d(e e d)ed*ed+e d e d,ed-e e d.e d/e e d0e e d1eeef d2e ee d3e ee d4e e d5e e d6e d7e e d8e e d9e e de d:ed;e e d<e e d=e e d>e e de e d?e e d@e e dAe e fLdB« Z dC Z dD Z!dEe"d e"fdFZ#dGedHefdIZ$dJ Z%dK Z&d e e fdLZ'd,ed dfdMZ(dN Z) d|dOe dPe e d dQfdRZ*ddddSdTe+dQgee,e-e, f f dUe.dPe e dVe dWe e f
|
dXZ/ d}dYe.dZe e d[ed\e d]e e d^e ee0 d_e d`e d e0fdaZ1d~dbZ2ddcZ3dddZ4dEe"d e"fdeZ5d efdfZ6d efdgZ7dh Z8diZ9e:jv e<jz fdje,dke,d dfdlZ>ddme e d dfdnZ? e@dodpdq¬r« ddme e d dfds« ZAdt ZBdueCfdvZDdw ZEdxeCdyeeef fdzZFy)rH a
|
Implementation of the Redis protocol.
|
|
This abstract class provides a Python interface to all Redis commands
|
and an implementation of the Redis protocol.
|
|
Pipelines derive from this, implementing how
|
the commands are sent and received to the Redis server. Based on
|
configuration, an instance will either use a ConnectionPool, or
|
Connection object to talk to redis.
|
Úresponse_callbacksFNÚurlÚsingle_connection_clientÚauto_close_connection_poolc ó t j |fi |¤} | ||¬« }| t j t d« « nd}||_ |S )a
|
Return a Redis client object configured from the given URL
|
|
For example::
|
|
redis://[[username]:[password]]@localhost:6379/0
|
rediss://[[username]:[password]]@localhost:6379/0
|
unix://[username@]/path/to/socket.sock?db=0[&password=password]
|
|
Three URL schemes are supported:
|
|
- `redis://` creates a TCP socket connection. See more at:
|
<https://www.iana.org/assignments/uri-schemes/prov/redis>
|
- `rediss://` creates a SSL wrapped TCP socket connection. See more at:
|
<https://www.iana.org/assignments/uri-schemes/prov/rediss>
|
- ``unix://``: creates a Unix Domain Socket connection.
|
|
The username, password, hostname, path and all querystring values
|
are passed through urllib.parse.unquote in order to replace any
|
percent-encoded values with their corresponding characters.
|
|
There are several ways to specify a database number. The first value
|
found will be used:
|
|
1. A ``db`` querystring option, e.g. redis://localhost?db=0
|
|
2. If using the redis:// or rediss:// schemes, the path argument
|
of the url, e.g. redis://localhost/0
|
|
3. A ``db`` keyword argument to this function.
|
|
If none of these options are specified, the default db=0 is used.
|
|
All querystring options are cast to their appropriate Python types.
|
Boolean arguments can be specified with string values "True"/"False"
|
or "Yes"/"No". Values that cannot be properly cast cause a
|
``ValueError`` to be raised. Once parsed, the querystring arguments
|
and keyword arguments are passed to the ``ConnectionPool``'s
|
class initializer. In the case of conflicting arguments, querystring
|
arguments always win.
|
|
©Úconnection_poolrd ú"auto_close_connection_pool" is deprecated since version 5.0.1. Please create a ConnectionPool explicitly and provide to the Redis() constructor instead.T)r Úfrom_urlÚwarningsÚwarnÚDeprecationWarningre )Úclsrc rd re rS rh Úclients rT rj zRedis.from_url sa ôd )×1Ñ1°#Ñ@¸Ñ@ÙØ +Ø%=ô
|
ð &Ð 1Ü MMÜ"ðBóõ ð *.Ð &Ø,FÔ)Ø rW rn rh Úreturnc ó& | |¬« }d|_ |S )zÁ
|
Return a Redis client from the given connection pool.
|
The Redis client will take ownership of the connection pool and
|
close it when the Redis client is closed.
|
)rh T)re )rn rh ro s rT Ú from_poolzRedis.from_poolÄ s ñ Ø +ô
|
ð -1Ô)Ø rW Úretry_on_timeoutz$TimeoutError is included by default.z6.0.0)Ú args_to_warnÚreasonÚversionÚ localhostië r zutf-8Ústricté é
|
)ÚbaseÚcapé )ÚbackoffÚretriesÚrequiredTzredis-pyé )'ÚhostÚportÚdbÚpasswordÚsocket_timeoutÚsocket_connect_timeoutÚsocket_keepaliveÚsocket_keepalive_optionsrh Úunix_socket_pathÚencodingÚencoding_errorsÚdecode_responsesrs ÚretryÚretry_on_errorÚsslÚ ssl_keyfileÚ ssl_certfileÚ ssl_cert_reqsÚssl_include_verify_flagsÚssl_exclude_verify_flagsÚ ssl_ca_certsÚ ssl_ca_dataÚssl_check_hostnameÚssl_min_versionÚ ssl_ciphersÚmax_connectionsrd Úhealth_check_intervalÚ client_nameÚlib_nameÚ lib_versionÚusernamere Úredis_connect_funcÚcredential_providerÚprotocolÚevent_dispatcherr r r r
r r r r r r r r r r r r r r r r r r r r r r r r r r r r¢ r£ r¤ c ' óZ |'t « | _ n|'| _ |# t j t d« « nd}#| sé|sg }i d|d|"d|d|%d|d | d
|
| d | d |d t j |« d| d| d| d| d|!d|$d|&}(|
|
|(j |
|
t d« n:|(j |||||d« |r!|(j t ||||||||||d « |#| _
|
t di |(¤} | j j t | gt j |%« « n<d| _
|
| j j t | gt j |%« « | | _ | | _ d| _ t' t( « | _ | j j, j/ d« dv r | j* j t0 « n | j* j t2 « t5 j6 « | _ d| _ t5 j6 « | _ y) a½
|
Initialize a new Redis client.
|
|
To specify a retry policy for specific errors, you have two options:
|
|
1. Set the `retry_on_error` to a list of the error/s to retry on, and
|
you can also set `retry` to a valid `Retry` object(in case the default
|
one is not appropriate) - with this approach the retries will be triggered
|
on the default errors specified in the Retry object enriched with the
|
errors specified in `retry_on_error`.
|
|
2. Define a `Retry` object with configured 'supported_errors' and set
|
it to the `retry` parameter - with this approach you completely redefine
|
the errors on which retries will happen.
|
|
`retry_on_timeout` is deprecated - please include the TimeoutError
|
either in the Retry object or in the `retry_on_error` list.
|
|
When 'connection_pool' is provided - the retry configuration of the
|
provided pool will be used.
|
Nri Tr r r
r¢ r r r r r r r r r r r r¡ r£ )ÚpathÚconnection_class)r r r r r ) r§ r r r r r r r r r r F)Ú3r} r rP ) r/ Ú_event_dispatcherrk rl rm ÚcopyÚdeepcopyÚupdater r re r Údispatchr+ r. ÚASYNCrh rd Ú
|
connectionr% r rb Úconnection_kwargsÚgetr r Úasyncior Ú_single_conn_lockÚ_usage_counterÚ _usage_lock))rR r r r r
r r r r rh r r r r rs r r r r r r r r r r r r r r rd r r r r r re r¡ r¢ r£ r¤ rS s) rT Ú__init__zRedis.__init__Ô sº ðP Ð #Ü%4Ó%6DÕ "à%5DÔ "ð &Ð 1Ü MMÜ"ðBóõ ð *.Ð &á á!Ø!#ðØbðàHðð Hðð &Ð':ð ð
|
! .ð ð Hð ð " ?ðð #Ð$4ðð ! .ðð uÓ-ðð " ?ðð (Ð)>ðð {ðð Hð ð {ð ð %Ð&8ð!ð" Hð#Fð( Ð+Ø à 0Ü,Fñõð à $Ø $Ø2HØ,<Ø4Lñ ôñ ØMMä0=Ø+6Ø,8Ø-:Ø8PØ8PØ,8Ø+6Ø2DØ/>Ø+6ñ ôð /IDÔ +Ü ,Ñ 6¨vÑ 6OØ × "Ñ "× +Ñ +Ü8Ø$Ð%¤z×'7Ñ'7Ð9Lóõ ð /4DÔ +Ø × "Ñ "× +Ñ +Ü8Ø$Ð%¤z×'7Ñ'7Ð9Lóô ð /Ô Ø(@Ô%Ø04ä"5´oÓ"FÔ à × Ñ × 1Ñ 1× 5Ñ 5°jÓ AÀXÑ MØ × #Ñ #× *Ñ *Ô+?Õ @à × #Ñ #× *Ñ *Ô+?Ô @ô
|
")§ ¡ £ Ô ð
|
ÔÜ"<<>ÕrW c ó~ d| j j d| j j d| j dS )Nú<ú.ú(z)>)Ú __class__rZ rY rh ©rR s rT Ú__repr__zRedis.__repr__ s? à×)Ñ)Ð*¨!¨D¯N©N×,CÑ,CÐ+DØ×$Ñ$Ð' rð +ð
|
rW c ó> | j « j « S rO )Ú
|
initializeÚ __await__r¼ s rT rÀ zRedis.__await__ s ØÓ ×*Ñ*Ó,Ð,rW rR c ó K | j r | j 4 d { | j '| j j « d { | _ d d d « d { | j
|
j t | j t j | j « « | S 7 7 e7 R# 1 d { 7 sw Y bxY wwrO )
|
rd r³ r¯ rh Úget_connectionr© r r- r. r® r¼ s rT r¿ zRedis.initialize s³ è ø Ø × (Ò (Ø×-Ñ-÷ Rñ RØ??Ð*Ø,0×,@Ñ,@×,OÑ,OÓ,Q×&QDO÷ R÷ Rð × "Ñ "× +Ñ +Ü7ØOO¤Z×%5Ñ%5°t×7MÑ7Móô ð
|
ð Røà&Qøð Rø÷ R÷ Rñ RüsW C B1 C £*B7Á B3Á B7Á C Á"B5Á#AC Â3B7Â5C Â7C Â=C Â>C ÃC ÚcommandÚcallbackc ó" || j |< y)z Set a custom Response CallbackN)rb )rR rà rÄ s rT Úset_response_callbackzRedis.set_response_callback§ s à+3× Ñ Ò(rW c ó6 | j j « S )z!Get the connection pool's encoder)rh Ú get_encoderr¼ s rT rÈ zRedis.get_encoder« s à×#Ñ#×/Ñ/Ó1Ð1rW c ó. | j j S )z'Get the connection's key-word arguments)rh r° r¼ s rT Úget_connection_kwargszRedis.get_connection_kwargs¯ s à×#Ñ#×5Ñ5Ð5rW c ó@ | j « j d« S ©Nr )rÊ r± r¼ s rT Ú get_retryzRedis.get_retry³ s Ø×)Ñ)Ó+×/Ñ/°Ó8Ð8rW c ó| | j « j d|i« | j j |« y rÌ )rÊ r¬ rh Ú set_retry)rR r s rT rÏ zRedis.set_retry¶ s2 Ø ×"Ñ"Ó$×+Ñ+¨W°eÐ,<Ô=Ø × Ñ ×&Ñ& uÕ-rW c ó t | ||« y)a
|
This function can be used to add externally defined redis modules,
|
and their namespaces to the redis client.
|
|
funcname - A string containing the name of the function to create
|
func - The function, being added to this class.
|
|
ex: Assume that one has a custom redis module named foomod that
|
creates command named 'foo.dothing' and 'foo.anotherthing' in redis.
|
To load function functions into this namespace:
|
|
from redis import Redis
|
from foomodule import F
|
r = Redis()
|
r.load_external_module("foo", F)
|
r.foo().dothing('your', 'arguments')
|
|
For a concrete example see the reimport of the redisjson module in
|
tests/test_connection.py::test_loading_external_modules
|
N)Úsetattr)rR ÚfuncnameÚfuncs rT Úload_external_modulezRedis.load_external_moduleº s ô* h Õ%rW Ú transactionÚ
|
shard_hintÚPipelinec óF t | j | j ||« S )a_
|
Return a new pipeline object that can queue multiple commands for
|
later execution. ``transaction`` indicates whether all commands
|
should be executed atomically. Apart from making a group of operations
|
atomic, pipelines are useful for reducing the back-and-forth overhead
|
between the client and server.
|
)r× rh rb )rR rÕ rÖ s rT ÚpipelinezRedis.pipelineÑ s& ô Ø × Ñ $×"9Ñ"9¸;È
|
ó
|
ð
|
rW )rÖ Úvalue_from_callableÚ watch_delayrÓ ÚwatchesrÚ rÛ c óÊ K | j d|« 4 d{ } |r |j | d{ ||« }t j |« r
|
| d{ }|j « d{ }|r|n| cddd« d{ S 7 v7 ]7 87 "7 # t
|
$ r( |#|dkD r t j |« d{ 7 Y ¬w xY w# 1 d{ 7 sw Y yxY ww)zç
|
Convenience method for executing the callable `func` as a transaction
|
while watching all keys specified in `watches`. The 'func' callable
|
should expect a single argument which is a Pipeline object.
|
TNr )rÙ ÚwatchÚinspectÚ isawaitableÚexecuter5 r² Úsleep) rR rÓ rÖ rÚ rÛ rÜ ÚpipeÚ
|
func_valueÚ
|
exec_values rT rÕ zRedis.transactionß sÞ è ø ð == zÓ2÷ ð °dØð Ù Ø (djj¨'Ð 2×2Ð2Ù!% d£JÜ ×*Ñ*¨:Ô6Ø+5×%5
|
Ø'+§|¡|£~×!5JÙ)<:À*ÐL÷ ÷ ò øð 3øð &6øØ!5øð ùô "ò Ø"Ð.°;À²?Ü %mm¨KÓ 8×8Ñ8Ù ð ú÷ ÷ ñ üs¡ C#BC#C B´Bµ&BÁBÁ BÁ3BÁ4 BÁ> C#Â
|
BÂ C#ÂBÂBÂBÂC#Â(C ÃCÃC ÃCÃ
|
C Ã CÃC ÃC ÃC Ã C#ÚnameÚtimeoutrâ ÚblockingÚblocking_timeoutÚ
|
lock_classÚ thread_localÚraise_on_release_errorc
|
ó2 |t } || |||||||¬« S )a}
|
Return a new Lock object using key ``name`` that mimics
|
the behavior of threading.Lock.
|
|
If specified, ``timeout`` indicates a maximum life for the lock.
|
By default, it will remain locked until release() is called.
|
|
``sleep`` indicates the amount of time to sleep per loop iteration
|
when the lock is in blocking mode and another client is currently
|
holding the lock.
|
|
``blocking`` indicates whether calling ``acquire`` should block until
|
the lock has been acquired or to fail immediately, causing ``acquire``
|
to return False and the lock not being acquired. Defaults to True.
|
Note this value can be overridden by passing a ``blocking``
|
argument to ``acquire``.
|
|
``blocking_timeout`` indicates the maximum amount of time in seconds to
|
spend trying to acquire the lock. A value of ``None`` indicates
|
continue trying forever. ``blocking_timeout`` can be specified as a
|
float or integer, both representing the number of seconds to wait.
|
|
``lock_class`` forces the specified lock implementation. Note that as
|
of redis-py 3.0, the only lock class we implement is ``Lock`` (which is
|
a Lua-based lock). So, it's unlikely you'll need this parameter, unless
|
you have created your own custom lock class.
|
|
``thread_local`` indicates whether the lock token is placed in
|
thread-local storage. By default, the token is placed in thread local
|
storage so that a thread only sees its token, not a token set by
|
another thread. Consider the following timeline:
|
|
time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds.
|
thread-1 sets the token to "abc"
|
time: 1, thread-2 blocks trying to acquire `my-lock` using the
|
Lock instance.
|
time: 5, thread-1 has not yet completed. redis expires the lock
|
key.
|
time: 5, thread-2 acquired `my-lock` now that it's available.
|
thread-2 sets the token to "xyz"
|
time: 6, thread-1 finishes its work and calls release(). if the
|
token is *not* stored in thread local storage, then
|
thread-1 would see the token value as "xyz" and would be
|
able to successfully release the thread-2's lock.
|
|
``raise_on_release_error`` indicates whether to raise an exception when
|
the lock is no longer owned when exiting the context manager. By default,
|
this is True, meaning an exception will be raised. If False, the warning
|
will be logged and the exception will be suppressed.
|
|
In some use cases it's necessary to disable thread local storage. For
|
example, if you have code where one thread acquires a lock and passes
|
that lock instance to a worker thread to release later. If thread
|
local storage isn't disabled in this case, the worker thread won't see
|
the token set by the thread that acquired the lock. Our assumption
|
is that these cases aren't common and as such default to using
|
thread local storage.)rç râ rè ré rë rì r ) rR ræ rç râ rè ré rê rë rì s rT Úlockz
|
Redis.lockü s5 ðH Ð Ü JÙØ Ø ØØØ Ø -Ø%Ø#9ô
|
ð
|
rW c óF t | j fd| j i|¤S )z¨
|
Return a Publish/Subscribe object. With this object, you can
|
subscribe to channels and listen for messages that get published to
|
them.
|
r¤ )ÚPubSubrh r© )rR rS s rT Úpubsubz Redis.pubsubM s0 ô Ø × Ñ ñ
|
Ø37×3IÑ3Ið
|
ØMSñ
|
ð
|
rW c ó, t | j « S rO )ÚMonitorrh r¼ s rT Úmonitorz Redis.monitorW s Üt×+Ñ+Ó,Ð,rW c ó< | j | j d¬« S )NTrg )r» rh r¼ s rT ro z Redis.clientZ s# Ø~~Ø × 0Ñ 0È4ð ó
|
ð
|
rW c óÂ K | j « d{ | j « d{ S 7 7 # t $ r | j « d{ 7 w xY ww)z¸
|
Async context manager entry. Increments a usage counter so that the
|
connection pool is only closed (via aclose()) when no context is using
|
the client.
|
N)Ú_increment_usager¿ Ú ExceptionÚ_decrement_usager¼ s rT Ú
|
__aenter__zRedis.__aenter___ s] è ø ð ×#Ñ#Ó%×%Ð%ð à Ó*×*Ð *ð &øð +ùÜò à×'Ñ'Ó)× )Ñ )Ø ð üs: A 4A 8 ¯6°8 ³A ¶8 ¸ A ÁAÁA Á A c óÊ K | j 4 d{ | xj dz c_ | j cddd« d{ S 7 67 # 1 d{ 7 sw Y yxY ww)z
|
Helper coroutine to increment the usage counter while holding the lock.
|
Returns the new value of the usage counter.
|
Nry ©rµ r´ r¼ s rT r÷ zRedis._increment_usagen óZ è ø ð
|
×#Ñ#÷ 'ñ 'Ø × Ò 1Ñ $Õ Ø×&Ñ&÷ '÷ 'ò 'øð 'ø÷ '÷ 'ñ 'üóC A#A
|
A#!A¸ A#ÁA ÁA#Á A#ÁA ÁA ÁA Á A#c óÊ K | j 4 d{ | xj dz c_ | j cddd« d{ S 7 67 # 1 d{ 7 sw Y yxY ww)z
|
Helper coroutine to decrement the usage counter while holding the lock.
|
Returns the new value of the usage counter.
|
Nry rü r¼ s rT rù zRedis._decrement_usagew rý rþ c óÌ K t j | j « « d{ }|dk( r,t j | j « « d{ yy7 67 w)z©
|
Async context manager exit. Decrements a usage counter. If this is the
|
last exit (counter becomes zero), the client closes its connection pool.
|
Nr )r² Úshieldrù Úaclose)rR Úexc_typeÚ exc_valueÚ tracebackÚ current_usages rT Ú __aexit__zRedis.__aexit__ sS è ø ô
|
&nn¨T×-BÑ-BÓ-DÓ E×E Ø AÒ ä.. §¡£ Ó/× /Ñ /ð ð Føð 0ús! 'A$©A ª/A$ÁA"ÁA$Á"A$zUnclosed Redis clientÚ_warnÚ_grlc óú t | d« r`| j S |d| t | ¬« | | j d} |« j |« | j j « y y y # t
|
$ r Y (w xY w)Nr¯ zUnclosed client session )Úsource)ro Úmessage)Úhasattrr¯ ÚResourceWarningÚ _DEL_MESSAGEÚcall_exception_handlerÚ RuntimeErrorÚ_close)rR r r Úcontexts rT Ú__del__z Redis.__del__ s ô
|
4 Ô &¨D¯O©OÐ,GÙ Ð,¨T¨HÐ5´ÈtÕ Tð Ø%)°d×6GÑ6GÑHÙ×-Ñ-¨gÔ6ð OO× "Ñ "Õ $ð -HÐ &øô
|
ò Ùð ús ¬%A. Á. A:Á9A:Úclose_connection_poolc óì K | j }|r*d| _ | j j |« d{ |s|0| j r#| j j « d{ yyy7 97 w)au
|
Closes Redis client connection
|
|
Args:
|
close_connection_pool:
|
decides whether to close the connection pool used by this Redis client,
|
overriding Redis.auto_close_connection_pool.
|
By default, let Redis.auto_close_connection_pool decide
|
whether to close the connection pool.
|
N)r¯ rh Úreleasere Ú
|
disconnect)rR r Úconns rT r z Redis.aclose sr è ø ð Ù Ø "DOØ×&Ñ&×.Ñ.¨tÓ4× 4Ð 4Ù Ø !Ð )¨d×.MÒ.Mà×&Ñ&×1Ñ1Ó3× 3Ñ 3ð /NÐ )ð 5øð 4ús! 4A4¶A0·1A4Á(A2Á)A4Á2A4ú5.0.1úUse aclose() insteadÚclose©rv ru ræ c óB K | j |« d{ y7 w)zA
|
Alias for aclose(), for backwards compatibility
|
N©r )rR r s rT r z Redis.close° s è ø ð
|
kkÐ/Ó0×0Ò0úó c óx K |j | d{ | j ||fi |¤ d{ S 7 7 w)z7
|
Send a command and parse the response
|
N)Ú send_commandÚparse_response)rR r Ú command_nameÚargsÚoptionss rT Ú _send_command_parse_responsez"Redis._send_command_parse_response· sD è ø ð d× Ñ Ð&×&Ð&Ø(T×(Ñ(¨¨|ÑG¸wÑG×GÐGð 'øØGús :6:±8²:¸:r c ó@ K |j « d{ y7 w)aE
|
Close the connection before retrying.
|
|
The supported exceptions are already checked in the
|
retry object so we don't need to do it here.
|
|
After we disconnect the connection, it will try to reconnect and
|
do a health check as part of the send_command logic(on connection level).
|
N)r ©rR r s rT Ú_close_connectionzRedis._close_connection¾ s è ø ð ooÓ × Ò úó c ó¾ K j « d{ j }d j xs |j « d{ j r" j
|
j « d{ j j fd fd« d{ j r j
|
j « j s|j « d{ S S 7 å7 °7 7 V7 # j r j
|
j « j s|j « d{ 7 w w xY ww)z.Execute a command and return a parsed responseNr c ó2 j g ¢i ¤S rO ©r' ©r% r$ r r& rR s rT ú<lambda>z'Redis.execute_command.<locals>.<lambda>Ö s* ø Ð9×9Ñ9Ø,ðØ)-òØ18ñ rW c ó& j « S rO )r* ©Ú_r rR s rT r0 z'Redis.execute_command.<locals>.<lambda>Ù s ø $×0Ñ0°Ó6 rW )
|
r¿ rh r¯ r rd r³ Úacquirer Úcall_with_retryr )rR r% r& Úpoolr$ r s ``` @@rT Úexecute_commandzRedis.execute_commandË s üè ø àooÓ × Ð Ø×#Ñ#ØAw ØÒ=¨×(;Ñ(;Ó(=×"=à × (Ò (Ø×(Ñ(×0Ñ0Ó2× 2Ð 2ð )Ø ×3Ñ3÷ô 7ó ÷ ð ×,Ò,Ø×&Ñ&×.Ñ.Ô0Ø??Øll 4Ó(×(Ñ(ð #ð# øð #>øð 3øðøð )ùð ×,Ò,Ø×&Ñ&×.Ñ.Ô0Ø??Øll 4Ó(×(Ò(ð #üs} E D6E ÁDÁ-E  DÂE Â*D Â0DÂ1D Â4AE Ã:D Ã;E ÄE ÄE ÄD Ä E Ä AEÅEÅEÅE r¯ r$ c ó K t |v r0|j d¬« d{ }|j t « n|j « d{ }t |v r|j t « |j dd« || j
|
v rGt t |« } | j
|
| |fi |¤}t j |« r
|
| d{ S |S |S 7 ¸7 # t $ r t |v r |t cY S w xY w7 -w)z'Parses a response from the Redis serverT)Údisable_decodingNÚkeys)
|
r# Ú read_responseÚpopr4 r" rb r Ústrrß rà )rR r¯ r$ r& rM Úretvals rT r# zRedis.parse_responseá s÷ è ø ð ÜwÑ&Ø!+×!9Ñ!9È4Ð!9Ó!P×PØ LÕ)à!+×!9Ñ!9Ó!;×;ô WÑ $Ø KKÔ 'ð FDÔ!à 4×2Ñ2Ñ 2ä ¤ \Ó2LØ:T×,Ñ,¨\Ñ:¸8ÑOÀwÑOFÜ#*×#6Ñ#6°vÔ#><Ð JÀFÐ JØð) Qøð <ùÜ ò Ü Ñ(Ø ~Ñ.Ò.Ø ð úð úsW D C ¡C¢-C ÁC ÁC ÁA=DÃC?ÃDÃC Ã C Ã C<Ã8DÃ:C<Ã<D)FN)TN)Ng¹?TNNTT)rp rð )rp ró )rp rH rO )GrY rZ r[ Ú__doc__r r r= ÚbytesÚResponseCallbackTÚ__annotations__Ú classmethodÚboolr rj r r rr r; r r! r= ÚintÚfloatr ÚlistrC r
|
rB rA r* r/ r¶ r½ rÀ rG r¿ rÆ rÈ rÊ rÍ rÏ rÔ rÙ r r r r8 rÕ r rî rñ rô ro rú r÷ rù r r rk rl r² Úget_running_loopr r r< r r' r r* r7 r# rP rW rT rH rH n s
ñ
|
ð ' u¨S°%¨ZÑ'8Ð:KÐ'KÑLÓLàð */Ø59ñ Bà ðBð #'ðBð %-¨T¡Nò Bó ðBðH ð Ø ']ð à'ð ð
|
ò ó ð ñ Ø(Ð)Ø5Øôð ØØ Ø"&Ø*.Ø26Ø+/ØNRØ48Ø*.Ø Ø 'Ø!&Ø!&Ù Ù0°a¸RÔ@È!ô
|
ð *.ØØ%)Ø&*Ø0:Ø@DØ@DØ&*Ø%)Ø#'Ø04Ø%)Ø)-Ø).Ø%&Ø%)Ø",Ù%4Ó%6Ø"&Ø59Ø Ø<@Ø"#Ø6:òWv*ð ðv*ð ð v*ð
|
#s(Oð v*ð 3-ð v*ð ! ðv*ð !)¨¡ðv*ð # 4.ðv*ð #+¨7°3¸¸cÀ5¸jÑ8IÐ3IÑ+JÑ"Kðv*ð " .Ñ1ðv*ð # 3-ðv*ð ðv*ð ð v*ð ð v*ð ð!v*ð" ð#v*ð( ! ð)v*ð* ð+v*ð, c]ð-v*ð. smð/v*ð0 S *_Ñ-ð1v*ð2 #+¨4° Ñ+<Ñ"=ð3v*ð4 #+¨4° Ñ+<Ñ"=ð5v*ð6 smð7v*ð8 c]ð9v*ð: !ð;v*ð< " *Ñ-ð=v*ð> c]ð?v*ð@ " # ðAv*ðB #'ðCv*ðD #ðEv*ðF c]ðGv*ðH 3-ðIv*ðJ c]ðKv*ðL 3-ðMv*ðN %-¨T¡NðOv*ðR &Ð&8Ñ 9ðSv*ðT 3-ðUv*ðV # ?Ñ3òWv*ó ð
|
v*òp
|
ò -ð wð ¨7ó ð4¨Sð 4Ð<Mó 4ò2ò6ð98 E?ó 9ð.uð .¨ó .ò&ð0 EIñ
|
Ø ð
|
Ø4<¸S±Mð
|
à ó
|
ð$ %)Ø$)Ø'+ò à
|
| U¨3° ¸#±Ð+>Ñ%?Ð?Ñ@ð ð ð ð SMð ð
|
"ð ð e_ó ð@ $(ØØ Ø,0Ø+/Ø !Ø'+ñO
|
àðO
|
ð % ðO
|
ð ð O
|
ð
|
ð O
|
ð # 5/ð O
|
ð T $ZÑ(ðO
|
ð ðO
|
ð !%ðO
|
ð
|
óO
|
ób
|
ó-ó
|
ð
|
wð ¨7ó ð '¨ó 'ð'¨ó 'ò0ð +Lð ]]Ø×,Ñ,ñ %àð %ð ð %ð
|
ó %ñ 4°(¸4±.ð 4ÈDó 4ñ( Ð1GÈgÔVñ1°¸$± ð 1È4ò 1ó Wð1ò Hð
|
¨Jó
|
ò)ð,Ø$ðØ49¸#¸u¸*Ñ4EôrW c óJ e Zd ZU eed< eed< eed< eed< eed< eed< y)ÚMonitorCommandInfoÚtimer Úclient_addressÚ client_portÚ client_typerà N)rY rZ r[ rF rB rE r= rP rW rT rJ rJ s#
Ø
|
KØ GØÓØÓØÓØ LrW rJ c ó e Zd ZdZ ej
|
d« Z ej
|
d« ZdefdZ d Z
|
d Z d Z d e fd
|
Zd ee fd Zy ) ró z¾
|
Monitor is useful for handling the MONITOR command to the redis server.
|
next_command() method returns one command from monitor
|
listen() method yields commands from monitor.
|
z\[(\d+) (.*?)\] (.*)z"(.*?)(?<!\\)"rh c ó || _ d | _ y rO )rh r¯ )rR rh s rT r¶ zMonitor.__init__ s Ø .Ô Ø04rW c óx K | j (| j j « d { | _ y y 7 wrO )r¯ rh r r¼ s rT ÚconnectzMonitor.connect s1 è ø Ø ??Ð "Ø$(×$8Ñ$8×$GÑ$GÓ$I× IDOð #Ø Iús *:¬8 :c ó K | j « d { | j j d« d { | j j « d { }t |« st d| « | S 7 d7 C7 #w)NÚMONITORzMONITOR failed: )rR r¯ r" r; r r3 ©rR rM s rT rú zMonitor.__aenter__ so è ø Ølln× Ð Øoo×*Ñ*¨9Ó5×5Ð5à ×6Ñ6Ó8×8ÜxÔ Ü Ð /°¨zÐ :Ó;Ð ;Ø ð øØ5øà8ús1 BA;"B¹A=º!BÁA?Á BÁ=BÁ?Bc ó² K | j j « d { | j j | j « d { y 7 27 wrO )r¯ r rh r )rR r% s rT r zMonitor.__aexit__% sC è ø Øoo×(Ñ(Ó*×*Ð*Ø×"Ñ"×*Ñ*¨4¯?©?Ó;×;Ñ;ð +øØ;ús! A A¡,AÁ AÁAÁArp c óª K | j « d{ | j j « d{ }t |t « r'| j j
|
j |d¬« }|j dd« \ }}| j j |« }|j « \ }}}dj | j j |« « }|j dd« }|dk( rd}d } d}
|
n2|j d
|
« r
|
d
|
}|d d } d
|
}
|
n|j! d d« \ }} d }
|
t# |« t% |« || |
|
|dS 7 77 w)z)Parse the response from a monitor commandNT©Úforceú ry z\"ú"ÚluaÚ Úunixé ú:Útcp)rK r rL rM rN rà )rR r¯ r; Ú
|
isinstancer@ ÚencoderÚdecodeÚsplitÚ
|
monitor_reÚmatchÚgroupsÚjoinÚ
|
command_reÚfindallÚreplaceÚ
|
startswithÚrsplitrF rE ) rR rM Ú command_timeÚ command_dataÚmÚdb_idÚ client_inforà rL rM rN s rT Ú next_commandzMonitor.next_command) sC è ø àlln× Ð Ø ×6Ñ6Ó8×8Ü h¤Ô &Ø×.Ñ.×5Ñ5°hÀdÐ5ÓKHØ%-§^¡^°C¸Ó%;Ñ" lØ OO× !Ñ ! ,Ó /Ø&'§h¡h£jÑ#{GØ((4??×2Ñ2°7Ó;Ó<ð // %¨Ó-à %Ò Ø "NØ KØ KØ × #Ñ # FÔ +Ø #NØ% a b/KØ Kð +6×*<Ñ*<¸SÀ!Ó*DÑ 'NKØ Kä,Ó'Üe*Ø ,Ø&Ø&Ø ñ
|
ð
|
ð3 ùØ8ûs EE !E¸E¹DEÅEc óH K | j « d{ 7 w)z)Listen for commands coming to the server.N)rt r¼ s rT ÚlistenzMonitor.listenM s# è ø àØ ×)Ñ)Ó+×+Ó +ð Ø+ús " "N)rY rZ r[ r? ÚreÚcompilerf rj r r¶ rR rú r rJ rt r rv rP rW rT ró ró
|
sg ñð Ð 3Ó4JØÐ -Ó.Jð5¨ó 5òJòò<ð"
|
Ð$6ó "
|
ðH,mÐ,>Ñ ?ô ,rW ró c óº e Zd ZdZdZdZdZ d6dedee de
|
d ee d
|
ed f
|
d Z d Z d Zd Zd Z eddd¬« d7d« Z eddd¬« d7d« ZdefdZed « Zd efd Zd Zd Zd Z d8d!e
|
d"e fd#Z d$ Z d%e de fd&Z!d e"d'e#fd(Z$d e"de%fd)Z&d e"d'e fd*Z'de%fd+Z(de)fd,Z* d9de
|
d"ee fd-Z+d:de%e
|
fd.Z,d;d/Z-dd0dd1d2ed3 d4e ddfd5Z.y)<rð a*
|
PubSub provides publish, subscribe and listen support to Redis channels.
|
|
After subscribing to one or more channels, the listen() method will block
|
until a message arrives on one of the subscribed channels. That message
|
will be returned and it's safe to start listening again.
|
)r Úpmessage)Ú unsubscribeÚ punsubscribezredis-py-health-checkNrh rÖ Úignore_subscribe_messagesÚpush_handler_funcr¤ r/ c ó¤ |t « | _ n|| _ || _ || _ || _ d | _ || _ || _ | j | j j « | _ | j j r d| j g| j g| _ nQd| j j | j « g| j j | j « g| _ | j
|
t « i | _ t « | _ i | _ t « | _ t' j( « | _ y )NÚpongó pong)r/ r© rh rÖ r} r¯ rc r~ rÈ r ÚHEALTH_CHECK_MESSAGEÚhealth_check_responseÚencoder: ÚchannelsÚsetÚ pending_unsubscribe_channelsÚpatternsÚ pending_unsubscribe_patternsr² r Ú_lock)rR rh rÖ r} rc r~ r¤ s rT r¶ zPubSub.__init__` s ð Ð #Ü%4Ó%6DÕ "à%5DÔ "Ø .Ô Ø$Ø)BÔ&Ø ð Ø!2Ô Ø <<Ð Ø ×/Ñ/×;Ñ;Ó=DLØ <<× (Ò (à×2Ñ2Ð3Ø×)Ñ)ð*DÕ &ð $,,×-Ñ-¨d×.GÑ.GÓHÐIØ ×#Ñ# D×$=Ñ$=Ó>ð*DÔ &ð × !Ñ !Ð )Ü Ô Ø Ü,/«EÔ)Ø Ü,/«EÔ)Ü \\^
|
rW c ó K | S wrO rP r¼ s rT rú zPubSub.__aenter__ ó è ø Ø ùó c ó@ K | j « d { y 7 wrO r ©rR r r r s rT r zPubSub.__aexit__ s è ø Økkm×Òúr+ c óh | j r&| j j | j « y y rO )r¯ Úderegister_connect_callbackÚ
|
on_connectr¼ s rT r zPubSub.__del__ s$ Ø ??Ø OO× 7Ñ 7¸¿¹Õ Hð rW c ó K t | d« sy | j 4 d { | j r{| j j « d { | j j | j
|
« | j j | j « d { d | _ i | _ t « | _
|
i | _ t « | _ d d d « d { y 7 È7 7 L7 # 1 d { 7 sw Y y xY ww)Nr¯ ) r r r¯ r r r rh r r
r r r r r¼ s rT r z PubSub.aclose sÍ è ø ô t\Ô*Ø Ø::÷ 6ñ 6ØØoo×0Ñ0Ó2×2Ð2Ø×;Ñ;¸D¿O¹OÔLØ×*Ñ*×2Ñ2°4·?±?ÓC×CÐCØ"&Ø DMÜ03³DÔ -Ø DMÜ03³DÔ -÷ 6÷ 6ñ 6øà2øàCøð 6ø÷ 6÷ 6ñ 6üsi D C)¡D¤*C1ÁC+ÁAC1 C-Â!7C1à DÃ#C/Ã$DÃ+C1Ã-C1Ã/DÃ1DÃ7C: Ã8DÃ?Dr r r r rp c ó@ K | j « d{ y7 w©z/Alias for aclose(), for backwards compatibilityNr r¼ s rT r z PubSub.close¤ ó è ø ð kkm×Òúr+ Úresetc ó@ K | j « d{ y7 wr r r¼ s rT r z PubSub.reset© r r+ r¯ c ó& K | j j « | j j « | j r^i }| j j « D ]% \ }}||| j
|
j |d¬« < ' | j di |¤ d{ | j r_i }| j j « D ]% \ }}||| j
|
j |d¬« < ' | j di |¤ d{ yy7 p7 w)zBRe-subscribe to any channels and patterns previously subscribed toTrX NrP )
|
r Úclearr r
Úitemsrc rd Ú subscriber Ú
|
psubscribe)rR r¯ r
ÚkÚvr s rT r zPubSub.on_connect® s è ø ð
|
×)Ñ)×/Ñ/Ô1Ø ×)Ñ)×/Ñ/Ô1Ø ==ØHØ ×+Ñ+Ó-ò A1Ø?@ ×,Ñ,¨Q°dÐ,Ó;Ò<ð Aà $..Ñ, 8Ñ,× ,Ð ,Ø ==ØHØ ×+Ñ+Ó-ò A1Ø?@ ×,Ñ,¨Q°dÐ,Ó;Ò<ð Aà!$//Ñ- HÑ-× -Ñ -ð ð -øð
|
.ús% BDÂ D Â A)DÄDÄDÄDc óH t | j xs | j « S )z@Indicates if there are subscriptions to any channels or patterns)rD r
r r¼ s rT Ú
|
subscribedzPubSub.subscribedÀ s ô DMMÒ2 T§]¡]Ó3Ð3rW r% c óÌ K | j « d{ | j }d| j i} | j ||j g|¢i |¤ d{ y7 I7 w)z#Execute a publish/subscribe commandNÚ check_health)rR r¯ r¡ Ú_executer" )rR r% r¯ rS s rT r7 zPubSub.execute_commandÅ sc è ø ð lln× Ð Ø__
|
Ø d§o¡oÐ"5Ð6ØdmmJ¨
|
×(?Ñ(?ÐQÀ$ÒQÈ&ÑQ×QÑQð øð Rús" A$A AA$ÁA"ÁA$Á"A$c ó& K | j M| j j « d{ | _ | j j | j « n"| j j « d{ | j /| j j j | j « | j j t | j | j t j | j « « y7 à7 w)z5
|
Ensure that the PubSub is connected
|
N)r¯ rh r Úregister_connect_callbackr rR r~ Ú_parserÚset_pubsub_push_handlerr© r r, r. r® r r¼ s rT rR zPubSub.connectÑ sÈ è ø ð ??Ð "Ø$(×$8Ñ$8×$GÑ$GÓ$I× IDOð OO× 5Ñ 5°d·o±oÕ Fà//×)Ñ)Ó+× +Ð +Ø × !Ñ !Ð -Ø OO× #Ñ #× ;Ñ ;¸D×<RÑ<RÔ Sà × Ñ ×'Ñ'Ü 3Ø ×!5Ñ!5´z×7GÑ7GÈÏÉó õ
|
ð Jøð
|
,ús# *D¬D A DÁ9DÁ:BDÄDc ót K |j « d{ |j « d{ y7 7 w)z"
|
Try to reconnect
|
N)r rR r) s rT Ú
|
_reconnectzPubSub._reconnectå s0 è ø ð ooÓ × Ð Ølln× Ñ ð øØ ús 848®6¯8¶8c ór K j j fd fd« d{ S 7 w)aU
|
Connect manually upon disconnection. If the Redis server is down,
|
this will fail and raise a ConnectionError as desired.
|
After reconnection, the ``on_connect`` callback should have been
|
called by the # connection to resubscribe us to any channels and
|
patterns we were previously listening to
|
c ó i ¤S rO rP )r% rà rS s rT r0 z!PubSub._execute.<locals>.<lambda>õ s ø GTÐ, VÑ, rW c ó& j « S rO )rª r2 s rT r0 z!PubSub._execute.<locals>.<lambda>ö s ø doo dÓ+ rW N)r r5 )rR r rà r% rS s `````rT r¤ zPubSub._executeì s0 üè ø ð ZZ×/Ñ/Ý ,Ü +ó
|
÷
|
ð
|
ð
|
ús )7°5±7Úblockrç c óV K | j }| t d« | j « d{ |j s|j « d{ |rdn|}| j ||j |dd¬« d{ }|j r|| j v ry|S 7 s7 Q7 %w)z3Parse the response from a publish/subscribe commandNúNpubsub connection not set: did you forget to call subscribe() or psubscribe()?FT)rç Údisconnect_on_errorÚ push_request) r¯ r r£ Ú is_connectedrR r¤ r; r r )rR r® rç r Ú read_timeoutrM s rT r# zPubSub.parse_responseù sº è ø àØ <Ü ðFóð ð
|
× Ñ Ó!×!Ð!à× Ò Ø,,.× Ð á $t¨' Ø Ø Ø × Ñ Ø Ø %Ø ð 'ó
|
÷
|
ð × %Ò %¨(°d×6PÑ6PÑ*PàØð# "øð !øð
|
ús3 -B)¯B#°#B)ÁB%Á-B)ÂB'Â"B)Â%B)Â'B)c ó K | j }| t d« |j rWt j « j « |j kD r'|j d| j d¬« d { y y y 7 w)Nr° ÚPINGF)r£ ) r¯ r r r² rH rK Únext_health_checkr" r r) s rT r£ zPubSub.check_health s è ø ØØ <Ü ðFóð ð × &Ò &Ü×(Ñ(Ó*×/Ñ/Ó1°D×4JÑ4JÒJà×#Ñ#Ø×1Ñ1Àð $ó ÷ ñ ð Kð 'ð ús A6BÁ8B Á9BÚdatac óÆ | j j }| j j }|j « D ci c] \ }} | ||« « | c}}S c c}}w )z×
|
normalize channel/pattern names to be either bytes or strings
|
based on whether responses are automatically decoded. this saves us
|
from coercing the value for each message coming in.
|
)rc r rd r )rR r¸ r rd r r s rT Ú_normalize_keyszPubSub._normalize_keys% sN ð ×$Ñ$Ø ×$Ñ$Ø15·±³ ×>©¨¨AvayÓ! 1Ñ$Ó>Ð>ùÓ>s Á A rS c ól K |rt |d f|dd « n|}t j |« }|j |« | j dg|j « ¢ d{ }| j |« }| j j |« | j j |« |S 7 Mw)aE
|
Subscribe to channel patterns. Patterns supplied as keyword arguments
|
expect a pattern name as the key and a callable as the value. A
|
pattern's callable will be invoked automatically when a message is
|
received on that pattern rather than producing a message via
|
``listen()``.
|
r ry NÚ
|
PSUBSCRIBE)
|
r) ÚdictÚfromkeysr¬ r7 r: rº r r Údifference_update)rR r% rS Ú parsed_argsÚ new_patternsÚret_vals rT r zPubSub.psubscribe/ s§ è ø ñ =Al D¨¡G :¨t°A°B¨xÔ8Àd Ü6:·m±mÀKÓ6P à×ÑFÔ#Ø,×,Ñ,¨\ÐP¸L×<MÑ<MÓ<OÒP×Pð ×+Ñ+¨LÓ9 Ø × Ñ \Ô*Ø ×)Ñ)×;Ñ;¸LÔIØð Qúó A"B4Á$B2Á%AB4c ó
|
|rFt |d f|dd « }| j t j |« « j « }ng }| j
|
}| j j |« | j dg|¢ S )zj
|
Unsubscribe from the supplied patterns. If empty, unsubscribe from
|
all patterns.
|
r ry NÚ PUNSUBSCRIBE) r) rº r½ r¾ r: r r r¬ r7 )rR r% rÀ r s rT r| zPubSub.punsubscribeD s{ ñ Ü&¨¨Q© z°4¸¸°8Ó<KØ×+Ñ+¬D¯M©M¸+Ó,FÓG×LÑLÓNHà KØ}}HØ ×)Ñ)×0Ñ0°Ô:Ø#t×#Ñ# NÐA°[ÒAÐArW c ól K |rt |d f|dd « nd}t j |« }|j |« | j dg|j « ¢ d{ }| j |« }| j j |« | j j |« |S 7 Mw)aR
|
Subscribe to channels. Channels supplied as keyword arguments expect
|
a channel name as the key and a callable as the value. A channel's
|
callable will be invoked automatically when a message is received on
|
that channel rather than producing a message via ``listen()`` or
|
``get_message()``.
|
r ry NrP Ú SUBSCRIBE)
|
r) r½ r¾ r¬ r7 r: rº r
r r¿ )rR r% rS rÀ Ú new_channelsr s rT r zPubSub.subscribeS s§ è ø ñ =Al D¨¡G :¨t°A°B¨xÔ8Àb Ü}} [Ó1 à×ÑFÔ#Ø,×,Ñ,¨[ÐO¸<×;LÑ;LÓ;NÒO×Oð ×+Ñ+¨LÓ9 Ø × Ñ \Ô*Ø ×)Ñ)×;Ñ;¸LÔIØð Púrà c óì |r7t |d |dd « }| j t j |« « }ng }| j }| j
|
j |« | j dg|¢ S )zi
|
Unsubscribe from the supplied channels. If empty, unsubscribe from
|
all channels
|
r ry NÚ UNSUBSCRIBE)r) rº r½ r¾ r
r r¬ r7 )rR r% rÀ r
s rT r{ zPubSub.unsubscribeh sp ñ
|
Ü& t¨A¡w°°Q°R°Ó9KØ×+Ñ+¬D¯M©M¸+Ó,FÓGHà KØ}}HØ ×)Ñ)×0Ñ0°Ô:Ø#t×#Ñ# MÐ@°KÒ@Ð@rW c ó¸ K | j rF| j | j d¬« d{ « d{ }|| | j rEyy7 &7 w)zBListen for messages on channels this client has been subscribed toT)r® N)r¡ Úhandle_messager# rU s rT rv z PubSub.listenv sM è ø àooØ !× 0Ñ 0°t×7JÑ7JÐQUÐ7JÓ7V×1VÓ W×WHØÐ#Ø ð ooØ1VøÐWús% -A¯A° A»A¼AÁAÁAc ó K | j |du |¬« d{ }|r| j ||« d{ S y7 !7 w)a
|
Get the next message if one is available, otherwise None.
|
|
If timeout is specified, the system will wait for `timeout` seconds
|
before returning. Timeout should be specified as a floating point
|
number or None to wait indefinitely.
|
N)r® rç )r# rÌ )rR r} rç rM s rT Ú get_messagezPubSub.get_message} sK è ø ð ×,Ñ,°G¸t°OÈgÐ,ÓV×VÙ Ø ×,Ñ,¨XÐ7PÓQ×QÐ QØð WøàQús A=A·?¸A¿Ac ó2 |d|gndg} | j | S )z¬
|
Ping the Redis server to test connectivity.
|
|
Sends a PING command to the Redis server and returns True if the server
|
responds with "PONG".
|
r¶ ©r7 )rR r r% s rT Úpingz PubSub.ping s* ð %,Ð$7Ñ ¸f¸XØ#t×#Ñ# TÐ*Ð*rW c óV K |yt |t « r |dk7 rd|gnddg}t |d « }|dk( r||d |d |d d
|
}n |d k( r |dd|d d
|
}n |d|d |d d
|
}|| j v r|d k( rK|d }|| j v r| j j |« | j j |d« nJ|d }|| j v r7| j j |« | j j |d« || j v rw|dk( r | j j |d d« }n | j j |d d« }|r/t j |« r ||« d{ y ||« y|S |d k7 r|s | j ry|S 7 &w)zÂ
|
Parses a pub/sub message. If the channel or pattern was subscribed to
|
with a message handler, the handler is invoked instead of a parsed
|
message being returned.
|
Ns PONGr rW r rz ry r r} )ÚtypeÚpatternÚchannelr¸ r r| rÔ rÕ )rb r@ r? ÚUNSUBSCRIBE_MESSAGE_TYPESr Úremover r< r r
ÚPUBLISH_MESSAGE_TYPESr± rß Úiscoroutinefunctionr} )rR rM r} Ú message_typer rÔ rÕ Úhandlers rT rÌ zPubSub.handle_message sä è ø ð Ð ØÜ h¤Ô &Ø.6¸'Ò.A Ñ*ÈÐQTÀ~HÜ# H¨Q¡KÓ0 Ø :Ò %à$Ø# A;Ø# A;Ø ñ Gð VÒ #à$Ø Ø Ø ñ Gð %Ø Ø# A;Ø ñ Gð 4×9Ñ9Ñ 9Ø~Ò-Ø" 1+Ød× ?Ñ ?Ñ?Ø×5Ñ5×<Ñ<¸WÔEØMM×%Ñ% g¨tÕ4à" 1+Ød× ?Ñ ?Ñ?Ø×5Ñ5×<Ñ<¸WÔEØMM×%Ñ% g¨tÔ4à 4×5Ñ5Ñ 5àzÒ)Ø --×+Ñ+¨G°IÑ,>ÀÓEà --×+Ñ+¨G°IÑ,>ÀÓEÙÜ×.Ñ.¨wÔ7Ù! 'Ó*×*Ð*ð ñ GÔ$Øð ð VÒ #ñ )¨D×,JÒ,JØàð +ús E>F)Æ F'Æ'F)g ð?)Úexception_handlerÚ poll_timeoutrñ rÜ ÚPSWorkerThreadExcHandlerTrÝ c ór K | j j « D ] \ }}| t d| d« | j j « D ] \ }}| t d| d« | j « d{ | | j d|¬« d{ n|j d|¬« d{ t j d« d{ X7 ]7 @7 &# t j $ r t $ r6}| ||| « }t j |« r | d{ 7 Y d}~qd}~ww xY w7 `w)a Process pub/sub messages using registered callbacks.
|
|
This is the equivalent of :py:meth:`redis.PubSub.run_in_thread` in
|
redis-py, but it is a coroutine. To launch it as a separate task, use
|
``asyncio.create_task``:
|
|
>>> task = asyncio.create_task(pubsub.run())
|
|
To shut it down, use asyncio cancellation:
|
|
>>> task.cancel()
|
>>> await task
|
Nz
|
Channel: 'z' has no handler registeredz
|
Pattern: 'T)r} rç r ) r
r r2 r rR rÎ r² ÚCancelledErrorÚ BaseExceptionrß rà râ ) rR rÜ rÝ rñ rÕ rÛ rÔ ÚeÚress rT Úrunz
|
PubSub.runØ se è ø ð( !%§ ¡ × 3Ñ 3Ó 5ò UÑ GWØÜ! J¨w¨iÐ7RÐ"SÓTÐTð Uð !%§ ¡ × 3Ñ 3Ó 5ò UÑ GWØÜ! J¨w¨iÐ7RÐ"SÓTÐTð Uð lln× Ð Øð Ø>Ø ×*Ñ*Ø26À ð +ó ÷ ñ ð !×,Ñ,Ø26À ð -ó ÷ ð ô -- Ó"× "Ð "ð) ð øðøðùô ×)Ñ)ò ØÜ ò Ø$Ð,ØÙ'¨¨4Ó0Ü×&Ñ& sÔ+Ø IIÿøð úð #ús #D7¦2D7Á#D7Á<CÁ=D7ÂC ÂC  C Â7C Â8C Â<D7ÃD5ÃD7à C à C à D2Ã<&D-Ä"D%Ä#D-Ä(D7Ä-D2Ä2D7)NFNNN©rp N)Tr )Fg rO )F)/rY rZ r[ r? rØ rÖ r r r r= rD r r¶ rú r r r r< r r r r Úpropertyr¡ r7 r7 rR rª r¤ rF r# r£ rI rº r6 Ú PubSubHandlerr r r| r r{ r rv rÎ rÑ rÌ rä rP rW rT rð rð S sï ñð 4ÐØ ?Ð Ø2Ðð
|
%)Ø*/ØØ04Ø8<ñ'$à'ð'$ð SMð'$ð $(ð '$ð $ HÑ-ð '$ð #Ð#4Ñ5ó'$òRò òIò6ñ" Ð1GÈgÔVò ó Wð ñ Ð1GÈgÔVò ó Wð ð.¨:ó .ð$ ñ4ó ð4ð
|
R¨:ó
|
Rò
|
ò( ò
|
ñ¨$ð Àó ò8ð ? Oð ?¸ó ?ð hð ¸-ó ð* B (ð B¨yó Bð Xð ¸ó ð* A Ió Að mó ð SVñ Ø)-ð Ø@HÈÁó ñ + I¨d¡Oó +ó@ðJ DHØ !Øò 0#ð $Ð$?Ñ@ð0#ð ð 0#ð
|
ô 0#rW rð c ó e Zd ZdedefdZy)Ú PubsubWorkerExceptionHandlerrâ rñ c ó y rO rP ©rR râ rñ s rT rU z%PubsubWorkerExceptionHandler.__call__ rV rW N©rY rZ r[ rá rð rU rP rW rT ré ré s Ø=-Ð=°Ô=rW ré c ó e Zd ZdedefdZy)Ú!AsyncPubsubWorkerExceptionHandlerrâ rñ c ó K y wrO rP rë s rT rU z*AsyncPubsubWorkerExceptionHandler.__call__ r_ r` Nrì rP rW rT rî rî s ØC ÐC°vÔCrW rî .c ó e Zd ZdZh d£Zdedeeee f e
|
f de de e fdZ ded efd
|
Zd Zd Zd Zd Zd Zd Zd Zd/dZd Zd ed ed f fdZdede fdZ d Z d Z ded e fd Z!ded e d e fd Z"d e d e#e$ fd!Z%d"e d#e&d$e#e' d dfd%Z(ded&eee f f fd' Z)d( Z*dede fd)Z+d0d e d e,e$ fd*Z-d+ Z.d,e/fd-Z0d. Z1 xZ2S )1r× a¦
|
Pipelines provide a way to transmit multiple commands to the Redis server
|
in one transmission. This is convenient for batch processing, such as
|
saving all the values in a list to Redis.
|
|
All commands executed within a pipeline(when running in transactional mode,
|
which is the default behavior) are wrapped with MULTI and EXEC
|
calls. This guarantees all commands executed in the pipeline will be
|
executed atomically.
|
|
Any command raising an exception does *not* halt the execution of
|
subsequent commands in the pipeline. Instead, the exception is caught
|
and its instance is placed into the response list returned by execute().
|
Code iterating over the response list should be able to deal with an
|
instance of an exception as a potential value. In general, these will be
|
ResponseError exceptions, such as those raised when issuing a command
|
on a key of a different datatype.
|
> ÚEXECÚDISCARDÚUNWATCHrh rb rÕ rÖ c ó || _ d | _ || _ || _ || _ d| _ g | _ t « | _ d| _ y )NF)
|
rh r¯ rb Úis_transactionrÖ ÚwatchingÚ command_stackr ÚscriptsÚexplicit_transaction)rR rh rb rÕ rÖ s rT r¶ zPipeline.__init__2 sJ ð /Ô Ø Ø"4Ô Ø )ÔØ$Ø Ø,.ÔÜ$'£E Ø$)Õ!rW rR rp c ó K | S wrO rP r¼ s rT rú zPipeline.__aenter__C r r c ó@ K | j « d { y 7 wrO ©r r s rT r zPipeline.__aexit__F s è ø Øjjl×Òúr+ c ó> | j « j « S rO )Ú _async_selfrÀ r¼ s rT rÀ zPipeline.__await__I s Ø× Ñ Ó!×+Ñ+Ó-Ð-rW zUnclosed Pipeline clientc ó, t | j « S rO )Úlenr÷ r¼ s rT Ú__len__zPipeline.__len__N s Ü4×%Ñ%Ó&Ð&rW c ó y)z1Pipeline instances should always evaluate to TrueTrP r¼ s rT Ú__bool__zPipeline.__bool__Q s àrW c ó K | S wrO rP r¼ s rT rþ zPipeline._async_selfU r r c ó K g | _ t « | _ | j rR| j rF | j j d« d { | j j « d { d| _ d| _ | j r5| j j | j « d { d | _ y y 7 v7 V# t $ r2 | j r#| j j « d { 7 Y w xY w7 Ow)Nró F) r÷ r rø rö r¯ r" r; r0 r rù rh r r¼ s rT r zPipeline.resetX sÛ è ø Ø ÔÜu ð ==T__ð 7ð oo×2Ñ2°9Ó=×=Ð=Øoo×3Ñ3Ó5×5Ð5ð Ø$)Ô!ð ??Ø×&Ñ&×.Ñ.¨t¯©Ó?× ?Ð ?Ø "DOð ð >øØ5ùÜ"ò 7à??Ø //×4Ñ4Ó6×6Ñ6ùð 7úð @úse /D ² C ÁCÁ!C Á2C Á3C Á7AD Â9D Â: D ÃC à C à 2DÃ=D Ã>DÄD ÄDÄD Nc ó@ K | j « d{ y7 w)z5Alias for reset(), a standard method name for cleanupNrü r¼ s rT r zPipeline.aclosep s è ø àjjl×Òúr+ c ón | j r t d« | j r t d« d| _ y)z
|
Start a transactional block of the pipeline after WATCH commands
|
are issued. End the transactional block with `execute`.
|
z"Cannot issue nested calls to MULTIz:Commands without an initial WATCH have already been issuedTN)rù r3 r÷ r¼ s rT ÚmultizPipeline.multit s< ð
|
× $Ò $Ü Ð AÓBÐ BØ × Ò Ü ØLóð ð %)Õ!rW c ó | j s|d dk( r | j s | j |i |¤S | j |i |¤S )Nr ÚWATCH)rö rù Úimmediate_execute_commandÚpipeline_execute_command)rR r% rS s rT r7 zPipeline.execute_command sN ð MMT !W¨Ò /¸×9RÒ9RØ14×1Ñ1°4ÐB¸6ÑBÐ BØ,t×,Ñ,¨dÐ=°fÑ=Ð=rW r Úerrorc óÐ K |j « d{ | j r:| j « d{ t dt |« j
|
d« y7 K7 )w)a}
|
Close the connection reset watching state and
|
raise an exception if we were watching.
|
|
The supported exceptions are already checked in the
|
retry object so we don't need to do it here.
|
|
After we disconnect the connection, it will try to reconnect and
|
do a health check as part of the send_command logic(on connection level).
|
NúA ú) occurred while watching one or more keys)r rö r r5 rÓ rY ©rR r r s rT Ú#_disconnect_reset_raise_on_watchingz,Pipeline._disconnect_reset_raise_on_watching se è ø ð ooÓ × Ð ð ==Ø**,× Ð Ü ØT%[×)Ñ)Ð*Ð*SÐTóð ð ð øð
|
ús A&A"#A&ºA$»(A&Á$A&c óò K d j s) j j « d{ _ j j fd fd« d{ S 7 :7 w)a
|
Execute a command immediately, but don't auto-retry on the supported
|
errors for retry if we're already WATCHing a variable.
|
Used when issuing WATCH or subsequent commands retrieving their values but before
|
MULTI is called.
|
r Nc ó2 j g ¢i ¤S rO r. r/ s rT r0 z4Pipeline.immediate_execute_command.<locals>.<lambda>° s* ø Ð5D×5Ñ5ØlðØ%)òØ-4ñ rW c ó( j | « S rO )r ©r r rR s rT r0 z4Pipeline.immediate_execute_command.<locals>.<lambda>³ s ø $×BÑBÀ4ÈÓO rW )r¯ rh r r r5 )rR r% r& r$ r s ```@@rT r z"Pipeline.immediate_execute_command¡ sn üè ø ð Aw ØáØ ×-Ñ-×<Ñ<Ó>×>DØ "DOàZZ×/Ñ/÷ ô Pó
|
÷
|
ð
|
ð ?øð
|
ús! 1A7¸A3¹5A7Á.A5Á/A7Á5A7c ó@ | j j ||f« | S )ar
|
Stage a command to be executed when execute() is next called
|
|
Returns the current Pipeline object back so commands can be
|
chained together, such as:
|
|
pipe = pipe.set('foo', 'bar').incr('baz').decr('bang')
|
|
At some other point, you can then run: pipe.execute(),
|
which will execute all commands queued in the pipe.
|
)r÷ Úappend)rR r% r& s rT r z!Pipeline.pipeline_execute_command¶ s! ð ×Ñ×!Ñ! 4¨ /Ô2Ø rW r¯ Úcommandsc ó< K di f}di f}|g|¢|}|j d |D « « }|j |« d { g } | j |d« d { t |« D ]I \ }
|
} t | d v r |j |
|
| d t f« / | j |d« d { K | j |d« d { } d| _ | t d« d |D ] \ }
|
} | j |
|
| « t | « t |« k7 r:| j r"| j j « d { t d « d |r| j || « g }t! | |« D ]
\ }}t# |t$ « s_|\ }}|d }|j' d
|
d « || j( v r5 | j( | |fi |¤}t+ j, |« r
|
| d { }|j |« |S 7 Â7 ¨# t $ r } |j d| f« Y d } ~ Èd } ~ ww xY w7 # t $ r7} | j | |
|
dz | d « |j |
|
| f« Y d } ~ d } ~ ww xY w7 ©# t $ r} |r |d d | d } ~ ww xY w7 S7 ²w) N)ÚMULTI)rñ c 3 ó8 K | ] \ }}t |vs| y wrO )r" )Ú.0r% r& s rT ú <genexpr>z0Pipeline._execute_transaction.<locals>.<genexpr>Ë s è ø ò ,
|
Ù"T7¬nÀGÒ.KDñ,
|
ùs r3 r ry FzWatched variable changed.z6Wrong number of response items from pipeline executionr: )Ú pack_commandsÚsend_packed_commandr# r4 r Ú enumerater" Úannotate_exceptionr1 rö r5 Úinsertr r¯ r Úraise_first_errorÚziprb rø r< rb rß rà )rR r¯ r Úraise_on_errorÚpreÚpostÚcmdsÚall_cmdsÚerrorsÚerrÚirà rM râ r¸ ÚrÚcmdr% r& r$ s rT Ú_execute_transactionz Pipeline._execute_transactionÅ sÒ è ø ð $ RÐ(Ø# R ØÐ%hÐ% Ñ%Ø ×+Ñ+ñ ,
|
Ø&*ô,
|
ó
|
ð ×,Ñ,¨XÓ6×6Ð6Øð $Ø×%Ñ% j°#Ó6× 6Ð 6ô
|
$ HÓ-ò ,JAwÜ ¨¡Ñ+Ø q '¨!¡*¬^Ñ"<Ð =Õ>ð,Ø ×-Ñ-¨j¸#Ó>×>Ñ>ð ,ð Ø !× 0Ñ 0°¸SÓ A×AHð à Ð Ü Ð 8Ó9¸tÐ Cð ò "DAqØ OOAqÕ !ð "ô x=C MÒ )ØØoo×0Ñ0Ó2×2Ð2Ü ØHóàð ñ
|
Ø × "Ñ " 8¨XÔ 6ð Ü( HÓ-ò FAsÜ a¤Ô+Ø # gØ # Aw ð F DÔ)à 4×#:Ñ#:Ñ:Ø=×/Ñ/° Ñ=¸aÑKÀ7ÑKAÜ ×*Ñ*¨1Ô-Ø"#GØ KKNð ð ðG 7ùð 7úÜ ò $Ø MM1c(× #Ò #ûð $úð ?úÜ$ò ,Ø×+Ñ+¨C°°Q±¸À¹
|
ÔCØMM 1 c (×+Ò+ûð,úð BúÜ ò ÙØ Qi l¨Ð+Ø ûð úð" 3ùð, $úsÞ =J ¿HÁ J ÁH Á HÁ H Á!:J  H4Â1H1Â2H4Â6J Â9I: ÃI7ÃI: ÃA1J ÅJÅB"J Ç'JÇ(J ÈH È H.ÈH)È#J È)H.È.J È1H4È4 I4È=,I/É)J É/I4É4J É7I: É: JÊ JÊJÊJ ÊJ r& c ó K |j |D cg c] \ }}| c}}« }|j |« d { g }|D ]4 \ }} |j | j ||d fi |¤ d { « 6 |r| j ||« |S c c}}w 7 [7 (# t $ r} |j | « Y d } ~ vd } ~ ww xY ww)Nr )r r r r# r4 r$ )
|
rR r¯ r r& r% r3 r* rM r& râ s
|
rT Ú_execute_pipelinezPipeline._execute_pipeline sÊ è ø ð ×+Ñ+À×,J±g°d¸AªTÓ,JÓKØ×,Ñ,¨XÓ6×6Ð6àØ %ò #MD'ð #ØØ-$×-Ñ-¨j¸$¸q¹'ÑMÀWÑM×Mõð #ñ Ø × "Ñ " 8¨XÔ 6Øùó -KØ6øð Nùä ò #Ø ×"Ñ"ûð #üsU C B
|
C»B¼CÁ %BÁ0B
|
Á1BÁ9 CÂB B?Â$B:Â5CÂ:B?Â?CrM c ó t |« D ]3 \ }}t |t « s| j ||dz || d « | y )Nry r )r! rb r4 r" )rR r rM r- r. s rT r$ zPipeline.raise_first_error' sG Ü hÓ'ò DAqÜ!]Õ+Ø×'Ñ'¨¨1¨q©5°(¸1±+¸a±.ÔAØñ rW Ú exceptionÚnumberrà c ó dj t t |« « }d| dt |« d}|f|j dd z |_ y )NrZ z
|
Command # z (z,) of pipeline caused error: {exception.args}ry )ri Úmapr> r@ r% )rR r4 r5 rà r/ Úmsgs rT r" zPipeline.annotate_exception- sV ð hhs8 WÓ-Ó.à ¤=°Ó#5Ð"6ð 79ð 9ð ð )§.¡.°°Ð"4Ñ4 rW r$ c ó K t | ||fi |¤ d { }|| j v r d| _ |S |dk( rd| _ |S 7 )w)NFr
|
T)Úsuperr# ÚUNWATCH_COMMANDSrö )rR r¯ r$ r& Úresultr» s rT r# zPipeline.parse_response7 sZ øè ø ô wÑ-¨j¸,ÑRÈ'ÑR×RØ 4×0Ñ0Ñ 0Ø !DMð ð WÒ $Ø DMØ ð Sús AA*Ac ó: K t | j « }| j }|D cg c] }|j }} |dg|¢ d { }t |« s8t ||« D ]( \ }}|r |d|j « d { |_ * y y c c}w 7 M7 w)Nz SCRIPT EXISTSz SCRIPT LOAD)rG rø r ÚshaÚallr% Úscript)rR rø Ú immediateÚsÚshasÚexistsÚexists rT Ú load_scriptszPipeline.load_scriptsA s è ø ät||Ó$Ø×2Ñ2 Ø &Ö'!Ð'Ð'ñ ! Ð8°4Ò8×8Ü6{Ü ¨Ó 0ò E5Ú Ù"+¨M¸1¿8¹8Ó"D× DAEñ Eð ùò (ð 9øð Eús3 &B¨B»BÁ BÁ
|
#BÁ.BÂBÂBÂBc ó K |j « d{ | j r"t dt |« j d« y7 3w)a]
|
Close the connection, raise an exception if we were watching.
|
|
The supported exceptions are already checked in the
|
retry object so we don't need to do it here.
|
|
After we disconnect the connection, it will try to reconnect and
|
do a health check as part of the send_command logic(on connection level).
|
Nr r )r rö r5 rÓ rY r s rT Ú _disconnect_raise_on_watchingz&Pipeline._disconnect_raise_on_watchingN sP è ø ð ooÓ × Ð ð ==Ü ØT%[×)Ñ)Ð*Ð*SÐTóð ð ð ús A A
|
4A c ó^ K j s j sg S j r j « d{ j s j
|
r j n j j s) j j « d{ _ t t « j j fd fd« d{ j « d{ S 7 Ã7 d7 7 # j « d{ 7 w xY ww)z0Execute all the commands in the current pipelineNc ó « S rO rP )r rá r& Ústacks rT r0 z"Pipeline.execute.<locals>.<lambda>w s ø e¨^Ó< rW c ó( j | « S rO )rH r s rT r0 z"Pipeline.execute.<locals>.<lambda>x s ø d× @Ñ @ÀÀuÓ M rW )r÷ rö rø rF rõ rù r0 r2 r¯ rh r r r r r5 r )rR r& r rá rK s ``@@@rT rá zPipeline.executea sñ üè ø à×"Ñ"ÙT]]ØIØ <<Ø×#Ñ#Ó%× %Ð %Ø × Ò $×";Ò";Ø×/Ñ/Gà×,Ñ,GàÙØ ×-Ñ-×<Ñ<Ó>×>Dð #DOÜJ Ó%ð Ø ×3Ñ3Þ<ÜMó÷ ð
|
**,× Ñ ð) &øð ?øðøð
|
ù$**,× Ò üsl <D-ÁDÁA D-Â$D Â%D-Ã)D Ã*D Ã+D Ã.D-ÄD ÄD-Ä D-Ä D Ä D-ÄD*Ä#D&Ä$D*Ä*D-c óB K | j d« d{ y7 w)z^Flushes all previously queued commands
|
See: https://redis.io/commands/DISCARD
|
rò NrÐ r¼ s rT ÚdiscardzPipeline.discard} s è ø ð ×"Ñ" 9Ó-×-Ò-úr Únamesc ór K | j r t d« | j dg|¢ d{ S 7 w)z$Watches the values at keys ``names``z"Cannot issue a WATCH after a MULTIr
|
N)rù r3 r7 )rR rO s rT rÞ zPipeline.watch s9 è ø à × $Ò $Ü Ð AÓBÐ BØ)T×)Ñ)¨'Ð:°EÒ:×:Ð:Ð:ús .7°5±7c ód K | j xr | j d« d{ xs dS 7 w)z'Unwatches all previously specified keysró NT)rö r7 r¼ s rT ÚunwatchzPipeline.unwatch s+ è ø à}}ÒF t×';Ñ';¸IÓ'F×!FÒNÈ$ÐNÐ!Fús #0¥.¦ 0rå )T)3rY rZ r[ r? r; r r r r= r@ rA rD r r¶ rG rú r rÀ r r r rþ r r r r r7 r rø r r r Ú CommandStackTr0 r2 r r r$ rE Úobjectr" r# rF rH r
|
rá rN r8 rÞ rR Ú __classcell__)r» s @rT r× r× s® ø ñò& 6Ðð*à'ð*ð +¨5°°e°Ñ+<Ð>OÐ+OÑ Pð*ð ð *ð
|
SMó *ð"wð ¨7ó òò.ð .Lò'òòò#ó0ò )ð>à z9 ZÑ0Ð0Ñ 1ó>ðàðð óò2
|
ò* ð LØ$ðLØ0=óLð\Ø$ðØ0=ðØOSóð(¨-ð À8ÈCÁ=ó ð 5Ø"ð5Ø,/ð5Ø:BÀ6Ñ:Jð5à ó5ðØ$ðØ49¸#¸u¸*Ñ4Eõò Eð¸
|
ð È9ó ñ& ¨Dð ¸DÀ¹Ió ò8.ð ; $ó ;ö OrW r× )kr² rª rß rw rk Útypingr r r r r r r r
|
r r r r r r r r r r r Úredis._parsers.helpersr r r r Úredis.asyncio.connectionr r r r Úredis.asyncio.lockr Úredis.asyncio.retryr Ú redis.backoffr! Ú redis.clientr" r# r$ r% Úredis.commandsr& r' r( r) Úredis.credentialsr* Ú redis.eventr+ r, r- r. r/ Úredis.exceptionsr0 r1 r2 r3 r4 r5 Ú redis.typingr6 r7 r8 Ú redis.utilsr9 r: r; r< r= r> r? r@ r rA rB rC r= rç rD rF rG rT rI Úredis.commands.corerJ rL r] rA rH Ú StrictRedisrJ ró rð ré rî rÞ r@ ÚCommandTrS r× rP rW rT ú<module>rf sú ðÛ Û Û Û Û ÷÷ ÷ ÷ ÷ ñ ÷,ó ÷ ó õ $Ý %Ý 6÷ó ÷ ó õ 1÷õ ÷÷ ÷ 4Ñ 3÷ ÷ ó ñ ]ß7Ò7àJØJØKà$s Cx.Ð)¨9°T©?Ð:Ñ; ÙtÔ$ÙzÓ*Ù
|
) 7Ô
|
+ÙÐ+°7¸8ÀVÐ;KÑ3LÔMÙÝ*ô5xô 5ô; Hô ;ð Ð2Ð4QÐQÑRÐ ôM
|
ØÐ+Ð->Ð@UôM
|
ð` ôô ÷F,ñ F,÷Ru#ñ u#ôp > 8ô >ôD¨ô Dð "Ø Ð"CÐCñ Ð ð
|
uS %ZÑ(¨#Ð-Ñ.°¸¸S¸Ñ0AÐAÑ BØX ôoOuõ oOrW
|
