Ë
    §Œjh¾ ã            	       óì  — d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZm	Z	 d dl
m
Z
 d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZmZmZmZ d dlmZmZ d dlm Z m!Z!m"Z" d dl#m$Z$m%Z%m&Z& d d	l'm(Z( d d
l)m*Z*m+Z+m,Z, d dl-m.Z. d dl/m0Z0m1Z1 d dl2m3Z3 d dl4m5Z5 d dl6m7Z7m8Z8 d dl9m:Z:m;Z;m<Z< d dl=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZG d dlHmIZImJZJ d dlKmLZLmMZM d dlNmOZOmPZP d dlQmRZR d dlSmTZTmUZU d dlVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZh d dlimjZjmkZkmlZl d dlmmnZnmoZompZpmqZqmrZrmsZsmtZt enrd dlumvZvmwZwmxZx ndZvdZxdZw edeyded   eedf   «      Zz G d„ de<eBeJ«      Z{ G d„ d«      Z| G d „ d!«      Z} G d"„ d#e<eBeJ«      Z~e>D ]:  Ze�j                  d$d%«      �j                  «       Zed&k(  rŒ+ e‚e~e eEe«      «       Œ<  G d'„ d(«      Zƒ G d)„ d*e«      Z„ G d+„ d,e„«      Z… G d-„ d.e…«      Z† G d/„ d0e…«      Z‡y)1é    N)ÚABCÚabstractmethod)Úcopy)Úchain)ÚAnyÚCallableÚ	CoroutineÚDequeÚDictÚ	GeneratorÚListÚMappingÚOptionalÚSetÚTupleÚTypeÚTypeVarÚUnion)ÚAsyncCommandsParserÚEncoder)ÚCommandPoliciesÚRequestPolicyÚResponsePolicy)Ú_RedisCallbacksÚ_RedisCallbacksRESP2Ú_RedisCallbacksRESP3)ÚResponseCallbackT)Ú
ConnectionÚSSLConnectionÚ	parse_url©ÚLock)Úrecord_error_countÚrecord_operation_duration)ÚRetry)ÚTokenInterface)ÚExponentialWithJitterBackoffÚ	NoBackoff)ÚEMPTY_RESPONSEÚNEVER_DECODEÚAbstractRedis)
ÚPIPELINE_BLOCKED_COMMANDSÚPRIMARYÚREPLICAÚSLOT_IDÚAbstractRedisClusterÚLoadBalancerÚLoadBalancingStrategyÚblock_pipeline_commandÚget_node_nameÚparse_cluster_slots)ÚREAD_COMMANDSÚAsyncRedisClusterCommands)ÚAsyncPolicyResolverÚAsyncStaticPolicyResolver)ÚREDIS_CLUSTER_HASH_SLOTSÚkey_slot)ÚCredentialProvider)Ú#AfterAsyncClusterInstantiationEventÚEventDispatcher)ÚAskErrorÚBusyLoadingErrorÚClusterDownErrorÚClusterErrorÚConnectionErrorÚCrossSlotTransactionErrorÚ	DataErrorÚExecAbortErrorÚInvalidPipelineStackÚMaxConnectionsErrorÚ
MovedErrorÚRedisClusterExceptionÚ
RedisErrorÚResponseErrorÚSlotNotCoveredErrorÚTimeoutErrorÚTryAgainErrorÚ
WatchError)ÚAnyKeyTÚ
EncodableTÚKeyT)ÚSSL_AVAILABLEÚdeprecated_argsÚdeprecated_functionÚget_lib_versionÚsafe_strÚstr_if_bytesÚtruncate_text)Ú
TLSVersionÚVerifyFlagsÚ
VerifyModeÚTargetNodesTÚClusterNodec            [       ó   — e Zd ZdZedededd fd„«       ZdZ e	dgdd	¬
«       e	dgdd¬
«      ddddddddddddddddddd e
«       dddddddddddddddddddddd e«       f+dee   deeef   deed      deded ee   d!ed"eded#ed$ed%   d&eeee         d'eeef   d(ee   d)ee   d*ee   d+ee   d,ee   d-ee   d.ee   d/ed0ed1ed2ed3ee   d4ed5eeeeeef   f      d6ee   d7ed8ee   d9ee   d:eeef   d;eee      d<eee      d=ee   d>ed?ee   d@ee   dAee   dBee   dCeeeeef   geeef   f      dDee   dEeddfXdF„«       «       Zd‘dG„Z d’dH„Z! e"dIdJdK¬L«      d’dM„«       Z#d‘dN„Z$defdO„Z%defdP„Z&dQ„ Z'de(edd f   fdR„Z)dSZ*e+jX                  e-j\                  fdTedUeddfdV„Z/dWe0ddfdX„Z1ded   fdY„Z2ded   fdZ„Z3ded   fd[„Z4d“d\„Z5d“d]„Z6d”d^„Z7	 	 	 d•dee   dee   d_ee   ded   fd`„Z8	 d–daedbeded   fdc„Z9dd„ Z:d“de„Z;dfefdg„Z<dee=d      fdh„Z>dae?defdi„Z@deAfdj„ZBdeCeee   f   fdk„ZDd$eEddfdl„ZFdfedmeGddfdn„ZHddoœdfedpedqeIdree   ded   f
ds„ZJdfedpedefdt„ZKduedefdv„ZLdueded   fdw„ZM	 	 d—dxedWee0df   dyedzee   fd{„ZN	 d˜d|ed}edWee0df   dxee   fd~„ZOdpe?dedefd„ZPd€ddpeeQe?f   dedefd�„ZR	 d™d‚ee   dƒee   dd„fd…„ZS	 	 	 	 	 	 	 dšd†eQd‡ee   dˆed‰edŠee   d‹eeeT      dŒed�edeTfdŽ„ZUd�eVdd„ef   fd�„ZWy)›ÚRedisClustera·  
    Create a new RedisCluster client.

    Pass one of parameters:

      - `host` & `port`
      - `startup_nodes`

    | Use ``await`` :meth:`initialize` to find cluster nodes & create connections.
    | Use ``await`` :meth:`close` to disconnect connections & close client.

    Many commands support the target_nodes kwarg. It can be one of the
    :attr:`NODE_FLAGS`:

      - :attr:`PRIMARIES`
      - :attr:`REPLICAS`
      - :attr:`ALL_NODES`
      - :attr:`RANDOM`
      - :attr:`DEFAULT_NODE`

    Note: This client is not thread/process/fork safe.

    :param host:
        | Can be used to point to a startup node
    :param port:
        | Port used if **host** is provided
    :param startup_nodes:
        | :class:`~.ClusterNode` to used as a startup node
    :param require_full_coverage:
        | When set to ``False``: the client will not require a full coverage of
          the slots. However, if not all slots are covered, and at least one node
          has ``cluster-require-full-coverage`` set to ``yes``, the server will throw
          a :class:`~.ClusterDownError` for some key-based commands.
        | When set to ``True``: all slots must be covered to construct the cluster
          client. If not all slots are covered, :class:`~.RedisClusterException` will be
          thrown.
        | See:
          https://redis.io/docs/manual/scaling/#redis-cluster-configuration-parameters
    :param read_from_replicas:
        | @deprecated - please use load_balancing_strategy instead
        | Enable read from replicas in READONLY mode.
          When set to true, read commands will be assigned between the primary and
          its replications in a Round-Robin manner.
          The data read from replicas is eventually consistent with the data in primary nodes.
    :param load_balancing_strategy:
        | Enable read from replicas in READONLY mode and defines the load balancing
          strategy that will be used for cluster node selection.
          The data read from replicas is eventually consistent with the data in primary nodes.
    :param dynamic_startup_nodes:
        | Set the RedisCluster's startup nodes to all the discovered nodes.
          If true (default value), the cluster's discovered nodes will be used to
          determine the cluster nodes-slots mapping in the next topology refresh.
          It will remove the initial passed startup nodes if their endpoints aren't
          listed in the CLUSTER SLOTS output.
          If you use dynamic DNS endpoints for startup nodes but CLUSTER SLOTS lists
          specific IP addresses, it is best to set it to false.
    :param reinitialize_steps:
        | Specifies the number of MOVED errors that need to occur before reinitializing
          the whole cluster topology. If a MOVED error occurs and the cluster does not
          need to be reinitialized on this current error handling, only the MOVED slot
          will be patched with the redirected node.
          To reinitialize the cluster on every MOVED error, set reinitialize_steps to 1.
          To avoid reinitializing the cluster on moved errors, set reinitialize_steps to
          0.
    :param cluster_error_retry_attempts:
        | @deprecated - Please configure the 'retry' object instead
          In case 'retry' object is set - this argument is ignored!

          Number of times to retry before raising an error when :class:`~.TimeoutError`,
          :class:`~.ConnectionError`, :class:`~.SlotNotCoveredError`
          or :class:`~.ClusterDownError` are encountered
    :param retry:
        | A retry object that defines the retry strategy and the number of
          retries for the cluster client.
          In current implementation for the cluster client (starting form redis-py version 6.0.0)
          the retry object is not yet fully utilized, instead it is used just to determine
          the number of retries for the cluster client.
          In the future releases the retry object will be used to handle the cluster client retries!
    :param max_connections:
        | Maximum number of connections per node. If there are no free connections & the
          maximum number of connections are already created, a
          :class:`~.MaxConnectionsError` is raised.
    :param address_remap:
        | An optional callable which, when provided with an internal network
          address of a node, e.g. a `(host, port)` tuple, will return the address
          where the node is reachable.  This can be used to map the addresses at
          which the nodes _think_ they are, to addresses at which a client may
          reach them, such as when they sit behind a proxy.

    | Rest of the arguments will be passed to the
      :class:`~redis.asyncio.connection.Connection` instances when created

    :raises RedisClusterException:
        if any arguments are invalid or unknown. Eg:

        - `db` != 0 or None
        - `path` argument for unix socket connection
        - none of the `host`/`port` & `startup_nodes` were provided

    ÚurlÚkwargsÚreturnc                 ó€   — |j                  t        |«      «       |j                  dd«      t        u rd|d<    | di |¤Ž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

        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>

        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.

        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
        :class:`~redis.asyncio.connection.Connection` when created.
        In the case of conflicting arguments, querystring arguments are used.
        Úconnection_classNTÚssl© )Úupdater    Úpopr   )Úclsrb   rc   s      ú_/var/www/html/Fitness-lenito-AI-main/venv/lib/python3.12/site-packages/redis/asyncio/cluster.pyÚfrom_urlzRedisCluster.from_urlÐ   s=   € ð8 	�‰”i “nÔ%Ø�:‰:Ð(¨$Ó/´=Ñ@Ø ˆF�5‰MÙ‰}�V‰}Ðó    )Ú_initializeÚ_lockÚretryÚcommand_flagsÚcommands_parserÚconnection_kwargsÚencoderÚ
node_flagsÚnodes_managerÚread_from_replicasÚreinitialize_counterÚreinitialize_stepsÚresponse_callbacksÚresult_callbacksrx   z6Please configure the 'load_balancing_strategy' insteadz5.3.0)Úargs_to_warnÚreasonÚversionÚcluster_error_retry_attemptsz+Please configure the 'retry' object insteadz6.0.0Nië  TFé   é   ì        r   zredis-pyzutf-8ÚstrictÚrequiredé   ÚhostÚportÚstartup_nodesr_   Úrequire_full_coverageÚload_balancing_strategyÚdynamic_startup_nodesrz   Úmax_connectionsrq   r%   Úretry_on_errorÚdbÚpathÚcredential_providerÚusernameÚpasswordÚclient_nameÚlib_nameÚlib_versionÚencodingÚencoding_errorsÚdecode_responsesÚhealth_check_intervalÚsocket_connect_timeoutÚsocket_keepaliveÚsocket_keepalive_optionsÚsocket_timeoutrg   Ússl_ca_certsÚssl_ca_dataÚssl_cert_reqsÚssl_include_verify_flagsÚssl_exclude_verify_flagsÚssl_certfileÚssl_check_hostnameÚssl_keyfileÚssl_min_versionÚssl_ciphersÚprotocolÚaddress_remapÚevent_dispatcherÚpolicy_resolverc,                 óJ	  ‡ — |rt        d«      ‚|rt        d«      ‚|r|s|st        d«      ‚i d|
“dt        “d|“d|“d|“d	|“d
|“d|“d|“d|“d|“d|“d|“d|“d|“d|“d|(“},|r!|,j                  t        ||| |!|"|#|$|%|&|'dœ«       |s|r‰ j                  |,d<   |r|‰ _        nt        t        dd¬«      |	¬«      ‰ _        |r‰ j
                  j                  |«       t        j                  «       |,d<   |,j                  d«      dv r|,d   j                  t        «       n|,d   j                  t        «       |,‰ _        |rFg }-|D ]<  }.|-j                  t!        |.j"                  |.j$                  fi ‰ j                  ¤Ž«       Œ> |-}ng }|r(|r&|j                  t!        ||fi ‰ j                  ¤Ž«       |*€t'        «       ‰ _        n|*‰ _        |‰ _        t-        |||,||)‰ j(                  ¬«      ‰ _        t1        |||«      ‰ _        |‰ _        |‰ _        |‰ _        d‰ _        ‰ j<                  j>                  t@        jB                  ‰ j<                  jD                  t@        jF                  ‰ j<                  jH                  t@        jH                  ‰ j<                  jJ                  t@        jL                  ‰ j<                  jN                  t@        jN                  tP        t@        jR                  i‰ _*        t@        jB                  ˆ fd„t@        jR                  ‰ jV                  t@        jN                  ˆ fd „t@        jF                  ‰ jX                  t@        jH                  ‰ jZ                  t@        jL                  ‰ j\                  t@        j^                  ‰ j`                  tb        jB                  d!„ tb        jR                  d"„ i	‰ _2        |+‰ _3        ti        «       ‰ _5        d ‰ _6        ‰ j<                  jn                  j                  «       ‰ _8        ‰ j<                  jr                  j                  «       ‰ _:        |,d   ‰ _;        ‰ j<                  jx                  j                  «       ‰ _=        d#„ ‰ jz                  d$<   d%‰ _>        d ‰ _?        d‰ _@        tƒ        j„                  «       ‰ _C        y )&Nz/Argument 'db' must be 0 or None in cluster modez3Unix domain socket is not supported in cluster modea1  RedisCluster requires at least one node to discover the cluster.
Please provide one of the following or use RedisCluster.from_url:
   - host and port: RedisCluster(host="localhost", port=6379)
   - startup_nodes: RedisCluster(startup_nodes=[ClusterNode("localhost", 6379), ClusterNode("localhost", 6380)])r�   rf   r‘   r’   r“   r”   r•   r–   r—   r˜   r™   rš   r›   rœ   r�   rž   r©   )rf   rŸ   r    r¡   r¢   r£   r¤   r¥   r¦   r§   r¨   Úredis_connect_funcé   é
   )ÚbaseÚcap)ÚbackoffÚretriesr{   )Ú3r‚   )rŒ   rª   r«   r   c                 ó(   •— ‰j                  | «      gS ©N)Úget_random_primary_or_all_nodes)Úcommand_nameÚselfs    €rl   Ú<lambda>z'RedisCluster.__init__.<locals>.<lambda>¿  s   ø€ Ø×4Ñ4°\ÓBñArn   c                  ó&   •— ‰ j                  «       gS r·   )Úget_default_node©rº   s   €rl   r»   z'RedisCluster.__init__.<locals>.<lambda>Ã  s   ø€ °×1FÑ1FÓ1HÑ0Irn   c                 ó   — | S r·   rh   ©Úress    rl   r»   z'RedisCluster.__init__.<locals>.<lambda>È  s   € ¹rn   c                 ó   — | S r·   rh   rÀ   s    rl   r»   z'RedisCluster.__init__.<locals>.<lambda>É  s   € ±crn   c                 óN   — t        t        |j                  «       «      d   fi |¤ŽS ©Nr   )r5   ÚlistÚvalues)ÚcmdrÁ   rc   s      rl   r»   z'RedisCluster.__init__.<locals>.<lambda>Ô  s%   € Ô':Ü�S—Z‘Z“\Ó" 1Ñ%ñ(Ø)/ò(rn   úCLUSTER SLOTST)DrJ   r   ri   r   Ú
on_connectrq   r%   r'   Úupdate_supported_errorsr   r   Úgetr   r   rt   Úappendr_   r‡   rˆ   r>   Ú_event_dispatcherr‰   ÚNodesManagerrw   r   ru   rx   r‹   rz   ry   Ú	__class__ÚRANDOMr   ÚDEFAULT_KEYLESSÚ	PRIMARIESÚ
ALL_SHARDSÚ	ALL_NODESÚREPLICASÚALL_REPLICASÚDEFAULT_NODEr/   ÚDEFAULT_KEYEDÚ_command_flags_mappingÚget_nodes_from_slotÚget_primariesÚ	get_nodesÚget_replicasÚSPECIALÚget_special_nodesr   Ú_policies_callback_mappingÚ_policy_resolverr   rs   Ú_aggregate_nodesÚ
NODE_FLAGSrv   ÚCOMMAND_FLAGSrr   r{   ÚRESULT_CALLBACKSr|   ro   rp   Ú_usage_counterÚasyncior"   Ú_usage_lock)/rº   r‡   rˆ   r‰   rŠ   rx   r‹   rŒ   rz   r€   r�   rq   rŽ   r�   r�   r‘   r’   r“   r”   r•   r–   r—   r˜   r™   rš   r›   rœ   r�   rž   rg   rŸ   r    r¡   r¢   r£   r¤   r¥   r¦   r§   r¨   r©   rª   r«   r¬   rc   Úpassed_nodesÚnodes/   `                                              rl   Ú__init__zRedisCluster.__init__  s³  ø€ ñ~ Ü'ØAóð ñ Ü'ØEóð ñ ™D©-Ü'ðSóð ð"
Ø˜ð"
à¤
ð"
ð "Ð#6ð	"
ð
 ˜ð"
ð ˜ð"
ð ˜;ð"
ð ˜ð"
ð ˜;ð"
ð ˜ð"
ð ˜ð"
ð Ð 0ð"
ð $Ð%:ð"
ð  %Ð&<ð!"
ð" Ð 0ð#"
ð$ 'Ð(@ð%"
ð& ˜nð'"
ð( ˜ð)"
ˆñ. à�M‰Mä(5Ø$0Ø#.Ø%2Ø0HØ0HØ$0Ø*<Ø#.Ø'6Ø#.ñôñ  Ñ!8à+/¯?©?ˆFÐ'Ñ(áØˆD�JäÜ4¸!ÀÔDØ4ôˆDŒJñ Ø�J‰J×.Ñ.¨~Ô>ä'6×';Ñ';Ó'=ˆÐ#Ñ$Ø�:‰:�jÓ! XÑ-ØÐ'Ñ(×/Ñ/Ô0DÕEàÐ'Ñ(×/Ñ/Ô0DÔEØ!'ˆÔáØˆLÛ%�Ø×#Ñ#Ü §	¡	¨4¯9©9ÑO¸×8NÑ8NÑOõð &ð )‰MàˆMÙ‘DØ× Ñ ¤¨T°4Ñ!R¸4×;QÑ;QÑ!RÔSàÐ#Ü%4Ó%6ˆDÕ"à%5ˆDÔ"à*ˆÔÜ)ØØ!ØØ"7Ø'Ø!×3Ñ3ô
ˆÔô ˜x¨Ð:JÓKˆŒØ"4ˆÔØ'>ˆÔ$Ø"4ˆÔØ$%ˆÔ!ð �N‰N×!Ñ!¤=×#@Ñ#@Ø�N‰N×$Ñ$¤m×&>Ñ&>Ø�N‰N×$Ñ$¤m×&=Ñ&=Ø�N‰N×#Ñ#¤]×%?Ñ%?Ø�N‰N×'Ñ'¬×)CÑ)CÜ”]×0Ñ0ðX
ˆÔ#ô ×)Ñ)ó ,ô ×'Ñ'¨×)AÑ)AÜ×&Ñ&Ó(IÜ×$Ñ$ d×&8Ñ&8Ü×#Ñ# T§^¡^Ü×&Ñ&¨×(9Ñ(9Ü×!Ñ! 4×#9Ñ#9Ü×*Ñ*©OÜ×(Ñ(©/ð
ð 	Ô'ð  !0ˆÔÜ2Ó4ˆÔØ $ˆÔØŸ.™.×3Ñ3×8Ñ8Ó:ˆŒØ!Ÿ^™^×9Ñ9×>Ñ>Ó@ˆÔØ"(Ð)=Ñ">ˆÔØ $§¡× ?Ñ ?× DÑ DÓ FˆÔñð 	×Ñ˜oÑ.ð  ˆÔØ-1ˆŒ
ð
  ˆÔÜ"Ÿ<™<›>ˆÕrn   c              ƒ   ó~  K  — | j                   r¹| j                  st        j                  «       | _        | j                  4 ƒd{  –—†  | j                   ra	 | j                  j                  «       ƒ d{  –—†  | j                  j                  | j                  j                  «      ƒ d{  –—†  d| _         ddd«      ƒd{  –—†  | S | S 7 Œ…7 ŒX7 Œ## t        $ rI | j                  j                  «       ƒ d{  –—†7   | j                  j                  d«      ƒ d{  –—†7   ‚ w xY w7 Œc# 1 ƒd{  –—†7  sw Y   | S xY w­w)zJGet all nodes from startup nodes & creates connections if not initialized.NFr‰   )
ro   rp   rç   r"   rw   Ú
initializers   Údefault_nodeÚBaseExceptionÚacloser¾   s    rl   rí   zRedisCluster.initializeâ  s  è ø€ à×ÒØ—:’:Ü$Ÿ\™\›^�”
Ø—z—z“zØ×#Ò#ð	Ø"×0Ñ0×;Ñ;Ó=×=Ð=Ø"×2Ñ2×=Ñ=Ø ×.Ñ.×;Ñ;ó÷ ð ð ,1˜Ô(÷ "—zð ˆˆtˆð "øð >øðùô )ò Ø"×0Ñ0×7Ñ7Ó9×9Ñ9Ø"×0Ñ0×7Ñ7¸ÓH×HÑHØðúð "ø—z—z�zð ˆüs–   ‚AD=ÁC
ÁD=ÁD'ÁCÁ3CÁ46CÂ*CÂ+CÂ6D=ÃD%Ã	D=ÃCÃCÃ&D"Ã6C9Ã7#D"ÄDÄD"Ä"D'Ä%D=Ä'D:Ä-D0Ä.D:Ä5D=c              ƒ   ó¤  K  — | j                   s£| j                  st        j                  «       | _        | j                  4 ƒd{  –—†  | j                   sLd| _         | j                  j                  «       ƒ d{  –—†  | j                  j                  d«      ƒ d{  –—†  ddd«      ƒd{  –—†  yy7 Œn7 Œ;7 Œ7 Œ# 1 ƒd{  –—†7  sw Y   yxY w­w)z.Close all connections & client if initialized.NTr‰   )ro   rp   rç   r"   rw   rð   r¾   s    rl   rð   zRedisCluster.acloseõ  s™   è ø€ à×ÒØ—:’:Ü$Ÿ\™\›^�”
Ø—z—z“zØ×'Ò'Ø'+�DÔ$Ø×,Ñ,×3Ñ3Ó5×5Ð5Ø×,Ñ,×3Ñ3°OÓD×DÐD÷	 "—z�zð  ð "øð 6øØDøð	 "ø—z—z‘züsl   ‚ACÁB3ÁCÁ1B;Á9B5Á:"B;ÂB7ÂB;Â!CÂ,B9Â-CÂ5B;Â7B;Â9CÂ;CÃCÃCÃ	Cz5.0.0zUse aclose() insteadÚclose)r   r~   Únamec              ƒ   ó@   K  — | j                  «       ƒ d{  –—†  y7 Œ­w)z.alias for aclose() for backwards compatibilityN)rð   r¾   s    rl   rò   zRedisCluster.close   s   è ø€ ð �k‰k‹m×Òúó   ‚–—c              ƒ   óÂ   K  — | j                  «       ƒ d{  –—†  	 | j                  «       ƒ d{  –—† S 7 Œ7 Œ# t        $ r | j                  «       ƒ d{  –—†7   ‚ w xY w­w)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    rl   Ú
__aenter__zRedisCluster.__aenter__  s]   è ø€ ð ×#Ñ#Ó%×%Ð%ð	àŸ™Ó*×*Ð*ð 	&øð +ùÜò 	à×'Ñ'Ó)×)Ñ)Øð	üs:   ‚A–4—Aœ8 ¯6°8 ³A¶8 ¸AÁAÁAÁAc              ƒ   óÊ   K  — | j                   4 ƒd{  –—†  | xj                  dz  c_        | j                  cddd«      ƒd{  –—†  S 7 Œ67 Œ# 1 ƒd{  –—†7  sw Y   yxY w­w)z�
        Helper coroutine to increment the usage counter while holding the lock.
        Returns the new value of the usage counter.
        Nr¯   ©rè   ræ   r¾   s    rl   r÷   zRedisCluster._increment_usage  óG   è ø€ ð
 ×#×#Ó#Ø×Ò 1Ñ$ÕØ×&Ñ&÷ $×#Ò#øÐ#ø×#×#Ñ#üóC   ‚A#“A
”A#—!A¸A#ÁAÁA#ÁA#ÁA ÁAÁA ÁA#c              ƒ   óÊ   K  — | j                   4 ƒd{  –—†  | xj                  dz  c_        | j                  cddd«      ƒd{  –—†  S 7 Œ67 Œ# 1 ƒd{  –—†7  sw Y   yxY w­w)z�
        Helper coroutine to decrement the usage counter while holding the lock.
        Returns the new value of the usage counter.
        Nr¯   rü   r¾   s    rl   rù   zRedisCluster._decrement_usage  rý   rþ   c              ƒ   óÌ   K  — t        j                  | j                  «       «      ƒ d{  –—† }|dk(  r,t        j                  | j                  «       «      ƒ d{  –—†  yy7 Œ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ù   rð   )rº   Úexc_typeÚ	exc_valueÚ	tracebackÚcurrent_usages        rl   Ú	__aexit__zRedisCluster.__aexit__&  sS   è ø€ ô
 &Ÿn™n¨T×-BÑ-BÓ-DÓE×EˆØ˜AÒä—.‘. §¡£Ó/×/Ñ/ð ð Føð 0ús!   ‚'A$©A ª/A$ÁA"ÁA$Á"A$c                 ó>   — | j                  «       j                  «       S r·   ©rí   Ú	__await__r¾   s    rl   r	  zRedisCluster.__await__0  ó   € Ø�‰Ó ×*Ñ*Ó,Ð,rn   zUnclosed RedisCluster clientÚ_warnÚ_grlc                 óÞ   — t        | d«      rR| j                  sE || j                  › d| ›�t        | ¬«       	 | | j                  dœ} |«       j	                  |«       y y y # t
        $ r Y y w xY w)Nro   Ú ©Úsource©ÚclientÚmessage)Úhasattrro   Ú_DEL_MESSAGEÚResourceWarningÚcall_exception_handlerÚRuntimeError)rº   r  r  Úcontexts       rl   Ú__del__zRedisCluster.__del__5  sv   € ô
 �4˜Ô'°×0@Ò0@Ù�T×&Ñ&Ð' q¨¨Ð1´?È4ÕPðØ%)°d×6GÑ6GÑH�Ù“×-Ñ-¨gÕ6ð	 1AÐ'øô
  ò Ùðús   ¸%A  Á 	A,Á+A,Ú
connectionc              ƒ   óØ   K  — |j                  «       ƒ d {  –—†  |j                  d«      ƒ d {  –—†  t        |j                  «       ƒ d {  –—† «      dk7  rt	        d«      ‚y 7 ŒM7 Œ67 Œ­w)NÚREADONLYÚOKzREADONLY command failed)rÉ   Úsend_commandrY   Úread_responserC   ©rº   r  s     rl   rÉ   zRedisCluster.on_connectB  sh   è ø€ Ø×#Ñ#Ó%×%Ð%ð ×%Ñ% jÓ1×1Ð1Ü˜j×6Ñ6Ó8×8Ó9¸TÒAÜ!Ð";Ó<Ð<ð Bð 	&øð 	2øØ8ús1   ‚A*–A$—A*¯A&°A*ÁA(ÁA*Á&A*Á(A*c                 ó\   — t        | j                  j                  j                  «       «      S )zGet all nodes of the cluster.)rÅ   rw   Únodes_cacherÆ   r¾   s    rl   rÜ   zRedisCluster.get_nodesN  s"   € ä�D×&Ñ&×2Ñ2×9Ñ9Ó;Ó<Ð<rn   c                 ó@   — | j                   j                  t        «      S )z%Get the primary nodes of the cluster.)rw   Úget_nodes_by_server_typer-   r¾   s    rl   rÛ   zRedisCluster.get_primariesR  ó   € à×!Ñ!×:Ñ:¼7ÓCÐCrn   c                 ó@   — | j                   j                  t        «      S )z%Get the replica nodes of the cluster.)rw   r%  r.   r¾   s    rl   rÝ   zRedisCluster.get_replicasV  r&  rn   c                 ó‚   — t        j                  t        | j                  j                  j                  «       «      «      S )z!Get a random node of the cluster.)ÚrandomÚchoicerÅ   rw   r#  rÆ   r¾   s    rl   Úget_random_nodezRedisCluster.get_random_nodeZ  s+   € ä�}‰}œT $×"4Ñ"4×"@Ñ"@×"GÑ"GÓ"IÓJÓKÐKrn   c                 ó.   — | j                   j                  S )z#Get the default node of the client.)rw   rî   r¾   s    rl   r½   zRedisCluster.get_default_node^  s   € à×!Ñ!×.Ñ.Ð.rn   c                 óx   — |r| j                  |j                  ¬«      st        d«      ‚|| j                  _        y)z†
        Set the default node of the client.

        :raises DataError: if None is passed or node does not exist in cluster.
        ©Ú	node_namez1The requested node does not exist in the cluster.N)Úget_noderó   rE   rw   rî   )rº   rê   s     rl   Úset_default_nodezRedisCluster.set_default_nodeb  s2   € ñ ˜4Ÿ=™=°4·9±9˜=Ô=ÜÐOÓPÐPà*.ˆ×ÑÕ'rn   r/  c                 ó<   — | j                   j                  |||«      S )z&Get node by (host, port) or node_name.)rw   r0  ©rº   r‡   rˆ   r/  s       rl   r0  zRedisCluster.get_nodem  s   € ð ×!Ñ!×*Ñ*¨4°°yÓAÐArn   ÚkeyÚreplicac                 óü   — | j                  |«      }| j                  j                  j                  |«      }|st	        d|› d�«      ‚|r-t        | j                  j                  |   «      dk  ryd}||   S d}||   S )aG  
        Get the cluster node corresponding to the provided key.

        :param key:
        :param replica:
            | Indicates if a replica should be returned
            |
              None will returned if no replica holds this key

        :raises SlotNotCoveredError: if the key is not covered by any slot.
        úSlot "z " is not covered by the cluster.r†   Nr¯   r   )Úkeyslotrw   Úslots_cacherË   rM   Úlen)rº   r4  r5  ÚslotÚ
slot_cacheÚnode_idxs         rl   Úget_node_from_keyzRedisCluster.get_node_from_keyv  sŽ   € ð �|‰|˜CÓ ˆØ×'Ñ'×3Ñ3×7Ñ7¸Ó=ˆ
ÙÜ%¨¨t¨fÐ4TÐ&UÓVÐVáÜ�4×%Ñ%×1Ñ1°$Ñ7Ó8¸1Ò<ØØˆHð ˜(Ñ#Ð#ð ˆHà˜(Ñ#Ð#rn   c                 ój   — | j                   r|t        v r| j                  «       S | j                  «       S )zO
        Returns random primary or all nodes depends on READONLY mode.
        )rx   r6   r+  Úget_random_primary_node)rº   r¹   s     rl   r¸   z,RedisCluster.get_random_primary_or_all_nodes’  s2   € ð ×"Ò" |´}Ñ'DØ×'Ñ'Ó)Ð)à×+Ñ+Ó-Ð-rn   c                 óH   — t        j                  | j                  «       «      S )z/
        Returns a random primary node
        )r)  r*  rÛ   r¾   s    rl   r@  z$RedisCluster.get_random_primary_node›  s   € ô �}‰}˜T×/Ñ/Ó1Ó2Ð2rn   Úcommandc              ‡   óÖ   K  — | j                   j                   | j                  |g|¢­Ž ƒ d{  –—† | j                  xr |t        v |t        v r| j
                  «      gS d«      gS 7 Œ8­w)zN
        Returns a list of nodes that hold the specified keys' slots.
        N)rw   Úget_node_from_slotÚ_determine_slotrx   r6   r‹   )rº   rB  Úargss      rl   rÚ   z RedisCluster.get_nodes_from_slot¡  sz   è ø€ ð ×Ñ×1Ñ1Ø*�d×*Ñ*¨7Ð:°TÒ:×:Ø×'Ñ'ÒD¨G´}Ð,DØ07¼=Ñ0H�×,Ñ,óð
ð 	
ð OSóð
ð 	
à:ús   ‚,A)®A'¯9A)c                 óH   — | j                   st        d«      ‚| j                   S )zM
        Returns a list of nodes for commands with a special policy.
        z6Cannot execute FT.CURSOR commands without FT.AGGREGATE)râ   rJ   r¾   s    rl   rß   zRedisCluster.get_special_nodes®  s+   € ð ×$Ò$Ü'ØHóð ð ×$Ñ$Ð$rn   c                 óJ   — t        | j                  j                  |«      «      S )zƒ
        Find the keyslot for a given key.

        See: https://redis.io/docs/manual/scaling/#redis-cluster-data-sharding
        )r;   ru   Úencode)rº   r4  s     rl   r8  zRedisCluster.keyslot¹  s   € ô ˜Ÿ™×+Ñ+¨CÓ0Ó1Ð1rn   c                 ó   — | j                   S )z%Get the encoder object of the client.)ru   r¾   s    rl   Úget_encoderzRedisCluster.get_encoderÁ  s   € à�|‰|Ðrn   c                 ó   — | j                   S )zGGet the kwargs passed to :class:`~redis.asyncio.connection.Connection`.)rt   r¾   s    rl   Úget_connection_kwargsz"RedisCluster.get_connection_kwargsÅ  s   € à×%Ñ%Ð%rn   c                 ó   — || _         y r·   )rq   )rº   rq   s     rl   Ú	set_retryzRedisCluster.set_retryÉ  s	   € Øˆ�
rn   Úcallbackc                 ó"   — || j                   |<   y)zSet a custom response callback.N)r{   ©rº   rB  rP  s      rl   Úset_response_callbackz"RedisCluster.set_response_callbackÌ  s   € à+3ˆ×Ñ Ò(rn   )Ú	node_flagrF  Úrequest_policyrT  c             ‡   óh  K  — |s| j                   j                  |«      }|| j                  v r| j                  |   }| j                  |   }|t        j
                  k(  r ||g|¢­Ž ƒ d {  –—† }n#|t        j                  k(  r	 ||«      }n |«       }|j                  «       dk(  r|| _        |S 7 ŒD­w)Nzft.aggregate)	rr   rË   rÙ   rà   r   rØ   rÑ   Úlowerrâ   )rº   rB  rU  rT  rF  Úpolicy_callbackÚnodess          rl   Ú_determine_nodeszRedisCluster._determine_nodesÐ  s¯   è ø€ ñ à×*Ñ*×.Ñ.¨wÓ7ˆIà˜×3Ñ3Ñ3Ø!×8Ñ8¸ÑCˆNà×9Ñ9¸.ÑIˆàœ]×8Ñ8Ò8Ù)¨'Ð9°DÒ9×9‰EØœ}×<Ñ<Ò<Ù# GÓ,‰Eá#Ó%ˆEà�=‰=‹?˜nÒ,Ø$)ˆDÔ!àˆð :ús   ‚A)B2Á+B0Á,AB2c              ‡   óÖ  K  — | j                   j                  |«      t        k(  rt        |d   «      S |j	                  «       dv rPt        |«      dk  rt        d|g|¢­› �«      ‚|ddt        |d   «      z    }|s{t        j                  dt        «      S  | j                  j                  |g|¢­Ž ƒ d {  –—† }|s:|j	                  «       dv rt        j                  dt        «      S t        d|› �«      ‚t        |«      dk(  r| j                  |d   «      S |D �ch c]  }| j                  |«      ’Œ }}t        |«      dk7  rt        |› d�«      ‚|j                  «       S 7 Œ¬c c}w ­w)	Nr   )ÚEVALÚEVALSHAr†   zInvalid args in command: r¯   )ÚFCALLÚFCALL_ROz€No way to dispatch this command to Redis Cluster. Missing key.
You can execute the command by specifying target nodes.
Command: z) - all keys must map to the same key slot)rr   rË   r/   ÚintÚupperr:  rJ   r)  Ú	randranger:   rs   Úget_keysr8  rj   )rº   rB  rF  Úkeysr4  Úslotss         rl   rE  zRedisCluster._determine_slotî  sz  è ø€ Ø×Ñ×!Ñ! 'Ó*¬gÒ5ä�t˜A‘w“<Ðð �=‰=‹?Ð1Ñ1ä�4‹y˜1Š}Ü+Ø/°°¸$±Ð/?Ð@óð ð ˜˜A¤ D¨¡G£Ñ,Ð-ˆDñ Ü×'Ñ'¨Ô+CÓDÐDà6˜×-Ñ-×6Ñ6°wÐFÀÒF×FˆDÙð —=‘=“?Ð&;Ñ;Ü!×+Ñ+¨AÔ/GÓHÐHÜ+ð/à/3¨fð6óð ô ˆt‹9˜Š>Ø—<‘<  Q¡Ó(Ð(ñ /3Ó3©d s�—‘˜cÕ"¨dˆÐ3Üˆu‹:˜Š?Ü'Ø�)ÐDÐEóð ð �y‰y‹{Ðð1 Gúò$ 4ùs%   ‚B3E)Â5E"Â6A&E)ÄE$Ä4/E)Å$E)Útarget_nodesc                 óB   — t        |t        «      xr || j                  v S r·   )Ú
isinstanceÚstrrv   )rº   rf  s     rl   Ú_is_node_flagzRedisCluster._is_node_flag!  s   € Ü˜,¬Ó,ÒP°ÀÇÁÐ1PÐPrn   c                 óØ   — t        |t        «      r|}|S t        |t        «      r|g}|S t        |t        «      rt        |j	                  «       «      }|S t        dt        |«      › �«      ‚)Nz°target_nodes type can be one of the following: node_flag (PRIMARIES, REPLICAS, RANDOM, ALL_NODES),ClusterNode, list<ClusterNode>, or dict<any, ClusterNode>. The passed type is )rh  rÅ   r_   ÚdictrÆ   Ú	TypeErrorÚtype)rº   rf  rY  s      rl   Ú_parse_target_nodesz RedisCluster._parse_target_nodes$  s€   € Ü�l¤DÔ)Ø ˆEð  ˆô ˜¤kÔ2à!�NˆEð ˆô ˜¤dÔ+ô ˜×,Ñ,Ó.Ó/ˆEð ˆô ð&ô '+¨<Ó&8Ð%9ð;óð rn   ÚerrorÚis_internalÚretry_attemptsc           	   ƒ   óœ   K  — t        |j                  |j                  |j                  |j                  ||�|nd|¬«      ƒ d{  –—†  y7 Œ­w)zq
        Records error count metric directly.
        Accepts either a Connection or ClusterNode object.
        Nr   ©Úserver_addressÚserver_portÚnetwork_peer_addressÚnetwork_peer_portÚ
error_typerr  rq  )r#   r‡   rˆ   )rº   rp  r  rq  rr  s        rl   Ú_record_error_metricz!RedisCluster._record_error_metric8  sF   è ø€ ô !Ø%Ÿ?™?Ø"Ÿ™Ø!+§¡Ø(Ÿo™oØØ-;Ð-G™>ÈQØ#ô
÷ 	
ò 	
ús   ‚AAÁA
ÁAr¹   Úduration_secondsc           	   ƒ   óî   K  — t        |d«      r|j                  }n|j                  j                  dd«      }t	        |||j
                  |j                  |�t        |«      nd|¬«      ƒ d{  –—†  y7 Œ­w)zx
        Records operation duration metric directly.
        Accepts either a Connection or ClusterNode object.
        r�   r   N©r¹   r{  ru  rv  Údb_namespacerp  )r  r�   rt   rË   r$   r‡   rˆ   ri  )rº   r¹   r{  r  rp  r�   s         rl   Ú_record_command_metricz#RedisCluster._record_command_metricM  si   è ø€ ô �:˜tÔ$Ø—‘‰Bà×-Ñ-×1Ñ1°$¸Ó:ˆBÜ'Ø%Ø-Ø%Ÿ?™?Ø"Ÿ™Ø$& Nœ˜Rœ¸Øô
÷ 	
ò 	
ús   ‚A+A5Á-A3Á.A5c           
   �   ó˜  ‡ ‡‡K  — ‰d   }g }d}‰ j                   j                  «       }‰j                  dd«      }|r&‰ j                  |«      s‰ j	                  |«      }d}d}‰ j
                  j                  ‰d   j                  «       «      ƒ d{  –—† }|s³|s±‰ j                  j                  |«      }	|	sa‰ j                  «       sd}
n ‰ j                  ‰Ž ƒ d{  –—† }
|
€t        «       }nkt        t        j                  t        j                  ¬«      }nA|	‰ j                   v rt        ‰ j                   |	   ¬«      }nt        «       }n|s|r
t        «       }d|z   }d}t#        j$                  «       }t'        |«      D �]Â  }‰ j(                  rL‰ j+                  «       ƒ d{  –—†  t-        |«      dk(  r&|d   ‰ j                  «       k(  r‰ j/                  «        	 |s6 ‰ j0                  ‰|j2                  |d	œŽƒ d{  –—† }|st5        d
‰› d�«      ‚t-        |«      dk(  rv ‰ j6                  |d   g‰¢­i ‰¤Žƒ d{  –—† }|‰ j8                  v r& ‰ j8                  |   ||d   j:                  |ifi ‰¤Ž} ‰ j<                  |j>                     |«      c S |D �cg c]  }|j:                  ‘Œ }}tA        jB                  ˆˆˆ fd„|D «       Ž ƒ d{  –—† }|‰ j8                  v r, ‰ j8                  |   |tE        tG        ||«      «      fi ‰¤Žc S  ‰ j<                  |j>                     tE        tG        ||«      «      «      c S  y7 �Œµ7 �Œm7 �Œª7 �ŒQ7 �Œc c}w 7 Œˆ# tH        $ rá}|dkD  r¡tK        |«      ‰ jL                  jN                  v r€|dz  }|dz  }tQ        |d«      rd‰ jS                  |t#        j$                  «       |z
  |jT                  |¬«      ƒ d{  –—†7   ‰ jW                  ||jT                  |¬«      ƒ d{  –—†7   Y d}~�ŒŒtQ        |d«      r(‰ jW                  ||jT                  |d¬«      ƒ d{  –—†7   |‚d}~ww xY w­w)a�  
        Execute a raw command on the appropriate cluster node or target_nodes.

        It will retry the command as specified by the retries property of
        the :attr:`retry` & then raise an exception.

        :param args:
            | Raw command args
        :param kwargs:

            - target_nodes: :attr:`NODE_FLAGS` or :class:`~.ClusterNode`
              or List[:class:`~.ClusterNode`] or Dict[Any, :class:`~.ClusterNode`]
            - Rest of the kwargs are passed to the Redis connection

        :raises RedisClusterException: if target_nodes is not provided & the command
            can't be mapped to a slot
        r   Frf  NT©rU  Úresponse_policy©rU  r¯   ©rU  rT  ú!No targets were found to execute ú command onc              3   óp   •K  — | ]-  }t        j                   ‰j                  |g‰¢­i ‰¤Ž«      –— Œ/ y ­wr·   )rç   Úcreate_taskÚ_execute_command)Ú.0rê   rF  rc   rº   s     €€€rl   Ú	<genexpr>z/RedisCluster.execute_command.<locals>.<genexpr>È  sB   øè ø€ ð ñ )5 ô $×/Ñ/Ø 5 × 5Ñ 5°dÐ L¸TÒ LÀVÑ L÷ñ )5ùs   ƒ36r  ©r¹   r{  r  rp  )rp  r  rr  )rp  r  rr  rq  ),rq   Úget_retriesrj   rj  ro  rá   ÚresolverW  rr   rË   r½   rE  r   r   rØ   r   rÙ   ÚtimeÚ	monotonicÚrangero   rí   r:  Úreplace_default_noderZ  rU  rJ   r‰  r|   ró   rà   r‚  rç   Úgatherrl  Úziprø   rn  rÏ   ÚERRORS_ALLOW_RETRYr  r  r  rz  )rº   rF  rc   rB  rf  Útarget_nodes_specifiedrr  Úpassed_targetsÚcommand_policiesÚcommand_flagr;  Úexecute_attemptsÚfailure_countÚ
start_timeÚ_Úretrê   rd  rÆ   Úes   ```                 rl   Úexecute_commandzRedisCluster.execute_commandf  sz  úè ø€ ð$ �q‘'ˆØˆØ!&ÐØŸ™×/Ñ/Ó1ˆàŸ™ N°DÓ9ˆÙ $×"4Ñ"4°^Ô"DØ×3Ñ3°NÓCˆLØ%)Ð"ØˆNà!%×!6Ñ!6×!>Ñ!>¸tÀA¹w¿}¹}»Ó!O×OÐáÑ(>Ø×-Ñ-×1Ñ1°'Ó:ˆLÙà×,Ñ,Ô.Ø‘Dà!5 ×!5Ñ!5°tÐ!<×<�DØ�<Ü'6Ó'8Ñ$ä'6Ü'4×'BÑ'BÜ(6×(DÑ(Dô(Ñ$ð
   4×#>Ñ#>Ñ>Ü'6Ø'+×'BÑ'BÀ<Ñ'Pô(Ñ$ô (7Ó'8Ñ$Ù!Ñ&<Ü.Ó0Ðð ˜~Ñ-ÐØˆô —^‘^Ó%ˆ
äÐ'×(ˆAØ×ÒØ—o‘oÓ'×'Ð'ä˜Ó%¨Ò*Ø$ Q™¨4×+@Ñ+@Ó+BÒBð ×-Ñ-Ô/ðEÙ-à)>¨×)>Ñ)>ØØ'7×'FÑ'FØ"0ò*÷ $�Lñ
 (Ü3Ø?À¸vÀ[ÐQóð ô �|Ó$¨Ò)à 5 × 5Ñ 5°lÀ1±oÐ WÈÒ WÐPVÑ W×W�CØ $×"7Ñ"7Ñ7Ø<˜d×3Ñ3°GÑ<Ø# l°1¡o×&:Ñ&:¸CÐ%@ñØDJñ˜ð˜4×:Ñ:Ø(×8Ñ8ñàóò ñ 3?Ó?±,¨$˜DŸI›I°,�DÐ?Ü#*§>¡>õñ )5ó	ð$÷ �Fð  $×"7Ñ"7Ñ7Ø=˜t×4Ñ4°WÑ=Ø#¤T¬#¨d°FÓ*;Ó%<ñ Ø@Fñ ò ð˜4×:Ñ:Ø(×8Ñ8ñäœ3˜t VÓ,Ó-ó/ò /ñ] )ðE Pùð =ùð6 (ùð$ùð Xûò @ðùô ò Ø! AÒ%¬$¨q«'°T·^±^×5VÑ5VÑ*Vð # aÑ'�NØ! QÑ&�Mä˜q ,Ô/Ø"×9Ñ9Ø)0Ü-1¯^©^Ó-=À
Ñ-JØ'(§|¡|Ø"#ð	 :ó ÷ ñ ð #×7Ñ7Ø"#Ø'(§|¡|Ø+8ð 8ó ÷ ñ õ
 ô ˜q ,Ô/Ø"×7Ñ7Ø"#Ø'(§|¡|Ø+8Ø(-ð	 8ó ÷ ñ ð �Gûð;üsè   …BQ
ÂMÂA
Q
ÃM
ÃCQ
Æ#MÆ$8Q
Ç"MÇ?MÈ ?MÈ?MÉ AMÊQ
ÊMÊMÊ0"MËMË;MÌQ
Ì1MÍQ
Í
Q
ÍQ
ÍMÍMÍMÍ	QÍ&A3QÏOÏ&QÐ PÐQÐQ
Ð.QÐ:P=Ð;QÑQÑQ
Útarget_nodec              �   ó`  K  — dx}}d }| j                   }|d   }t        j                  «       }	|dkD  ré|dz  }	 |r.| j                  |¬«      }|j	                  d«      ƒ d {  –—†  d}nf|rd | j
                  |Ž ƒ d {  –—† }
| j                  j                  |
| j                  xr |d   t        v |d   t        v r| j                  nd «      }d} |j                  |i |¤Žƒ d {  –—† }| j                  |t        j                  «       |	z
  |¬«      ƒ d {  –—†  |S tO        d«      }||_        | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†  |‚7 �Œ7 Œç7 Œ‚7 ŒS# t        $ r@}||_        | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   ‚ d }~wt        $ r@}||_        | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   ‚ d }~wt        t         f$ r•}|j#                  «        |j%                  «       ƒ d {  –—†7   | j                  j'                  |j(                  «       d| _        ||_        | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   ‚ d }~wt,        t.        f$ rw}| j1                  «       ƒ d {  –—†7   t3        j4                  d	«      ƒ d {  –—†7   ||_        | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   ‚ d }~wt6        $ rÕ}| xj8                  dz  c_        | j:                  r=| j8                  | j:                  z  dk(  r!| j1                  «       ƒ d {  –—†7   d| _        n| j                  j=                  |«       d}| j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   | j?                  ||¬
«      ƒ d {  –—†7   Y d }~�nªd }~wt@        $ r}}tC        |jD                  |jF                  ¬«      }d}| j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   | j?                  ||¬
«      ƒ d {  –—†7   Y d }~�n&d }~wtH        $ r‰}|| j                   dz  k  rt3        j4                  d«      ƒ d {  –—†7   | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   | j?                  ||¬
«      ƒ d {  –—†7   Y d }~n–d }~wtJ        $ r@}||_        | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   ‚ d }~wtL        $ r@}||_        | j                  |t        j                  «       |	z
  ||¬«      ƒ d {  –—†7   ‚ d }~ww xY w|dkD  r�Œv�Œ�7 �ŒP­w)NFr   r¯   r.  ÚASKING)r¹   r{  r  rŒ  Tç      Ð?)rp  r  ©r‡   rˆ   r†   gš™™™™™©?zTTL exhausted.)(ÚRedisClusterRequestTTLr�  r�  r0  r   rE  rw   rD  rx   r6   r‹   r  r@   r  rH   rC   rN   Ú'update_active_connections_for_reconnectÚdisconnect_free_connectionsÚ move_node_to_end_of_cached_nodesró   ro   rA   rM   rð   rç   ÚsleeprI   ry   rz   Ú	move_slotrz  r?   r4   r‡   rˆ   rO   rL   rø   rB   )rº   r¡  rF  rc   ÚaskingÚmovedÚredirect_addrÚttlrB  rœ  r;  ÚresponserŸ  s                rl   r‰  zRedisCluster._execute_commandõ  sÀ  è ø€ ð Ðˆ�ØˆØ×)Ñ)ˆØ�q‘'ˆÜ—^‘^Ó%ˆ
à�AŠgØ�1‰HˆCðcÙØ"&§-¡-¸- -Ó"H�KØ%×5Ñ5°hÓ?×?Ð?Ø"‘FÙð "6 ×!5Ñ!5°tÐ!<×<�DØ"&×"4Ñ"4×"GÑ"GØØ×/Ñ/ÒL°D¸±G¼}Ð4Là ™7¤mÑ3ð ×4Ò4à!ó#�Kð "�Eà!< ×!<Ñ!<¸dÐ!MÀfÑ!M×M�Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*ð 2ó ÷ ð ð
  �ôZ Ð)Ó*ˆØ"ˆŒØ×)Ñ)Ø Ü!Ÿ^™^Ó-°
Ñ:Ø"Øð	 *ó 
÷ 	
ð 	
ð ˆðU @ùð
 =øð Nøðùô $ò Ø*�”Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ûÜ&ò ð
  +�”Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ûÜ#¤\Ð2ò ð
 ×CÑCÔEØ!×=Ñ=Ó?×?Ñ?ð ×"Ñ"×CÑCÀK×DTÑDTÔUð $(�Ô Ø*�”Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ûÜ$Ô&9Ð:ò ð —k‘k“m×#Ñ#Ü—m‘m DÓ)×)Ñ)Ø*�”Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ûÜò ð ×)Ò)¨QÑ.Õ)à×+Ò+Ø×1Ñ1°D×4KÑ4KÑKÈqÒPàŸ+™+›-×'Ñ'à01�DÕ-à×&Ñ&×0Ñ0°Ô3Ø�Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ×/Ñ/ØØ*ð 0ó ÷ ÷ ûô ò Ü -°1·6±6ÀÇÁÔ G�Ø�Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ×/Ñ/ØØ*ð 0ó ÷ ÷ ûô !ò Ø˜×4Ñ4°qÑ8Ò8Ü!Ÿ-™-¨Ó-×-Ñ-Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ×/Ñ/ØØ*ð 0ó ÷ ö ûô !ò Ø*�”Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ûÜò Ø*�”Ø×1Ñ1Ø!(Ü%)§^¡^Ó%5¸
Ñ%BØ*Øð	 2ó ÷ ñ ð ûðúð{ �AŒgùðR	
ûsÆ  ‚6V.¹(E+ Á!E"Á"E+ Á=E%Á>A&E+ Ã$E'Ã%0E+ ÄE)ÄE+ ÄA V.ÅV+ÅV.Å"E+ Å%E+ Å'E+ Å)E+ Å+	VÅ44F/Æ(F+Æ)F/Æ/VÆ;4G6Ç/G2Ç0G6Ç6VÈ#JÈ+H.È,A%JÊJÊJÊVÊ*LÊ=K Ê>LËKË9LÌLÌLÌVÌ(AO8Í8M;Í9AO8ÏOÏO8Ï,O/Ï-O8Ï2V.Ï8VÐAQ<ÑQÑQ<Ñ0Q3Ñ1Q<Ñ6V.Ñ<VÒ*TÒ2R5Ò32TÓ%S(Ó&TÔTÔTÔV.ÔVÔ4UÕUÕUÕVÕ4VÖVÖVÖVÖV.Ö+V.ÚtransactionÚ
shard_hintÚClusterPipelinec                 ó4   — |rt        d«      ‚t        | |«      S )zù
        Create & return a new :class:`~.ClusterPipeline` object.

        Cluster implementation of pipeline does not support transaction or shard_hint.

        :raises RedisClusterException: if transaction or shard_hint are truthy values
        z(shard_hint is deprecated in cluster mode)rJ   r³  )rº   r±  r²  s      rl   ÚpipelinezRedisCluster.pipeline¯  s    € ñ Ü'Ð(RÓSÐSä˜t [Ó1Ð1rn   ró   Ú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!   )	rº   ró   r¶  rª  r·  r¸  r¹  rº  r»  s	            rl   ÚlockzRedisCluster.lock¾  s5   € ðH ÐÜˆJÙØØØØØØ-Ø%Ø#9ô	
ð 		
rn   Úfuncc              �   óö  K  — |j                  dd«      }|j                  dd«      }|j                  dd«      }| j                  d|«      4 ƒd{  –—† }	 	 |r |j                  |Ž ƒ d{  –—†   ||«      ƒ d{  –—† }|j                  «       ƒ d{  –—† }	|r|n|		 cddd«      ƒd{  –—†  S 7 Œ_7 ŒF7 Œ87 Œ"7 Œ# t        $ r |�|dkD  rt        j                  |«       Y ŒŒw xY w# 1 ƒd{  –—†7  sw Y   yxY w­w)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.
        r²  NÚvalue_from_callableFÚwatch_delayTr   )rj   rµ  ÚwatchÚexecuterP   r�  rª  )
rº   r¾  Úwatchesrc   r²  rÀ  rÁ  ÚpipeÚ
func_valueÚ
exec_values
             rl   r±  zRedisCluster.transaction  sæ   è ø€ ð —Z‘Z ¨dÓ3ˆ
Ø$Ÿj™jÐ)>ÀÓFÐØ—j‘j °Ó5ˆØ—=‘=  z×2Ô2°dØð	ÙØ(˜dŸj™j¨'Ð2×2Ð2Ù'+¨D£z×!1�JØ'+§|¡|£~×!5�JÙ)<™:À*ÐL÷ 3×2Ò2øð 3øØ!1øØ!5øð 3ùô "ò Ø"Ð.°;À²?ÜŸ
™
 ;Ô/Ùðú÷ 3×2Ñ2üsœ   ‚AC9ÁB/ÁC9ÁC$ÁB9Á*B1Á+B9Á:B3Á;B9ÂB5Â	B9ÂC9Â)B7Â*C9Â1B9Â3B9Â5B9Â7C9Â9%C!ÃC$Ã C!Ã!C$Ã$C6Ã*C-Ã+C6Ã2C9)rd   ra   ©rd   N)rd   r_   )rê   r_   rd   N©NNN©F)TNr·   )NN)Ngš™™™™™¹?TNNTT)XÚ__name__Ú
__module__Ú__qualname__Ú__doc__Úclassmethodri  r   rm   Ú	__slots__rU   rW   r9   r   r   r`  r   Úboolr2   r   rø   r<   Úfloatr   Úbytesr]   r\   r[   r   r   r>   r8   rë   rí   rð   rV   rò   rú   r÷   rù   r  r   r	  r  ÚwarningsÚwarnrç   Úget_running_loopr  r   rÉ   rÜ   rÛ   rÝ   r+  r½   r1  r0  r>  r¸   r@  rÚ   rÅ   rß   rR   r8  r   rK  r   rM  r%   rO  r   rS  r   rZ  rE  rj  ro  rz  r  r   rS   r‰  rµ  r"   r½  r	   r±  rh   rn   rl   ra   ra   j   s  „ ñcðJ ð˜3ð ¨#ð °.ò ó ðð@€Iñ" Ø*Ð+ØGØôñ
 à*ð
ð =Øôð #Ø $à7;Ø&*Ø#(ØCGØ&*Ø"#Ø,-Ø$Ø#'Ø:>àØ"Ø<@Ø"&Ø"&Ø%)Ø",Ù%4Ó%6àØ'Ø!&à'(Ø26Ø!&ØNRØ*.àØ&*Ø%)Ø0:Ø@DØ@DØ&*Ø#'Ø%)Ø04Ø%)Ø"#ØPTØ6:Ù/HÓ/JñcR*à�s‰mðR*ð �C˜�H‰oðR*ð
    ]Ñ 3Ñ4ðR*ð  $ðR*ð !ðR*ð "*Ð*?Ñ!@ðR*ð  $ðR*ð  ðR*ð '*ðR*ð ðR*ð ˜Ñ ðR*ð !  d¨9¡oÑ!6Ñ7ðR*ð  �#�s�(‰Oð!R*ð" �s‰mð#R*ð$ &Ð&8Ñ9ð%R*ð& ˜3‘-ð'R*ð( ˜3‘-ð)R*ð* ˜c‘]ð+R*ð, ˜3‘-ð-R*ð. ˜c‘]ð/R*ð2 ð3R*ð4 ð5R*ð6 ð7R*ð:  %ð;R*ð< !)¨¡ð=R*ð> ð?R*ð@ #+¨7°3¸¸cÀ5¸jÑ8IÐ3IÑ+JÑ"KðAR*ðB ! ™ðCR*ðF ðGR*ðH ˜s‘mðIR*ðJ ˜c‘]ðKR*ðL ˜S *˜_Ñ-ðMR*ðN #+¨4°Ñ+<Ñ"=ðOR*ðP #+¨4°Ñ+<Ñ"=ðQR*ðR ˜s‘mðSR*ðT !ðUR*ðV ˜c‘]ðWR*ðX " *Ñ-ðYR*ðZ ˜c‘]ð[R*ð\ ˜3‘-ð]R*ð^   ¨%°°S°©/Ð):¸EÀ#ÀsÀ(¹OÐ)KÑ LÑMð_R*ð` # ?Ñ3ðaR*ðb -ðcR*ðd 
òeR*óóðR*óhó&	Eñ  Ð1GÈgÔVòó Wðóð'¨ó 'ð'¨ó 'ò0ð-˜9 S¨$°Ð%>Ñ?ó -ð 2€Lð —]‘]Ø×,Ñ,ñàðð ðð 
ó	ð
=¨:ð 
=¸$ó 
=ð=˜4 Ñ.ó =ðD˜t MÑ2ó DðD˜d =Ñ1ó DóLó/ó	/ð #Ø"Ø#'ñ	Bà�s‰mðBð �s‰mðBð ˜C‘=ð	Bð
 
�-Ñ	 óBð ).ñ$Øð$Ø!%ð$à	�-Ñ	 ó$ò8.ó3ð
°ó 
ð	% 8¨D°Ñ,?Ñ#@ó 	%ð2˜:ð 2¨#ó 2ð˜Wó ð& t¨C°¸#±Ð,>Ñ'?ó &ð˜uð ¨ó ð4¨Sð 4Ð<Mð 4ÐRVó 4ð $(òàðð ðð &ð	ð
 ˜C‘=ðð 
ˆmÑ	óð<1¨Sð 1¸ð 1Àó 1ðfQ¨#ð Q°$ó Qð°ð ¸¸]Ñ8Kó ð0 !Ø(,ñ
àð
ð ˜* mÐ3Ñ4ð
ð ð	
ð
 ! ™ó
ð4 &*ñ
àð
ð  ð
ð ˜* mÐ3Ñ4ð	
ð
 ˜	Ñ"ó
ð2M¨:ð MÀð MÈó Mð^xØ(ðxØ16°t¸ZÐ7GÑ1HðxØTWðxà	óxðv NRñ2Ø# C™=ð2Ø=EÀc¹]ð2à	ó2ð$ $(ØØØ,0Ø+/Ø!Ø'+ñO
àðO
ð ˜%‘ðO
ð ð	O
ð
 ðO
ð # 5™/ðO
ð ˜T $™ZÑ(ðO
ð ðO
ð !%ðO
ð 
óO
ðbØ˜dÐ$5°sÐ:Ñ;ôrn   ra   c                   óf  — e Zd ZdZdZ	 d)dedœdedeeef   de	e   d	ed
e
e   deddfd„Zdefd„Zdedefd„Zdefd„ZdZej&                  ej*                  fdededdfd„Zd*d„Zdefd„Zdeddfd„Zdeddfd„Zd*d„Zd*d„Zdedededefd„Zd ededefd!„Zd"ed#   defd$„Z d%e!fd&„Z"d'e#fd(„Z$y)+r_   zš
    Create a new ClusterNode.

    Each ClusterNode manages multiple :class:`~redis.asyncio.connection.Connection`
    objects for the (host, port).
    )Ú_connectionsÚ_freerp   rÍ   rf   rt   r‡   r�   ró   rˆ   r{   Úserver_typeNrƒ   )r�   rf   r‡   rˆ   rÚ  r�   rf   rt   rd   c                óÂ  — |dk(  rt        j                  |«      }||d<   ||d<   || _        || _        t	        ||«      | _        || _        || _        || _        || _	        |j                  di «      | _        g | _        t        j                  | j                  ¬«      | _        | j                  j!                  dd «      | _        | j"                  €t%        «       | _        y y )NÚ	localhostr‡   rˆ   r{   )Úmaxlenr«   )ÚsocketÚgethostbynamer‡   rˆ   r4   ró   rÚ  r�   rf   rt   rj   r{   rØ  ÚcollectionsÚdequerÙ  rË   rÍ   r>   )rº   r‡   rˆ   rÚ  r�   rf   rt   s          rl   rë   zClusterNode.__init__?  sÝ   € ð �;ÒÜ×'Ñ'¨Ó-ˆDà$(Ð˜&Ñ!Ø$(Ð˜&Ñ!ØˆŒ	ØˆŒ	Ü! $¨Ó-ˆŒ	Ø&ˆÔà.ˆÔØ 0ˆÔØ!2ˆÔØ"3×"7Ñ"7Ð8LÈbÓ"QˆÔà.0ˆÔÜ(3×(9Ñ(9À×AUÑAUÔ(VˆŒ
Ø!%×!7Ñ!7×!;Ñ!;Ð<NÐPTÓ!UˆÔØ×!Ñ!Ð)Ü%4Ó%6ˆDÕ"ð *rn   c           	      óp   — d| j                   › d| j                  › d| j                  › d| j                  › d�	S )Nz[host=z, port=z, name=z, server_type=Ú])r‡   rˆ   ró   rÚ  r¾   s    rl   Ú__repr__zClusterNode.__repr__^  s?   € à�T—Y‘Y�K˜w t§y¡y kð 2Ø—I‘I�;˜n¨T×-=Ñ-=Ð,>¸aðAð	
rn   Úobjc                 óX   — t        |t        «      xr |j                  | j                  k(  S r·   )rh  r_   ró   )rº   rå  s     rl   Ú__eq__zClusterNode.__eq__d  s!   € Ü˜#œ{Ó+ÒE°·±¸D¿I¹IÑ0EÐErn   c                 ó,   — t        | j                  «      S r·   )Úhashró   r¾   s    rl   Ú__hash__zClusterNode.__hash__g  s   € Ü�D—I‘I‹Ðrn   zUnclosed ClusterNode objectr  r  c                 óê   — | j                   D ]T  }|j                  sŒ || j                  › d| ›�t        | ¬«       	 | | j                  dœ} |«       j	                  |«        y  y # t
        $ r Y  y w xY w)Nr  r  r  )rØ  Úis_connectedr  r  r  r  )rº   r  r  r  r  s        rl   r  zClusterNode.__del__l  s|   € ð
 ×+Ô+ˆJØ×&Ó&Ù˜×*Ñ*Ð+¨1¨T¨HÐ5´ÈtÕTðØ)-¸$×:KÑ:KÑL�GÙ“F×1Ñ1°'Ô:ñ ñ ,øô $ò ØÙðús   ¼%A%Á%	A2Á1A2c              ƒ   óš   K  — t        j                  d„ | j                  D «       ddiŽƒ d {  –—† }t        d„ |D «       d «      }|r|‚y 7 Œ­w)Nc              3   ób   K  — | ]'  }t        j                  |j                  «       «      –— Œ) y ­wr·   ©rç   rˆ  Ú
disconnect©rŠ  r  s     rl   r‹  z)ClusterNode.disconnect.<locals>.<genexpr>~  s,   è ø€ ð á"3�Jô ×#Ñ# J×$9Ñ$9Ó$;×<Ù"3ùó   ‚-/Úreturn_exceptionsTc              3   óB   K  — | ]  }t        |t        «      sŒ|–— Œ y ­wr·   )rh  rø   )rŠ  rÁ   s     rl   r‹  z)ClusterNode.disconnect.<locals>.<genexpr>„  s   è ø€ ÐE¡3˜C¬*°S¼)Õ*D”C¡3ùs   ‚˜)rç   r“  rØ  Únext)rº   rž  Úexcs      rl   rð  zClusterNode.disconnect|  s\   è ø€ Ü—N‘Nñà"&×"3Ò"3óð
ð
 #ñ
÷ 
ˆô ÑE¡3ÓEÀtÓLˆÙØˆIð ð
ús   ‚*A¬A	­Ac                 ó€  — 	 | j                   j                  «       S # t        $ r˜ t        | j                  «      | j
                  k  rkt        t        «       dt        f¬«      }| j                  j                  «       }||d<    | j                  di |¤Ž}| j                  j                  |«       |cY S t        «       ‚w xY w)Nr   )r³   r´   Úsupported_errorsrq   rh   )rÙ  ÚpopleftÚ
IndexErrorr:  rØ  r�   r%   r(   rC   rt   r   rf   rÌ   rH   )rº   rq   rt   r  s       rl   Úacquire_connectionzClusterNode.acquire_connectionˆ  s·   € ð	(Ø—:‘:×%Ñ%Ó'Ð'øÜò 	(Ü�4×$Ñ$Ó%¨×(<Ñ(<Ò<ô Ü%›KØÜ&5Ð%7ô�ð
 %)×$:Ñ$:×$?Ñ$?Ó$AÐ!Ø-2Ð! 'Ñ*Ø2˜T×2Ñ2ÑGÐ5FÑG�
Ø×!Ñ!×(Ñ(¨Ô4Ø!Ò!ä%Ó'Ð'ð-	(ús   ‚ œBB=Â2B=r  c              ƒ   ób   K  — |j                  «       r|j                  «       ƒ d{  –—†  yy7 Œ­w)zÄ
        Disconnect a connection if it's marked for reconnect.
        This implements lazy disconnection to avoid race conditions.
        The connection will auto-reconnect on next use.
        N)Úshould_reconnectrð  r!  s     rl   Údisconnect_if_neededz ClusterNode.disconnect_if_needed£  s.   è ø€ ð ×&Ñ&Ô(Ø×'Ñ'Ó)×)Ñ)ð )Ø)ús   ‚$/¦-§/c                 ó:   — | j                   j                  |«       y)zÁ
        Release connection back to free queue.
        If the connection is marked for reconnect, it will be disconnected
        lazily when next acquired via disconnect_if_needed().
        N)rÙ  rÌ   r!  s     rl   ÚreleasezClusterNode.release¬  s   € ð 	�
‰
×Ñ˜*Õ%rn   c                 óz   — t        | j                  «      }| j                  D ]  }||vsŒ|j                  «        Œ y)zØ
        Mark all in-use (active) connections for reconnect.
        In-use connections are those in _connections but not currently in _free.
        They will be disconnected when released back to the pool.
        N)ÚsetrÙ  rØ  Úmark_for_reconnect)rº   Úfree_setr  s      rl   r§  z3ClusterNode.update_active_connections_for_reconnect´  s5   € ô �t—z‘z“?ˆØ×+Ô+ˆJØ Ò)Ø×-Ñ-Õ/ñ ,rn   c              ƒ   ó˜   K  — | j                   r8t        j                  d„ t        | j                   «      D «       ddiŽƒ d{  –—†  yy7 Œ­w)a	  
        Disconnect all free/idle connections in the pool.
        This is useful after topology changes (e.g., failover) to clear
        stale connection state like READONLY mode.
        The connections remain in the pool and will reconnect on next use.
        c              3   ó<   K  — | ]  }|j                  «       –— Œ y ­wr·   )rð  rñ  s     rl   r‹  z:ClusterNode.disconnect_free_connections.<locals>.<genexpr>É  s   è ø€ ÐNÑ<M¨j�*×'Ñ'×)Ñ<Mùs   ‚ró  TN)rÙ  rç   r“  Útupler¾   s    rl   r¨  z'ClusterNode.disconnect_free_connections¿  sH   è ø€ ð �:Š:ä—.‘.ÙN¼EÀ$Ç*Á*Ô<MÓNðà"&ñ÷ ñ ð ðús   ‚?A
ÁAÁA
rB  rc   c              ‹   ó   K  — 	 t         |v r0|j                  d¬«      ƒ d {  –—† }|j                  t         «       n|j                  «       ƒ d {  –—† }t        |v r|j                  t        «       |j                  dd «       || j
                  v r | j
                  |   |fi |¤ŽS |S 7 Œ‡7 Œ[# t        $ r t        |v r|t           cY S ‚ w xY w­w)NT)Údisable_decodingrd  )r*   r   rj   rL   r)   r{   )rº   r  rB  rc   r°  s        rl   Úparse_responsezClusterNode.parse_responseÍ  sÎ   è ø€ ð		Ü˜vÑ%Ø!+×!9Ñ!9È4Ð!9Ó!P×P�Ø—
‘
œ<Õ(à!+×!9Ñ!9Ó!;×;�ô ˜VÑ#Ø�J‰J”~Ô&ð 	�
‰
�6˜4Ô ð �d×-Ñ-Ñ-Ø3�4×*Ñ*¨7Ñ3°HÑGÀÑGÐGàˆð' Qøð <ùÜò 	Ü Ñ'ØœnÑ-Ò-Øð	üsK   ‚C„B- ¡B)¢-B- ÁB+ÁB- ÁACÂ)B- Â+B- Â-CÃCÃ	CÃCrF  c              �   óÖ  K  — | j                  «       }| j                  |«      ƒ d {  –—†  |j                   |j                  |Ž d«      ƒ d {  –—†  	  | j                  ||d   fi |¤Žƒ d {  –—† | j                  |«      ƒ d {  –—†  | j
                  j                  |«       S 7 Œ7 ŒZ7 Œ<7 Œ&# | j                  |«      ƒ d {  –—†7   | j
                  j                  |«       w xY w­w)NFr   )rû  rþ  Úsend_packed_commandÚpack_commandr
  rÙ  rÌ   )rº   rF  rc   r  s       rl   r   zClusterNode.execute_commandç  sÔ   è ø€ à×,Ñ,Ó.ˆ
à×'Ñ'¨
Ó3×3Ð3ð ×,Ñ,Ð-D¨Z×-DÑ-DÀdÐ-KÈUÓS×SÐSð	*Ø,˜×,Ñ,¨Z¸¸a¹ÑKÀFÑK×Kà×+Ñ+¨JÓ7×7Ð7à�J‰J×Ñ˜jÕ)ð 	4øð 	Tøð Løà7ù�$×+Ñ+¨JÓ7×7Ñ7à�J‰J×Ñ˜jÕ)üsi   ‚%C)§B'¨&C)ÁB)ÁC)ÁB/ Á.B+Á/B/ Á2C)ÂB-Â!C)Â)C)Â+B/ Â-C)Â/C&ÃCÃ!C&Ã&C)ÚcommandsÚPipelineCommandc              ƒ   óú  K  — | j                  «       }| j                  |«      ƒ d {  –—†  |j                  |j                  d„ |D «       «      d«      ƒ d {  –—†  d}|D ];  }	  | j                  ||j
                  d   fi |j                  ¤Žƒ d {  –—† |_        Œ= | j                  |«      ƒ d {  –—†  | j                  j                  |«       |S 7 Œ¬7 Œ~7 ŒE# t        $ r}||_        d}Y d }~Œ‘d }~ww xY w7 ŒF­w)Nc              3   ó4   K  — | ]  }|j                   –— Œ y ­wr·   )rF  )rŠ  rÇ   s     rl   r‹  z/ClusterNode.execute_pipeline.<locals>.<genexpr>   s   è ø€ Ð$B¹°# S§X¥X¹ùs   ‚Fr   T)rû  rþ  r  Úpack_commandsr
  rF  rc   Úresultrø   rÙ  rÌ   )rº   r  r  rž  rÇ   rŸ  s         rl   Úexecute_pipelinezClusterNode.execute_pipelineø  s  è ø€ à×,Ñ,Ó.ˆ
à×'Ñ'¨
Ó3×3Ð3ð ×,Ñ,Ø×$Ñ$Ñ$B¹Ó$BÓBÀEó
÷ 	
ð 	
ð
 ˆÛˆCðØ#6 4×#6Ñ#6Ø §¡¨¡ñ$Ø/2¯z©zñ$÷ �•
ð ð ×'Ñ'¨
Ó3×3Ð3Ø�
‰
×Ñ˜*Ô%àˆ
ð- 	4øð	
øðùô ò Ø�”
Ø•ûðúð
 	4úsi   ‚%C;§C¨/C;ÁCÁC;Á$.CÂCÂ	CÂC;Â2C9Â3"C;ÃC;ÃCÃ	C6Ã#	C1Ã,C;Ã1C6Ã6C;Útokenc              ƒ   óÖ  ‡ ‡‡K  — t        j                  «       }‰ j                  r�‰ j                  j                  «       Š‰j                  j                  ˆˆfd„ˆ fd„«      ƒ d {  –—†  ‰j                  j                  ˆfd„ˆ fd„«      ƒ d {  –—†  |j                  ‰«       ‰ j                  rŒ�|r/|j                  «       Š‰ j                  j                  ‰«       |rŒ.y y 7 Œ~7 ŒV­w)Nc                  ód   •— ‰ j                  d‰j                  d«      ‰j                  «       «      S )NÚAUTHÚoid)r  Útry_getÚ	get_value)Úconnr  s   €€rl   r»   z.ClusterNode.re_auth_callback.<locals>.<lambda>  s'   ø€ ˜×)Ñ)Ø˜EŸM™M¨%Ó0°%·/±/Ó2Côrn   c                 ó&   •— ‰j                  | «      S r·   ©Ú_mock©rp  rº   s    €rl   r»   z.ClusterNode.re_auth_callback.<locals>.<lambda>  s   ø€ ˜dŸj™j¨Ô/rn   c                  ó$   •— ‰ j                  «       S r·   )r   )r  s   €rl   r»   z.ClusterNode.re_auth_callback.<locals>.<lambda>  s   ø€ ˜×*Ñ*Ô,rn   c                 ó&   •— ‰j                  | «      S r·   r  r   s    €rl   r»   z.ClusterNode.re_auth_callback.<locals>.<lambda>  s   ø€ ¸D¿J¹JÀuÔ<Mrn   )rà  rá  rÙ  rù  rq   Úcall_with_retryrÌ   )rº   r  Ú	tmp_queuer  s   `` @rl   Úre_auth_callbackzClusterNode.re_auth_callback  sÆ   úè ø€ Ü×%Ñ%Ó'ˆ	Ø�jŠjØ—:‘:×%Ñ%Ó'ˆDØ—*‘*×,Ñ,ôó 0ó	÷ ð ð —*‘*×,Ñ,Û,Ó.Mó÷ ð ð ×Ñ˜TÔ"ð �j‹jñ Ø×$Ñ$Ó&ˆDØ�J‰J×Ñ˜dÔ#ô ðøðús0   …A!C)Á&C%Á')C)ÂC'Â!C)Â3/C)Ã#C)Ã'C)rp  c              ƒ   ó   K  — y­w)z
        Dummy functions, needs to be passed as error callback to retry object.
        :param error:
        :return:
        Nrh   )rº   rp  s     rl   r  zClusterNode._mock'  s   è ø€ ð 	ùó   ‚r·   rÈ  )%rË  rÌ  rÍ  rÎ  rÐ  r   ri  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%  rK   r  rh   rn   rl   r_   r_   (  s“  „ ñð€Ið& &*ð	7ð  %Ø-7ò7àð7ð �C˜�H‰oð7ð ˜c‘]ð	7ð ð7ð ˜zÑ*ð7ð !ð7ð 
ó7ð>
˜#ó 
ðF˜#ð F $ó Fð˜#ó ð 1€Lð —]‘]Ø×,Ñ,ñàðð ðð 
ó	ó 
ð( Jó (ð6*°Zð *ÀDó *ð& *ð &°ó &ó	0óðØ$ðØ/2ðØ>Aðà	óð4*¨3ð *¸#ð *À#ó *ð"¨tÐ4EÑ/Fð È4ó ð8$¨Nó $ð& ô rn   c                   ój  — e Zd ZdZ	 	 	 d ded   dedeeef   dede	e
eeef   geeef   f      d	e	e   d
dfd„Z	 	 	 d!de	e   de	e   de	e   d
e	d   fd„Z	 d"deedf   deedf   ded
dfd„Zded
dfd„Zdeez  fd„Z	 	 d#deded
dfd„Zded
ed   fd„Zd$d„Zd%ded
dfd„Zdeded
eeef   fd„Zy)&rÎ   )Ú_dynamic_startup_nodesrÍ   Ú_background_tasksrt   rî   r#  Ú_epochÚread_load_balancerÚ_initialize_lockrŠ   r9  r‰   rª   Nr‰   r_   rŠ   rt   rŒ   rª   r«   rd   c                 ó^  — |D �ci c]  }|j                   |“Œ c}| _        || _        || _        || _        d | _        i | _        i | _        d| _        t        «       | _
        t        j                  «       | _        t        «       | _        || _        |€t#        «       | _        y || _        y c c}w rÄ   )ró   r‰   rŠ   rt   rª   rî   r#  r9  r+  r1   r,  rç   r"   r-  r  r*  r)  r>   rÍ   )rº   r‰   rŠ   rt   rŒ   rª   r«   rê   s           rl   rë   zNodesManager.__init__A  s¤   € ñ ;HÓH¹-°$˜dŸi™i¨™o¸-ÑHˆÔØ%:ˆÔ"Ø!2ˆÔØ*ˆÔà+/ˆÔØ57ˆÔØ;=ˆÔØˆŒÜ".£.ˆÔÜ.5¯l©l«nˆÔä47³EˆÔØ,AˆÔ#ØÐ#Ü%4Ó%6ˆDÕ"à%5ˆDÕ"ùò# Is   …B*r‡   rˆ   r/  c                 óÚ   — |rB|r@|dk(  rt        j                  |«      }| j                  j                  t	        ||¬«      «      S |r| j                  j                  |«      S t        d«      ‚)NrÜ  r¥  zEget_node requires one of the following: 1. node name 2. host and port)rÞ  rß  r#  rË   r4   rE   r3  s       rl   r0  zNodesManager.get_node]  si   € ñ ‘Dà�{Ò"Ü×+Ñ+¨DÓ1�Ø×#Ñ#×'Ñ'¬¸4ÀdÔ(KÓLÐLÙØ×#Ñ#×'Ñ'¨	Ó2Ð2äØWóð rn   ÚoldÚnewÚ
remove_oldc                 ó  — |r§t        |j                  «       «      D ]‹  }||vsŒ|j                  |«      }|j                  «        t	        j
                  |j                  «       «      }| j                  j                  |«       |j                  | j                  j                  «       Œ� |j                  «       D ]E  \  }}||v r7||   }|j                  «        |j                  D ]  }	|	j                  «        Œ ŒA|||<   ŒG y r·   )rÅ   rd  rj   r§  rç   rˆ  r¨  r*  ÚaddÚadd_done_callbackÚdiscardÚitemsrÙ  r  )
rº   r0  r1  r2  ró   Úremoved_nodeÚtaskrê   Úexisting_noder  s
             rl   Ú	set_nodeszNodesManager.set_nodeso  sæ   € ñ Ü˜SŸX™X›ZÖ(�Ø˜s’?ð $'§7¡7¨4£=�LØ ×HÑHÔJÜ"×.Ñ.Ø$×@Ñ@ÓBó�Dð ×*Ñ*×.Ñ.¨tÔ4Ø×*Ñ*¨4×+AÑ+A×+IÑ+IÕJð )ð  Ÿ)™)ž+‰JˆD�$Ø�s‰{ð !$ D¡	�Ø×EÑEÔGØ)×/Ô/�DØ×+Ñ+Õ-ð 0ààˆC�ŠIñ &rn   c                 óH  — || j                   v rBt        | j                   «      dkD  r*| j                   j                  |«      }|| j                   |<   || j                  v rDt        | j                  «      dkD  r+| j                  j                  |«      }|| j                  |<   yyy)zí
        Move a failing node to the end of startup_nodes and nodes_cache so it's
        tried last during reinitialization and when selecting the default node.
        If the node is not in the respective list, nothing is done.
        r¯   N)r‰   r:  rj   r#  )rº   r/  rê   s      rl   r©  z-NodesManager.move_node_to_end_of_cached_nodes—  s›   € ð ˜×*Ñ*Ñ*¬s°4×3EÑ3EÓ/FÈÒ/JØ×%Ñ%×)Ñ)¨)Ó4ˆDØ,0ˆD×Ñ˜yÑ)ð ˜×(Ñ(Ñ(¬S°×1AÑ1AÓ-BÀQÒ-FØ×#Ñ#×'Ñ'¨	Ó2ˆDØ*.ˆD×Ñ˜YÒ'ð .GÐ(rn   rŸ  c                 ó`  — | j                  |j                  |j                  ¬«      }|r|j                  t        k7  rdt        |_        nXt        |j                  |j                  t        fi | j                  ¤Ž}| j                  | j                  |j                  |i«       | j                  |j                     }||vr|g| j                  |j                  <   y ||d   urO|d   }t        |_        |j                  |«       |j                  |«       ||d<   | j                  |k(  r|| _        y y y )Nr¥  r   )r0  r‡   rˆ   rÚ  r-   r_   rt   r;  r#  ró   r9  Úslot_idr.   rÌ   Úremoverî   )rº   rŸ  Úredirected_nodeÚ
slot_nodesÚold_primarys        rl   r«  zNodesManager.move_slot¨  s  € ØŸ-™-¨Q¯V©V¸!¿&¹&˜-ÓAˆÙà×*Ñ*¬gÒ5ä.5�Õ+ô *Ø—‘˜Ÿ™¤ñØ+/×+AÑ+AñˆOð �N‰N˜4×+Ñ+¨o×.BÑ.BÀOÐ-TÔUØ×%Ñ% a§i¡iÑ0ˆ
Ø *Ñ,ð ,;Ð*;ˆD×Ñ˜QŸY™YÒ'Ø J¨q¡MÑ1ð % Q™-ˆKô '.ˆKÔ#Ø×Ñ˜kÔ*ð ×Ñ˜oÔ.à+ˆJ�q‰MØ× Ñ  KÒ/à$3�Õ!ð 0ð 2rn   r;  rx   c                 ó®  — |du r|€t         j                  }	 t        | j                  |   «      dkD  rc|ra| j                  |   d   j                  }| j
                  j                  |t        | j                  |   «      |«      }| j                  |   |   S | j                  |   d   S # t        t        f$ r t        d|› d| j                  › d�«      ‚w xY w)NTr¯   r   r7  z5" not covered by the cluster. "require_full_coverage=Ú")r2   ÚROUND_ROBINr:  r9  ró   r,  Úget_server_indexrú  rm  rM   rŠ   )rº   r;  rx   r‹   Úprimary_namer=  s         rl   rD  zNodesManager.get_node_from_slotÍ  sö   € ð  Ñ%Ð*AÐ*IÜ&;×&GÑ&GÐ#ð	Ü�4×#Ñ# DÑ)Ó*¨QÒ.Ñ3Jà#×/Ñ/°Ñ5°aÑ8×=Ñ=�Ø×2Ñ2×CÑCØ ¤# d×&6Ñ&6°tÑ&<Ó"=Ð?Vó�ð ×'Ñ'¨Ñ-¨hÑ7Ð7Ø×#Ñ# DÑ)¨!Ñ,Ð,øÜœIÐ&ò 	Ü%Ø˜˜ð *Ø*.×*DÑ*DÐ)EÀQðHóð ð	ús   ˜A=B( ÂB( Â(,CrÚ  c                 óz   — | j                   j                  «       D �cg c]  }|j                  |k(  r|‘Œ c}S c c}w r·   )r#  rÆ   rÚ  )rº   rÚ  rê   s      rl   r%  z%NodesManager.get_nodes_by_server_typeå  sF   € ð ×(Ñ(×/Ñ/Ô1ó
á1�Ø×Ñ ;Ò.ò Ø1ñ
ð 	
ùò 
s   �8c              ƒ   óZ	  K  — | j                   j                  «        i }i }g }d}d}d }| j                  }| j                  4 ƒd {  –—†  | j                  |k7  r	 d d d «      ƒd {  –—†  y t	        | j
                  j                  «       «      D �]à  }	 	 | j                  j                  t        | j                  | j                  j                  dd «      «      «       |j                  d«      ƒ d {  –—† }	d}t#        |	«      dk(  r8|	d   d   d   s-t#        | j
                  «      dk(  r|j$                  |	d   d   d<   |	D �]	  }t'        dt#        |«      «      D ]!  }||   D �cg c]  }t)        |«      ‘Œ c}||<   Œ# |d   }|d   }|d	k(  r|j$                  }t+        |d   «      }| j-                  ||«      \  }}g }|j                  t/        ||«      «      }|st1        ||t2        fi | j                  ¤Ž}|||j4                  <   |j7                  |«       |d
d  }|D ]z  }|d   }|d   }| j-                  ||«      \  }}|j                  t/        ||«      «      }|st1        ||t8        fi | j                  ¤Ž}|||j4                  <   |j7                  |«       Œ| t'        t+        |d   «      t+        |d   «      dz   «      D ]†  }||vr|||<   Œ||   d   }|j4                  |j4                  k7  sŒ/|j7                  |j4                  › d|j4                  › d|› �«       t#        |«      dkD  sŒkt        ddj;                  |«      › �«      ‚ �Œ d}t'        t<        «      D ]
  }||vsŒd} n |s�Œá n |st        dt?        |«      › �«      |‚|s+| j@                  rt        dt#        |«      › dt<        › d�«      ‚|| _!        | jE                  | j                  |d¬«       | jF                  r(| jE                  | j
                  | j                  d¬«       | jI                  t2        «      d   | _%        | xj                  dz  c_        d d d «      ƒd {  –—†  y 7 �Œ7 �Œó7 �Œj# t        $ r t        d«      ‚w xY w# t         $ r}
|
}Y d }
~
�Œùd }
~
ww xY wc c}w 7 ŒD# 1 ƒd {  –—†7  sw Y   y xY w­w)NFr‘   rÈ   z(Cluster mode is not enabled on this nodeTr¯   r   r†   Ú r‚   z vs z
 on slot: r�   z6startup_nodes could not agree on a valid slots cache: z, zORedis Cluster cannot be connected. Please provide at least one reachable node: z9All slots are not covered after query all startup_nodes. z of z covered...)r2  )&r,  Úresetr+  r-  r  r‰   rÆ   rÍ   Údispatchr=   r#  rt   rË   r   rL   rJ   rø   r:  r‡   r‘  rY   r`  Úremap_host_portr4   r_   r-   ró   rÌ   r.   Újoinr:   ri  rŠ   r9  r;  r)  r%  rî   )rº   Útmp_nodes_cacheÚ	tmp_slotsÚdisagreementsÚstartup_nodes_reachableÚfully_coveredÚ	exceptionÚepochÚstartup_nodeÚcluster_slotsrŸ  r;  ÚiÚvalÚprimary_noder‡   rˆ   Únodes_for_slotr¡  Úreplica_nodesÚreplica_nodeÚtarget_replica_nodeÚtmp_slots                          rl   rí   zNodesManager.initializeì  sû  è ø€ Ø×Ñ×%Ñ%Ô'Ø46ˆØ46ˆ	ØˆØ"'ÐØˆØˆ	Ø—‘ˆà×(×(Ó(Ø�{‰{˜eÒ#ð ÷ )×(Ð(ô !& d×&8Ñ&8×&?Ñ&?Ó&A× B�ððØ×.Ñ.×7Ñ7Ü?Ø $× 0Ñ 0Ø $× 6Ñ 6× :Ñ :Ð;PÐRVÓ Wóôð /;×.JÑ.JØ+ó/÷ )˜ð /3Ð+ô ˜Ó&¨!Ò+Ø)¨!Ñ,¨QÑ/°Ò2Ü˜D×.Ñ.Ó/°1Ò4à-9×->Ñ->�M !Ñ$ QÑ'¨Ñ*ä)�DÜ" 1¤c¨$£iÖ0˜Ø@DÀQÂÓ"HÁ¸¤<°Õ#4ÀÑ"H˜˜Qšð 1à#'¨¡7�LØ'¨™?�DØ˜r’zØ+×0Ñ0˜Ü˜|¨A™Ó/�DØ!%×!5Ñ!5°d¸DÓ!A‘J�D˜$à%'�Nà"1×"5Ñ"5´mÀDÈ$Ó6OÓ"P�KÙ&Ü&1Ø  $¬ñ'Ø37×3IÑ3Iñ'˜ð 9D�O K×$4Ñ$4Ñ5Ø"×)Ñ)¨+Ô6à$(¨¨ H�MÛ(5˜Ø+¨A™˜Ø+¨A™˜Ø%)×%9Ñ%9¸$ÀÓ%E™
˜˜dà.=×.AÑ.AÜ)¨$°Ó5ó/Ð+ñ  3Ü2=Ø $ d¬Gñ3Ø7;×7MÑ7Mñ3Ð/ð EX˜Ð(;×(@Ñ(@ÑAØ&×-Ñ-Ð.AÕBð )6ô  #¤3 t¨A¡w£<´°T¸!±W³ÀÑ1AÖB˜Ø IÑ-Ø+9˜I ašLð (1°¡|°A¡˜HØ'Ÿ}™}°×0@Ñ0@Ó@Ø -× 4Ñ 4Ø'/§}¡} o°T¸+×:JÑ:JÐ9KÈ:ÐVWÐUXÐ$Yô!"ô $' }Ó#5¸Ó#9Ü*?ð+8Ø8<¿	¹	À-Ó8PÐ7Qð)Só+&ð %&ò CðM *ðr !%�ÜÔ7Ö8�AØ 	Ò)Ø(-˜Ùð 9ó !ÙðK !CñN +Ü+ð+Ü+.¨y«>Ð*:ð<óð !ð!ñ ! T×%?Ò%?ô ,ØOÜ˜9“~Ð& dÔ+CÐ*Dð E!ð"óð ð  )ˆDÔØ�N‰N˜4×+Ñ+¨_ÈˆNÔNà×*Ò*à—‘˜t×1Ñ1°4×3CÑ3CÐPT�ÔUð !%× =Ñ =¼gÓ FÀqÑ IˆDÔØ�KŠK˜1Ñ�K÷U )×(Ñ(ùÐ(ùð&)úô )ò Ü3ØFóð ðûô
 !ò ð !"�IÝûð	üò, #Iðc )ø×(×(Ñ(üsÜ   ‚AR+ÁQÁR+Á	RÁR+Á%QÁ&R+Á+'RÂAQÃ1QÃ2QÃ6Q6Ã8A+RÅ#RÅ5E:RË0;RÌ,9RÍ&RÍ/CRÑR+ÑRÑR+ÑR+ÑQÑQ3Ñ3Q6Ñ6	RÑ?RÒRÒRÒRÒR+ÒR(ÒRÒR(Ò$R+Úattrc              ƒ   ó�   K  — d | _         t        j                  d„ t        | |«      j	                  «       D «       Ž ƒ d {  –—†  y 7 Œ­w)Nc              3   ób   K  — | ]'  }t        j                  |j                  «       «      –— Œ) y ­wr·   rï  ©rŠ  rê   s     rl   r‹  z&NodesManager.aclose.<locals>.<genexpr>…  s*   è ø€ ð á8�Dô ×#Ñ# D§O¡OÓ$5×6Ù8ùrò  )rî   rç   r“  ÚgetattrrÆ   )rº   r`  s     rl   rð   zNodesManager.aclose‚  sA   è ø€ Ø ˆÔÜ�n‰nñä# D¨$Ó/×6Ñ6Ô8óð
÷ 	
ò 	
ús   ‚<A¾A¿Ac                 óH   — | j                   r| j                  ||f«      S ||fS )z³
        Remap the host and port returned from the cluster to a different
        internal value.  Useful if the client is not connecting directly
        to the cluster.
        )rª   )rº   r‡   rˆ   s      rl   rM  zNodesManager.remap_host_port‹  s,   € ð ×ÒØ×%Ñ% t¨T lÓ3Ð3Ø�TˆzÐrn   )TNNrÉ  rÊ  )FNrÈ  )r#  )rË  rÌ  rÍ  rÐ  r   rÑ  r   ri  r   r   r   r   r`  r>   rë   r0  r;  r©  r?   rI   r«  rD  r%  rí   rð   rM  rh   rn   rl   rÎ   rÎ   0  s¿  „ ð€Ið* '+ØPTØ6:ñ6à˜MÑ*ð6ð  $ð6ð    S ™>ð	6ð
  $ð6ð   ¨%°°S°©/Ð):¸EÀ#ÀsÀ(¹OÐ)KÑ LÑMð6ð # ?Ñ3ð6ð 
ó6ð< #Ø"Ø#'ñ	à�s‰mðð �s‰mðð ˜C‘=ð	ð
 
�-Ñ	 óð, !ñ	&à�#�}Ð$Ñ%ð&ð �#�}Ð$Ñ%ð&ð ð	&ð
 
ó&ðP/¸#ð /À$ó /ð""4˜8 jÑ0ó "4ðP $)Ø $ñ	àðð !ðð
 
óð0
°Cð 
¸DÀÑ<Oó 
óTñl
 ð 
¸ó 
ð Cð ¨sð °u¸SÀ#¸X±ô rn   rÎ   c                   ó.  — e Zd ZdZdZ	 d"dedee   ddfd„Ze	d#d„«       Z
d	ed
eddfd„Zd$d„Zd$d„Zd%d„Zdeedd f   fd„Zdefd„Zdefd„Zdeeef   dedd fd„Z	 d&dededee   fd„Zd	ededd fd„Zd„ Zd„ Zd„ Z d„ Z!d„ Z"d„ Z#d e$e%ef   dd fd!„Z&y)'r³  a·  
    Create a new ClusterPipeline object.

    Usage::

        result = await (
            rc.pipeline()
            .set("A", 1)
            .get("A")
            .hset("K", "F", "V")
            .hgetall("K")
            .mset_nonatomic({"A": 2, "B": 3})
            .get("A")
            .get("B")
            .delete("A", "B", "K")
            .execute()
        )
        # result = [True, "1", 1, {"F": "V"}, True, True, "2", "3", 1, 1, 1]

    Note: For commands `DELETE`, `EXISTS`, `TOUCH`, `UNLINK`, `mset_nonatomic`, which
    are split across multiple nodes, you'll get multiple results for them in the array.

    Retryable errors:
        - :class:`~.ClusterDownError`
        - :class:`~.ConnectionError`
        - :class:`~.TimeoutError`

    Redirection errors:
        - :class:`~.TryAgainError`
        - :class:`~.MovedError`
        - :class:`~.AskError`

    :param client:
        | Existing :class:`~.RedisCluster` client
    )Úcluster_clientÚ_transactionÚ_execution_strategyNr  r±  rd   c                 óz   — || _         || _        | j                  st        | «      | _        y t        | «      | _        y r·   )rg  rh  ÚPipelineStrategyÚTransactionStrategyri  )rº   r  r±  s      rl   rë   zClusterPipeline.__init__½  sC   € ð %ˆÔØ'ˆÔð ×$Ò$ô ˜TÓ"ð 	Õ ô % TÓ*ð 	Õ rn   c                 ó.   — | j                   j                  S )z.Get the nodes manager from the cluster client.)rg  rw   r¾   s    rl   rw   zClusterPipeline.nodes_managerÈ  s   € ð ×"Ñ"×0Ñ0Ð0rn   rB  rP  c                 ó<   — | j                   j                  ||«       y)z5Set a custom response callback on the cluster client.N)rg  rS  rR  s      rl   rS  z%ClusterPipeline.set_response_callbackÍ  s   € à×Ñ×1Ñ1°'¸8ÕDrn   c              ƒ   óV   K  — | j                   j                  «       ƒ d {  –—†  | S 7 Œ­wr·   )ri  rí   r¾   s    rl   rí   zClusterPipeline.initializeÑ  s(   è ø€ Ø×&Ñ&×1Ñ1Ó3×3Ð3Øˆð 	4ús   ‚) '¡)c              ƒ   ó>   K  — | j                  «       ƒ d {  –—† S 7 Œ­wr·   )rí   r¾   s    rl   rú   zClusterPipeline.__aenter__Õ  s   è ø€ Ø—_‘_Ó&×&Ð&Ð&ús   ‚–—c              ƒ   ó@   K  — | j                  «       ƒ d {  –—†  y 7 Œ­wr·   ©rK  )rº   r  r  r  s       rl   r  zClusterPipeline.__aexit__Ø  ó   è ø€ Ø�j‰j‹l×Òúrõ   c                 ó>   — | j                  «       j                  «       S r·   r  r¾   s    rl   r	  zClusterPipeline.__await__Û  r
  rn   c                  ó   — y)z?Pipeline instances should  always evaluate to True on Python 3+Trh   r¾   s    rl   Ú__bool__zClusterPipeline.__bool__Þ  s   € àrn   c                 ó,   — t        | j                  «      S r·   )r:  ri  r¾   s    rl   Ú__len__zClusterPipeline.__len__â  s   € Ü�4×+Ñ+Ó,Ð,rn   rF  rc   c                 ó:   —  | j                   j                  |i |¤ŽS )ad  
        Append a raw command to the pipeline.

        :param args:
            | Raw command args
        :param kwargs:

            - target_nodes: :attr:`NODE_FLAGS` or :class:`~.ClusterNode`
              or List[:class:`~.ClusterNode`] or Dict[Any, :class:`~.ClusterNode`]
            - Rest of the kwargs are passed to the Redis connection
        )ri  r   ©rº   rF  rc   s      rl   r   zClusterPipeline.execute_commandå  s"   € ð 8ˆt×'Ñ'×7Ñ7¸ÐHÀÑHÐHrn   Úraise_on_errorÚallow_redirectionsc              ƒ   óÈ   K  — 	 | j                   j                  ||«      ƒ d{  –—† | j                  «       ƒ d{  –—†  S 7 Œ7 Œ# | j                  «       ƒ d{  –—†7   w xY w­w)a  
        Execute the pipeline.

        It will retry the commands as specified by retries specified in :attr:`retry`
        & then raise an exception.

        :param raise_on_error:
            | Raise the first error if there are any errors
        :param allow_redirections:
            | Whether to retry each failed command individually in case of redirection
              errors

        :raises RedisClusterException: if target_nodes is not provided & the command
            can't be mapped to a slot
        N)ri  rÃ  rK  ©rº   r{  r|  s      rl   rÃ  zClusterPipeline.executeõ  sU   è ø€ ð$	Ø×1Ñ1×9Ñ9ØÐ 2ó÷ ð —*‘*“,×Ñð	øð ù�$—*‘*“,×ÒüsG   ‚A"„A £A ¤A §A"ºA»A"Á A ÁA"ÁAÁAÁAÁA"rd  c                 óˆ   — | j                   j                  |«      j                  «       D ]  } | j                  |g|¢­Ž  Œ | S r·   )rg  Ú_partition_keys_by_slotrÆ   r   )rº   rB  rd  Ú	slot_keyss       rl   Ú_split_command_across_slotsz+ClusterPipeline._split_command_across_slots  sE   € ð ×,Ñ,×DÑDÀTÓJ×QÑQÖSˆIØ ˆD× Ñ  Ð5¨9Ô5ð Tð ˆrn   c              ƒ   óT   K  — | j                   j                  «       ƒ d{  –—†  y7 Œ­w©z/
        Reset back to empty pipeline.
        N)ri  rK  r¾   s    rl   rK  zClusterPipeline.reset  s    è ø€ ð ×&Ñ&×,Ñ,Ó.×.Ò.úó   ‚( &¡(c                 ó8   — | j                   j                  «        y)z’
        Start a transactional block of the pipeline after WATCH commands
        are issued. End the transactional block with `execute`.
        N)ri  Úmultir¾   s    rl   r‡  zClusterPipeline.multi  s   € ð
 	× Ñ ×&Ñ&Õ(rn   c              ƒ   óT   K  — | j                   j                  «       ƒ d{  –—†  y7 Œ­w)r  N)ri  r6  r¾   s    rl   r6  zClusterPipeline.discard#  ó   è ø€ à×&Ñ&×.Ñ.Ó0×0Ò0úr…  c              ‡   óR   K  —  | j                   j                  |Ž ƒ d{  –—†  y7 Œ­w)z$Watches the values at keys ``names``N)ri  rÂ  ©rº   Únamess     rl   rÂ  zClusterPipeline.watch'  s"   è ø€ à,ˆd×&Ñ&×,Ñ,¨eÐ4×4Ò4úó   ‚'Ÿ% 'c              ƒ   óT   K  — | j                   j                  «       ƒ d{  –—†  y7 Œ­w)z'Unwatches all previously specified keysN)ri  Úunwatchr¾   s    rl   r�  zClusterPipeline.unwatch+  r‰  r…  c              ‡   óR   K  —  | j                   j                  |Ž ƒ d {  –—†  y 7 Œ­wr·   )ri  Úunlinkr‹  s     rl   r‘  zClusterPipeline.unlink/  s"   è ø€ Ø-ˆd×&Ñ&×-Ñ-¨uÐ5×5Ò5úr�  Úmappingc                 ó8   — | j                   j                  |«      S r·   )ri  Úmset_nonatomic©rº   r’  s     rl   r”  zClusterPipeline.mset_nonatomic2  s   € ð ×'Ñ'×6Ñ6°wÓ?Ð?rn   r·   )rd   rÎ   ©rd   r³  )r  Nr  Nr  Nrd   N©TT)'rË  rÌ  rÍ  rÎ  rÐ  ra   r   rÑ  rë   Úpropertyrw   ri  r   rS  rí   rú   r  r   r   r	  rv  r`  rx  r   rS   rR   r   r   rÃ  r‚  rK  r‡  r6  rÂ  r�  r‘  r   rQ   r”  rh   rn   rl   r³  r³  –  s\  „ ñ"ðH J€Ið CGñ	
Ø"ð	
Ø19¸$±ð	
à	ó	
ð ò1ó ð1ðE¨Sð EÐ<Mð EÐRVó Eóó'óð-˜9 S¨$Ð0AÐ%AÑBó -ð˜$ó ð-˜ó -ðIØ˜4 Ð+Ñ,ðIØ8;ðIà	óIð" GKñØ"ðØ?Cðà	ˆc‰óð2ØðØ#'ðà	óò/ò)ò1ò5ò1ò6ð@Ø˜w¨
Ð2Ñ3ð@à	ô@rn   r³  r  r�  r”  c                   ó0   — e Zd Zdedededdfd„Zdefd„Zy)r  ÚpositionrF  rc   rd   Nc                 óJ   — || _         || _        || _        d | _        d | _        y r·   )rF  rc   rš  r  r˜  )rº   rš  rF  rc   s       rl   rë   zPipelineCommand.__init__A  s&   € ØˆŒ	ØˆŒØ ˆŒØ-1ˆŒØ;?ˆÕrn   c                 óV   — d| j                   › d| j                  › d| j                  › d�S )NÚ[z] ú (Ú))rš  rF  rc   r¾   s    rl   rä  zPipelineCommand.__repr__H  s)   € Ø�4—=‘=�/  D§I¡I ;¨b°·±°¸QÐ?Ð?rn   )rË  rÌ  rÍ  r`  r   rë   ri  rä  rh   rn   rl   r  r  @  s6   „ ð@ ð @¨Sð @¸Cð @ÀDó @ð@˜#ô @rn   r  c            	       ó  — e Zd Zedd„«       Zedeeef   deddfd„«       Z	e	 dde
de
dee   fd	„«       Zed
eeef   ddfd„«       Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zedefd„«       Zy)ÚExecutionStrategyrd   r³  c              ƒ   ó   K  — y­w)z^
        Initialize the execution strategy.

        See ClusterPipeline.initialize()
        Nrh   r¾   s    rl   rí   zExecutionStrategy.initializeM  ó   è ø€ ð 	ùr'  rF  rc   c                  ó   — y)zf
        Append a raw command to the pipeline.

        See ClusterPipeline.execute_command()
        Nrh   rz  s      rl   r   z!ExecutionStrategy.execute_commandV  ó   € ð 	rn   r{  r|  c              ƒ   ó   K  — y­w)zÈ
        Execute the pipeline.

        It will retry the commands as specified by retries specified in :attr:`retry`
        & then raise an exception.

        See ClusterPipeline.execute()
        Nrh   r~  s      rl   rÃ  zExecutionStrategy.executea  s   è ø€ ð 	ùr'  r’  c                  ó   — y)z�
        Executes multiple MSET commands according to the provided slot/pairs mapping.

        See ClusterPipeline.mset_nonatomic()
        Nrh   r•  s     rl   r”  z ExecutionStrategy.mset_nonatomico  r¥  rn   c              ƒ   ó   K  — y­w)zZ
        Resets current execution strategy.

        See: ClusterPipeline.reset()
        Nrh   r¾   s    rl   rK  zExecutionStrategy.resetz  r£  r'  c                  ó   — y)zU
        Starts transactional context.

        See: ClusterPipeline.multi()
        Nrh   r¾   s    rl   r‡  zExecutionStrategy.multiƒ  s   € ð 	rn   c              ‡   ó   K  — y­w)zI
        Watch given keys.

        See: ClusterPipeline.watch()
        Nrh   r‹  s     rl   rÂ  zExecutionStrategy.watchŒ  r£  r'  c              ƒ   ó   K  — y­w)za
        Unwatches all previously specified keys

        See: ClusterPipeline.unwatch()
        Nrh   r¾   s    rl   r�  zExecutionStrategy.unwatch•  r£  r'  c              ƒ   ó   K  — y ­wr·   rh   r¾   s    rl   r6  zExecutionStrategy.discardž  ó	   è ø€ àùr'  c              ‡   ó   K  — y­w)z^
        "Unlink a key specified by ``names``"

        See: ClusterPipeline.unlink()
        Nrh   r‹  s     rl   r‘  zExecutionStrategy.unlink¢  r£  r'  c                  ó   — y r·   rh   r¾   s    rl   rx  zExecutionStrategy.__len__«  ó   € àrn   Nr–  r—  )rË  rÌ  rÍ  r   rí   r   rS   rR   r   r   rÑ  r   rÃ  r   rQ   r”  rK  r‡  rÂ  r�  r6  r‘  r`  rx  rh   rn   rl   r¡  r¡  L  s>  „ Øòó ðð ðØ˜4 Ð+Ñ,ðØ8;ðà	òó ðð àFJñØ"ðØ?Cðà	ˆc‰òó ðð ðØ˜w¨
Ð2Ñ3ðà	òó ðð ñó ðð ñó ðð ñó ðð ñó ðð ñó ðð ñó ðð ð˜ò ó ñrn   r¡  c            	       ó   — e Zd Zdeddfd„Zdd„Zdeeef   de	ddfd	„Z
d
„ Zedeeef   ddfd„«       Ze	 ddededee	   fd„«       Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zed„ «       Zdefd„Zy)ÚAbstractStrategyrÅ  rd   Nc                 ó    — || _         g | _        y r·   )Ú_pipeÚ_command_queue)rº   rÅ  s     rl   rë   zAbstractStrategy.__init__±  s   € Ø&*ˆŒ
Ø79ˆÕrn   r³  c              ƒ   óÌ   K  — | j                   j                  j                  r,| j                   j                  j                  «       ƒ d {  –—†  g | _        | j                   S 7 Œ­wr·   )r´  rg  ro   rí   rµ  r¾   s    rl   rí   zAbstractStrategy.initializeµ  sL   è ø€ Ø�:‰:×$Ñ$×0Ò0Ø—*‘*×+Ñ+×6Ñ6Ó8×8Ð8Ø ˆÔØ�z‰zÐð 9ús   ‚AA$Á
A"ÁA$rF  rc   c                 ó�   — | j                   j                  t        t        | j                   «      g|¢­i |¤Ž«       | j                  S r·   )rµ  rÌ   r  r:  r´  rz  s      rl   r   z AbstractStrategy.execute_command»  sA   € ð 	×Ñ×"Ñ"ÜœC × 3Ñ 3Ó4ÐF°tÒF¸vÑFô	
ð �z‰zÐrn   c                 ó´   — dj                  t        t        |«      «      }d|› dt        |«      › d|j                  d   › �}|f|j                  dd z   |_        y)zS
        Provides extra context to the exception prior to it being handled
        r  ú
Command # rž  ú) of pipeline caused error: r   r¯   N)rN  ÚmaprX   rZ   rF  )rº   rT  ÚnumberrB  rÇ   Úmsgs         rl   Ú_annotate_exceptionz$AbstractStrategy._annotate_exceptionÃ  se   € ð �h‰h”sœ8 WÓ-Ó.ˆà˜˜ ¤=°Ó#5Ð"6ð 7Ø&Ÿ^™^¨AÑ.Ð/ð1ð 	ð ˜ )§.¡.°°Ð"4Ñ4ˆ	�rn   r’  c                  ó   — y r·   rh   r•  s     rl   r”  zAbstractStrategy.mset_nonatomicÎ  s   € ð 	rn   r{  r|  c              ƒ   ó   K  — y ­wr·   rh   r~  s      rl   rÃ  zAbstractStrategy.executeÔ  s   è ø€ ð 	ùr'  c              ƒ   ó   K  — y ­wr·   rh   r¾   s    rl   rK  zAbstractStrategy.resetÚ  r­  r'  c                  ó   — y r·   rh   r¾   s    rl   r‡  zAbstractStrategy.multiÞ  r°  rn   c              ‡   ó   K  — y ­wr·   rh   r‹  s     rl   rÂ  zAbstractStrategy.watchâ  r­  r'  c              ƒ   ó   K  — y ­wr·   rh   r¾   s    rl   r�  zAbstractStrategy.unwatchæ  r­  r'  c              ƒ   ó   K  — y ­wr·   rh   r¾   s    rl   r6  zAbstractStrategy.discardê  r­  r'  c              ‡   ó   K  — y ­wr·   rh   r‹  s     rl   r‘  zAbstractStrategy.unlinkî  r­  r'  c                 ó,   — t        | j                  «      S r·   )r:  rµ  r¾   s    rl   rx  zAbstractStrategy.__len__ò  s   € Ü�4×&Ñ&Ó'Ð'rn   r–  r—  )rË  rÌ  rÍ  r³  rë   rí   r   rS   rR   r   r   r¾  r   r   rQ   r”  rÑ  r   rÃ  rK  r‡  rÂ  r�  r6  r‘  r`  rx  rh   rn   rl   r²  r²  °  s+  „ ð:˜_ð :°ó :óðØ˜4 Ð+Ñ,ðØ8;ðà	óò	5ð ðØ˜w¨
Ð2Ñ3ðà	òó ðð
 àFJñØ"ðØ?Cðà	ˆc‰òó ðð
 ñó ðð ñó ðð ñó ðð ñó ðð ñó ðð ñó ðð(˜ô (rn   r²  c                   ó²   ‡ — e Zd Zdeddfˆ fd„Zdeeef   ddfd„Z	 dde	d	e	de
e   fd
„Z	 	 dddde
d   de	d	e	de
e   f
d„Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zˆ xZS )rk  rÅ  rd   Nc                 ó$   •— t         ‰| �  |«       y r·   )Úsuperrë   ©rº   rÅ  rÏ   s     €rl   rë   zPipelineStrategy.__init__÷  s   ø€ Ü‰Ñ˜Õrn   r’  r³  c                 óT  — | j                   j                  j                  }i }|j                  «       D ]@  }t	        |j                  |d   «      «      }|j                  |g «      j                  |«       ŒB |j                  «       D ]  } | j                  dg|¢­Ž  Œ | j                   S )Nr   ÚMSET)
r´  rg  ru   r7  r;   rI  Ú
setdefaultÚextendrÆ   r   )rº   r’  ru   Úslots_pairsÚpairr;  Úpairss          rl   r”  zPipelineStrategy.mset_nonatomicú  s–   € ð —*‘*×+Ñ+×3Ñ3ˆàˆØ—M‘M–OˆDÜ˜GŸN™N¨4°©7Ó3Ó4ˆDØ×"Ñ" 4¨Ó,×3Ñ3°DÕ9ð $ð !×'Ñ'Ö)ˆEØ ˆD× Ñ  Ð0¨%Ô0ð *ð �z‰zÐrn   r{  r|  c              ƒ   ó  K  — | j                   sg S 	 | j                  j                  j                  j	                  «       }	 	 | j                  j                  j
                  r,| j                  j                  j                  «       ƒ d {  –—†  | j                  | j                  j                  | j                   ||¬«      ƒ d {  –—† | j                  «       ƒ d {  –—†  S 7 ŒW7 Œ7 Œ	# t        j                  $ rb}|dkD  rQ|dz  }| j                  j                  j                  «       ƒ d {  –—†7   t        j                  d«      ƒ d {  –—†7   n|‚Y d }~nd }~ww xY w�Œ # | j                  «       ƒ d {  –—†7   w xY w­w)N)r{  r|  r   r¯   r¤  )rµ  r´  rg  rq   r�  ro   rí   Ú_executerK  ra   r•  rð   rç   rª  )rº   r{  r|  rr  rŸ  s        rl   rÃ  zPipelineStrategy.execute		  sB  è ø€ ð ×"Ò"ØˆIð	Ø!ŸZ™Z×6Ñ6×<Ñ<×HÑHÓJˆNØð Ø—z‘z×0Ñ0×<Ò<Ø"Ÿj™j×7Ñ7×BÑBÓD×DÐDØ!%§¡ØŸ
™
×1Ñ1Ø×+Ñ+Ø'5Ø+=ð	 "/ó "÷ ð$ —*‘*“,×Ñð' Eøðøð$ ùô $×6Ñ6ò 	 Ø%¨Ò)ð '¨!Ñ+˜Ø"Ÿj™j×7Ñ7×>Ñ>Ó@×@Ñ@Ü%Ÿm™m¨DÓ1×1Ò1ð  ˜ô 2ûð	 úñ øð, —*‘*“,×Òüs›   ‚E?’/E! ÁAC' Â	C!Â
:C' ÃC#ÃC' ÃE?ÃC%ÃE?Ã!C' Ã#C' Ã%E?Ã'EÃ:1EÄ+D.Ä,EÅ	EÅ
EÅE! ÅEÅE! Å!E<Å5E8Å6E<Å<E?r  ra   Ústackr  c           
   ƒ   ó~
  K  — |D �cg c]+  }|j                   rt        |j                   t        «      sŒ*|‘Œ- }}i }|D �]  }|j                  j	                  dd «      }|j
                  j                  |j                  d   j                  «       «      ƒ d {  –—† }	|r1|j                  |«      s |j                  |«      }
|	�st        «       }	�n|	sÇ|j                  j                  |j                  d   «      }|sk|j                  «       sd }n! |j                  |j                  Ž ƒ d {  –—† }|€t        «       }	n\t        t         j"                  t$        j"                  ¬«      }	n2||j&                  v rt        |j&                  |   ¬«      }	n
t        «       }	 |j(                  |j                  |	j*                  |dœŽƒ d {  –—† }
|
st-        d|j                  › d�«      ‚|	|_        t1        |
«      dkD  rt-        d	|j                  › �«      ‚|
d   }|j2                  |vr|g f||j2                  <   ||j2                     d   j5                  |«       �Œ t7        j8                  «       }t;        j<                  d
„ |j?                  «       D «       Ž ƒ d {  –—† }|jA                  «       D ]¤  \  }\  }}d }|D ]*  }t        |j                   t        «      sŒ|j                   } n |jB                  j                  dd«      }tE        dt7        j8                  «       |z
  |jF                  |jH                  |�tK        |«      nd |¬«      ƒ d {  –—†  Œ¦ tM        |«      �r�|rˆ|D ]ƒ  }t        |j                   tN        tP        tR        f«      sŒ)	  |jT                  |j.                  jV                      |jX                  |j                  i |j                  ¤Žƒ d {  –—† «      |_         Œ… |r‘|D ]Œ  }|j                   }t        |t        «      sŒ dj[                  t]        t^        |j                  «      «      }d|j`                  dz   › dtc        |«      › d|j                  › �}|f|j                  dd  z   |_        |‚ |j                  «       }|�^|j                  |j2                  «      }|�A|d   D ]9  }te        |j                   «      tf        jh                  v sŒ)|jk                  «         n |D �cg c]  }|j                   ‘Œ c}S c c}w 7 �Œr7 �Œâ7 �ŒM7 �Œ}7 �ŒË7 �ŒA# t        $ r}||_         Y d }~�ŒÐd }~ww xY wc c}w ­w)Nrf  r   r�  rƒ  r„  r…  r†  r¯   zToo many targets for command c              3   óp   K  — | ].  }t        j                  |d    j                  |d   «      «      –— Œ0 y­w)r   r¯   N)rç   rˆ  r  rc  s     rl   r‹  z,PipelineStrategy._execute.<locals>.<genexpr>o	  s6   è ø€ ð á*�Dô ×#Ñ# D¨¡G×$<Ñ$<¸TÀ!¹WÓ$E×FÙ*ùs   ‚46r�   ÚPIPELINEr}  r  r¹  rž  rº  )6r  rh  rø   rc   rj   rá   rŽ  rF  rW  rj  ro  r   rr   rË   r½   rE  r   rØ   r   rÙ   rZ  rU  rJ   r˜  r:  ró   rÌ   r�  r�  rç   r“  rÆ   r7  rt   r$   r‡   rˆ   ri  ÚanyrO   rI   r?   rà   r‚  r   rN  r»  rX   rš  rZ   rn  ra   r•  r’  )rº   r  rÕ  r{  r|  rÇ   ÚtodorY  r—  r˜  rf  r™  r;  rê   rœ  Úerrorsr/  r  Ú
node_errorr�   rŸ  r  rB  r½  Údefault_cluster_noderî   s                             rl   rÔ  zPipelineStrategy._execute)	  sÝ  è ø€ ñ !ó
Ù �C¨¯
ª
´jÀÇÁÌYÕ6WŠC˜5ð 	ð 
ð ˆÜˆCØ ŸZ™ZŸ^™^¨N¸DÓAˆNØ%+×%<Ñ%<×%DÑ%DØ—‘˜‘×!Ñ!Ó#ó&÷  Ðñ  f×&:Ñ&:¸>Ô&JØ%×9Ñ9¸.ÓI�â'Ü'6Ó'8Ò$á'Ø#)×#7Ñ#7×#;Ñ#;¸C¿H¹HÀQ¹KÓ#H�LÙ'à%×6Ñ6Ô8Ø#'™Dà)?¨×)?Ñ)?ÀÇÁÐ)J×#J˜DØ˜<Ü/>Ó/@Ñ,ä/>Ü/<×/JÑ/JÜ0>×0LÑ0Lô0Ñ,ð
 (¨6×+HÑ+HÑHÜ/>Ø/5×/LÑ/LØ$0ñ0"ô0Ñ,ô 0?Ó/@Ð,à%< V×%<Ñ%<Ø—X‘XØ#3×#BÑ#BØ,ò&÷  �ñ
 $Ü/Ø;¸C¿H¹H¸:À[ÐQóð ð $4ˆCÔ Ü�<Ó  1Ò$Ü+Ð.KÈCÏHÉHÈ:Ð,VÓWÐWØ ‘?ˆDØ�y‰y Ñ%Ø$(¨" :��d—i‘iÑ Ø�$—)‘)Ñ˜QÑ×&Ñ& sÖ+ði ôn —^‘^Ó%ˆ
ä—~‘~ñà!ŸL™LœNóð
÷ 
ˆð ,1¯;©;®=Ñ'ˆIÑ'˜˜hàˆJÛ�Ü˜cŸj™j¬)Õ4Ø!$§¡�JÙð  ð
 ×'Ñ'×+Ñ+¨D°!Ó4ˆBÜ+Ø'Ü!%§¡Ó!1°JÑ!>Ø#Ÿy™yØ ŸI™IØ(*¨œS œW¸DØ ô÷ ñ ð ,9ô$ ˆv�;Ù!ã�CÜ! #§*¡*¬}¼jÌ(Ð.SÕTð+ð*¨×)JÑ)JØ #× 4Ñ 4× DÑ Dñ*à$: F×$:Ñ$:¸C¿H¹HÐ$SÈÏ
É
Ñ$S×Só*U˜C�Jð  ñ Û�CØ ŸZ™Z�FÜ! &¬)Õ4Ø"%§(¡(¬3¬x¸¿¹Ó+BÓ"C˜à(¨¯©¸Ñ)9Ð(:ð ; Ü -¨gÓ 6Ð7ð 89Ø9?¿¹¸ðGð ð
 (+ f¨v¯{©{¸1¸2¨Ñ&>˜œØ$˜ð  ð $*×#:Ñ#:Ó#<Ð ð
 $Ð/Ø$Ÿy™yÐ)=×)BÑ)BÓC�ØÐ+ð
  ,¨Aœ˜ô   §
¡
Ó+¬|×/NÑ/NÒNØ"×7Ñ7Ô9Ù!ð  /ñ ',Ó,¡e˜s�—
“
 eÑ,Ð,ùòI
ð ùð" $Kùð$ ùð(
ùð"ùð" TúÜ(ò +Ø)*˜CŸJšJûð+üòF -ùsÉ   ‚T=‡+T³T·AT=ÂTÂBT=Ä)TÄ*BT=ÇTÇCT=ÊTÊ>T=ËA5T=Í	TÍ
>T=Î
ATÏT
ÏTÏ$%T=Ð
CT=ÓT=Ó-T8Ô 	T=ÔT=ÔT=ÔT=ÔT=ÔTÔ	T5Ô#T0Ô*T=Ô0T5Ô5T=c              ƒ   ó   K  — g | _         y­wr„  )rµ  r¾   s    rl   rK  zPipelineStrategy.reset¶	  s   è ø€ ð !ˆÕùs   ‚	c                 ó   — t        d«      ‚)Nz@method multi() is not supported outside of transactional context©rJ   r¾   s    rl   r‡  zPipelineStrategy.multi¼	  s   € Ü#ØNó
ð 	
rn   c              ‡   ó    K  — t        d«      ‚­w)Nz@method watch() is not supported outside of transactional contextrà  r‹  s     rl   rÂ  zPipelineStrategy.watchÁ	  s   è ø€ Ü#ØNó
ð 	
ùó   ‚c              ƒ   ó    K  — t        d«      ‚­w)NzBmethod unwatch() is not supported outside of transactional contextrà  r¾   s    rl   r�  zPipelineStrategy.unwatchÆ	  ó   è ø€ Ü#ØPó
ð 	
ùrâ  c              ƒ   ó    K  — t        d«      ‚­w)NzBmethod discard() is not supported outside of transactional contextrà  r¾   s    rl   r6  zPipelineStrategy.discardË	  rä  râ  c              ‡   óf   K  — t        |«      dk7  rt        d«      ‚| j                  d|d   «      S ­w)Nr¯   z>unlinking multiple keys is not implemented in pipeline commandÚUNLINKr   )r:  rJ   r   r‹  s     rl   r‘  zPipelineStrategy.unlinkÐ	  s:   è ø€ Üˆu‹:˜Š?Ü'ØPóð ð ×#Ñ# H¨e°A©hÓ7Ð7ùs   ‚/1r—  )rË  rÌ  rÍ  r³  rë   r   rQ   rR   r”  rÑ  r   r   rÃ  rÔ  rK  r‡  rÂ  r�  r6  r‘  Ú__classcell__©rÏ   s   @rl   rk  rk  ö  sÊ   ø„ ð˜_ð °õ ðØ˜w¨
Ð2Ñ3ðà	óð  GKñØ"ðØ?Cðà	ˆc‰óðH  $Ø#'ñK-àðK-ð Ð%Ñ&ðK-ð ð	K-ð
 !ðK-ð 
ˆc‰óK-òZ!ò
ò

ò

ò

ö
8rn   rk  c                   ó^  ‡ — e Zd ZdhZddhZh d£ZeefZe	e
eefZdeddfˆ fd„Zdeeef   fd„Zd	eeef   d
eddfd„Zd	eeef   d
edefˆ fd„Zd„ Zd„ Zd„ Zdedefd„Zd„ Zd„ Zde e!ef   ddfd„Z"	 d&de#de#de$e   fd„Z%de$d   de#fd„Z&de$d   de#fd„Z'd „ Z(d!„ Z)d"„ Z*d#„ Z+d$„ Z,d%„ Z-ˆ xZ.S )'rl  ÚUNWATCHÚWATCH>   ÚEXECÚDISCARDrë  rÅ  rd   Nc                 óP  •— t         ‰| �  |«       d| _        d| _        t	        «       | _        d | _        d | _        d| _        t        | j                  j                  j                  «      | _        | j                  j                  t        j                   | j"                  z   «       y )NF)rÊ  rë   Ú_explicit_transactionÚ	_watchingr  Ú_pipeline_slotsÚ_transaction_nodeÚ_transaction_connectionÚ
_executingr   r´  rg  rq   Ú_retryrÊ   ra   r•  ÚSLOT_REDIRECT_ERRORSrË  s     €rl   rë   zTransactionStrategy.__init__å	  s‚   ø€ Ü‰Ñ˜ÔØ%*ˆÔ"ØˆŒÜ),«ˆÔØ8<ˆÔØ=AˆÔ$ØˆŒÜ˜4Ÿ:™:×4Ñ4×:Ñ:Ó;ˆŒØ�‰×+Ñ+Ü×+Ñ+¨d×.GÑ.GÑGõ	
rn   c                 óT  — | j                   st        d«      ‚| j                  j                  j                  j                  t        | j                   «      d   d«      }|| _        | j                  s!| j                  j                  «       }|| _        | j                  | j                  fS )ao  
        Find a connection for a pipeline transaction.

        For running an atomic transaction, watch keys ensure that contents have not been
        altered as long as the watch commands for those keys were sent over the same
        connection. So once we start watching a key, we fetch a connection to the
        node that owns that slot and reuse it.
        z:At least a command with a key is needed to identify a noder   F)
rò  rJ   r´  rg  rw   rD  rÅ   ró  rô  rû  )rº   rê   r  s      rl   Ú*_get_client_and_connection_for_transactionz>TransactionStrategy._get_client_and_connection_for_transactionò	  sš   € ð ×#Ò#Ü'ØLóð ð !ŸJ™J×5Ñ5×CÑC×VÑVÜ�×%Ñ%Ó& qÑ)¨5ó
ˆð "&ˆÔà×+Ò+Ø%)×%;Ñ%;×%NÑ%NÓ%PˆJØ+5ˆDÔ(à×%Ñ% t×'CÑ'CÐCÐCrn   rF  rc   r   c                 óž   ‡ ‡‡‡‡— d Šd Šˆˆˆˆˆ fd„}t        j                  |¬«      }|j                  «        |j                  «        ‰r‰‚‰S )Nc                  ó‚   •— 	 t        j                   ‰j                  ‰i ‰¤Ž«      Šy # t        $ r} | ŠY d } ~ y d } ~ ww xY wr·   )rç   Úrunr‰  rø   )rŸ  rF  rp  rc   r°  rº   s    €€€€€rl   Úrunnerz3TransactionStrategy.execute_command.<locals>.runner
  s>   ø€ ðÜ"Ÿ;™;Ð'< t×'<Ñ'<¸dÐ'MÀfÑ'MÓN‘øÜò Ø•ûðús   ƒ%) ©	>²9¹>)Útarget)Ú	threadingÚThreadÚstartrN  )rº   rF  rc   rý  Úthreadrp  r°  s   ```  @@rl   r   z#TransactionStrategy.execute_command
  sH   ü€ àˆØˆ÷	ð 	ô ×!Ñ!¨Ô0ˆØ�‰ŒØ�‰ŒáØˆKàˆrn   c              �   óô  •K  — | j                   j                  j                  r,| j                   j                  j                  «       ƒ d {  –—†  d }|d   | j                  vr+ | j                   j                  j
                  |Ž ƒ d {  –—† }| j                  s|d   | j                  v rœ| j                  s�|d   dk(  r| j                  «        |�A| j                  r|| j                  vrt        d«      ‚| j                  j                  |«       n#|d   | j                  vrt        d|d   › d�«      ‚ | j                  |i |¤ŽS |�| j                  j                  |«       t        ‰| �@  |i |¤ŽS 7 �Œ(7 Œì­w)Nr   rì  z0Cannot watch or send commands on different slotsz)Cannot identify slot number for command: z(,it cannot be triggered in a transaction)r´  rg  ro   rí   ÚNO_SLOTS_COMMANDSrE  rñ  ÚIMMEDIATE_EXECUTE_COMMANDSrð  Ú_validate_watchrò  rD   r4  rJ   Ú_immediate_execute_commandrÊ  r   )rº   rF  rc   Úslot_numberrÏ   s       €rl   r‰  z$TransactionStrategy._execute_command#
  su  øè ø€ ð �:‰:×$Ñ$×0Ò0Ø—*‘*×+Ñ+×6Ñ6Ó8×8Ð8à%)ˆØ�‰7˜$×0Ñ0Ñ0Ø I §
¡
× 9Ñ 9× IÑ IÈ4Ð P×PˆKð �NŠN˜d 1™g¨×)HÑ)HÑHØ×,Ò,Ø�A‰w˜'Ò!Ø×$Ñ$Ô&àÐ&Ø×'Ò'¨K¸t×?SÑ?SÑ,SÜ3ØJóð ð ×$Ñ$×(Ñ(¨Õ5Ø�a‘ × 6Ñ 6Ñ6Ü+Ø?ÀÀQÁ¸yð I>ð >óð ð
 3�4×2Ñ2°DÐC¸FÑCÐCàÐ&Ø×$Ñ$×(Ñ(¨Ô5ä‘7Ñ*¨DÐ;°FÑ;Ð;ð= 9ùð Qús%   ƒAE8ÁE3Á=E8Â	E6Â
C*E8Å6E8c                 ó@   — | j                   rt        d«      ‚d| _        y )Nú"Cannot issue a WATCH after a MULTIT)rð  rK   rñ  r¾   s    rl   r  z#TransactionStrategy._validate_watchG
  s   € Ø×%Ò%ÜÐAÓBÐBàˆ�rn   c              �   ó~   ‡ ‡‡K  — ‰ j                   j                  ˆˆˆ fd„‰ j                  d¬«      ƒ d {  –—† S 7 Œ­w)Nc                  ó(   •—  ‰j                   ‰ i ‰¤ŽS r·   )Ú _get_connection_and_send_command)rF  Úoptionsrº   s   €€€rl   r»   z@TransactionStrategy._immediate_execute_command.<locals>.<lambda>O
  s   ø€ Ð9�D×9Ñ9¸4ÐKÀ7ÒKrn   T©Úwith_failure_count)rö  r#  Ú_reinitialize_on_error)rº   rF  r  s   ```rl   r  z.TransactionStrategy._immediate_execute_commandM
  s<   úè ø€ Ø—[‘[×0Ñ0ÝKØ×'Ñ'Ø#ð 1ó 
÷ 
ð 	
ð 
ús   …1=¶;·=c           
   �   óŒ  K  — | j                  «       \  }}| j                  s|j                  |«      ƒ d {  –—†  t        j                  «       }	  | j
                  |||d   g|¢­i |¤Žƒ d {  –—† }t        |d   t        j                  «       |z
  |j                  |j                  t        |j                  «      ¬«      ƒ d {  –—†  |S 7 Œ•7 Œ_7 Œ
# t        $ rf}||_        t        |d   t        j                  «       |z
  |j                  |j                  t        |j                  «      |¬«      ƒ d {  –—†7   ‚ d }~ww xY w­w)Nr   ©r¹   r{  ru  rv  r~  r}  )rù  rñ  rþ  r�  r�  Ú_send_command_parse_responser$   r‡   rˆ   ri  r�   rø   r  )rº   rF  r  Ú
redis_noder  rœ  r°  rŸ  s           rl   r  z4TransactionStrategy._get_connection_and_send_commandT
  s7  è ø€ Ø!%×!PÑ!PÓ!RÑˆ
�Jà�~Š~Ø×1Ñ1°*Ó=×=Ð=ô —^‘^Ó%ˆ
ð	Ø>˜T×>Ñ>Ø˜J¨¨Q©ðØ26òØ:Añ÷ ˆHô ,Ø! !™WÜ!%§¡Ó!1°JÑ!>Ø)Ÿ™Ø&ŸO™OÜ  §¡Ó/ô÷ ð ð ˆOð% >øðøðùô ò 
	Ø%ˆAŒLÜ+Ø! !™WÜ!%§¡Ó!1°JÑ!>Ø)Ÿ™Ø&ŸO™OÜ  §¡Ó/Øô÷ ñ ð ûð
	üse   ‚4E¶C·EÁC Á.CÁ/AC ÃCÃC ÃEÃC ÃC Ã	EÃAD<Ä5D8Ä6D<Ä<EÅEr  r  c              �   ó¦   K  —  |j                   |Ž ƒ d{  –—†   |j                  ||fi |¤Žƒ d{  –—† }|| j                  v rd| _        |S 7 Œ77 Œ­w)z7
        Send a command and parse the response
        NF)r  r
  ÚUNWATCH_COMMANDSrñ  )rº   r  r  r¹   rF  r  Úoutputs          rl   r  z0TransactionStrategy._send_command_parse_responsew
  s]   è ø€ ð &ˆj×%Ñ% tÐ,×,Ð,Ø0�z×0Ñ0°¸\ÑUÈWÑU×Uˆà˜4×0Ñ0Ñ0Ø"ˆDŒNØˆð 	-øØUús   ‚A•A–A±A²AÁAc           	   ƒ   óÖ  K  — t        |d«      rjt        |j                  j                  |j                  j                  |j                  j                  |j                  j                  ||d¬«      ƒ d {  –—†  | j
                  r.t        |«      | j                  v r| j                  rt        d«      ‚t        |«      | j                  v st        |«      | j                  v �rw| j                  rZ| j                  rN| j                  j                  «       ƒ d {  –—†  | j                  j                  | j                  «       d | _        | j                  j                   xj"                  dz  c_        | j                  j                   j$                  r‰| j                  j                   j"                  | j                  j                   j$                  z  dk(  rE| j                  j                   j&                  j)                  «       ƒ d {  –—†  d| _        d| _        y t+        |t,        «      r/| j                  j                   j&                  j/                  |«       d| _        y 7 �Œí7 �ŒM7 Œ`­w)Nr  Trt  z-Slot rebalancing occurred while watching keysr¯   r   F)r  r#   r  r‡   rˆ   rñ  rn  r÷  rõ  rP   ÚCONNECTION_ERRORSrô  ró  rð  r   r´  rg  ry   rz   rw   rí   rh  r?   r«  )rº   rp  r›  s      rl   r  z*TransactionStrategy._reinitialize_on_errorŠ
  sà  è ø€ Ü�5˜,Ô'Ü$Ø$×/Ñ/×4Ñ4Ø!×,Ñ,×1Ñ1Ø%*×%5Ñ%5×%:Ñ%:Ø"'×"2Ñ"2×"7Ñ"7Ø Ø,Ø ô÷ ð ð �>Š>Ü�E‹{˜d×7Ñ7Ñ7¸D¿OºOÜ Ð!PÓQÐQô �‹K˜4×4Ñ4Ñ4Ü�E‹{˜d×4Ñ4Ò4à×+Ò+°×0FÒ0Fà×2Ñ2×=Ñ=Ó?×?Ð?Ø×&Ñ&×.Ñ.¨t×/KÑ/KÔLØ/3�Ô,à�J‰J×%Ñ%×:Ò:¸aÑ?Õ:à—
‘
×)Ñ)×<Ò<Ø—J‘J×-Ñ-×BÑBØ—*‘*×+Ñ+×>Ñ>ñ?àòð —j‘j×/Ñ/×=Ñ=×HÑHÓJ×JÐJØ,-�Ô)ð
  ˆ�ô ˜e¤XÔ.Ø—J‘J×-Ñ-×;Ñ;×EÑEÀeÔLàˆ�ðKùð( @ùð Kús9   ‚A2I)Á4I!Á5B"I)ÄI$ÄC.I)ÈI'ÈAI)É$I)É'I)c           
   ƒ   ó–  K  — t        ||«      D ]´  \  }}t        |t        «      sŒ| j                  ||j                  dz   |j
                  «       t        dt        j                  «       |z
  | j                  j                  | j                  j                  t        | j                  j                  «      |¬«      ƒ d{  –—†  |‚ y7 Œ­w)z8
        Raise the first exception on the stack
        r¯   ÚTRANSACTIONr}  N)r”  rh  rø   r¾  rš  rF  r$   r�  r�  rô  r‡   rˆ   ri  r�   )rº   Ú	responsesrÕ  rœ  ÚrrÇ   s         rl   Ú_raise_first_errorz&TransactionStrategy._raise_first_error³
  s«   è ø€ ô ˜) UÖ+‰FˆAˆsÜ˜!œYÕ'Ø×(Ñ(¨¨C¯L©L¸1Ñ,<¸c¿h¹hÔGä/Ø!.Ü%)§^¡^Ó%5¸
Ñ%BØ#'×#?Ñ#?×#DÑ#DØ $× <Ñ <× AÑ AÜ!$ T×%AÑ%A×%DÑ%DÓ!EØô÷ ð ð �ñ ,ðús   ‚#C	¦BC	Â>CÂ?	C	r’  r³  c                 ó   — t        d«      ‚)Nz1Method is not supported in transactional context.)ÚNotImplementedErrorr•  s     rl   r”  z"TransactionStrategy.mset_nonatomicÆ
  s   € ô "Ð"UÓVÐVrn   r{  r|  c              ƒ   ó’   K  — | j                   }|s| j                  r| j                  sg S | j                  ||«      ƒ d {  –—† S 7 Œ­wr·   )rµ  rñ  rò  Ú!_execute_transaction_with_retries)rº   r{  r|  rÕ  s       rl   rÃ  zTransactionStrategy.executeË
  sB   è ø€ ð ×#Ñ#ˆÙ˜dŸnšn°D×4HÒ4HØˆIà×;Ñ;¸EÀ>ÓR×RÐRÐRús   ‚>AÁ AÁArÕ  r  c              ƒ   óp   ‡ ‡‡K  — ‰ j                   j                  ˆˆ ˆfd„ˆ fd„d¬«      ƒ d {  –—† S 7 Œ­w)Nc                  ó(   •— ‰j                  ‰‰ «      S r·   )Ú_execute_transaction)r{  rº   rÕ  s   €€€rl   r»   zGTransactionStrategy._execute_transaction_with_retries.<locals>.<lambda>Ø
  s   ø€ �D×-Ñ-¨e°^ÔDrn   c                 ó(   •— ‰j                  | |«      S r·   )r  )rp  r›  rº   s     €rl   r»   zGTransactionStrategy._execute_transaction_with_retries.<locals>.<lambda>Ù
  s   ø€ ¨×)DÑ)DØ�}ô*rn   Tr  )rö  r#  )rº   rÕ  r{  s   ```rl   r#  z5TransactionStrategy._execute_transaction_with_retriesÔ
  s<   úè ø€ ð —[‘[×0Ñ0ÝDóð  $ð 1ó 
÷ 
ð 	
ð 
ús   …*6¯4°6c           	   ƒ   ó¬	  K  — t        | j                  «      dkD  rt        d«      ‚d| _        | j	                  «       \  }}| j
                  s|j                  |«      ƒ d {  –—†  t        t        dd«      g|t        dd«      g«      }|D �cg c]!  }t        |j                  vsŒ|j                  ‘Œ# }}|j                  |«      }t        j                  «       }|j                  |«      ƒ d {  –—†  g }		 |j!                  |d«      ƒ d {  –—†  t-        | j.                  «      D ]W  \  }}t        |j                  v r%|	j'                  ||j                  t           f«       Œ=	 |j!                  |d«      ƒ d {  –—† }ŒY d }	 |j!                  |d«      ƒ d {  –—† }d| _        d| _        |€t5        d	«      ‚|	D ]  \  }}
|j7                  ||
«       Œ t        |«      t        | j.                  «      k7  rIt9        d
j;                  | j.                  D �cg c]  }|j                  d   ‘Œ c}t        |«      «      «      ‚|st        |	«      dkD  r%| j=                  || j.                  |«      ƒ d {  –—†  g }t?        || j.                  «      D ]‹  \  }}tA        |tB        «      se|j                  d   }|| jD                  jF                  jH                  v r4 | jD                  jF                  jH                  |   |fi |j                  ¤Ž}|j'                  |«       Œ� tK        dt        j                  «       |z
  |jL                  |jN                  tQ        |jR                  «      ¬«      ƒ d {  –—†  |S 7 �Œc c}w 7 �Œˆ7 �Œn# t"        $ r/}
| j%                  |
dd«       |	j'                  |
«       Y d }
~
�ŒŸd }
~
w| j(                  $ r }| j%                  |dd«       ||_        ‚ d }~ww xY w7 �Œl# | j0                  $ r<}| j%                  ||dz   |j                  «       |	j'                  |«       Y d }~�Œd }~w| j(                  $ r-}| j%                  ||dz   |j                  «       ||_        ‚ d }~wt"        $ r<}
| j%                  |
|dz   |j                  «       |	j'                  |
«       Y d }
~
�Œ…d }
~
ww xY w7 �Œ# t2        $ r	 |	r|	d   ‚‚ w xY wc c}w 7 �Œb7 �Œk­w)Nr¯   zDAll keys involved in a cluster transaction must map to the same slotTr   ÚMULTIrí  r�  FzWatched variable changed.zeUnexpected response length for cluster pipeline EXEC. Command stack was {} but response had length {}r  r  )*r:  rò  rD   rõ  rù  rñ  rþ  r   r  r)   rc   rF  r  r�  r�  r  r
  rL   r¾  rÌ   r  r  Ú	enumeraterµ  r÷  rF   rP   ÚinsertrG   Úformatr  r”  rh  rø   r´  rg  r{   r$   r‡   rˆ   ri  r�   )rº   rÕ  r{  r  r  Úcr  Úpacked_commandsrœ  rÛ  rŸ  Úcluster_errorrX  rB  r�  Ú
slot_errorr°  Údatar  rÇ   r¹   s                        rl   r&  z(TransactionStrategy._execute_transactionß
  s{  è ø€ ô ˆt×#Ñ#Ó$ qÒ(Ü+ØVóð ð ˆŒà!%×!PÑ!PÓ!RÑˆ
�Jà�~Š~Ø×1Ñ1°*Ó=×=Ð=äÜ˜Q Ó(Ð)ØÜ˜Q Ó'Ð(ó
ˆñ
 %*ÓL¡E˜q¬^À1Ç8Á8Ò-K�A—F“F EˆÐLØ$×2Ñ2°8Ó<ˆô —^‘^Ó%ˆ
à×,Ñ,¨_Ó=×=Ð=Øˆð	Ø×+Ñ+¨J¸Ó@×@Ð@ô $ D×$7Ñ$7Ö8‰JˆAˆwÜ §¡Ñ/Ø—‘˜q '§.¡.´Ñ"@ÐAÕBð%Ø(×7Ñ7¸
ÀCÓH×H‘Að 9ð" ˆð	Ø'×6Ñ6°zÀ6ÓJ×JˆHð  ˆŒð ˆŒàÐÜÐ8Ó9Ð9ó ‰DˆAˆqØ�O‰O˜A˜qÕ!ð ô ˆx‹=œC × 3Ñ 3Ó4Ò4Ü&ðCßCIÁ6Ø(,×(;Ò(;Ó<Ñ(; 1�Q—V‘V˜A“YÐ(;Ñ<¼cÀ(»móDóð ñ œS ›[¨1š_Ø×)Ñ)ØØ×#Ñ#Øó÷ ð ð ˆÜ˜( D×$7Ñ$7Ö8‰FˆAˆsÜ˜a¤Ô+Ø"Ÿx™x¨™{�Ø 4§:¡:×#<Ñ#<×#OÑ#OÑOØR˜Ÿ
™
×1Ñ1×DÑDÀ\ÑRØñØ ŸZ™Zñ�Að �K‰K˜�Nð 9ô (Ø&Ü!Ÿ^™^Ó-°
Ñ:Ø%Ÿ?™?Ø"Ÿ™Ü˜ZŸ]™]Ó+ô
÷ 	
ð 	
ð ˆðQ >ûò Mð 	>ùð AúÜò 	Ø×$Ñ$ Q¨¨7Ô3Ø�M‰M˜!×ÒûØ×%Ñ%ò 	Ø×$Ñ$ ]°A°wÔ?Ø'1ˆMÔ$Øûð	úð IúØ×0Ñ0ò .Ø×,Ñ,¨Z¸¸Q¹ÀÇÁÔMØ—M‘M *×-Ò-ûØ×-Ñ-ò Ø×,Ñ,¨]¸AÀ¹EÀ7Ç<Á<ÔPØ/9�MÔ,ØûÜ$ò %Ø×,Ñ,¨Q°°A±°w·|±|ÔDØ—M‘M !×$Ò$ûð%úð KúÜò 	ÙØ˜Q‘i�Øð	üò* =ðùð"	
ûs0  ‚ASÁ M-Á!+SÂM0Â$M0Â2;SÃ-M5Ã.SÃ5M; Ä
M8ÄM; ÄASÅ"O&Å7O#Å8O&Å<SÆR4 ÆR1ÆR4 ÆA6SÈS	È'ASÉ,SÉ-C9SÍ&SÍ'SÍ0SÍ8M; Í;	O Î$N.Î(SÎ.O Ï OÏO Ï SÏ#O&Ï&R.Ï51P,Ð&SÐ,R.Ð>(Q&Ñ&R.Ñ21R)Ò#SÒ)R.Ò.SÒ1R4 Ò4SÓ	SÓSc              ƒ   ó„  K  — g | _         | j                  r~	 | j                  rE| j                  j                  d«      ƒ d {  –—†  | j                  j	                  «       ƒ d {  –—†  | j
                  j                  | j                  «       d | _        d | _        d| _        d| _	        t        «       | _        d| _        y 7 Œ~7 Œ^# | j                  $ rj | j                  r[| j
                  rO| j                  j                  «       ƒ d {  –—†7   | j
                  j                  | j                  «       d | _        Y Œ¨w xY w­w)Nrë  F)rµ  rô  rñ  r  r   ró  r   r  rð  rð  r  rò  rõ  r¾   s    rl   rK  zTransactionStrategy.resetV  s  è ø€ Ø ˆÔð ×'Ò'ð8Ø—>’>ð ×6Ñ6×CÑCÀIÓN×NÐNØ×6Ñ6×DÑDÓF×FÐFð ×&Ñ&×.Ñ.¨t×/KÑ/KÔLØ/3�Ô,ð "&ˆÔØˆŒØ%*ˆÔ"Ü"›uˆÔØˆ�ð% OøØFùð
 ×)Ñ)ò 8à×/Ò/°D×4JÒ4JØ×6Ñ6×AÑAÓC×CÑCØ×*Ñ*×2Ñ2°4×3OÑ3OÔPØ37�DÔ0ùð8üsY   ‚E —*C ÁC Á!C Á#CÁ$0C Â,E Ã C ÃC ÃAD=ÄDÄ	1D=Ä:E Ä<D=Ä=E c                 ón   — | j                   rt        d«      ‚| j                  rt        d«      ‚d| _         y )Nz"Cannot issue nested calls to MULTIz:Commands without an initial WATCH have already been issuedT)rð  rK   rµ  r¾   s    rl   r‡  zTransactionStrategy.multit  s:   € Ø×%Ò%ÜÐAÓBÐBØ×ÒÜØLóð ð &*ˆÕ"rn   c              ‡   ór   K  — | j                   rt        d«      ‚ | j                  dg|¢­Ž ƒ d {  –—† S 7 Œ­w)Nr
  rì  )rð  rK   r   r‹  s     rl   rÂ  zTransactionStrategy.watch}  s9   è ø€ Ø×%Ò%ÜÐAÓBÐBà)�T×)Ñ)¨'Ð:°EÒ:×:Ð:Ð:ús   ‚.7°5±7c              ƒ   óZ   K  — | j                   r| j                  d«      ƒ d {  –—† S y7 Œ­w)Nrë  T)rñ  r   r¾   s    rl   r�  zTransactionStrategy.unwatchƒ  s)   è ø€ Ø�>Š>Ø×-Ñ-¨iÓ8×8Ð8àð 9ús   ‚!+£)¤+c              ƒ   ó@   K  — | j                  «       ƒ d {  –—†  y 7 Œ­wr·   rr  r¾   s    rl   r6  zTransactionStrategy.discard‰  rs  rõ   c              ‡   ó0   K  —  | j                   dg|¢­Ž S ­w)Nrç  )r   r‹  s     rl   r‘  zTransactionStrategy.unlinkŒ  s   è ø€ Ø#ˆt×#Ñ# HÐ5¨uÒ5Ð5ùs   ‚r—  )/rË  rÌ  rÍ  r  r  r  r?   rI   r÷  rC   ÚOSErrorrA   rM   r  r³  rë   r   r_   r   rù  r   rS   rR   r   r   r‰  r  r  r  r  r  r  r   rQ   r”  rÑ  r   rÃ  r#  r&  rK  r‡  rÂ  r�  r6  r‘  rè  ré  s   @rl   rl  rl  Ù	  sŒ  ø„ Ø"˜ÐØ")¨9Ð!5ÐÚ5ÐØ$ jÐ1ÐàØØØð	Ðð
˜_ð 
°õ 
ðDà	ˆ{˜JÐ&Ñ	'óDð6 U¨4°Ð+;Ñ%<ð Èð ÐPUó ð,"<Ø˜4 Ð+Ñ,ð"<Ø8;ð"<à	õ"<òHò
ò!ðFàðð  óò&' òRð&WØ˜w¨
Ð2Ñ3ðWà	óWð GKñSØ"ðSØ?CðSà	ˆc‰óSð	
ØÐ+Ñ,ð	
Ø>Bó	
ðuØÐ+Ñ,ðuØ>Bóuòn ò<*ò;òòö6rn   rl  )ˆrç   rà  r)  rÞ  rÿ  r�  rÔ  Úabcr   r   r   Ú	itertoolsr   Útypingr   r   r	   r
   r   r   r   r   r   r   r   r   r   r   Úredis._parsersr   r   Úredis._parsers.commandsr   r   r   Úredis._parsers.helpersr   r   r   Úredis.asyncio.clientr   Úredis.asyncio.connectionr   r   r    Úredis.asyncio.lockr"   Ú$redis.asyncio.observability.recorderr#   r$   Úredis.asyncio.retryr%   Úredis.auth.tokenr&   Úredis.backoffr'   r(   Úredis.clientr)   r*   r+   Úredis.clusterr,   r-   r.   r/   r0   r1   r2   r3   r4   r5   Úredis.commandsr6   r7   Úredis.commands.policiesr8   r9   Ú	redis.crcr:   r;   Úredis.credentialsr<   Úredis.eventr=   r>   Úredis.exceptionsr?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   Úredis.typingrQ   rR   rS   Úredis.utilsrT   rU   rV   rW   rX   rY   rZ   rg   r[   r\   r]   ri  r^   ra   r_   rÎ   r³  rB  ÚreplacerW  Úsetattrr  r¡  r²  rk  rl  rh   rn   rl   Ú<module>rR     sÒ  ðÛ Û Û Û Û Û Û ß #Ý Ý ÷÷ ÷ ÷ ÷" 8ß RÑ R÷ñ õ
 3ß IÑ IÝ #÷õ &Ý +ß Aß DÑ D÷÷ ÷ ÷ Dß Rß 8Ý 0ß L÷÷ ÷ ÷ ÷ ÷( 3Ñ 2÷÷ ñ ñ ß7Ò7à€JØ€JØ€KáØ�C˜¨¨]Ñ(;¸TÀ#À}ÐBTÑ=Uó€ô
{�=Ð"6Ð8Qô {÷|%Eñ E÷Pcñ côL_@�mÐ%9Ð;Tô _@óD )€GØ�oŠo˜c 3Ó'×-Ò-Ó/€GØÐ"Ò"ØáˆO˜WÑ&<¸WÓ&EÕFð )÷	@ñ 	@ôa˜ô aôHC(Ð(ô C(ôL`8Ð'ô `8ôFt6Ð*õ t6rn   