ph9 SSKrSSKrSSKrSSKJr SSKJrJrJrJ r J r J r J r J r JrJrJrJrJrJrJrJr SSKJrJrJrJr SSKJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r. SSK/J0r0J1r1 SSK2J3r3 \(aSSK4r5SSK6r5"S S \ 5r7\7r8"S S \ 5r9"S S\95r:"SS5r;"SS\ 5r<"SS\<5r="SS\ 5r>\>r?"SS\ 5r@"SS\@5rA"SS\ 5rB\BrC"SS\ 5rD\DrE"SS \ 5rF\FrG"S!S"\ 5rH\HrI"S#S$\5rJ"S%S&\ 5rK\KrL"S'S(5rM"S)S*5rN"S+S,\ 5rO\OrP"S-S.\ 5rQ"S/S0\Q5rR"S1S2\ 5rS\SrT"S3S4\ 5rU"S5S6\U5rV"S7S8\ 5rW\WrX"S9S:5rY\YrZ"S;S<\<\H\K\S\>\@\B\D\F5 r["S=S>\=\I\L\T\?\A\C\E\G5 r\"S?S@\7\W\[\9\U\O\Q\Y5 r]"SASB\8\X\\\:\V\P\R\Z5 r^g)CN)Enum) TYPE_CHECKINGAny AsyncIterator AwaitableCallableDictIterableIteratorListLiteralMappingOptionalSequenceSetTupleUnion)ConnectionError DataError NoScriptError RedisError) AbsExpiryTAnyKeyTBitfieldOffsetTChannelTCommandsProtocol ConsumerT EncodableTExpiryTFieldTGroupTKeysTKeyTNumberPatternT ResponseT ScriptTextT StreamIdT TimeoutSecT ZScoreBoundT)deprecated_functionextract_expire_flags) list_or_argsc\rSrSrSrS%S\\S\4SjjrSr S\S\4S jr S%S \\ S\4S jjr S\S\4S jr S\4S jrS\4SjrS%S\\ S\4SjjrS\4SjrS\4SjrS\4SjrS&S\S\S\S\\\\\4S\\\\\4S\\\S\\\S\\\S\\\S\\\\\4S\S\S\S \S\4S!jjrS\4S"jrS\4S#jrS$rg)' ACLCommands<zL Redis Access Control List (ACL) commands. see: https://redis.io/topics/acl Ncategoryreturnc FU(aU/O/nUR"S/UQ70UD6$)a Returns a list of categories or commands within a category. If ``category`` is not supplied, returns a list of all categories. If ``category`` is supplied, returns a list of all commands within that category. For more information, see https://redis.io/commands/acl-cat zACL CATexecute_command)selfr2kwargspiecess M/home/james-whalen/.local/lib/python3.13/site-packages/redis/commands/core.pyacl_catACLCommands.acl_catBs*2:H:r##IAA&AAc0UR"SU/UQ70UD6$)z Simulate the execution of a given command by a given ``username``. For more information, see https://redis.io/commands/acl-dryrun z ACL DRYRUNr5)r7usernameargsr8s r: acl_dryrunACLCommands.acl_dryrunOs! ##L(LTLVLLr=r?c.UR"S/UQ70UD6$)zr Delete the ACL for the specified ``username``\s For more information, see https://redis.io/commands/acl-deluser z ACL DELUSERr5r7r?r8s r: acl_deluserACLCommands.acl_deluserWs ##MGHGGGr=bitsc /nUb/[U5nUS:dUS:a[eURU5 UR"S/UQ70UD6$![a [S5ef=f)zGenerate a random password value. If ``bits`` is supplied then use this number of bits, rounded to the next multiple of 4. See: https://redis.io/commands/acl-genpass riz?genpass optionally accepts a bits argument, between 0 and 4096.z ACL GENPASS)int ValueErrorappendrr6)r7rGr8r9bs r: acl_genpassACLCommands.acl_genpass_sz    Iq5AH$$ a ##MEFEfEE  U s .A A!c *UR"SU40UD6$)z Get the ACL details for the specified ``username``. If ``username`` does not exist, return None For more information, see https://redis.io/commands/acl-getuser z ACL GETUSERr5rDs r: acl_getuserACLCommands.acl_getuserrs##M8FvFFr=c &UR"S0UD6$)zThe ACL HELP command returns helpful text describing the different subcommands. For more information, see https://redis.io/commands/acl-help )zACL HELPr5r7r8s r:acl_helpACLCommands.acl_help| ##9&99r=c &UR"S0UD6$)zg Return a list of all ACLs on the server For more information, see https://redis.io/commands/acl-list )zACL LISTr5rSs r:acl_listACLCommands.acl_listrVr=countc /nUb1[U[5(d [S5eURU5 UR"S/UQ70UD6$)z Get ACL logs as a list. :param int count: Get logs[0:count]. :rtype: List. For more information, see https://redis.io/commands/acl-log z ACL LOG count must be an integerACL LOG) isinstancerIrrKr6)r7rZr8r@s r:acl_logACLCommands.acl_logsO  eS)) BCC KK ##I????r=c 4S/nUR"S/UQ70UD6$)z_ Reset ACL logs. :rtype: Boolean. For more information, see https://redis.io/commands/acl-log sRESETr\r5)r7r8r@s r: acl_log_resetACLCommands.acl_log_resets&z##I????r=c &UR"S0UD6$)z Load ACL rules from the configured ``aclfile``. Note that the server must be configured with the ``aclfile`` directive to be able to load ACL rules from an aclfile. For more information, see https://redis.io/commands/acl-load )zACL LOADr5rSs r:acl_loadACLCommands.acl_load##9&99r=c &UR"S0UD6$)z Save ACL rules to the configured ``aclfile``. Note that the server must be configured with the ``aclfile`` directive to be able to save ACL rules to an aclfile. For more information, see https://redis.io/commands/acl-save )zACL SAVEr5rSs r:acl_saveACLCommands.acl_saverfr=enablednopass passwordshashed_passwords categoriescommandskeyschannels selectorsreset reset_keysreset_channelsreset_passwordsc UR5nU/nU (aURS5 U (aURS5 U (aURS5 U(aURS5 U(aURS5 OURS5 U(dU(aU(a [S5eU(a[U/5n[ U5HunnUR U5nUR S5(aURS US S -5 MFUR S 5(aURS US S -5 Mu[SUS35e U(a[U/5n[ U5HunnUR U5nUR S5(aURSUS S -5 MFUR S 5(aURSUS S -5 Mu[SUS35e U(aURS5 U(aUHnUR U5nUR S5(aURU5 M=UR S5(aURSUS S -5 MlUR S5(aURU5 MUR S 5(aURSUS S -5 M[SURUSS9S35e U(atUHnnUR U5nUR S5(d3UR S 5(d[SURUSS9S35eURU5 Mp U(a\UHVnUR U5nUR S5(dUR S5(dSU-nURU5 MX U (a.U H(nUR U5nURS U-5 M* U (aU HunnUR U5nUR S5(d3UR S 5(d[SURUSS9S35eUR U5nUR S5(dUR S5(dSU-nURS!UU4-5 M UR"S"/UQ70UD6$)#a Create or update an ACL user. Create or update the ACL for `username`. If the user already exists, the existing ACL is completely overwritten and replaced with the specified values. For more information, see https://redis.io/commands/acl-setuser Args: username: The name of the user whose ACL is to be created or updated. enabled: Indicates whether the user should be allowed to authenticate. Defaults to `False`. nopass: Indicates whether the user can authenticate without a password. This cannot be `True` if `passwords` are also specified. passwords: A list of plain text passwords to add to or remove from the user. Each password must be prefixed with a '+' to add or a '-' to remove. For convenience, a single prefixed string can be used when adding or removing a single password. hashed_passwords: A list of SHA-256 hashed passwords to add to or remove from the user. Each hashed password must be prefixed with a '+' to add or a '-' to remove. For convenience, a single prefixed string can be used when adding or removing a single password. categories: A list of strings representing category permissions. Each string must be prefixed with either a '+' to add the category permission or a '-' to remove the category permission. commands: A list of strings representing command permissions. Each string must be prefixed with either a '+' to add the command permission or a '-' to remove the command permission. keys: A list of key patterns to grant the user access to. Key patterns allow ``'*'`` to support wildcard matching. For example, ``'*'`` grants access to all keys while ``'cache:*'`` grants access to all keys that are prefixed with ``cache:``. `keys` should not be prefixed with a ``'~'``. reset: Indicates whether the user should be fully reset prior to applying the new ACL. Setting this to `True` will remove all existing passwords, flags, and privileges from the user and then apply the specified rules. If `False`, the user's existing passwords, flags, and privileges will be kept and any new specified rules will be applied on top. reset_keys: Indicates whether the user's key permissions should be reset prior to applying any new key permissions specified in `keys`. If `False`, the user's existing key permissions will be kept and any new specified key permissions will be applied on top. reset_channels: Indicates whether the user's channel permissions should be reset prior to applying any new channel permissions specified in `channels`. If `False`, the user's existing channel permissions will be kept and any new specified channel permissions will be applied on top. reset_passwords: Indicates whether to remove all existing passwords and the `nopass` flag from the user prior to applying any new passwords specified in `passwords` or `hashed_passwords`. If `False`, the user's existing passwords and `nopass` status will be kept and any new specified passwords or hashed passwords will be applied on top. sresets resetkeyss resetchannelss resetpasssonsoffz@Cannot set 'nopass' and supply 'passwords' or 'hashed_passwords'+s>%sr-N-s<%sz Password z6 must be prefixed with a "+" to add or a "-" to removes#%ss!%szHashed password snopasss+@s+@%ss-@s-@%sz Category "T)forcez"" must be prefixed with "+" or "-"z Command "%~s~%ss&%ss(%s %s)z ACL SETUSER) get_encoderrKrr. enumerateencode startswithdecoder6)r7r?rjrkrlrmrnrorprqrrrsrtrurvr8encoderr9ipasswordhashed_passwordr2cmdkeychannels r: acl_setuserACLCommands.acl_setusers}V""$$,:  MM( #  MM, '  MM* +  MM, '  MM% MM& ! )vR  %Y3I(3 8">>(3&&t,,MM&8AB<"78((..MM&8AB<"78##A3'89 4  ,,">?$//55MM&?12+>">?#*1#.89'B  MM) $ &">>(3&&u--MM(+((..MM'HQRL"89((//MM(+((..MM'HQRL"89#$W^^HD^%I$JK;;' nnS)~~d++CNN44H4H##GNN3dN$C#DE;; c"  nnS)~~d++CNN44H4H 3,C c"  #!..1 fw./$ %SnnS)~~d++CNN44H4H##GNN3dN$C#DE;; nnS)~~d++CNN44H4H 3,C jC:56&##MEFEfEEr=c &UR"S0UD6$)zuReturns a list of all registered users on the server. For more information, see https://redis.io/commands/acl-users )z ACL USERSr5rSs r: acl_usersACLCommands.acl_users{s ##:6::r=c &UR"S0UD6$)zlGet the username for the current connection For more information, see https://redis.io/commands/acl-whoami )z ACL WHOAMIr5rSs r: acl_whoamiACLCommands.acl_whoamis ##;F;;r=N) FFNNNNNNNFFFF)__name__ __module__ __qualname____firstlineno____doc__rstrr&r;rArErIrMrPrTrXr^rardrhboolrr r#rrrrr__static_attributes__rr=r:r0r0<s B B9 BMHSHyHF F9F&GCGiG:I::I:@Xc]@ @ @@ :I : :I :9=@D.2,0)-15:> $ %}F}F}F }F E#x}"456 }F #5hsm);#<= }FXc]+}F8C=)}Fx~&}F8H-.}FHU39%567}F}F}F}F}F" #}F~;Y;jr*SS?\\S@\\SA\\S \ 4SBjjr+SC\S \\\\\44SDjr,SEr-SSA\.SC\.S \ 4SFjjr/S.\S1\SC\\\4S \ 4SGjr0S \ 4SHjr1S \ 4SIjr2S \ 4SJjr3SK\S \ 4SLjr4SSMjr5S1\S \ 4SNjr6SSO\ S \ 4SPjjr7SSO\ S \ 4SQjjr8S \ 4SRjr9SS\ST\4SUjr:SV\SW\S \ 4SXjr;SY\S \ 4SZjrS^r?S_r@S`\\\A4S \ 4SajrBS \ 4SbjrCSSc\Sd\Se\DSf\S5\Sg\ Sh\ Si\\S \ 4SjjjrESk\SK\S \ 4SljrFSSmjrGSSnjrHS \ 4SojrIS \ 4SpjrJSSK\Sq\\S \ 4SrjjrKS \ 4SsjrLStrMSu\S \ 4SvjrNS \ 4SwjrOSx\S \ 4SyjrPS \\%\ \ 44SzjrQS \ 4S{jrRS \ 4S|jrSS \ 4S}jrTSS~\ S\ S\ S\ S\ S S4 SjjrUSSc\\Sd\\S \ 4SjjrVSS\\S \ 4SjjrWS \ 4SjrXS \ 4SjrYS \ 4SjrZS\S5\S \ 4Sjr[S\S\S5\S \ 4Sjr\Sr]Sr^Sr_g)ManagementCommandsiz Redis management commands Nrr?c |/nUbURU5 URU5 UR"S/UQ70UD6$)z Authenticates the user. If you do not pass username, Redis will try to authenticate for the "default" user. If you do pass username, it will authenticate for the given user. For more information, see https://redis.io/commands/auth AUTHrKr6)r7rr?r8r9s r:authManagementCommands.authsB   MM( # h##F>V>v>>r=c &UR"S0UD6$)zTell the Redis server to rewrite the AOF file from data in memory. For more information, see https://redis.io/commands/bgrewriteaof ) BGREWRITEAOFr5rSs r: bgrewriteaofManagementCommands.bgrewriteaofs ##=f==r=Tscheduler3c b/nU(aURS5 UR"S/UQ70UD6$)z Tell the Redis server to save its data to disk. Unlike save(), this method is asynchronous and returns immediately. For more information, see https://redis.io/commands/bgsave SCHEDULEBGSAVEr)r7rr8r9s r:bgsaveManagementCommands.bgsaves3  MM* %##H@v@@@r=c$URS5$)z Provide information on the role of a Redis instance in the context of replication, by returning if the instance is currently a master, slave, or sentinel. For more information, see https://redis.io/commands/role ROLEr5r7s r:roleManagementCommands.roles##F++r=addressc *UR"SU40UD6$)zqDisconnects the client at ``address`` (ip:port) For more information, see https://redis.io/commands/client-kill CLIENT KILLr5)r7rr8s r: client_killManagementCommands.client_kills ##M7EfEEr=_id_typeaddrskipmeladdrusermaxagec T/n UbASn [U5R5U ;a[SU <35eU RSU45 UbJ[ U[ 5(d [S5eU(aU RS5 OU RS5 UbU RSU45 UbU RSU45 UbU RS U45 UbU RS U45 UbU RS U45 U (d [S 5eUR "S /U Q70UD6$)a Disconnects client(s) using a variety of filter options :param _id: Kills a client by its unique ID field :param _type: Kills a client by type where type is one of 'normal', 'master', 'slave' or 'pubsub' :param addr: Kills a client by its 'address:port' :param skipme: If True, then the client calling the command will not get killed even if it is identified by one of the filter options. If skipme is not provided, the server defaults to skipme=True :param laddr: Kills a client by its 'local (bind) address:port' :param user: Kills a client for a specific user name :param maxage: Kills clients that are older than the specified age in seconds )normalmasterslavepubsubz CLIENT KILL type must be one of TYPEz!CLIENT KILL skipme must be a bool)SKIPMEsYES)rNOIDsADDRsLADDRsUSERsMAXAGEzVCLIENT KILL ... ... must specify at least one filterr)rlowerrextendr]rr6) r7rrrrrrrr8r@ client_typess r:client_kill_filter%ManagementCommands.client_kill_filters+0  BL5z!5"B
v>>r=moduler2patternc/nUbURSU/5 UbURSU/5 UbURSU/5 U(aURSS5 UR"S/UQ76$)aB Return an array of the server's command names. You can use one of the following filters: ``module``: get the commands that belong to the module ``category``: get the commands in the ACL category ``pattern``: get the commands that match the given pattern For more information, see https://redis.io/commands/command-list/ MODULEACLCATPATTERNrFILTERBYz COMMAND LIST)rinsertr6)r7r1r2r2r9s r: command_listManagementCommands.command_list%su   MM8V, -   MM8X. /   MM9g. /  MM!Z (##NSSKJn 0n/X!'UR"S0UD6$)zk Initiates a replication stream from the master. For more information, see https://redis.io/commands/sync r NEVER_DECODESYNC redis.clientrkr6r7rkoptionss r:syncManagementCommands.syncs( . "##6g66r= replicationidoffsetcBSSKJn 0n/XC'UR"SX40UD6$)z Initiates a replication stream from the master. Newer version for `sync`. For more information, see https://redis.io/commands/sync rrjPSYNCrn)r7rtrurkrqs r:psyncManagementCommands.psyncs, . "##G]NgNNr=firstsecondc *UR"SX40UD6$)zP Swap two databases For more information, see https://redis.io/commands/swapdb SWAPDBr5)r7rzr{r8s r:swapdbManagementCommands.swapdbs ##HeFvFFr=indexc *UR"SU40UD6$)zSSelect the Redis logical database at index. See: https://redis.io/commands/select SELECTr5)r7rr8s r:selectManagementCommands.selects ##He>v>>r=sectioncZUcUR"S0UD6$UR"SU/UQ70UD6$)a6 Returns a dictionary containing information about the Redis server The ``section`` option can be used to select a specific section of information The section option is not supported by older versions of Redis Server, and will generate ResponseError For more information, see https://redis.io/commands/info INFO)rr5)r7rr@r8s r:infoManagementCommands.infos: ?''9&9 9''I$I&I Ir=c &UR"S0UD6$)z Return a Python datetime object representing the last time the Redis database was saved to disk For more information, see https://redis.io/commands/lastsave )LASTSAVEr5rSs r:lastsaveManagementCommands.lastsaves##9&99r=c[S5e)zRaise a NotImplementedError, as the client will not support LATENCY DOCTOR. This function is best used within the redis-cli. For more information, see https://redis.io/commands/latency-doctor z LATENCY DOCTOR is intentionally not implemented in the client. For more information, see https://redis.io/commands/latency-doctor r(rs r:latency_doctor!ManagementCommands.latency_doctor "   r=c[S5e)zRaise a NotImplementedError, as the client will not support LATENCY GRAPH. This function is best used within the redis-cli. For more information, see https://redis.io/commands/latency-graph. z LATENCY GRAPH is intentionally not implemented in the client. For more information, see https://redis.io/commands/latency-graph r(rs r: latency_graph ManagementCommands.latency_graphrr=version_numbersc`U(aUR"S/UQ70UD6$UR"S0UD6$)ze Get the Redis version and a piece of generative computer art See: https://redis.io/commands/lolwut zLOLWUT VERSION)LOLWUTr5)r7rr8s r:lolwutManagementCommands.lolwuts7 ''(8U?UfU U'';F; ;r=c$URS5$)zdPerform a full reset on the connection's server-side context. See: https://redis.io/commands/reset RESETr5rs r:rsManagementCommands.resets ##G,,r=hostportrpdestination_dbcopyreplacerc  j[U/5nU(d [S5e/n U(aU RS5 U(aU RS5 U(a"U RS5 U RU5 U RS5 U RU5 UR"SXSXE/U Q70U D6$)a Migrate 1 or more keys from the current Redis server to a different server specified by the ``host``, ``port`` and ``destination_db``. The ``timeout``, specified in milliseconds, indicates the maximum time the connection between the two servers can be idle before the command is interrupted. If ``copy`` is True, the specified ``keys`` are NOT deleted from the source server. If ``replace`` is True, this operation will overwrite the keys on the destination server if they exist. If ``auth`` is specified, authenticate to the destination server with the password provided. For more information, see https://redis.io/commands/migrate z!MIGRATE requires at least one keysCOPYsREPLACEsAUTHsKEYSMIGRATE)r.rrKrr6) r7rrrprrrrrr8r9s r:migrateManagementCommands.migrate&s>D"%?@ @  MM' "  MM* %  MM' " MM$  g d## t2~ AG KQ  r=infotypec .UR"SX4SU0UD6$)z: Return the encoding, idletime, or refcount about the key OBJECTrr5)r7rrr8s r:objectManagementCommands.objectVs,## h .6 :@  r=c [S5e)Nz MEMORY DOCTOR is intentionally not implemented in the client. For more information, see https://redis.io/commands/memory-doctor r(rSs r: memory_doctor ManagementCommands.memory_doctor^rYr=c [S5e)Nz MEMORY HELP is intentionally not implemented in the client. For more information, see https://redis.io/commands/memory-help r(rSs r: memory_helpManagementCommands.memory_helpgrYr=c &UR"S0UD6$)zg Return a dictionary of memory stats For more information, see https://redis.io/commands/memory-stats )z MEMORY STATSr5rSs r: memory_statsManagementCommands.memory_statsp ##=f==r=c &UR"S0UD6$)zu Return an internal statistics report from the memory allocator. See: https://redis.io/commands/memory-malloc-stats )zMEMORY MALLOC-STATSr5rSs r:memory_malloc_stats&ManagementCommands.memory_malloc_statsxs ##DVDDr=samplesc /n[U[5(aURSU/5 UR"SU/UQ70UD6$)a9 Return the total memory usage for key, its value and associated administrative overheads. For nested data structures, ``samples`` is the number of elements to sample. If left unspecified, the server's default is 5. Use 0 to sample all elements. For more information, see https://redis.io/commands/memory-usage sSAMPLESz MEMORY USAGE)r]rIrr6)r7rrr8r@s r: memory_usageManagementCommands.memory_usagesD gs # # KKW- .##NCI$I&IIr=c &UR"S0UD6$)z~ Attempts to purge dirty pages for reclamation by allocator For more information, see https://redis.io/commands/memory-purge )z MEMORY PURGEr5rSs r: memory_purgeManagementCommands.memory_purgerr=c[S5e)r@zALATENCY HISTOGRAM is intentionally not implemented in the client.r(r<s r:latency_histogram$ManagementCommands.latency_histograms " O  r=eventc&URSU5$)z Returns the raw data of the ``event``'s latency spikes time series. For more information, see https://redis.io/commands/latency-history zLATENCY HISTORYr5)r7rs r:latency_history"ManagementCommands.latency_historys ##$5u==r=c$URS5$)zo Reports the latest latency events logged. For more information, see https://redis.io/commands/latency-latest zLATENCY LATESTr5rs r:latency_latest!ManagementCommands.latency_latests ##$455r=eventsc(UR"S/UQ76$)z Resets the latency spikes time series of all, or only some, events. For more information, see https://redis.io/commands/latency-reset z LATENCY RESETr5)r7rs r: latency_reset ManagementCommands.latency_resets ##O=f==r=c &UR"S0UD6$)a^ Ping the Redis server to test connectivity. Sends a PING command to the Redis server and returns True if the server responds with "PONG". This command is useful for: - Testing whether a connection is still alive - Verifying the server's ability to serve data For more information on the underlying ping command see https://redis.io/commands/ping )PINGr5rSs r:pingManagementCommands.pings##5f55r=c &UR"S0UD6$)zc Ask the server to close the connection. For more information, see https://redis.io/commands/quit )QUITr5rSs r:quitManagementCommands.quits ##5f55r=c.UR"S/UQ70UD6$)z Update the replication settings of a redis replica, on the fly. Examples of valid arguments include: NO ONE (set no replication) host port (set to the host and port of a redis server) For more information, see https://redis.io/commands/replicaof REPLICAOFr5r7r@r8s r: replicaofManagementCommands.replicaofs##KA$A&AAr=c &UR"S0UD6$)z Tell the Redis server to save its data to disk, blocking until the save is complete For more information, see https://redis.io/commands/save )SAVEr5rSs r:saveManagementCommands.save##5f55r=rnosavenowrzabortc U(aU(a [S5eS/nU(aURS5 U(aURS5 U(aURS5 U(aURS5 U(aURS5 UR"U0UD6 [ S 5e![a gf=f) aShutdown the Redis server. If Redis has persistence configured, data will be flushed before shutdown. It is possible to specify modifiers to alter the behavior of the command: ``save`` will force a DB saving operation even if no save points are configured. ``nosave`` will prevent a DB saving operation even if one or more save points are configured. ``now`` skips waiting for lagging replicas, i.e. it bypasses the first step in the shutdown sequence. ``force`` ignores any errors that would normally prevent the server from exiting ``abort`` cancels an ongoing shutdown and cannot be combined with other flags. For more information, see https://redis.io/commands/shutdown +SHUTDOWN save and nosave cannot both be setSHUTDOWNrNOSAVENOWFORCEABORTNSHUTDOWN seems to have failed.rrKr6rrr7rrrrzrr8r@s r:shutdownManagementCommands.shutdowns, FIJ J|  KK   KK !  KK   KK  KK    $ 1& 19::   sB33 C?Cc ZUcUcUR"S0UD6$UR"SX40UD6$)z Set the server to be a replicated slave of the instance identified by the ``host`` and ``port``. If called without arguments, the instance is promoted to a master instead. For more information, see https://redis.io/commands/slaveof )SLAVEOFrsONErr5)r7rrr8s r:slaveofManagementCommands.slaveofs9 v>>r=c &UR"S0UD6$)z Returns the server time as a 2-item tuple of ints: (seconds since epoch, microseconds into this second). For more information, see https://redis.io/commands/time )TIMEr5rSs r:timeManagementCommands.timeArr= num_replicasc *UR"SX40UD6$)z Redis synchronous replication That returns the number of replicas that processed the query when we finally have at least ``num_replicas``, or when the ``timeout`` was reached. For more information, see https://redis.io/commands/wait WAITr5)r7rrr8s r:waitManagementCommands.waitJs##FLLVLLr= num_localc ,UR"SXU40UD6$)a This command blocks the current client until all previous write commands by that client are acknowledged as having been fsynced to the AOF of the local Redis and/or at least the specified number of replicas. For more information, see https://redis.io/commands/waitaof WAITAOFr5)r7r rrr8s r:waitaofManagementCommands.waitaofUs&## y ;A  r=c[S5e)r@z5HELLO is intentionally not implemented in the client.r(rs r:helloManagementCommands.hellods " C  r=c[S5e)r@z8FAILOVER is intentionally not implemented in the client.r(rs r:failoverManagementCommands.failoverms " F  r=rr)T)NNNNNNNFr3NNNN*)FFNFFFFFNN)`rrrrrrrrrrr&rrrrIrrr rrrrrr rrrr#rrrrrr rrrrrr r$r*r/r9r=rAr%rDrGrJrMrQrTrWr\rcrgrrrxr~rrrrrfloatrrsr"rrrrrrrrrrrrrrrrrrrrrrrr rrrrr=r:rrs ?S ?HSM ?> At A A,i,F3FYF"#"!% $" $4D c]4D}4Dsm 4D  4D ~ 4Dsm4D 4D 4Dl=y=&*Dc]D6::6FD D6@)@A9AE74='%.'&/IJE E0;Y;#'!# 3-           *#'!# 3-           *"&!#:@ :@3-:@ :@  :@  :@:@:@ :@xEyE F3 FY FM3MsMM-255%)5 5 5C5d5 58@)@=C=E)C.#2E,F= =C =E)C.#2E,F =9 ?? !%"&!% = =3-=# =  =8FSFT%T#Y:O5PF #&LL.6L L P P PT:%& P  PBIB@)@8)8CC9C =*=9= AT A A @D @y @ 7i 7 O3 O OGCGG9G?C?i?JHSMJJ9J":I:      >EyE37JJ"*3-J J$> > >S>Y>6 6>S>Y> 6iot&; < 66 6 BI B6 6 (;(;(; (;  (;  (; (;VAE ESM E08  E  E5x}5)5"=y=??6 6 M Ms M M    ,/  :=      r=rc ^\rSrSrSU4SjjrSU4SjjrSU4SjjrSU4SjjrSS\S \S \S \S \SS4 S jjr Sr U=r $)AsyncManagementCommandsiwr3Nc,># [TU]"S0UD6$7fNrsuperr*r7r8 __class__s r:r*$AsyncManagementCommands.command_infoxsw#-f--c,># [TU]"S0UD6$7fr )r"rWr#s r:rW&AsyncManagementCommands.debug_segfault{sw%///r&c,># [TU]"S0UD6$7fr )r"rr#s r:r%AsyncManagementCommands.memory_doctor~sw$.v..r&c,># [TU]"S0UD6$7fr )r"rr#s r:r#AsyncManagementCommands.memory_helpsw",V,,r&rrrrzrc# U(aU(a [S5eS/nU(aURS5 U(aURS5 U(aURS5 U(aURS5 U(aURS5 UR"U0UD6IShvN [ S 5eN![a gf=f7f) aShutdown the Redis server. If Redis has persistence configured, data will be flushed before shutdown. If the "save" option is set, a data flush will be attempted even if there is no persistence configured. If the "nosave" option is set, no data flush will be attempted. The "save" and "nosave" options cannot both be set. For more information, see https://redis.io/commands/shutdown rrrrrrrNrrrs r:r AsyncManagementCommands.shutdowns" FIJ J|  KK   KK !  KK   KK  KK  &&77 7 79:: 8   s<BCB?-B=.B?2 C=B?? C  C C  Crrr) rrrrr*rWrrrrr __classcell__r$s@r:rrwsl.0/-  #;#;#; #;  #;  #; #;#;r=rc \rSrSrSrSS\SS\S\\4SjjrS r S \4S jr SS \S \ S\ S \\4Sjjr S \S \ 4SjrS \S \ S\ 4Sjr\S5rS\4SjrSrg)BitFieldOperationiz( Command builder for BITFIELD commands. Nclientredis.client.Redisredis.asyncio.client.Redisrdefault_overflowcdXlX lX0l/UlSUlUR 5 g)NWRAP)r3r_default_overflow operations_last_overflowrs)r7r3rr7s r:__init__BitFieldOperation.__init__s,  !18:$ r=c|/UlSUlURUR=(d UR5 g)z< Reset the state of the instance to when it was constructed r9N)r;r<overflowr:rs r:rsBitFieldOperation.resets0$ d,,C0C0CDr=r@cUR5nXR:wa#XlURRSU45 U$)z Update the overflow algorithm of successive INCRBY operations :param overflow: Overflow algorithm, one of WRAP, SAT, FAIL. See the Redis docs for descriptions of these algorithmsself. :returns: a :py:class:`BitFieldOperation` instance. OVERFLOW)upperr<r;rK)r7r@s r:r@BitFieldOperation.overflows>>># ** *"*  OO " "J#9 : r=fmtru incrementcjUbURU5 URRSXU45 U$)aX Increment a bitfield by a given amount. :param fmt: format-string for the bitfield being updated, e.g. 'u8' for an unsigned 8-bit integer. :param offset: offset (in number of bits). If prefixed with a '#', this is an offset multiplier, e.g. given the arguments fmt='u8', offset='#2', the offset will be 16. :param int increment: value to increment the bitfield by. :param str overflow: overflow algorithm. Defaults to WRAP, but other acceptable values are SAT and FAIL. See the Redis docs for descriptions of these algorithms. :returns: a :py:class:`BitFieldOperation` instance. INCRBY)r@r;rK)r7rFrurGr@s r:incrbyBitFieldOperation.incrbys4(   MM( # #yAB r=c@URRSX45 U$)al Get the value of a given bitfield. :param fmt: format-string for the bitfield being read, e.g. 'u8' for an unsigned 8-bit integer. :param offset: offset (in number of bits). If prefixed with a '#', this is an offset multiplier, e.g. given the arguments fmt='u8', offset='#2', the offset will be 16. :returns: a :py:class:`BitFieldOperation` instance. GETr;rK)r7rFrus r:rBitFieldOperation.gets  s34 r=r cBURRSXU45 U$)a Set the value of a given bitfield. :param fmt: format-string for the bitfield being read, e.g. 'u8' for an unsigned 8-bit integer. :param offset: offset (in number of bits). If prefixed with a '#', this is an offset multiplier, e.g. given the arguments fmt='u8', offset='#2', the offset will be 16. :param int value: value to set at the given position. :returns: a :py:class:`BitFieldOperation` instance. SETrN)r7rFrur s r:setBitFieldOperation.sets" sE:; r=cjSUR/nURHnURU5 M U$)NBITFIELD)rr;r)r7ropss r:r$BitFieldOperation.commands.488$??C JJsO# r=r3clURnUR5 URR"U6$)z Execute the operation(s) in a single BITFIELD command. The return value is a list of values corresponding to each operation. If the client used to create this instance was a pipeline, the list of values will be present within the pipeline's execute. )r$rsr3r6)r7r$s r:executeBitFieldOperation.executes+,, {{**G44r=)r:r<r3rr;r)rrrrrrrrr=rsr@rrIrJrrRpropertyr$r&rYrrr=r:r2r2s+/ HI  #3- E  $#'     3- 4 s O  s O C  5 5r=r2cZ\rSrSrSrS\S\S\4SjrSS\S\ \ S \ \ S \ \ S\4 S jjr SS \ S S\S\ \ S\4SjjrSS \ S S\S\ S\S\ \S\4 SjjrS\ S\S\S\4SjrSS\S\ S\ \ S \ \ S \ \ S\4 SjjrSS\ S\ S\ \ S\S\4 SjjrSS\S \ S\4S!jjr\rS"\S\4S#jrS\4S$jrS\S\4S%jrS"\S\4S&jr\rSS\S'\S(\S)\S*\S+\S\4S,jjrSS\S-\ S(\S)\S*\S+\S\4S.jjr!S\ S\ 4S/jr"S\S\4S0jr#S\S\4S1jr$SS\S2\ \S3\ \S4\ \ S5\ \ S6\S\4S7jjr%S\4S8jr&S\S\ S\4S9jr'S\S\ S \ S\4S:jr(S\S\S\4S;jr)SS\S \ S\4S<jjr*\*r+SS\S \,S\4S=jjr-SS>\.S\4S?jjr/SS@\ SA\ SB\ S\ S\4 SCjjr0SS@\ SA\ SD\ SB\ S\ S\4 SEjjr1S\2SF\S\4SGjr3SH\4\5\4S\4SIjr6SH\4\5\4S\4SJjr7S\SK\ S\4SLjr8S\S\4SMjr9SS\S'\S(\S)\S*\S+\S\4SNjjr:SS\S-\ S(\S)\S*\S+\S\4SOjjr;S\ S\ 4SPjrSS\ ST\ \ SU\S\4SVjjr?S\4SWjr@SB\SX\S\4SYjrASB\SX\4SZjrBSS\S[\,S\S\S\\S]\ \ S^\ \ S\4S_jjrCSS\S\S2\ \S3\ \S(\S)\S`\Sa\S4\ \ S5\ \ S\4SbjjrDS\S\4ScjrES\S\ S\ S\4SdjrFS\S'\S\S\4SejrGS\S\S\4SfjrHS\S\ S\S\4SgjrISSi\JSjSk\Sl\Sm\ \JSh\JS4Sn\So\Sp\ \ Sq\S\4SrjjrKS\S\4SsjrLSS\S\ S \ S\4StjjrMSF\S\4SujrNS\S\4SvjrOS\S\4SwjrPS"\SS4SxjrQSSyjrRS"\S\4SzjrSSS{\ S|\ Sn\ \So\ \Sp\ \ Sq\ \S\ \ \ \44S}jjrTS~rUg)BasicKeyCommandsiz Redis basic key-based commands rr r3c&URSX5$)z Appends the string ``value`` to the value at ``key``. If ``key`` doesn't already exist, create it with a value of ``value``. Returns the new length of the value at ``key``. For more information, see https://redis.io/commands/append APPENDr5)r7rr s r:rKBasicKeyCommands.appends##Hc99r=NstartendrcU/nUb&Ub#URU5 URU5 OUbUbUbUc [S5eUbURU5 UR"S/UQ7SU/06$)z Returns the count of set bits in the value of ``key``. Optional ``start`` and ``end`` parameters indicate which bytes to consider For more information, see https://redis.io/commands/bitcount z$Both start and end must be specifiedBITCOUNTrp)rKrr6)r7rrarbrparamss r:bitcountBasicKeyCommands.bitcount)sz   MM% MM# CKS_BC C   MM$ ##JDDseDDr=r7r4r7c[XUS9$)z Return a BitFieldOperation instance to conveniently construct one or more bitfield operations on ``key``. For more information, see https://redis.io/commands/bitfield )r7)r2)r7rr7s r:bitfieldBasicKeyCommands.bitfield@s!=MNNr=encodingruitemscUSX#/nU=(d /nUHup#URSX#/5 M UR"S/UQ7SU/06$)aL Return an array of the specified bitfield values where the first value is found using ``encoding`` and ``offset`` parameters and remaining values are result of corresponding encoding/offset pairs in optional list ``items`` Read-only variant of the BITFIELD command. For more information, see https://redis.io/commands/bitfield_ro rM BITFIELD_ROrprr6)r7rrkrurlres r: bitfield_roBasicKeyCommands.bitfield_roMsT uh/  % H MM5(3 4!&##MGFG#GGr= operationdestrpc*UR"SX/UQ76$)z Perform a bitwise operation using ``operation`` between ``keys`` and store the result in ``dest``. For more information, see https://redis.io/commands/bitop BITOPr5)r7rrrsrps r:bitopBasicKeyCommands.bitopds##GYDtDDr=bitc US;a [S5eX/nUSL=(a URU5 UbUbURU5 OUcUb [S5eUbURU5 UR"S/UQ7SU/06$)a, Return the position of the first bit set to 1 or 0 in a string. ``start`` and ``end`` defines search range. The range is interpreted as a range of bytes and not a range of bits, so start=0 and end=2 means to look at the first three bytes. For more information, see https://redis.io/commands/bitpos )rr-zbit must be 0 or 1Nz0start argument is not set, when end is specifiedBITPOSrprrKr6)r7rrxrarbrres r:bitposBasicKeyCommands.bitposms f 01 1 T2fmmE2   MM#  ]sNO O   MM$ ##HBvBSEBBr=source destinationrrcX/nUbURSU/5 U(aURS5 UR"S/UQ76$)a Copy the value stored in the ``source`` key to the ``destination`` key. ``destination_db`` an alternative destination database. By default, the ``destination`` key is created in the source Redis database. ``replace`` whether the ``destination`` key should be removed before copying the value to it. By default, the value is not copied if the ``destination`` key already exists. For more information, see https://redis.io/commands/copy DBREPLACECOPY)rrKr6)r7r~rrrres r:rBasicKeyCommands.copysH&&  % MM40 1  MM) $##F4V44r=ramountc&URSX5$)z Decrements the value of ``key`` by ``amount``. If no key exists, the value will be initialized as 0 - ``amount`` For more information, see https://redis.io/commands/decrby DECRBYr5r7rrs r:decrbyBasicKeyCommands.decrby##Hd;;r=namesc(UR"S/UQ76$)z0 Delete one or more keys specified by ``names`` DELr5r7rs r:deleteBasicKeyCommands.deletes##E2E22r=c&URU5 gr)rr7rs r: __delitem__BasicKeyCommands.__delitem__s Dr=cBSSKJn 0n/X2'UR"SU40UD6$)z Return a serialized version of the value stored at the specified key. If key does not exist a nil bulk reply is returned. For more information, see https://redis.io/commands/dump rrjDUMPrn)r7rrkrqs r:dumpBasicKeyCommands.dumps, . "##FD Set expiry only when the key has no expiry XX -> Set expiry only when the key has an existing expiry GT -> Set expiry only when the new expiry is greater than current one LT -> Set expiry only when the new expiry is less than current one For more information, see https://redis.io/commands/expire NXXXGTLTEXPIREr]datetime timedeltarI total_secondsrrKr6r7rrrrrr exp_options r:expireBasicKeyCommands.expires, dH.. / /t))+,DV   d #   d #   d #   d ###HdF:FFr=whencn[U[R5(a[UR55n[ 5nU(aUR S5 U(aUR S5 U(aUR S5 U(aUR S5 UR "SX/UQ76$)a Set an expire flag on key ``name`` with given ``option``. ``when`` can be represented as an integer indicating unix time or a Python datetime object. Valid options are: -> NX -- Set expiry only when the key has no expiry -> XX -- Set expiry only when the key has an existing expiry -> GT -- Set expiry only when the new expiry is greater than current one -> LT -- Set expiry only when the new expiry is less than current one For more information, see https://redis.io/commands/expireat rrrrEXPIREATr]rrI timestamprrKr6r7rrrrrrrs r:expireatBasicKeyCommands.expireats, dH-- . .t~~'(DV   d #   d #   d #   d ###JHZHHr=c&URSU5$)z Returns the absolute Unix timestamp (since January 1, 1970) in seconds at which the given key will expire. For more information, see https://redis.io/commands/expiretime EXPIRETIMEr5r7rs r: expiretimeBasicKeyCommands.expiretimes##L#66r=c$URSX/S9$)z} Return the value at key ``name``, or None if the key doesn't exist For more information, see https://redis.io/commands/get rMrpr5rs r:rBasicKeyCommands.get$s ##E4f#==r=c&URSU5$)z Get the value at key ``name`` and delete the key. This command is similar to GET, except for the fact that it also deletes the key on success (if and only if the key's value type is a string). For more information, see https://redis.io/commands/getdel GETDELr5rs r:getdelBasicKeyCommands.getdel,s##Hd33r=expxexatpxatpersistcX#XE1n[U5S:d[U5S:aU(a [S5e[X#XE5nU(aURS5 UR"SU/UQ76$)a~ Get the value of key and optionally set its expiration. GETEX is similar to GET, but is a write command with additional options. All time parameters can be given as datetime.timedelta or integers. ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds. ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds. ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds, specified in unix time. ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds, specified in unix time. ``persist`` remove the time to live associated with ``name``. For more information, see https://redis.io/commands/getex r-K``ex``, ``px``, ``exat``, ``pxat``, and ``persist`` are mutually exclusive.PERSISTGETEX)rrr,rKr6) r7rrrrrropset exp_optionss r:getexBasicKeyCommands.getex7sn:$ u:>SZ!^:  )=RT(P    y )##GT@K@@r=cDURU5nUbU$[U5e)zO Return the value at key ``name``, raises a KeyError if the key doesn't exist. )rKeyErrorr7rr s r: __getitem__BasicKeyCommands.__getitem__bs&   Ltnr=c&URSXU/S9$)z Returns an integer indicating the value of ``offset`` in ``name`` For more information, see https://redis.io/commands/getbit GETBITrr5)r7rrus r:getbitBasicKeyCommands.getbitls ##Hd$#HHr=c&URSXX1/S9$)z Returns the substring of the string value stored at ``key``, determined by the offsets ``start`` and ``end`` (both are inclusive) For more information, see https://redis.io/commands/getrange GETRANGErr5)r7rrarbs r:getrangeBasicKeyCommands.getrangets##JCe#LLr=c&URSX5$)a Sets the value at key ``name`` to ``value`` and returns the old value at key ``name`` atomically. As per Redis 6.2, GETSET is considered deprecated. Please use SET with GET parameter in new code. For more information, see https://redis.io/commands/getset GETSETr5rs r:getsetBasicKeyCommands.getset}s##Hd::r=c&URSX5$)z Increments the value of ``key`` by ``amount``. If no key exists, the value will be initialized as ``amount`` For more information, see https://redis.io/commands/incrby rIr5rs r:rJBasicKeyCommands.incrbyrr=c&URSX5$)z Increments the value at key ``name`` by floating ``amount``. If no key exists, the value will be initialized as ``amount`` For more information, see https://redis.io/commands/incrbyfloat INCRBYFLOATr5rs r: incrbyfloatBasicKeyCommands.incrbyfloats##M4@@r=r2c *UR"SU40UD6$)zg Returns a list of keys matching ``pattern`` For more information, see https://redis.io/commands/keys KEYSr5r7r2r8s r:rpBasicKeyCommands.keyss ##FG>v>>r= first_list second_listsrcc0XX4/nUR"S/UQ76$)z Atomically returns and removes the first/last element of a list, pushing it as the first/last element on the destination list. Returns the element being popped and pushed. For more information, see https://redis.io/commands/lmove LMOVEr5)r7rrrrsres r:lmoveBasicKeyCommands.lmoves$35##G5f55r=rc2XXEU/nUR"S/UQ76$)zX Blocking version of lmove. For more information, see https://redis.io/commands/blmove BLMOVEr5)r7rrrrrsres r:blmoveBasicKeyCommands.blmoves&3g>##H6v66r=r@crSSKJn [X5n0nU(d/XC'X$S'UR"S/UQ70UD6$)zt Returns a list of values ordered identically to ``keys`` For more information, see https://redis.io/commands/mget r)EMPTY_RESPONSErpMGET)rorr.r6)r7rpr@rrqs r:mgetBasicKeyCommands.mgetsC 0D'&(G ###F=T=W==r=mappingc|/nUR5HnURU5 M UR"S/UQ76$)z Sets key/values based on a mapping. Mapping is a dictionary of key/value pairs. Both keys and values should be strings or types that can be cast to a string via str(). For more information, see https://redis.io/commands/mset MSETrlrr6r7rrlpairs r:msetBasicKeyCommands.msets;MMOD LL $##F3U33r=c|/nUR5HnURU5 M UR"S/UQ76$)aG Sets key/values based on a mapping if none of the keys are already set. Mapping is a dictionary of key/value pairs. Both keys and values should be strings or types that can be cast to a string via str(). Returns a boolean indicating if the operation was successful. For more information, see https://redis.io/commands/msetnx MSETNXrrs r:msetnxBasicKeyCommands.msetnxs;MMOD LL $##H5u55r=dbc&URSX5$)zw Moves the key ``name`` to a different Redis database ``db`` For more information, see https://redis.io/commands/move MOVEr5)r7rr s r:moveBasicKeyCommands.moves ##FD55r=c&URSU5$)z` Removes an expiration on ``name`` For more information, see https://redis.io/commands/persist rr5rs r:rBasicKeyCommands.persists ##It44r=ct[U[R5(a[UR 5S-5n[ 5nU(aUR S5 U(aUR S5 U(aUR S5 U(aUR S5 UR"SX/UQ76$)a Set an expire flag on key ``name`` for ``time`` milliseconds with given ``option``. ``time`` can be represented by an integer or a Python timedelta object. Valid options are: NX -> Set expiry only when the key has no expiry XX -> Set expiry only when the key has an existing expiry GT -> Set expiry only when the new expiry is greater than current one LT -> Set expiry only when the new expiry is less than current one For more information, see https://redis.io/commands/pexpire rrrrPEXPIRErrs r:pexpireBasicKeyCommands.pexpires, dH.. / /t))+d23DV   d #   d #   d #   d ###ItGJGGr=ct[U[R5(a[UR5S-5n[ 5nU(aUR S5 U(aUR S5 U(aUR S5 U(aUR S5 UR "SX/UQ76$)a Set an expire flag on key ``name`` with given ``option``. ``when`` can be represented as an integer representing unix time in milliseconds (unix time * 1000) or a Python datetime object. Valid options are: NX -> Set expiry only when the key has no expiry XX -> Set expiry only when the key has an existing expiry GT -> Set expiry only when the new expiry is greater than current one LT -> Set expiry only when the new expiry is less than current one For more information, see https://redis.io/commands/pexpireat rrrrr PEXPIREATrrs r: pexpireatBasicKeyCommands.pexpireat s, dH-- . .t~~'$./DV   d #   d #   d #   d ###KIjIIr=c&URSU5$)z Returns the absolute Unix timestamp (since January 1, 1970) in milliseconds at which the given key will expire. For more information, see https://redis.io/commands/pexpiretime PEXPIRETIMEr5rs r: pexpiretimeBasicKeyCommands.pexpiretimeCs##M377r=time_msc[U[R5(a[UR 5S-5nUR SXU5$)z Set the value of key ``name`` to ``value`` that expires in ``time_ms`` milliseconds. ``time_ms`` can be represented by an integer or a Python timedelta object For more information, see https://redis.io/commands/psetex rPSETEXr]rrrIrr6)r7rrr s r:psetexBasicKeyCommands.psetexLsD gx11 2 2'//1D89G##HdUCCr=c&URSU5$)z Returns the number of milliseconds until the key ``name`` will expire For more information, see https://redis.io/commands/pttl PTTLr5rs r:pttlBasicKeyCommands.pttlXs ##FD11r=rZ withvaluesc/nUbURU5 U(aURS5 UR"SU/UQ76$)a! Return a random field from the hash value stored at key. count: if the argument is positive, return an array of distinct fields. If called with a negative count, the behavior changes and the command is allowed to return the same field multiple times. In this case, the number of returned fields is the absolute value of the specified count. withvalues: The optional WITHVALUES modifier changes the reply so it includes the respective values of the randomly selected hash fields. For more information, see https://redis.io/commands/hrandfield WITHVALUES HRANDFIELDr)r7rrZr'res r: hrandfieldBasicKeyCommands.hrandfield`sB    MM%  MM, '##L#???r=c &UR"S0UD6$)za Returns the name of a random key For more information, see https://redis.io/commands/randomkey ) RANDOMKEYr5rSs r: randomkeyBasicKeyCommands.randomkeyxrr=dstc&URSX5$)z[ Rename key ``src`` to ``dst`` For more information, see https://redis.io/commands/rename RENAMEr5r7rr1s r:renameBasicKeyCommands.renames ##Hc77r=c&URSX5$)z~ Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist For more information, see https://redis.io/commands/renamenx RENAMENXr5r4s r:renamenxBasicKeyCommands.renamenxs ##J99r=ttlabsttlidletime frequencycXU/nU(aURS5 U(aURS5 Ub,URS5 UR[U55 Ub,URS5 UR[U55 UR"S/UQ76$![a [S5ef=f![a [S5ef=f)a Create a key using the provided serialized value, previously obtained using DUMP. ``replace`` allows an existing key on ``name`` to be overridden. If it's not specified an error is raised on collision. ``absttl`` if True, specified ``ttl`` should represent an absolute Unix timestamp in milliseconds in which the key will expire. (Redis 5.0 or greater). ``idletime`` Used for eviction, this is the number of seconds the key must be idle, prior to execution. ``frequency`` Used for eviction, this is the frequency counter of the object stored at the key, prior to execution. For more information, see https://redis.io/commands/restore rABSTTLIDLETIMEzidletimemust be an integerFREQzfrequency must be an integerRESTORE)rKrIrJrr6) r7rr;r rr<r=r>res r:restoreBasicKeyCommands.restores:U#  MM) $  MM( #   MM* % > c(m,  MM& ! @ c)n-##I777 > <== > @ >?? @s B&9B?&B<?Ckeepttlrc X4X1n [U 5S:d[U 5S:aU(a [S5eU(aU(a [S5eX/n 0n U R[X4X55 U(aU R S5 U(aU R S5 U(aU R S5 U(aU R S5 S U S 'UR "S /U Q70U D6$) a Set the value at key ``name`` to ``value`` ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds. ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds. ``nx`` if set to True, set the value at key ``name`` to ``value`` only if it does not exist. ``xx`` if set to True, set the value at key ``name`` to ``value`` only if it already exists. ``keepttl`` if True, retain the time to live associated with the key. (Available since Redis 6.0) ``get`` if True, set the value at key ``name`` to ``value`` and return the old value stored at key, or None if the key did not exist. (Available since Redis 6.2) ``exat`` sets an expire flag on key ``name`` for ``ex`` seconds, specified in unix time. ``pxat`` sets an expire flag on key ``name`` for ``ex`` milliseconds, specified in unix time. For more information, see https://redis.io/commands/set rr-K``ex``, ``px``, ``exat``, ``pxat``, and ``keepttl`` are mutually exclusive.z)``nx`` and ``xx`` are mutually exclusive.KEEPTTLrrrMTrrQ)rrrr,rKr6)r7rr rrrrrFrrrrr9rqs r:rRBasicKeyCommands.setsR$ u:>SZ!^:  "GH H$(= *24>?  MM) $ MM$  MM$   MM% !GEN##E>F>g>>r=c&URX5 gr)rRrs r: __setitem__BasicKeyCommands.__setitem__ s r=cPU=(a S=(d SnURSXU5$)z Flag the ``offset`` in ``name`` as ``value``. Returns an integer indicating the previous value of ``offset``. For more information, see https://redis.io/commands/setbit r-rSETBITr5r7rrur s r:setbitBasicKeyCommands.setbit s' ! q##HdEBBr=c[U[R5(a[UR 55nUR SXU5$)z Set the value of key ``name`` to ``value`` that expires in ``time`` seconds. ``time`` can be represented by an integer or a Python timedelta object. For more information, see https://redis.io/commands/setex SETEXr )r7rrr s r:setexBasicKeyCommands.setex s? dH.. / /t))+,D##GT??r=c&URSX5$)z| Set the value of key ``name`` to ``value`` if key doesn't exist For more information, see https://redis.io/commands/setnx SETNXr5rs r:setnxBasicKeyCommands.setnx! s ##GT99r=c(URSXU5$)a Overwrite bytes in the value of ``name`` starting at ``offset`` with ``value``. If ``offset`` plus the length of ``value`` exceeds the length of the original value, the new value will be larger than before. If ``offset`` exceeds the length of the original value, null bytes will be used to pad between the end of the previous value and the start of what's being injected. Returns the length of the new string. For more information, see https://redis.io/commands/setrange SETRANGEr5rPs r:setrangeBasicKeyCommands.setrange) s##JeDDr=stringsalgoLCSvalue1value2specific_argumentridx minmatchlen withmatchlenc  S/n X;aSRU 5n [SU 35eUS;a [S5eU(aU(a [S5eXR5X#/n U(aU RS5 U(aU RS5 [ U5 U R S U/5 U(aU RS 5 UR"S /U Q7UUUUS .U D6$![ a N?f=f) a( Implements complex algorithms that operate on strings. Right now the only algorithm implemented is the LCS algorithm (longest common substring). However new algorithms could be implemented in the future. ``algo`` Right now must be LCS ``value1`` and ``value2`` Can be two strings or two keys ``specific_argument`` Specifying if the arguments to the algorithm will be keys or strings. strings is the default. ``len`` Returns just the len of the match. ``idx`` Returns the match positions in each string. ``minmatchlen`` Restrict the list of matches to the ones of a given minimal length. Can be provided only when ``idx`` set to True. ``withmatchlen`` Returns the matches with the len of the match. Can be provided only when ``idx`` set to True. For more information, see https://redis.io/commands/stralgo raz, zThe supported algorithms are: )rpr_z-specific_argument can be only keys or stringsz(len and idx cannot be provided together.sLENsIDXs MINMATCHLENs WITHMATCHLENSTRALGO)rrerfrg)joinrrDrKrIr TypeErrorr6) r7r`rbrcrdrrerfrgr8supported_algosupported_algos_strr9s r:stralgoBasicKeyCommands.stralgo8 s @   %"&))N"; <=P;7 8  MM/ *##   #%       sC&& C32C3c$URSX/S9$)zx Return the number of bytes stored in the value of ``name`` For more information, see https://redis.io/commands/strlen STRLENrr5rs r:strlenBasicKeyCommands.strlenx s ##Hd#@@r=c&URSXX1/S9$)z Return a substring of the string at key ``name``. ``start`` and ``end`` are 0-based integers specifying the portion of the string to return. SUBSTRrr5r7rrarbs r:substrBasicKeyCommands.substr s ##Hd3V#LLr=c(UR"S/UQ76$)z Alters the last access time of a key(s) ``*args``. A key is ignored if it does not exist. For more information, see https://redis.io/commands/touch TOUCHr5r<s r:touchBasicKeyCommands.touch s##G3d33r=c&URSU5$)z{ Returns the number of seconds until the key ``name`` will expire For more information, see https://redis.io/commands/ttl TTLr5rs r:r;BasicKeyCommands.ttl s ##E400r=c$URSX/S9$)z\ Returns the type of key ``name`` For more information, see https://redis.io/commands/type TYPErr5rs r:typeBasicKeyCommands.type  ##FDv#>>r=cB[R"[S55 g)z Watches the values at keys ``names``, or None if the key doesn't exist For more information, see https://redis.io/commands/watch z!Call WATCH from a Pipeline objectNwarningswarnDeprecationWarningrs r:watchBasicKeyCommands.watch s  ()LMNr=cB[R"[S55 g)zv Unwatches all previously watched keys for a transaction For more information, see https://redis.io/commands/unwatch z#Call UNWATCH from a Pipeline objectNrrs r:unwatchBasicKeyCommands.unwatch s  ()NOPr=c(UR"S/UQ76$)zl Unlink one or more keys specified by ``names`` For more information, see https://redis.io/commands/unlink UNLINKr5rs r:unlinkBasicKeyCommands.unlink s ##H5u55r=key1key2cX/nU(aURS5 U(aURS5 US:waURSU/5 U(aURS5 UR"S/UQ7SX/06$)a Find the longest common subsequence between ``key1`` and ``key2``. If ``len`` is true the length of the match will will be returned. If ``idx`` is true the match position in each strings will be returned. ``minmatchlen`` restrict the list of matches to the ones of the given ``minmatchlen``. If ``withmatchlen`` the length of the match also will be returned. For more information, see https://redis.io/commands/lcs LENIDXr MINMATCHLEN WITHMATCHLENrarprKrr6)r7rrrrerfrgr9s r:lcsBasicKeyCommands.lcs sn$  MM%  MM% !  MM=+6 7  MM. )##EFFF$FFr=rrrNFr-)FFFF)NNNNFg?r)LEFTRIGHT)FFNN)NNFFFFNN)r_FFNF)r)FFrF)Vrrrrrr#rr&rKrrIrrfrr2rirrrprvr|rrrdecrrrrr __contains__rrrrrrrrrrrrrJincrrrr%rprrr"rrrrrr rrrrr!r%r+r/r5r9rDrRrLrQrUrYr]r rnrrrwr{r;rrrrrrrr=r:r]r]s7 :$:z:i: $!" E E}Ec] E sm E  E4+/ OFG O  O#3- O  O$!% HFGH HH H ~ H  H.EsE$EtE E $!" C CC} C c] C sm C CF)- 555! 5  5  54<4<>> 44 4I 4!% $%)%))A)A W )A W  )A z" )A z" )A)A )AVI4IIIMDMM3M9M ;4 ; ;y ;<4< >z >i > 4GGZ$78 4Y 4 6ggz&9: 6y 66636965D5Y5"H"H"H  "H  "H  "H "H "HP!J!J!J  !J  !J  !J !J !JF8s8s8 D4 D' D* D22)2IN@@'}@AE@ @0;Y;8$8T8i8:D:t:"&#'080808 08  08  083-08C=08 08l!% $%)%)D?D?D? W  D? W  D?  D? D?D?D?z"D?z"D? D?LZC4CCSCYC @$ @g @j @Y @:$:z:i: ET E3 Ez Ei E(IR%)"> en> >  > !!3WV_!DE >  > > c]> >  > @A4AIAM4MM#MyM444I4111??)?ODOTOQ6T6i6$#%&',GGGd^ G d^ G c] GtnG sC~ GGr=r]c^\rSrSrS\4SjrS\4SjrS\4SjrS\S\4Sjr S\S S 4U4S jjr SU4S jjr S r U=r $)AsyncBasicKeyCommandsi rc[S5e)Nz2Async Redis client does not support class deletionrkrs r:r!AsyncBasicKeyCommands.__delitem__ sLMMr=c[S5e)Nz3Async Redis client does not support class inclusionrrs r:r"AsyncBasicKeyCommands.__contains__ MNNr=c[S5e)Nz3Async Redis client does not support class retrievalrrs r:r!AsyncBasicKeyCommands.__getitem__ rr=r c[S5e)Nz4Async Redis client does not support class assignmentrrs r:rL!AsyncBasicKeyCommands.__setitem__ sNOOr=rr3Nc&># [TU]"U6$7fr)r"r)r7rr$s r:rAsyncBasicKeyCommands.watch sw}e$$sc(># [TU]5$7fr)r"rr7r$s r:rAsyncBasicKeyCommands.unwatch sw  rr)rrrrr#rrrrrLrrrr/r0s@r:rr s`NNOOOOPPZP%$%4%!!r=rc\rSrSrSrS9S\S\\S\\ \ \ 44Sjjr S9S\S\\S\\ \ \ 44Sjjr S9S\ S \ S\\S\\ \\ \\ 44S jjrS S .S\S \S\ S\ S\\S\\ 4 SjjrS S .S\S\ S\ S\\S\\ \ \ 44 SjjrS\ S\S\\ \\ \\ 44SjrS\ S\ S\ S\ S\\ \\44 SjrS\ S\\ \\44SjrS:S\ S\\S\\ \\ \S4\\ \S444SjjrS\ S\S\\ \\44SjrS\ S\S\\ \\44S jrS\ S!\S"\S\\ \ \ 44S#jrS\ S\S\ S\\ \\44S$jrS\ S\S\ S\\ \ \ 44S%jrS\ S!\S"\S\\ \ \ 44S&jrS:S\ S\\S\\ \\ \S4\\ \S444S'jjrS\ S \ S\\ \ \ 44S(jrS\ S\S\\ \\44S)jr S\ S\ S\\ \\44S*jr!S;S\ S\ S+\\S\\S,\\S\\ \S44 S-jjr"S ListCommandsi zR Redis commands for List data type. see: https://redis.io/topics/data-types#lists rprr3clUcSn[US5nURU5 UR"S/UQ76$)a@ LPOP a value off of the first non-empty list named in the ``keys`` list. If none of the lists in ``keys`` has a value to LPOP, then block for ``timeout`` seconds, or until a value gets pushed on to one of the lists. If timeout is 0, then block indefinitely. For more information, see https://redis.io/commands/blpop NrBLPOPr.rKr6r7rprs r:blpopListCommands.blpop < ?GD$' G##G3d33r=clUcSn[US5nURU5 UR"S/UQ76$)a@ RPOP a value off of the first non-empty list named in the ``keys`` list. If none of the lists in ``keys`` has a value to RPOP, then block for ``timeout`` seconds, or until a value gets pushed on to one of the lists. If timeout is 0, then block indefinitely. For more information, see https://redis.io/commands/brpop NrBRPOPrrs r:brpopListCommands.brpop rr=rr1c2UcSnURSXU5$)a, Pop a value off the tail of ``src``, push it on the head of ``dst`` and then return it. This command blocks until a value is in ``src`` or until ``timeout`` seconds elapse, whichever is first. A ``timeout`` value of 0 blocks forever. For more information, see https://redis.io/commands/brpoplpush r BRPOPLPUSHr5)r7rr1rs r: brpoplpushListCommands.brpoplpush s# ?G##L#GDDr=r-)rZnumkeysr@ directionrZc>X/UQUPSPUPnUR"S/UQ76$)a, Pop ``count`` values (default 1) from first non-empty in the list of provided key names. When all lists are empty this command blocks the connection until another client pushes to it or until the timeout, timeout of 0 blocks indefinitely For more information, see https://redis.io/commands/blmpop COUNTBLMPOPr5)r7rrrrZr@cmd_argss r:blmpopListCommands.blmpop+ s6"GtGYGGG##H8x88r=num_keyscU/[U5-U/-nUS:waURSU/5 UR"S/UQ76$)z Pop ``count`` values (default 1) first non-empty list key from the list of args provided key names. For more information, see https://redis.io/commands/lmpop r-rLMPOP)rrr6)r7rrrZr@rs r:lmpopListCommands.lmpop@ sI:T *i[8 A: OOWe, -##G7h77r=rrc&URSXU/S9$)z Return the item from list ``name`` at position ``index`` Negative indexes are supported and will return an item at the end of the list For more information, see https://redis.io/commands/lindex LINDEXrr5)r7rrs r:lindexListCommands.lindexS s##Hd#GGr=whererefvaluer c(URSXX45$)z Insert ``value`` in list ``name`` either immediately before or after [``where``] ``refvalue`` Returns the new length of the list on success or -1 if ``refvalue`` is not in the list. For more information, see https://redis.io/commands/linsert LINSERTr5)r7rrrr s r:linsertListCommands.linsert` s##ItHLLr=c$URSX/S9$)zb Return the length of the list ``name`` For more information, see https://redis.io/commands/llen LLENrr5rs r:llenListCommands.llenn rr=NcPUbURSX5$URSU5$)aK Removes and returns the first elements of the list ``name``. By default, the command pops a single element from the beginning of the list. When provided with the optional ``count`` argument, the reply will consist of up to count elements, depending on the list's length. For more information, see https://redis.io/commands/lpop LPOPr5r7rrZs r:lpopListCommands.lpopv 0  ''< <''5 5r=valuesc*UR"SU/UQ76$)zo Push ``values`` onto the head of the list ``name`` For more information, see https://redis.io/commands/lpush LPUSHr5r7rrs r:lpushListCommands.lpush  ##GT;F;;r=c*UR"SU/UQ76$)z Push ``value`` onto the head of the list ``name`` if ``name`` exists For more information, see https://redis.io/commands/lpushx LPUSHXr5rs r:lpushxListCommands.lpushx  ##Hd 0: Remove elements equal to value moving from head to tail. count < 0: Remove elements equal to value moving from tail to head. count = 0: Remove all elements equal to value. For more information, see https://redis.io/commands/lrem LREMr5)r7rrZr s r:lremListCommands.lrem s##FD??r=c(URSXU5$)zr Set element at ``index`` of list ``name`` to ``value`` For more information, see https://redis.io/commands/lset LSETr5)r7rrr s r:lsetListCommands.lset s ##FD??r=c(URSXU5$)z Trim the list ``name``, removing all values not within the slice between ``start`` and ``end`` ``start`` and ``end`` can be negative numbers just like Python slicing notation For more information, see https://redis.io/commands/ltrim LTRIMr5rvs r:ltrimListCommands.ltrim s##GT#>>r=cPUbURSX5$URSU5$)aD Removes and returns the last elements of the list ``name``. By default, the command pops a single element from the end of the list. When provided with the optional ``count`` argument, the reply will consist of up to count elements, depending on the list's length. For more information, see https://redis.io/commands/rpop RPOPr5rs r:rpopListCommands.rpop rr=c&URSX5$)z RPOP a value off of the ``src`` list and atomically LPUSH it on to the ``dst`` list. Returns the value. For more information, see https://redis.io/commands/rpoplpush RPOPLPUSHr5r4s r: rpoplpushListCommands.rpoplpush s##K::r=c*UR"SU/UQ76$)zo Push ``values`` onto the tail of the list ``name`` For more information, see https://redis.io/commands/rpush RPUSHr5rs r:rpushListCommands.rpush rr=c*UR"SU/UQ76$)z Push ``value`` onto the tail of the list ``name`` if ``name`` exists For more information, see https://redis.io/commands/rpushx RPUSHXr5rs r:rpushxListCommands.rpushx rr=rankmaxlencX/nUbURSU/5 UbURSU/5 UbURSU/5 UR"S/UQ7SU/06$)a Get position of ``value`` within the list ``name`` If specified, ``rank`` indicates the "rank" of the first element to return in case there are multiple copies of ``value`` in the list. By default, LPOS returns the position of the first occurrence of ``value`` in the list. When ``rank`` 2, LPOS returns the position of the second ``value`` in the list. If ``rank`` is negative, LPOS searches the list in reverse. For example, -1 would return the position of the last occurrence of ``value`` and -2 would return the position of the next to last occurrence of ``value``. If specified, ``count`` indicates that LPOS should return a list of up to ``count`` positions. A ``count`` of 2 would return a list of up to 2 positions. A ``count`` of 0 returns a list of all positions matching ``value``. When ``count`` is specified and but ``value`` does not exist in the list, an empty list is returned. If specified, ``maxlen`` indicates the maximum number of list elements to scan. A ``maxlen`` of 1000 will only return the position(s) of items within the first 1000 entries in the list. A ``maxlen`` of 0 (the default) will scan the entire list. For more information, see https://redis.io/commands/lpos RANKrMAXLENLPOSrpro)r7rr rrZrr9s r:lposListCommands.lpos smB%)=   MM64. )   MM7E* +   MM8V, -##FAVA4&AAr=rbyrdescalphastoregroupsc UbUbUbUc [S5eU/n UbU RSU/5 UbUbU RSX#/5 UbK[U[[45(aU RSU/5 OUHn U RSU /5 M U(aU R S5 U(aU R S5 UbU RSU/5 U (a<U(a*[U[[45(d[ U5S :a [S 5eS U (a [ U5OS0n U/U S 'UR"S /U Q70U D6$)aZ Sort and return the list, set or sorted set at ``name``. ``start`` and ``num`` allow for paging through the sorted data ``by`` allows using an external key to weight and sort the items. Use an "*" to indicate where in the key the item value is located ``get`` allows for returning items from external keys rather than the sorted data itself. Use an "*" to indicate where in the key the item value is located ``desc`` allows for reversing the sort ``alpha`` allows for sorting lexicographically rather than numerically ``store`` allows for storing the result of the sort into the key ``store`` ``groups`` if set to True and if ``get`` contains at least two elements, sort will return a list of tuples, each containing the values fetched from the arguments to ``get``. For more information, see https://redis.io/commands/sort N,``start`` and ``num`` must both be specifiedsBYLIMITsGETDESCsALPHASTORErzVwhen using "groups" the "get" argument must be specified and contain at least two keysr"rpSORT)rrr]bytesrrKrr6) r7rrarrrrr r!r"r9grqs r:sortListCommands.sort s=J  #+3?u}JK K$(6 > MM5"+ &   MM8U0 1 ? #s|,, vsm,AMM61+.  MM' "  MM( #   MM8U+ , *S5#,773s8a< SXT:&##F?V?w??r=rc &URXX4XVUS9$)a Returns the elements contained in the list, set or sorted set at key. (read-only variant of the SORT command) ``start`` and ``num`` allow for paging through the sorted data ``by`` allows using an external key to weight and sort the items. Use an "*" to indicate where in the key the item value is located ``get`` allows for returning items from external keys rather than the sorted data itself. Use an "*" to indicate where in the key the item value is located ``desc`` allows for reversing the sort ``alpha`` allows for sorting lexicographically rather than numerically For more information, see https://redis.io/commands/sort_ro )rarrrrr )r+)r7rrarrrrr s r:sort_roListCommands.sort_roi s#:yy ##  r=rrrr)NNNNFFNF)NNNNFF)'rrrrrr rr$rrrrrrrrrIrrrrrrr rrrrrrrr rrrrr+r.rrr=r:rr s 7844#+F#34 y$ %4,7844#+F#34 y$ %4,?@EE E+3F+;E y#'#6 7E. ! 999 9  9 } 9 $94 ! 888 8 } 8 y$ % 8& H H # H y#'#6 7 H M M # M/2 M;> M y~s" # M??y~s':!;? $66}6 ysD$/0%T42HH I 6&<#<<539L3M<=3==E)C.#:M4N= M3 Ms M MyPT?T9U M @ @S @ @y~s?R9S @@@S@@y~s?R9S@ ?# ?c ? ?inc>Q8R ? $66}6 ysD$/0%T42HH I 6&;S;s;uYs^S5H/I;<#<<539L3M<=3==y~s7J1K=## $ +B+B+Bsm +B } +B  +B sD$ +B` $! #'#!&G@G@}G@c] G@ SM G@ d3i G@G@G@}G@G@ tSy G@X $! #'  } c]  SM  d3i       r=rc \rSrSrSrSS\S\\S4S\\S\\ S \ 4 S jjr SS\\S4S\\S\\ S \ 4S jjr SS \S\S\\S4S\\S \ 4 S jjrSS \S\\S4S\\S \ 4SjjrSS \S\S\\S4S\\S\\S4S \ 4 SjjrSS \ S\\S4S\\S\\S4S \ 4 SjjrSSS\4S \S\S\\S4S\\S\\\4S \ 4 SjjrSS\4S \S\\S4S\\S\\\4S \ 4 SjjrSrg) ScanCommandsi z: Redis SCAN commands. see: https://redis.io/commands/scan rNcursormatchrZrr3c U/nUbURSU/5 UbURSU/5 UbURSU/5 UR"S/UQ70UD6$)a Incrementally return lists of key names. Also return a cursor indicating the scan position. ``match`` allows for filtering the keys by pattern ``count`` provides a hint to Redis about the number of keys to return per batch. ``_type`` filters the returned values by a particular Redis type. Stock Redis instances allow for the following types: HASH, LIST, SET, STREAM, STRING, ZSET Additionally, Redis modules can expose other types as well. For more information, see https://redis.io/commands/scan MATCHCOUNTrSCANro)r7r3r4rZrr8r9s r:scanScanCommands.scan sk0%+8   MM8U+ ,   MM8U+ ,   MM7E* +##F>V>v>>r=c+t# SnUS:wa*UR"SXQX#S.UD6upVUShvN US:waM)ggN7fa Make an iterator using the SCAN command so that the client doesn't need to remember the cursor position. ``match`` allows for filtering the keys by pattern ``count`` provides a hint to Redis about the number of keys to return per batch. ``_type`` filters the returned values by a particular Redis type. Stock Redis instances allow for the following types: HASH, LIST, SET, STREAM, STRING, ZSET Additionally, Redis modules can expose other types as well. 0r)r3r4rZrNrr9)r7r4rZrr8r3datas r: scan_iterScanCommands.scan_iter sL*k99%HNLFOO k s%86 88rcX/nUbURSU/5 UbURSU/5 UR"S/UQ76$)a  Incrementally return lists of elements in a set. Also return a cursor indicating the scan position. ``match`` allows for filtering the keys by pattern ``count`` allows for hint the minimum number of returns For more information, see https://redis.io/commands/sscan r6r7SSCANro)r7rr3r4rZr9s r:sscanScanCommands.sscan sO"%)>   MM8U+ ,   MM8U+ ,##G5f55r=c#j# SnUS:wa%URXX#S9upEUShvN US:waM$ggN7fz Make an iterator using the SSCAN command so that the client doesn't need to remember the cursor position. ``match`` allows for filtering the keys by pattern ``count`` allows for hint the minimum number of returns r=r)r3r4rZNrD)r7rr4rZr3r?s r: sscan_iterScanCommands.sscan_iter s:k::d:TLFOOk s 31 33 no_valuescX/nUbURSU/5 UbURSU/5 UbURS/5 UR"S/UQ7SU06$)aO Incrementally return key/value slices in a hash. Also return a cursor indicating the scan position. ``match`` allows for filtering the keys by pattern ``count`` allows for hint the minimum number of returns ``no_values`` indicates to return only the keys, without values. For more information, see https://redis.io/commands/hscan r6r7sNOVALUESHSCANrKro)r7rr3r4rZrKr9s r:hscanScanCommands.hscan sh(%)>   MM8U+ ,   MM8U+ ,  MM;- (##GJfJ JJr=c## SnUS:waFURXX#US9upVU(a UShvN OUR5ShvN US:waMEggN'N7fa Make an iterator using the HSCAN command so that the client doesn't need to remember the cursor position. ``match`` allows for filtering the keys by pattern ``count`` allows for hint the minimum number of returns ``no_values`` indicates to return only the keys, without values r=r)r3r4rZrKNrNrl)r7rr4rZrKr3r?s r: hscan_iterScanCommands.hscan_iter s["k::5&LF::<''k  's'(AAAA AAAscore_cast_funccX/nUbURSU/5 UbURSU/5 SU0nUR"S/UQ70UD6$)aX Incrementally return lists of elements in a sorted set. Also return a cursor indicating the scan position. ``match`` allows for filtering the keys by pattern ``count`` allows for hint the minimum number of returns ``score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zscan r6r7rUZSCANro)r7rr3r4rZrUr9rqs r:zscanScanCommands.zscan4 s^(   MM8U+ ,   MM8U+ ,$o6##G@f@@@r=c#p# SnUS:wa(URUUUUUS9upVUShvN US:waM'ggN7fa Make an iterator using the ZSCAN command so that the client doesn't need to remember the cursor position. ``match`` allows for filtering the keys by pattern ``count`` allows for hint the minimum number of returns ``score_cast_func`` a callable used to cast the score return value r=r)r3r4rZrUNrX)r7rr4rZrUr3r?s r: zscan_iterScanCommands.zscan_iterP sN"k:: / &LFOOk s#64 66r)rNNNr)rNNr)rrrrrrIrr%rrr&r9r r@r#rDrIrrNrSrrrrXr]rrr=r:r2r2 s'+## ??Xt^$?} ? } ? ?F(,## Xt^$}}   >'+# 666Xt^$ 6 } 6  66(,# Xt^$}   ,'+#'+ KKKXt^$ K } K t$ K K@(,#'+ ((Xt^$(} ( t$ (  (<'+#16 AAAXt^$ A } A tX~. A A>(,#16 Xt^$}  tX~.   r=r2c \rSrSrSS\\S4S\\S\\S\ 4Sjjr SS\ S\\S4S\\S\ 4S jjr SS\S\\S4S\\S \\ S4S\ 4 S jjrSS\4S\ S\\S4S\\S \\\4S\ 4 S jjrSrg)AsyncScanCommandsim Nr4rZrr3c # SnUS:wa6UR"SXQX#S.UD6IShvN upVUHnU7v M US:waM5ggN7fr<r>)r7r4rZrr8r3r?ds r:r@AsyncScanCommands.scan_itern sY*k!%"%"HN"LF ks!AAAArc# SnUS:wa1URXX#S9IShvN upEUHnU7v M US:waM0ggN7frGrH)r7rr4rZr3r?rbs r:rIAsyncScanCommands.sscan_iter sQk!%5","LF ks?=??rKc# SnUS:waVURXX#US9IShvN upVU(aUHnU7v M OUR5HnU7v M US:waMUggNB7frQrR)r7rr4rZrKr3r?its r:rSAsyncScanCommands.hscan_iter sm"k!%5","LFBH**,BH'ksA$A">A$ A$rUc# SnUS:wa4URUUUUUS9IShvN upVUHnU7v M US:waM3ggN7fr[r\)r7rr4rZrUr3r?rbs r:r]AsyncScanCommands.zscan_iter s["k!% / ","LFksAAAArrr)rrrrrr%rrIrrr@r#rIrrSrrrr]rrr=r:r`r`m s<(,## Xt^$}}   @(,# Xt^$}   2(,#'+ Xt^$}  t$   @(,#16 Xt^$}  tX~.   r=r`c\rSrSrSrS\S\S\\\ \ 44Sjr S\S\\\ \ 44Sjr S\ S \ S\\\ \ 44S jrS \S\ S \ S\\\ \ 44S jrS\ S \ S\\\ \ 44S jrS$S\ S\ \S\ S\\\ \ 44SjjrS \S\ S \ S\\\ \ 44SjrS\S\S\\\\S\S4\\S\S444SjrS\S\\\\44SjrS\S\ S \ S\\\ \\S\S4\ \\S\S444SjrS\S\S\S\\\\44SjrS%S\S\\ S\\\ S44SjjrS%S\S\\ S\\\ S44SjjrS\S\S\\\ \ 44S jrS\ S \ S\\\ \ 44S!jrS \S\ S \ S\\\ \ 44S"jr S#r!g)& SetCommandsi zP Redis commands for Set data type. see: https://redis.io/topics/data-types#sets rrr3c*UR"SU/UQ76$)z\ Add ``value(s)`` to set ``name`` For more information, see https://redis.io/commands/sadd SADDr5rs r:saddSetCommands.sadd  ##FD:6::r=c$URSX/S9$)zj Return the number of elements in set ``name`` For more information, see https://redis.io/commands/scard SCARDrr5rs r:scardSetCommands.scard  ##GT#??r=rpr@cD[X5nUR"S/UQ7SU06$)zp Return the difference of sets specified by ``keys`` For more information, see https://redis.io/commands/sdiff SDIFFrpr.r6r7rpr@s r:sdiffSetCommands.sdiff s) D'##G>d>>>r=rsc@[X#5nUR"SU/UQ76$)z Store the difference of sets specified by ``keys`` into a new set named ``dest``. Returns the number of keys in the new set. For more information, see https://redis.io/commands/sdiffstore SDIFFSTOREryr7rsrpr@s r: sdiffstoreSetCommands.sdiffstore s&D'##L$>>>r=cD[X5nUR"S/UQ7SU06$)zs Return the intersection of sets specified by ``keys`` For more information, see https://redis.io/commands/sinter SINTERrpryrzs r:sinterSetCommands.sinter ) D'##H?t?$??r=rrlimitc@U/UQSPUPnUR"S/UQ7SU06$)aU Return the cardinality of the intersect of multiple sets specified by ``keys``. When LIMIT provided (defaults to 0 and means unlimited), if the intersection cardinality reaches limit partway through the computation, the algorithm will exit and yield limit as the cardinality For more information, see https://redis.io/commands/sintercard LIMIT SINTERCARDrpr5r7rrprr@s r: sintercardSetCommands.sintercard 6/$///##LC4CdCCr=c@[X#5nUR"SU/UQ76$)z Store the intersection of sets specified by ``keys`` into a new set named ``dest``. Returns the number of keys in the new set. For more information, see https://redis.io/commands/sinterstore SINTERSTOREryrs r: sinterstoreSetCommands.sinterstore &D'##M4?$??r=r r-c&URSXU/S9$)z Return whether ``value`` is a member of set ``name``: - 1 if the value is a member of the set. - 0 if the value is not a member of the set or if key does not exist. For more information, see https://redis.io/commands/sismember SISMEMBERrr5rs r: sismemberSetCommands.sismember+ s##KD6#JJr=c$URSX/S9$)zf Return all members of the set ``name`` For more information, see https://redis.io/commands/smembers SMEMBERSrr5rs r:smembersSetCommands.smembers7 s ##J6#BBr=cH[X#5nUR"SU/UQ7SU/06$)a) Return whether each value in ``values`` is a member of the set ``name`` as a list of ``int`` in the order of ``values``: - 1 if the value is a member of the set. - 0 if the value is not a member of the set or if key does not exist. For more information, see https://redis.io/commands/smismember SMISMEMBERrpry)r7rrr@s r: smismemberSetCommands.smismember? s-F)##L$KKTFKKr=rr1c(URSXU5$)zv Move ``value`` from set ``src`` to set ``dst`` atomically For more information, see https://redis.io/commands/smove SMOVEr5)r7rr1r s r:smoveSetCommands.smoveP s ##GSu==r=NrZcXUSL=(a U/=(d /nUR"SU/UQ76$)zm Remove and return a random member of set ``name`` For more information, see https://redis.io/commands/spop NSPOPr5)r7rrZr@s r:spopSetCommands.spopX s2 T!.w4"##FD8488r=numbercXUSL=(a U/=(d /nUR"SU/UQ76$)a If ``number`` is None, returns a random member of set ``name``. If ``number`` is supplied, returns a list of ``number`` random members of set ``name``. Note this is only available when running Redis 2.6+. For more information, see https://redis.io/commands/srandmember N SRANDMEMBERr5)r7rrr@s r: srandmemberSetCommands.srandmembera s2d"06B##M4?$??r=c*UR"SU/UQ76$)z_ Remove ``values`` from set ``name`` For more information, see https://redis.io/commands/srem SREMr5rs r:sremSetCommands.sremp rqr=cD[X5nUR"S/UQ7SU06$)zl Return the union of sets specified by ``keys`` For more information, see https://redis.io/commands/sunion SUNIONrpryrzs r:sunionSetCommands.sunionx rr=c@[X#5nUR"SU/UQ76$)z Store the union of sets specified by ``keys`` into a new set named ``dest``. Returns the number of keys in the new set. For more information, see https://redis.io/commands/sunionstore SUNIONSTOREryrs r: sunionstoreSetCommands.sunionstore rr=rr0r)"rrrrrr#r rrrIrortr rr{rrrrrr rrrrrrrrrrrrrrr=r:rlrl sT ;;;539L3M;@$@53)<#=@?$?t?iot6K0L? ? ?# ?,0 ? y~s" # ?@4@@y7L1M@<= D D"&t* D58 D y~s" # D @ @ $ @-1 @ y~s" # @ K K!$ K ywqz71:567wqz7ST:?U9VV W KCTCeIcNC,?&@CLL"&L/3L $uWQZ3456 U71:wqz) *+ - L">>D>>yPT?T9U>99hsm9uS$PT_?U937 @ @"*3- @ sD$  @;;;539L3M;@4@@y7L1M@ @ @ $ @-1 @ y~s" # @r=rlc4\rSrSrSrS\S\S\S\4Sjr SS .S\S\S\S \ S S\4 S jjr S=S\S\ \ \4S\S\\S\S\S\\S 4S\\S \\ S S\4SjjrS>S\S\S\S\S\S\\S\S\4SjjrS?S\S\S\S\S\\\\\4S\\S\\S\\S \S\S\4S!jjrS\S\S\4S"jrSS .S\S\S \ S S\4S#jjrS@S\S\S\S$\S%\\S\4 S&jjrS\S\S\S\4S'jrS\S\S\4S(jrS\S\S\S\4S)jrSAS\S\S\S%\\S\4 S*jjrS\S\S\4S+jr S\S\4S,jr!SBS\S-\S\4S.jjr"S\S\4S/jr#S\S\S\4S0jr$SCS\S\S1\S2\S\S\\S 4S\\S\4S3jjr%SDS\S1\S2\S\\S\4 S4jjr&SCS5\ \\4S\\S6\\S\4S7jjr'SES\(S\(S5\ \\4S\\S6\\S8\S\4S9jjr)SFS\S2\S1\S\\S\4 S:jjr*SGS\S\\S\S\\S 4S\\S \\ S S\4S;jjr+S$&  %"3VW W  !j8V&VTU U  fc**fqj JKK MM) $ d# MM#f+ &   MM( # d# MM%   MM8U+ ,  MM- (  ! MM* % b&$''3v;!+;BC CLLND MM$ ###FD:6::r= consumername min_idle_timestart_idrZjustidcJ[U5S:a [S5e0nXX4U/n [U5S:a [S5eU RSU/5 U(aU R S5 SUS'UR "S/U Q70UD6$![a Ntf=f![a NOf=f) aD Transfers ownership of pending stream entries that match the specified criteria. Conceptually, equivalent to calling XPENDING and then XCLAIM, but provides a more straightforward way to deal with message delivery failures via SCAN-like semantics. name: name of the stream. groupname: name of the consumer group. consumername: name of a consumer that claims the message. min_idle_time: filter messages that were idle less than this amount of milliseconds. start_id: filter messages with equal or greater ID. count: optional integer, upper limit of the number of entries that the command attempts to claim. Set to 100 by default. justid: optional boolean, false by default. Return just an array of IDs of messages successfully claimed, without returning the actual message For more information, see https://redis.io/commands/xautoclaim rz6XAUTOCLAIM min_idle_time must be a nonnegative integer%XPENDING count must be a integer >= 0r7JUSTIDT parse_justid XAUTOCLAIM)rIrrkrrKr6) r7rrrrrrZrr8r9s r: xautoclaimStreamCommands.xautoclaim s8 =!A%L&<I 5zA~ GHH MM8U+ ,  MM) $%)F> "##LD6DVDD!      s"B-B BB B"!B" message_idsidler retrycountrzc [U[5(aUS:a [S5e[U[[45(aU(d [S5e0n XU[ U5/n U R [U55 Ub<[U[5(d [S5eU R S[ U545 Ub<[U[5(d [S5eU R S[ U545 Ub<[U[5(d [S5eU R S [ U545 U (a1[U [5(d [S 5eU RS 5 U (a6[U [5(d [S 5eU RS 5 SU S'UR"S/U Q70U D6$)aH Changes the ownership of a pending message. name: name of the stream. groupname: name of the consumer group. consumername: name of a consumer that claims the message. min_idle_time: filter messages that were idle less than this amount of milliseconds message_ids: non-empty list or tuple of message IDs to claim idle: optional. Set the idle time (last time it was delivered) of the message in ms time: optional integer. This is the same as idle but instead of a relative amount of milliseconds, it sets the idle time to a specific Unix time (in milliseconds). retrycount: optional integer. set the retry counter to the specified value. This counter is incremented every time a message is delivered again. force: optional boolean, false by default. Creates the pending message entry in the PEL even if certain specified IDs are not already in the PEL assigned to a different client. justid: optional boolean, false by default. Return just an array of IDs of messages successfully claimed, without returning the actual message For more information, see https://redis.io/commands/xclaim rz3XCLAIM min_idle_time must be a non negative integerzLXCLAIM message_ids must be a non empty list or tuple of message IDs to claimzXCLAIM idle must be an integersIDLEzXCLAIM time must be an integersTIMEz$XCLAIM retrycount must be an integers RETRYCOUNTzXCLAIM force must be a booleansFORCEzXCLAIM justid must be a booleanrTrXCLAIM) r]rIrrtuplerrrrKr6) r7rrrrrrrrrzrr8r9s r:xclaimStreamCommands.xclaim,s^---1BQR R+e}55[0  $(\3}CU#V d;'(  dC(( @AA MM7CI. /  dC(( @AA MM7CI. /  !j#.. FGG MM=#j/: ; eT** @AA MM( # fd++ ABB MM) $%)F> "##H@v@@@r=c*UR"SU/UQ76$)z Deletes one or more messages from a stream. Args: name: name of the stream. *ids: message ids to delete. For more information, see https://redis.io/commands/xdel XDELr5)r7rrs r:xdelStreamCommands.xdels##FD7377r=cU(d [S5eUS;a [S5eXS[U5/nURU5 UR"S/UQ76$)zv Extended version of XDEL that provides more control over how message entries are deleted concerning consumer groups. z'XDELEX requires at least one message IDrz8XDELEX ref_policy must be one of: KEEPREF, DELREF, ACKEDrXDELEXr)r7rrrr9s r:xdelexStreamCommands.xdelexsZEF F ; ;VW WE3s84 c##H6v66r=mkstream entries_readcSXU/nU(aURS5 UbURSU/5 UR"U6$)a Create a new consumer group associated with a stream. name: name of the stream. groupname: name of the consumer group. id: ID of the last item in the stream to consider already delivered. For more information, see https://redis.io/commands/xgroup-create z XGROUP CREATEsMKSTREAM ENTRIESREADr)r7rrrrrr9s r: xgroup_createStreamCommands.xgroup_createsG %4Tb#I  MM+ &  # MM=,7 8##V,,r=c(URSXU5$)a9 Remove a specific consumer from a consumer group. Returns the number of pending messages that the consumer had before it was deleted. name: name of the stream. groupname: name of the consumer group. consumername: name of consumer to delete For more information, see https://redis.io/commands/xgroup-delconsumer zXGROUP DELCONSUMERr5r7rrrs r:xgroup_delconsumer!StreamCommands.xgroup_delconsumers##$8$<XXr=c&URSX5$)z Destroy a consumer group. name: name of the stream. groupname: name of the consumer group. For more information, see https://redis.io/commands/xgroup-destroy zXGROUP DESTROYr5r7rrs r:xgroup_destroyStreamCommands.xgroup_destroys##$4dFFr=c(URSXU5$)aD Consumers in a consumer group are auto-created every time a new consumer name is mentioned by some command. They can be explicitly created by using this command. name: name of the stream. groupname: name of the consumer group. consumername: name of consumer to create. See: https://redis.io/commands/xgroup-createconsumer zXGROUP CREATECONSUMERr5rs r:xgroup_createconsumer$StreamCommands.xgroup_createconsumers## #Tl  r=c\XU/nUbURSU/5 UR"S/UQ76$)a Set the consumer group last delivered ID to something else. name: name of the stream. groupname: name of the consumer group. id: ID of the last item in the stream to consider already delivered. For more information, see https://redis.io/commands/xgroup-setid rz XGROUP SETIDro)r7rrrrr9s r: xgroup_setidStreamCommands.xgroup_setids;2&  # MM=,7 8##N= 0IDLErr parse_detailT)rrrIrrkrKr6) r7rrrrrZrrr9s r:xpending_rangeStreamCommands.xpending_range)s, e  &<#;: ==1 1" ;#+9   4y1} FGG MM64. ) 5zA~ GHH MM3U+ ,  MM, '##JKKdKK      s$-C 2-C CC C*)C*cX#/nUbQ[U[5(aUS:a [S5eURS5 UR[ U55 UR "SU/UQ7SU/06$)a{ Read stream values within an interval. name: name of the stream. start: first stream ID. defaults to '-', meaning the earliest available. finish: last stream ID. defaults to '+', meaning the latest available. count: if set, only return this many items, beginning with the earliest available. For more information, see https://redis.io/commands/xrange r-z'XRANGE count must be a positive integerr7XRANGErpr]rIrrKrr6)r7rrrrZr9s r:xrangeStreamCommands.xrangebsk.  eS))UQY IJJ MM( # MM#e* %##HdIVI4&IIr=streamsblockcv/nUbQ[U[5(aUS:a [S5eURS5 UR[ U55 UbQ[U[5(aUS:a [S5eURS5 UR[ U55 [U[ 5(a[ U5S:Xa [S5eURS5 [UR56upVURU5 URU5 UR"S /UQ7S U06$) at Block and monitor multiple streams for new data. streams: a dict of stream names to stream IDs, where IDs indicate the last ID already seen. count: if set, only return this many items, beginning with the earliest available. block: number of milliseconds to wait, if nothing already present. For more information, see https://redis.io/commands/xread rz*XREAD block must be a non-negative integerBLOCKr-z&XREAD count must be a positive integerr7z&XREAD streams must be a non empty dictSTREAMSXREADrp) r]rIrrKrrrziprlrr6)r7r%rZr&r9rprs r:xreadStreamCommands.xreads&  eS))UQY LMM MM( # MM#e* %  eS))UQY HII MM( # MM#e* %'4((CLA,=DE E j!GMMO,  d f##G@f@4@@r=noackcSX/nUbQ[U[5(aUS:a [S5eURS5 UR[ U55 UbQ[U[5(aUS:a [S5eURS5 UR[ U55 U(aURS5 [U[ 5(a[ U5S:Xa [S 5eURS 5 URUR55 URUR55 UR"S /UQ76$) a Read from a stream via a consumer group. groupname: name of the consumer group. consumername: name of the requesting consumer. streams: a dict of stream names to stream IDs, where IDs indicate the last ID already seen. count: if set, only return this many items, beginning with the earliest available. block: number of milliseconds to wait, if nothing already present. noack: do not add messages to the PEL For more information, see https://redis.io/commands/xreadgroup sGROUPr-z+XREADGROUP count must be a positive integerr7rz/XREADGROUP block must be a non-negative integerr(sNOACKz+XREADGROUP streams must be a non empty dictr) XREADGROUP) r]rIrrKrrrrrprr6)r7rrr%rZr&r.r9s r: xreadgroupStreamCommands.xreadgroups 6%-i#F  eS))UQY MNN MM( # MM#e* %  eS))UQY QRR MM( # MM#e* %  MM( #'4((CLA,=IJ J j! glln% gnn&'##L:6::r=cX#/nUbQ[U[5(aUS:a [S5eURS5 UR[ U55 UR "SU/UQ7SU/06$)a Read stream values within an interval, in reverse order. name: name of the stream start: first stream ID. defaults to '+', meaning the latest available. finish: last stream ID. defaults to '-', meaning the earliest available. count: if set, only return this many items, beginning with the latest available. For more information, see https://redis.io/commands/xrevrange r-z*XREVRANGE count must be a positive integerr7 XREVRANGErpr")r7rrrrZr9s r: xrevrangeStreamCommands.xrevrangesk.%(:  eS))UQY LMM MM( # MM#e* %##KLLdVLLr=c/nUbUb [S5eUcUc [S5eUbUS;a [S5eUbURS5 UbURS5 U(aURS5 UbURU5 UbURU5 Ub"URS5 URU5 UbURU5 UR"S U/UQ76$) a Trims old messages from a stream. name: name of the stream. maxlen: truncate old stream messages beyond this size Can't be specified with minid. approximate: actual stream length may be slightly more than maxlen minid: the minimum id in the stream to query Can't be specified with maxlen. limit: specifies the maximum number of entries to retrieve ref_policy: optional reference policy for consumer groups: - KEEPREF (default): Trims entries but preserves references in consumer groups' PEL - DELREF: Trims entries and removes all references from consumer groups' PEL - ACKED: Only trims entries that were read and acknowledged by all consumer groups For more information, see https://redis.io/commands/xtrim z4Only one of ``maxlen`` or ``minid`` may be specifiedz0One of ``maxlen`` or ``minid`` must be specifiedrz7XTRIM ref_policy must be one of: KEEPREF, DELREF, ACKEDrrr|r%XTRIMr{)r7rrrrrrr9s r:xtrimStreamCommands.xtrims2$&  %"3RS S >emNO O  !j8V&VUV V   MM) $   MM( #  MM$    MM& !   MM%   MM( # MM%  ! MM* %##GT;F;;r=r)rNTFNNN)z0-0NF)NNNFF)$FNrrr)-+N)NNF)r=r<N)NTNNN)-rrrrrr#r!r(r&rr rr r rrrIrrrrrr rrrrrrrrrrr rrrrr#r,rr1r5r9rrr=r:rr s6 C C& C Ci C$=F 888 8 89 8  84 $  (,#FJ=;=;VZ'(=;  =;  =;  =;=;Y_%=;}=;W%ABC=; =;J$#1E1E1E 1E  1E  1E}1E1E 1Et#"$(QAQAQA QA  QA 4 ?E),<<= QAsmQAsmQASMQAQAQA QAf 8 8Y 89 8 =F 77789 7  70&* ---  -  - sm - -0 Y Y%+ Y;D Y  YG4GFGyG  %+ ;D  ,'+ ===  = sm =  =(HDHVH H::): H HT Hi H??)?NTNfNN"04"7L7L7L 7L  7L  7LItO,7Lsm7L 7Lx# JJJ J } J  JF $# $AdIo&$A}$A} $A  $AV $#-;-;-;dIo& -; } -; } -;-; -;d# MMM M } M  MF!% (,#FJ3<3< 3< 3< Y_% 3< } 3<W%ABC3< 3<3jjr2S\S?\3S \ 4S@jr4S\S\S\S \ 4SAjr5S\S\S\S \ 4SBjr6S\S\ S\ S \ 4SCjr7S\4S\S\S=\ S2\\(\)4S \ 4 SDjjr8S\S\S \ 4SEjr9SS\4S\\\\\\44S\\S\ S2\\(\)4S \ 4 SFjjr:SPS\S\\\\\\44S\\S \ 4SGjjr;S%\SH\\S \ 4SIjr<SPSJ\S\\S4S\\\\\\44S\\S \ 4 SKjjr=SLr>g)USortedSetCommandsi0zk Redis commands for Sorted Sets data type. see: https://redis.io/topics/data-types-intro#redis-sorted-sets Frrrrchrrrr3c U(d [S5eU(aU(a [S5eU(aU(a [S5eU(a[U5S:wa [S5eU(aU(dU(a [S5e/n 0n U(aU RS5 U(aU RS5 U(aU RS 5 U(aU RS 5 S U S 'U(aU RS 5 U(aU RS5 UR5H+n U RU S5 U RU S5 M- UR"SU/U Q70U D6$)a  Set any number of element-name, score pairs to the key ``name``. Pairs are specified as a dict of element-names keys to score values. ``nx`` forces ZADD to only create new elements and not to update scores for elements that already exist. ``xx`` forces ZADD to only update scores of elements that already exist. New elements will not be added. ``ch`` modifies the return value to be the numbers of elements changed. Changed elements include new elements that were added and elements whose scores changed. ``incr`` modifies ZADD to behave like ZINCRBY. In this mode only a single element/score pair can be specified and the score is the amount the existing score will be incremented by. When using this mode the return value of ZADD will be the new score of the element. ``lt`` only updates existing elements if the new score is less than the current score. This flag doesn't prevent adding new elements. ``gt`` only updates existing elements if the new score is greater than the current score. This flag doesn't prevent adding new elements. The return value of ZADD varies based on the mode specified. With no options, ZADD returns the number of new elements added to the sorted set. ``nx``, ``lt``, and ``gt`` are mutually exclusive options. See: https://redis.io/commands/ZADD z-ZADD requires at least one element/score pairz)ZADD allows either 'nx' or 'xx', not bothz)ZADD allows either 'gt' or 'lt', not bothr-zFZADD option 'incr' only works when passing a single element/score pairz/Only one of 'nx', 'lt', or 'gr' may be defined.sNXsXXsCHsINCRTas_scoresGTsLTrZADD)rrrKrlr6) r7rrrrr@rrrr9rqrs r:zaddSortedSetCommands.zadd6s&XKL L "GH H "GH H CLA%X  2MN N#% MM% MM% MM%  MM' ""&GJ  MM% MM% MMOD MM$q' " MM$q' "$##FDE6EWEEr=c$URSX/S9$)zu Return the number of elements in the sorted set ``name`` For more information, see https://redis.io/commands/zcard ZCARDrr5rs r:zcardSortedSetCommands.zcardrvr=rrc&URSXX1/S9$)z Returns the number of elements in the sorted set at key ``name`` with a score between ``min`` and ``max``. For more information, see https://redis.io/commands/zcount ZCOUNTrr5r7rrrs r:zcountSortedSetCommands.zcounts##Hd6#JJr=rp withscorescz[U5/UQnU(aURS5 UR"S/UQ7SU06$)z Returns the difference between the first and all successive input sorted sets provided in ``keys``. For more information, see https://redis.io/commands/zdiff WITHSCORESZDIFFrp)rrKr6)r7rprOr9s r:zdiffSortedSetCommands.zdiffs?d)#d#  MM, '##G@f@4@@r=rscF[U5/UQnUR"SU/UQ76$)z Computes the difference between the first and all successive input sorted sets provided in ``keys`` and stores the result in ``dest``. For more information, see https://redis.io/commands/zdiffstore ZDIFFSTORE)rr6)r7rsrpr9s r: zdiffstoreSortedSetCommands.zdiffstores-d)#d###L$@@@r=rr c(URSXU5$)z Increment the score of ``value`` in sorted set ``name`` by ``amount`` For more information, see https://redis.io/commands/zincrby ZINCRBYr5)r7rrr s r:zincrbySortedSetCommands.zincrbys ##ItUCCr=N aggregatec&URSSXUS9$)a Return the intersect of multiple sorted sets specified by ``keys``. With the ``aggregate`` option, it is possible to specify how the results of the union are aggregated. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists. For more information, see https://redis.io/commands/zinter ZINTERN)rO _zaggregate)r7rpr]rOs r:zinterSortedSetCommands.zinters$JWWr=c(URSXU5$)a Intersect multiple sorted sets specified by ``keys`` into a new sorted set, ``dest``. Scores in the destination will be aggregated based on the ``aggregate``. This option defaults to SUM, where the score of an element is summed across the inputs where it exists. When this option is set to either MIN or MAX, the resulting set will contain the minimum or maximum score of an element across the inputs where it exists. For more information, see https://redis.io/commands/zinterstore ZINTERSTOREr`r7rsrpr]s r: zinterstoreSortedSetCommands.zinterstores" t9EEr=rrc@U/UQSPUPnUR"S/UQ7SU06$)a[ Return the cardinality of the intersect of multiple sorted sets specified by ``keys``. When LIMIT provided (defaults to 0 and means unlimited), if the intersection cardinality reaches limit partway through the computation, the algorithm will exit and yield limit as the cardinality For more information, see https://redis.io/commands/zintercard r ZINTERCARDrpr5rs r: zintercardSortedSetCommands.zintercardrr=c&URSXX1/S9$)z Return the number of items in the sorted set ``name`` between the lexicographical range ``min`` and ``max``. For more information, see https://redis.io/commands/zlexcount ZLEXCOUNTrr5rLs r: zlexcountSortedSetCommands.zlexcounts##KCf#MMr=rZcfUSL=(a U/=(d /nSS0nUR"SU/UQ70UD6$)z Remove and return up to ``count`` members with the highest scores from the sorted set ``name``. For more information, see https://redis.io/commands/zpopmax NrOTZPOPMAXr5r7rrZr@rqs r:zpopmaxSortedSetCommands.zpopmaxAT!.w4"&##ItFdFgFFr=cfUSL=(a U/=(d /nSS0nUR"SU/UQ70UD6$)z Remove and return up to ``count`` members with the lowest scores from the sorted set ``name``. For more information, see https://redis.io/commands/zpopmin NrOTZPOPMINr5rss r:zpopminSortedSetCommands.zpopminrvr=rc/nUbURU5 U(aURS5 UR"SU/UQ76$)aB Return a random element from the sorted set value stored at key. ``count`` if the argument is positive, return an array of distinct fields. If called with a negative count, the behavior changes and the command is allowed to return the same field multiple times. In this case, the number of returned fields is the absolute value of the specified count. ``withscores`` The optional WITHSCORES modifier changes the reply so it includes the respective scores of the randomly selected elements from the sorted set. For more information, see https://redis.io/commands/zrandmember rQ ZRANDMEMBERr)r7rrZrOres r: zrandmemberSortedSetCommands.zrandmembersB$   MM%  MM, '##M3@@@r=rclUcSn[US5nURU5 UR"S/UQ76$)aX ZPOPMAX a value off of the first non-empty sorted set named in the ``keys`` list. If none of the sorted sets in ``keys`` has a value to ZPOPMAX, then block for ``timeout`` seconds, or until a member gets added to one of the sorted sets. If timeout is 0, then block indefinitely. For more information, see https://redis.io/commands/bzpopmax NrBZPOPMAXrrs r:bzpopmaxSortedSetCommands.bzpopmaxs< ?GD$' G##J666r=clUcSn[US5nURU5 UR"S/UQ76$)aX ZPOPMIN a value off of the first non-empty sorted set named in the ``keys`` list. If none of the sorted sets in ``keys`` has a value to ZPOPMIN, then block for ``timeout`` seconds, or until a member gets added to one of the sorted sets. If timeout is 0, then block indefinitely. For more information, see https://redis.io/commands/bzpopmin NrBZPOPMINrrs r:bzpopminSortedSetCommands.bzpopmin0s< ?G!-dD!9 G##J666r=rcU/U-nU(aU(dU(d U(d[eU(aURS5 OURS5 US:waURSU/5 UR"S/UQ76$)z Pop ``count`` values (default 1) off of the first non-empty sorted set named in the ``keys`` list. For more information, see https://redis.io/commands/zmpop MINMAXr-rZMPOPrrKrr6)r7rrprrrZr@s r:zmpopSortedSetCommands.zmpopCsgzD  CSO  KK  KK  A: KK%( )##G3d33r=cX/UQnU(aU(dU(dU(d [S5eU(aURS5 OURS5 URSU/5 UR"S/UQ76$)ac Pop ``count`` values (default 1) off of the first non-empty sorted set named in the ``keys`` list. If none of the sorted sets in ``keys`` has a value to pop, then block for ``timeout`` seconds, or until a member gets added to one of the sorted sets. If timeout is 0, then block indefinitely. For more information, see https://redis.io/commands/bzmpop z+Either min or max, but not both must be setrrrBZMPOPr)r7rrrprrrZr@s r:bzmpopSortedSetCommands.bzmpop\sh*(4( CSIJ J  KK  KK  We$%##H4t44r=rarbrbyscorebylexrUrurc U(aU(a [S5eU bU bU bU c [S5eU(aU (a [S5eU/n U(aU RU5 U RX4U/5 U(aU RS5 U(aU RS5 U(aU RS5 U bU bU RSX/5 U (aU RS5 XS .nU/US 'UR"U 0UD6$) Nz8``byscore`` and ``bylex`` can not be specified together.z.``offset`` and ``num`` must both be specified.z;``withscores`` not supported in combination with ``bylex``.BYSCOREBYLEXREVrrQrOrUrpr)r7r$rsrrarbrrrrOrUrurr9rqs r:_zrangeSortedSetCommands._zrange|s uVW W  3;COLM M ZM   MM$  tC()  MM) $  MM' "  MM%  #/ MM7F0 1  MM, '!+P&##V7w77r=c U(d'U(d U cU cU(aURXX5U5$URSSUUUUUUUUU U 5 $)a Return a range of values from sorted set ``name`` between ``start`` and ``end`` sorted in ascending order. ``start`` and ``end`` can be negative, indicating the end of the range. ``desc`` a boolean indicating whether to sort the results in reversed order. ``withscores`` indicates to return the scores along with the values. The return type is a list of (value, score) pairs. ``score_cast_func`` a callable used to cast the score return value. ``byscore`` when set to True, returns the range of elements from the sorted set having scores equal or between ``start`` and ``end``. ``bylex`` when set to True, returns the range of elements from the sorted set between the ``start`` and ``end`` lexicographical closed range intervals. Valid ``start`` and ``end`` must start with ( or [, in order to specify whether the range interval is exclusive or inclusive, respectively. ``offset`` and ``num`` are specified, then return a slice of the range. Can't be provided when using ``bylex``. For more information, see https://redis.io/commands/zrange NZRANGE) zrevranger) r7rrarbrrOrUrrrurs r:zrangeSortedSetCommands.zranges\Vu&.S[d>>$sP P||              r=cpSXU/nU(aURS5 XES.nXS'UR"U0UD6$)a Return a range of values from sorted set ``name`` between ``start`` and ``end`` sorted in descending order. ``start`` and ``end`` can be negative, indicating the end of the range. ``withscores`` indicates to return the scores along with the values The return type is a list of (value, score) pairs ``score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zrevrange ZREVRANGE WITHSCORESrrpr)r7rrarbrOrUr9rqs r:rSortedSetCommands.zrevrangesD*tC0  MM- (!+P##V7w77r=c :URSUUUUUUUSSUU 5 $)a{ Stores in ``dest`` the result of a range of values from sorted set ``name`` between ``start`` and ``end`` sorted in ascending order. ``start`` and ``end`` can be negative, indicating the end of the range. ``byscore`` when set to True, returns the range of elements from the sorted set having scores equal or between ``start`` and ``end``. ``bylex`` when set to True, returns the range of elements from the sorted set between the ``start`` and ``end`` lexicographical closed range intervals. Valid ``start`` and ``end`` must start with ( or [, in order to specify whether the range interval is exclusive or inclusive, respectively. ``desc`` a boolean indicating whether to sort the results in reversed order. ``offset`` and ``num`` are specified, then return a slice of the range. Can't be provided when using ``bylex``. For more information, see https://redis.io/commands/zrangestore ZRANGESTOREFN)r) r7rsrrarbrrrrurs r: zrangestoreSortedSetCommands.zrangestores:F||              r=cUbUbUbUc [S5eSXU/nUbUbURSXE/5 UR"USU/06$)z Return the lexicographical range of values from sorted set ``name`` between ``min`` and ``max``. If ``start`` and ``num`` are specified, then return a slice of the range. For more information, see https://redis.io/commands/zrangebylex r$ ZRANGEBYLEXr%rprrr6)r7rrrrarr9s r: zrangebylexSortedSetCommands.zrangebylex0sa"  #+3?u}JK KC0   MM8U0 1##V94&99r=cUbUbUbUc [S5eSXU/nUbUbURSXE/5 UR"USU/06$)z Return the reversed lexicographical range of values from sorted set ``name`` between ``max`` and ``min``. If ``start`` and ``num`` are specified, then return a slice of the range. For more information, see https://redis.io/commands/zrevrangebylex r$ZREVRANGEBYLEXrrpr)r7rrrrarr9s r:zrevrangebylex SortedSetCommands.zrevrangebylexHsa"  #+3?u}JK K"Ds3   MM7E/ 0##V94&99r=cUbUbUbUc [S5eSXU/nUbUbURSXE/5 U(aURS5 XgS.n U/U S'UR"U0U D6$)a Return a range of values from the sorted set ``name`` with scores between ``min`` and ``max``. If ``start`` and ``num`` are specified, then return a slice of the range. ``withscores`` indicates to return the scores along with the values. The return type is a list of (value, score) pairs `score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zrangebyscore r$ ZRANGEBYSCORErrQrrprrrKr6) r7rrrrarrOrUr9rqs r: zrangebyscoreSortedSetCommands.zrangebyscore`s0  #+3?u}JK K!4c2   MM7E/ 0  MM, '!+P&##V7w77r=cUbUbUbUc [S5eSXU/nUbUbURSXE/5 U(aURS5 XgS.n U/U S'UR"U0U D6$)a Return a range of values from the sorted set ``name`` with scores between ``min`` and ``max`` in descending order. If ``start`` and ``num`` are specified, then return a slice of the range. ``withscores`` indicates to return the scores along with the values. The return type is a list of (value, score) pairs ``score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zrevrangebyscore r$ZREVRANGEBYSCORErrQrrpr) r7rrrrarrOrUr9rqs r:zrevrangebyscore"SortedSetCommands.zrevrangebyscores0  #+3?u}JK K$d5   MM7E/ 0  MM, '!+P&##V7w77r= withscorecfSX/nU(aURS5 X4S.nUR"U0UD6$)a9 Returns a 0-based value indicating the rank of ``value`` in sorted set ``name``. The optional WITHSCORE argument supplements the command's reply with the score of the element returned. ``score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zrank ZRANK WITHSCORErrUrr7rr rrUr9rqs r:zrankSortedSetCommands.zranks;"4'  MM+ & )N##V7w77r=rc*UR"SU/UQ76$)zm Remove member ``values`` from sorted set ``name`` For more information, see https://redis.io/commands/zrem ZREMr5rs r:zremSortedSetCommands.zremrqr=c(URSXU5$)z Remove all elements in the sorted set ``name`` between the lexicographical range specified by ``min`` and ``max``. Returns the number of elements removed. For more information, see https://redis.io/commands/zremrangebylex ZREMRANGEBYLEXr5rLs r:zremrangebylex SortedSetCommands.zremrangebylexs##$4dEEr=c(URSXU5$)a6 Remove all elements in the sorted set ``name`` with ranks between ``min`` and ``max``. Values are 0-based, ordered from smallest score to largest. Values can be negative indicating the highest scores. Returns the number of elements removed For more information, see https://redis.io/commands/zremrangebyrank ZREMRANGEBYRANKr5rLs r:zremrangebyrank!SortedSetCommands.zremrangebyranks##$5t#FFr=c(URSXU5$)z Remove all elements in the sorted set ``name`` with scores between ``min`` and ``max``. Returns the number of elements removed. For more information, see https://redis.io/commands/zremrangebyscore ZREMRANGEBYSCOREr5rLs r:zremrangebyscore"SortedSetCommands.zremrangebyscores##$63GGr=cfSX/nU(aURS5 X4S.nUR"U0UD6$)aK Returns a 0-based value indicating the descending rank of ``value`` in sorted set ``name``. The optional ``withscore`` argument supplements the command's reply with the score of the element returned. ``score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zrevrank ZREVRANKrrrrs r:zrevrankSortedSetCommands.zrevranks;"d*  MM+ & )N##V7w77r=c&URSXU/S9$)zz Return the score of element ``value`` in sorted set ``name`` For more information, see https://redis.io/commands/zscore ZSCORErr5rs r:zscoreSortedSetCommands.zscores ##Hd#GGr=c *URSSUUUUS9$)aU Return the union of multiple sorted sets specified by ``keys``. ``keys`` can be provided as dictionary of keys and their weights. Scores will be aggregated based on the ``aggregate``, or SUM if none is provided. ``score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zunion ZUNIONNrr`)r7rpr]rOrUs r:zunionSortedSetCommands.zunion s."    !+    r=c(URSXU5$)z Union multiple sorted sets specified by ``keys`` into a new sorted set, ``dest``. Scores in the destination will be aggregated based on the ``aggregate``, or SUM if none is provided. For more information, see https://redis.io/commands/zunionstore ZUNIONSTOREr`rfs r: zunionstoreSortedSetCommands.zunionstore#s t9EEr=membersc`U(d [S5eU/U-nUR"S/UQ7SU/06$)a: Returns the scores associated with the specified members in the sorted set stored at key. ``members`` should be a list of the member name. Return type is a list of score. If the member does not exist, a None will be returned in corresponding position. For more information, see https://redis.io/commands/zmscore z(ZMSCORE members must be a non-empty listZMSCORErpr)r7rrr9s r:zmscoreSortedSetCommands.zmscore2s;FG G##ICCcUCCr=r$c TU/nUbURU5 UR[U55 [U[5(a UR 5UR 5psOSnUR U5 U(a"URS5 UR U5 U(aBUR5S;a#URS5 URU5 O [S5eURSS5(aURS5 X5S'UR"U0UD6$) NsWEIGHTS)SUMrrs AGGREGATEz!aggregate can be sum, min or max.rOFrrp) rKrr]rrprrrDrrr6)r7r$rsrpr]rqr9weightss r:raSortedSetCommands._zaggregateBs%,9   MM$  c$i dD ! ! IIK'G d  MM* % MM' "  $99 l+ i( CDD ;;|U + + MM- (##V7w77r=r)FFFFFFrrrr0)FFr-)FFFNNr)?rrrrrr#rrrrr&rDrHr*rMr"rSrWrr[rrrbrrrgrIr rrkrortryr}r)rrrrrrrrrrrrrrrrr rrrrrrrrrrarrr=r:r?r?0s KFKF*,-KF  KF  KF  KFKF KF KF KFZ@$@9@K4KlKK)K A% AT Ai AAtA5AYADDD%D DyDPUXX&.smXHLX X($( FFHTNGGUN$;;<FC= F  F(;< D D"&s) D47 D y~s" # DN GD G# G) G GD G# G) GJOAA ( ABFA A47U7[77&7U7[77.$# 443i4d^ 4 d^ 4 } 4 y$ %4<$# 5553i 5 d^ 5 d^ 5}5 $5N 7< $!'8D$J'8 '8  '8  '8'8'8'8'8tXt34'8 '8c]'8 '8\ 16 $!; ; ;  ;  ;  ; tX~.; ; ;  ; c];  ; D!16 888 8  8 tX~. 8 8D $!0 0 0  0  0  0 0 0  0 c]0  0 n $! ::: : } : c] : :: $! ::: : } : c] : :: $! 16!8!8!8 !8 } !8 c] !8!8tX~.!8 !8P $! 16!8!8!8 !8 } !8 c] !8!8tX~.!8N 16 888 8 tX~. 8  82;;;9; F4 Fj Fz Fi F GD Gs G G G H H+ H2> H  H 16 888 8 tX~. 8  82H4H HyH$( 16  HTNGGUN$;;< C=   tX~.    <$( F FHTNGGUN$;;< FC= F  FD4D$s)D D*$( 88D$J8HTNGGUN$;;< 8 C= 8 88r=r?cV\rSrSrSrS\S\S\4SjrS\S\4Sjr S \S\S\4S jr S r g ) HyperlogCommandsiezf Redis commands of HyperLogLogs data type. see: https://redis.io/topics/data-types-intro#hyperloglogs rrr3c*UR"SU/UQ76$)zv Adds the specified elements to the specified HyperLogLog. For more information, see https://redis.io/commands/pfadd PFADDr5rs r:pfaddHyperlogCommands.pfaddkrr=sourcesc(UR"S/UQ76$)z Return the approximated cardinality of the set observed by the HyperLogLog at key(s). For more information, see https://redis.io/commands/pfcount PFCOUNTr5)r7rs r:pfcountHyperlogCommands.pfcountss##I888r=rsc*UR"SU/UQ76$)zp Merge N different HyperLogLogs into a single one. For more information, see https://redis.io/commands/pfmerge PFMERGEr5)r7rsrs r:pfmergeHyperlogCommands.pfmerge|s ##It>g>>r=rN) rrrrrr#r r&rrrrrr=r:rresN <$<r0g )C HashCommandsiz_ Redis commands for Hash data type. see: https://redis.io/topics/data-types-intro#redis-hashes rrpr3c*UR"SU/UQ76$)z^ Delete ``keys`` from hash ``name`` For more information, see https://redis.io/commands/hdel HDELr5r7rrps r:hdelHashCommands.hdels ##FD8488r=rc&URSXU/S9$)z Returns a boolean indicating if ``key`` exists within hash ``name`` For more information, see https://redis.io/commands/hexists HEXISTSrr5r7rrs r:hexistsHashCommands.hexistss ##Itv#FFr=c&URSXU/S9$)zp Return the value of ``key`` within the hash ``name`` For more information, see https://redis.io/commands/hget HGETrr5rs r:hgetHashCommands.hgets##FDTF#CCr=c$URSX/S9$)zr Return a Python dict of the hash's name/value pairs For more information, see https://redis.io/commands/hgetall HGETALLrr5rs r:hgetallHashCommands.hgetalls ##It&#AAr=ct[U5S:Xa [S5eUR"SUS[U5/UQ76$)a8 Return the value of ``key`` within the hash ``name`` and delete the field in the hash. This command is similar to HGET, except for the fact that it also deletes the key on success from the hash with the provided ```name```. Available since Redis 8.0 For more information, see https://redis.io/commands/hgetdel rz/'hgetdel' should have at least one key providedHGETDELFIELDS)rrr6rs r:hgetdelHashCommands.hgetdels; t9>MN N##ItXs4yP4PPr=NF)rrrrrrrrrrcU(d [S5eX#XE1n[U5S:d[U5S:aU(a [S5e[X#XE5n U(aU RS5 UR"SU/U QSP[U5PUQ76$)a0 Return the values of ``key`` and ``keys`` within the hash ``name`` and optionally set their expiration. ``ex`` sets an expire flag on ``kyes`` for ``ex`` seconds. ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds. ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds, specified in unix time. ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds, specified in unix time. ``persist`` remove the time to live associated with the ``keys``. Available since Redis 8.0 For more information, see https://redis.io/commands/hgetex z.'hgetex' should have at least one key providedrr-rrHGETEXr)rrr,rKr6) r7rrrrrrrprrs r:hgetexHashCommands.hgetexs>LM M$ u:>SZ!^:  )=RT(P    y )##       I     r=rc(URSXU5$)z| Increment the value of ``key`` in hash ``name`` by ``amount`` For more information, see https://redis.io/commands/hincrby HINCRBYr5r7rrrs r:hincrbyHashCommands.hincrbys##It&AAr=c(URSXU5$)z Increment the value of ``key`` in hash ``name`` by floating ``amount`` For more information, see https://redis.io/commands/hincrbyfloat HINCRBYFLOATr5rs r: hincrbyfloatHashCommands.hincrbyfloats##NDvFFr=c$URSX/S9$)zi Return the list of keys within hash ``name`` For more information, see https://redis.io/commands/hkeys HKEYSrr5rs r:hkeysHashCommands.hkeysrvr=c$URSX/S9$)zj Return the number of elements in hash ``name`` For more information, see https://redis.io/commands/hlen HLENrr5rs r:hlenHashCommands.hlen rr=r rrlcUcU(dU(d [S5e/nU(aURU5 UbURX#45 U(a(UR5HnURU5 M UR"SU/UQ76$)a< Set ``key`` to ``value`` within hash ``name``, ``mapping`` accepts a dict of key/value pairs that will be added to hash ``name``. ``items`` accepts a list of key/value pairs that will be added to hash ``name``. Returns the number of fields that were added. For more information, see https://redis.io/commands/hset z'hset' with no key value pairsHSET)rrrlr6)r7rrr rrlr9rs r:hsetHashCommands.hset(sy& ;wu<= =  MM% ? MM3, '   d#(##FD:6::r=data_persist_optionrFc UcU(dU(d [S5eU(a[U5S-S:wa [S5eXgX1n [U 5S:d[U 5S:aU (a [S5e[XgX5n U (aU RU R5 U (aU RS5 /nU(aUR U5 UbUR X#45 U(a(UR 5HnUR U5 M UR"SU/U QS P[[U5S- 5PUQ76$) a# Set ``key`` to ``value`` within hash ``name`` ``mapping`` accepts a dict of key/value pairs that will be added to hash ``name``. ``items`` accepts a list of key/value pairs that will be added to hash ``name``. ``ex`` sets an expire flag on ``keys`` for ``ex`` seconds. ``px`` sets an expire flag on ``keys`` for ``px`` milliseconds. ``exat`` sets an expire flag on ``keys`` for ``ex`` seconds, specified in unix time. ``pxat`` sets an expire flag on ``keys`` for ``ex`` milliseconds, specified in unix time. ``data_persist_option`` can be set to ``FNX`` or ``FXX`` to control the behavior of the command. ``FNX`` will set the value for each provided key to each provided value only if all do not already exist. ``FXX`` will set the value for each provided key to each provided value only if all already exist. ``keepttl`` if True, retain the time to live associated with the keys. Returns the number of fields that were added. Available since Redis 8.0 For more information, see https://redis.io/commands/hsetex z 'hsetex' with no key value pairsrrzR'hsetex' with odd number of items. 'items' must contain a list of key/value pairs.r-rHrIHSETEXr) rrr,rKr rrlr6rI)r7rrr rrlrrrrr0rFrrr9rs r:hsetexHashCommands.hsetexIs8^ ;wu>? ? SZ!^q(B  $ u:>SZ!^:  )=RT(P    288 9    y )  MM% ? MM3, '   d#(## d ( *2 47F a4H KQ  r=c(URSXU5$)z Set ``key`` to ``value`` within hash ``name`` if ``key`` does not exist. Returns 1 if HSETNX created a field, otherwise 0. For more information, see https://redis.io/commands/hsetnx HSETNXr5)r7rrr s r:hsetnxHashCommands.hsetnxs##Hd??r=z4.0.0zUse 'hset' instead.hmset)versionreasonrcU(d [S5e/nUR5HnURU5 M UR"SU/UQ76$)z Set key to value within hash ``name`` for each corresponding key and value from the ``mapping`` dict. For more information, see https://redis.io/commands/hmset z"'hmset' with 'mapping' of length 0HMSET)rrlrr6)r7rrrlrs r:r9HashCommands.hmsetsL@A AMMOD LL $##GT:E::r=r@cH[X#5nUR"SU/UQ7SU/06$)zu Returns a list of values ordered identically to ``keys`` For more information, see https://redis.io/commands/hmget HMGETrpry)r7rrpr@s r:hmgetHashCommands.hmgets- D'##GTFDFvFFr=c$URSX/S9$)zk Return the list of values within hash ``name`` For more information, see https://redis.io/commands/hvals HVALSrr5rs r:hvalsHashCommands.hvalsrvr=c&URSXU/S9$)z Return the number of bytes stored in the value of ``key`` within hash ``name`` For more information, see https://redis.io/commands/hstrlen HSTRLENrr5rs r:hstrlenHashCommands.hstrlens##Itv#FFr=)rrrrsecondsrrrrrcX4XV/n[U5S:a [S5e[U[R5(a[ UR 55n/n U(aU RS5 U(aU RS5 U(aU RS5 U(aU RS5 UR"SX/U QSP[U5PUQ76$) a Sets or updates the expiration time for fields within a hash key, using relative time in seconds. If a field already has an expiration time, the behavior of the update can be controlled using the `nx`, `xx`, `gt`, and `lt` parameters. The return value provides detailed information about the outcome for each field. For more information, see https://redis.io/commands/hexpire Args: name: The name of the hash key. seconds: Expiration time in seconds, relative. Can be an integer, or a Python `timedelta` object. fields: List of fields within the hash to apply the expiration time to. nx: Set expiry only when the field has no expiry. xx: Set expiry only when the field has an existing expiry. gt: Set expiry only when the new expiry is greater than the current one. lt: Set expiry only when the new expiry is less than the current one. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `0` if the specified NX | XX | GT | LT condition was not met. - `1` if the expiration time was set or updated. - `2` if the field was deleted because the specified expiration time is in the past. r-4Only one of 'nx', 'xx', 'gt', 'lt' can be specified.rrrrHEXPIREr sumrJr]rrrIrrKr6r) r7rrKrrrrr conditionsrqs r:hexpireHashCommands.hexpiresNb% z?Q ST T gx11 2 2'//12G NN4 NN4 NN4 NN4 ## t '. 08 :=f+ HN  r= millisecondscX4XV/n[U5S:a [S5e[U[R5(a[ UR 5S-5n/n U(aU RS5 U(aU RS5 U(aU RS5 U(aU RS5 UR"SX/U QS P[U5PUQ76$) a Sets or updates the expiration time for fields within a hash key, using relative time in milliseconds. If a field already has an expiration time, the behavior of the update can be controlled using the `nx`, `xx`, `gt`, and `lt` parameters. The return value provides detailed information about the outcome for each field. For more information, see https://redis.io/commands/hpexpire Args: name: The name of the hash key. milliseconds: Expiration time in milliseconds, relative. Can be an integer, or a Python `timedelta` object. fields: List of fields within the hash to apply the expiration time to. nx: Set expiry only when the field has no expiry. xx: Set expiry only when the field has an existing expiry. gt: Set expiry only when the new expiry is greater than the current one. lt: Set expiry only when the new expiry is less than the current one. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `0` if the specified NX | XX | GT | LT condition was not met. - `1` if the expiration time was set or updated. - `2` if the field was deleted because the specified expiration time is in the past. r-rMrrrrrHPEXPIRErrO) r7rrTrrrrrrQrqs r:hpexpireHashCommands.hpexpiresNb% z?Q ST T lH$6$6 7 7|99;dBCL NN4 NN4 NN4 NN4 ##  -4 6> @CF  NT  r=unix_time_secondscX4XV/n[U5S:a [S5e[U[R5(a[ UR 55n/n U(aU R S5 U(aU R S5 U(aU R S5 U(aU R S5 UR"SUU/U QSP[U5PUQ76$) a! Sets or updates the expiration time for fields within a hash key, using an absolute Unix timestamp in seconds. If a field already has an expiration time, the behavior of the update can be controlled using the `nx`, `xx`, `gt`, and `lt` parameters. The return value provides detailed information about the outcome for each field. For more information, see https://redis.io/commands/hexpireat Args: name: The name of the hash key. unix_time_seconds: Expiration time as Unix timestamp in seconds. Can be an integer or a Python `datetime` object. fields: List of fields within the hash to apply the expiration time to. nx: Set expiry only when the field has no expiry. xx: Set expiry only when the field has an existing expiration time. gt: Set expiry only when the new expiry is greater than the current one. lt: Set expiry only when the new expiry is less than the current one. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `0` if the specified NX | XX | GT | LT condition was not met. - `1` if the expiration time was set or updated. - `2` if the field was deleted because the specified expiration time is in the past. r-rMrrrr HEXPIREATr rPrJr]rrIrrKr6r) r7rrYrrrrrrQrqs r: hexpireatHashCommands.hexpireatJsNb% z?Q ST T '):): ; ; #$5$?$?$A B  NN4 NN4 NN4 NN4 ##        K    r=unix_time_millisecondscX4XV/n[U5S:a [S5e[U[R5(a[ UR 5S-5n/n U(aU R S5 U(aU R S5 U(aU R S5 U(aU R S5 UR"SUU/U QS P[U5PUQ76$) a! Sets or updates the expiration time for fields within a hash key, using an absolute Unix timestamp in milliseconds. If a field already has an expiration time, the behavior of the update can be controlled using the `nx`, `xx`, `gt`, and `lt` parameters. The return value provides detailed information about the outcome for each field. For more information, see https://redis.io/commands/hpexpireat Args: name: The name of the hash key. unix_time_milliseconds: Expiration time as Unix timestamp in milliseconds. Can be an integer or a Python `datetime` object. fields: List of fields within the hash to apply the expiry. nx: Set expiry only when the field has no expiry. xx: Set expiry only when the field has an existing expiry. gt: Set expiry only when the new expiry is greater than the current one. lt: Set expiry only when the new expiry is less than the current one. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `0` if the specified NX | XX | GT | LT condition was not met. - `1` if the expiration time was set or updated. - `2` if the field was deleted because the specified expiration time is in the past. r-rMrrrrr HPEXPIREATrr\) r7rr_rrrrrrQrqs r: hpexpireatHashCommands.hpexpireatsNb% z?Q ST T ,h.?.? @ @%()?)I)I)Kd)R%S " NN4 NN4 NN4 NN4 ##   "     K    r=c@UR"SUS[U5/UQ76$)a: Removes the expiration time for each specified field in a hash. For more information, see https://redis.io/commands/hpersist Args: name: The name of the hash key. fields: A list of fields within the hash from which to remove the expiration time. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `-1` if the field exists but has no associated expiration time. - `1` if the expiration time was successfully removed from the field. HPERSISTrr6r)r7rrs r:hpersistHashCommands.hpersists$"##JhF UfUUr=cHUR"SUS[U5/UQ7SU/06$)as Returns the expiration times of hash fields as Unix timestamps in seconds. For more information, see https://redis.io/commands/hexpiretime Args: key: The hash key. fields: A list of fields within the hash for which to get the expiration time. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `-1` if the field exists but has no associated expire time. - A positive integer representing the expiration Unix timestamp in seconds, if the field has an associated expiration time. HEXPIRETIMErrprfr7rrs r: hexpiretimeHashCommands.hexpiretimes6$## 3#f+ 8> FIU  r=cHUR"SUS[U5/UQ7SU/06$)a~ Returns the expiration times of hash fields as Unix timestamps in milliseconds. For more information, see https://redis.io/commands/hpexpiretime Args: key: The hash key. fields: A list of fields within the hash for which to get the expiration time. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `-1` if the field exists but has no associated expire time. - A positive integer representing the expiration Unix timestamp in milliseconds, if the field has an associated expiration time. HPEXPIRETIMErrprfrks r: hpexpiretimeHashCommands.hpexpiretimes6$## C3v; 9? GJe  r=cHUR"SUS[U5/UQ7SU/06$)aH Returns the TTL (Time To Live) in seconds for each specified field within a hash key. For more information, see https://redis.io/commands/httl Args: key: The hash key. fields: A list of fields within the hash for which to get the TTL. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `-1` if the field exists but has no associated expire time. - A positive integer representing the TTL in seconds if the field has an associated expiration time. HTTLrrprfrks r:httlHashCommands.httl s6$## C3v; 17 ?Be  r=cHUR"SUS[U5/UQ7SU/06$)aS Returns the TTL (Time To Live) in milliseconds for each specified field within a hash key. For more information, see https://redis.io/commands/hpttl Args: key: The hash key. fields: A list of fields within the hash for which to get the TTL. Returns: Returns a list which contains for each field in the request: - `-2` if the field does not exist, or if the key does not exist. - `-1` if the field exists but has no associated expire time. - A positive integer representing the TTL in milliseconds if the field has an associated expiration time. HPTTLrrprfrks r:hpttlHashCommands.hpttl#s6$## S(CK 28 @Cu  r=rrr)NNNN) NNNNNNNNNF)1rrrrrrrrrIrrrrr rrr r)rr#rrrrrr"r&r*rr.rr3r7r+r9rArErIr&rRrWr]rbrgrlrprtrxrrr=r:rrs 99S9U9S>33F-G9GCGcGeIdOT4I.JGDD!D y#'#6 7DBCBE)D/4*?$@BQQ #Q (4c5j 1234htE#u*DU?V6WW Q.!% $%)%)5 5 5  W  5 W  5 z" 5 z"5 5  (4c5j 1234htE#u*DU?V6WW 5 p23BB!B+.B y~s" #B47GG!G+0G y& 'G@#@% $(=">@??y~s':!;?"#"& $ ;;c];} ; $ ; ~ ; y~s" #;H"#"& $ $ $%)%)@DQ Q c]Q } Q $ Q ~ Q  W Q  W Q z"Q z"Q &&<=Q Q  y~s" #Q f@3@S@@yPT?T9U@$  ;# ; ;y~s7J1K ;  ;G#GTG$G54RVAV;WG@#@% $(=">@GCGcGeIcNC4G.HG: : :  :  :  :  :  :  : B: : :  :  :  :  :  :  : B@ @ &@  @  @  @  @  @  @ N@ @ !+@  @  @  @  @  @  @ DVTVCVIV& t c i ,  s y ,  s y ,    r=rcv\rSrSrSrSSS\4SjrSS\\\ S4S \\ \ S4S \S 4S jjr S r Srg)Scripti=A An executable Lua script object returned by ``register_script`` registered_clientr5scriptcXlX l[U[5(a!UR 5nUR U5n[ R"U5R5Ul gr) r}r~r]rr}rhashlibsha1 hexdigestshar7r}r~rs r:r=Script.__init__BsS!2  fc " "&&(G^^F+F<<'113r=Nrpr@r3)r5NcU=(d /nU=(d /nUc URn[U5[U5-nSSKJn [ X45(aUR R U5 UR"UR[U5/UQ76$![aJ URUR5UlUR"UR[U5/UQ76s$f=f)1Execute the script, passing any required ``args``rPipeline) r}rrorr]scriptsaddevalsharrr script_loadr~r7rpr@r3rs r:__call__Script.__call__Nszrzr >++FT{U4[() f ' ' NN  t $ >>>$((CI== = >))$++6DH>>$((CI== =  >s/&BAC*)C*cURR5$![a' URRR5s$f=f)z4Get the encoder to encode string scripts into bytes.)r}r}AttributeErrorconnection_poolrs r:r}Script.get_encoderisK H))557 7 H))99EEG G Hs.A  A r}r~rr)rrrrrr'r=rrr#r rrr}rrr=r:r{r{=sp 4*> 4 4-12648 >HTND()>HZ($./>01 >6Hr=r{cp\rSrSrSrSSS\4SjrSS\\\ S4S \\ \ S4S \S 4S jjr S r g) AsyncScripti|r|r}r6r~c0XlX l[U[5(a,URR 5nURU5n[R"U5R5Ul g![ a UR 5nNWf=fr) r}r~r]rrr}rrrrrrrs r:r=AsyncScript.__init__s "3  fc " " :+;;GGI^^F+F<<'113 " :+779 :sA88BBNrpr@r3)r6Nc# U=(d /nU=(d /nUc URn[U5[U5-nSSKJn [ X45(aUR R U5 UR"UR[U5/UQ76IShvN $N![a\ URUR5IShvN UlUR"UR[U5/UQ76IShvN s$f=f7f)rNrr) r}rredis.asyncio.clientrr]rrrrrrrr~rs r:rAsyncScript.__call__szrzr >++FT{U4[(1 f ' ' NN  t $ D#d)CdCC CC D$// << 6.2, or accepts SYNC/ASYNC. For older versions, of redis leave as None.z SCRIPT FLUSHr)r7rr9s r: script_flushScriptCommands.script_flushZsI 3 3*   F[F##NtZ?O9P C y~s" # C F F$' F9>tZ?O9P F y~s" # FKKK K dJ./ K y~s" # KFF!$F6;D*# [TU]5$7fr)r"r)r7r@r$s r:r AsyncScriptCommands.script_debugw#%%rr7r6r~c[X5$r)rrs r:r#AsyncScriptCommands.register_scripts4((r=rr) rrrrrr'rrrr/r0s@r:rrs,& )* ) )  ) )r=rc\rSrSrSrS+S\S\\S\S\S\S\ 4 S jjr S,S\S \ S \ S \ \ S\ 4 SjjrS\S\ S\ 4SjrS\S\ S\ 4SjrS-S\S\S\S\S \ \ S\S\S\S\ \S\ \ S\ \S\ \S\S\ 4SjjrS-S\S\ S\S \ \ S\S\S\S\ \S\ \ S\\S 4S\\S 4S\S\ 4SjjrS\ S \S!\\S 4S\ 4S"jrS.S\S\\ S 4S\\S 4S\\S 4S \ S\\S 4S#\\S 4S$\\S 4S\ \ S\ \S\S\S\S\S\ 4S%jjrS/S&\S\S\ \ S\ \S\ \S \ S\ \S#\ \S$\ \S\ \ S\ \S\S'\S\ 4S(jjrS\ S \S!\\S 4S\ 4S)jrS*rg )0 GeoCommandsizf Redis Geospatial commands. see: https://redis.com/redis-best-practices/indexing-patterns/geospatial/ rrrrr@r3cLU(aU(a [S5e[U5S-S:wa [S5eU/nU(aURS5 U(aURS5 U(aURS5 URU5 UR"S/UQ76$) a Add the specified geospatial items to the specified key identified by the ``name`` argument. The Geospatial items are given as ordered members of the ``values`` argument, each item or place is formed by the triad longitude, latitude and name. Note: You can use ZREM to remove elements. ``nx`` forces ZADD to only create new elements and not to update scores for elements that already exist. ``xx`` forces ZADD to only update scores of elements that already exist. New elements will not be added. ``ch`` modifies the return value to be the numbers of elements changed. Changed elements include new elements that were added and elements whose scores changed. For more information, see https://redis.io/commands/geoadd z+GEOADD allows either 'nx' or 'xx', not bothrz4GEOADD requires places with lon, lat and name valuesrrCHGEOADD)rrrKrr6)r7rrrrr@r9s r:geoaddGeoCommands.geoadds8 "IJ J v;?a RS S MM$  MM$  MM$  f##H6v66r=Nplace1place2unitcXU/nU(aUS;a [S5eU(aURU5 UR"S/UQ7SU/06$)z Return the distance between ``place1`` and ``place2`` members of the ``name`` key. The units must be one of the following : m, km mi, ft. By default meters are used. For more information, see https://redis.io/commands/geodist mkmmiftzGEODIST invalid unitGEODISTrpr{)r7rrrrr9s r:geodistGeoCommands.geodistsQ%)  D 7723 3  MM$ ##IDDdVDDr=c2UR"SU/UQ7SU/06$)z Return the geo hash string for each item of ``values`` members of the specified key identified by the ``name`` argument. For more information, see https://redis.io/commands/geohash GEOHASHrpr5rs r:geohashGeoCommands.geohashs###ItJfJD6JJr=c2UR"SU/UQ7SU/06$)z Return the positions of each item of ``values`` as members of the specified key identified by the ``name`` argument. Each position is represented by the pairs lon and lat. For more information, see https://redis.io/commands/geopos GEOPOSrpr5rs r:geoposGeoCommands.geoposs###HdIVI4&IIr= longitudelatituderadiuswithdist withcoordwithhashrZr+r! store_distanyc:URSUUUUUUUUU U U U U S9$)ax Return the members of the specified key identified by the ``name`` argument which are within the borders of the area specified with the ``latitude`` and ``longitude`` location and the maximum distance from the center specified by the ``radius`` value. The units must be one of the following : m, km mi, ft. By default ``withdist`` indicates to return the distances of each place. ``withcoord`` indicates to return the latitude and longitude of each place. ``withhash`` indicates to return the geohash string of each place. ``count`` indicates to return the number of elements up to N. ``sort`` indicates to return the places in a sorted way, ASC for nearest to fairest and DESC for fairest to nearest. ``store`` indicates to save the places names in a sorted set named with a specific key, each element of the destination sorted set is populated with the score got from the original geo sorted set. ``store_dist`` indicates to save the places names in a sorted set named with a specific key, instead of ``store`` the sorted set destination score is set with the distance. For more information, see https://redis.io/commands/georadius GEORADIUS rrrrrZr+r!rr_georadiusgeneric)r7rr r rrrrrrZr+r!rrs r: georadiusGeoCommands.georadiussG\%%     !&  r=memberc 8URSUUUUUUUUU U U U S9 $)aR This command is exactly like ``georadius`` with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set. For more information, see https://redis.io/commands/georadiusbymember GEORADIUSBYMEMBERrr) r7rrrrrrrrZr+r!rrs r:georadiusbymemberGeoCommands.georadiusbymember1sC.%%    !&  r=r$r@r8c&[U5nUS(aUSS;a [S5eUS(aURUS5 OURS5 US(aUSc [S5eSH!upVX5(dMURU5 M# USb1URS US/5 US(aURS 5 US (aAUS S :XaURS 5 O&US S :XaURS 5 O [S5eUS(aUS(a [S5eUS(aURSUS/5 US(aURSUS/5 UR"U/UQ70UD6$)NrrzGEORADIUS invalid unitrrrZz+``any`` can't be provided without ``count``))rWITHDIST)r WITHCOORD)rWITHHASHrANYr+ASCDESCzGEORADIUS invalid sortr!rz3GEORADIUS store and store_dist cant be set togetherr' STOREDIST)rrrKrr6r7r$r@r8r9arg_name byte_reprs r:rGeoCommands._georadiusgenericXswd &>fVn4KK45 5 F^ MM&. ) MM#  %=VG_4IJ J$ H  i( $  '? & MM7F7O4 5e} e$ &>f~& e$6) f% 899 '?vl3QR R '? MM8VG_5 6 ,  MM< )=> ?##G?f???r=widthheightc@URSUUUUUUUUU U U U U USSS9$)aS Return the members of specified key identified by the ``name`` argument, which are within the borders of the area specified by a given shape. This command extends the GEORADIUS command, so in addition to searching within circular areas, it supports searching within rectangular areas. This command should be used in place of the deprecated GEORADIUS and GEORADIUSBYMEMBER commands. ``member`` Use the position of the given existing member in the sorted set. Can't be given with ``longitude`` and ``latitude``. ``longitude`` and ``latitude`` Use the position given by this coordinates. Can't be given with ``member`` ``radius`` Similar to GEORADIUS, search inside circular area according the given radius. Can't be given with ``height`` and ``width``. ``height`` and ``width`` Search inside an axis-aligned rectangle, determined by the given height and width. Can't be given with ``radius`` ``unit`` must be one of the following : m, km, mi, ft. `m` for meters (the default value), `km` for kilometers, `mi` for miles and `ft` for feet. ``sort`` indicates to return the places in a sorted way, ASC for nearest to furthest and DESC for furthest to nearest. ``count`` limit the results to the first count matching items. ``any`` is set to True, the command will return as soon as enough matches are found. Can't be provided without ``count`` ``withdist`` indicates to return the distances of each place. ``withcoord`` indicates to return the latitude and longitude of each place. ``withhash`` indicates to return the geohash string of each place. For more information, see https://redis.io/commands/geosearch GEOSEARCHNrr r rrr,r-r+rZrrrrr!r_geosearchgeneric)r7rrr r rrr,r-r+rZrrrrs r: geosearchGeoCommands.geosearchsPz%%  #&  r=rs storedistcBURSUUUUUUUUU U U U SSSSU S9$)a This command is like GEOSEARCH, but stores the result in ``dest``. By default, it stores the results in the destination sorted set with their geospatial information. if ``store_dist`` set to True, the command will stores the items in a sorted set populated with their distance from the center of the circle or box, as a floating-point number. For more information, see https://redis.io/commands/geosearchstore GEOSEARCHSTORENr0r1)r7rsrrr r rrr,r-r+rZrr5s r:geosearchstoreGeoCommands.geosearchstoresR4%%    %&  r=c[U5nUScUSbUSc [S5eUS(a5US(d US(a [S5eURSUS/5 USb USbURSUSUS/5 UScUS bUS c [S 5eUS c [S 5eUS R5S;a [S5eUS(a9US (d US (a [S5eURSUSUS /5 US (a(US (aURSUS US US /5 US(a]USR 5S:XaUR S5 O4USR 5S:XaUR S5 O [S5eUS(a2URSUS/5 US(aUR S5 OUS(a [S5eSH!upVX5(dMUR U5 M# US:XaUS OUS!/US"'UR "U/UQ70UD6$)#Nrr r z4GEOSEARCH must have member or longitude and latitudez?GEOSEARCH member and longitude or latitude cant be set togethers FROMMEMBERs FROMLONLATrr,r-z.GEOSEARCH must have radius or width and heightrzGEOSEARCH must have unitrzGEOSEARCH invalid unitz9GEOSEARCH radius and width or height cant be set togethersBYRADIUSsBYBOXr+r%sASCr&r&zGEOSEARCH invalid sortrZr7rsANYz1GEOSEARCH ``any`` can't be provided without count))rsWITHDIST)rs WITHCOORD)rsWITHHASH)rr'r/rr-rp)rrrrrDrKr6r(s r:r2GeoCommands._geosearchgenericsd (  #k"*fZ.@.H VWW ( k"fZ&8U MM=&*:; < +  *vj/A/M MM=&*=vj?QR S (  #g&&*:*B PQQ &> !67 7 &>   !)@ @45 5 ( g&"2O MM;x(8&.I J '?vh/ MM8VG_fX6FvW X &>f~##%. f%%%'61 g& 899 '? MM8VG_5 6e} f% E]OP P$ H  i($ &- %;$q'aIv##G?f???r=r)FFFr) NFFFNNNNF) NNNrNNNNNFFFF) NNNrNNNNNFF)rrrrrr#rrrr&rr rrrrr rrIrrrrr3r8r2rrr=r:rrs (7(7$(7  (7  (7  (7 (7VQUEE"(E28E@H E E$KDK6KiKJ4J&JYJ ##" $%)= = =  =  = sm = = = = }= sm= ~= TN= =  = H##"#'(,% % %  % sm %  % % % }% sm% T4Z % $*%% %  % N,@,@#-,@9>z4?O9P,@ ,@b'+(,'+%)$(%)"#O O fdl#O % O t $ O  O eTk"O UD[!O eTk"O smO }O O O O O !O j$(%)$("&!%"&"#- - -  - E? - 5/ - - - - - sm- }- - -  - ^@@@@#-@@9>z4?O9P@@ @@r=rc \rSrSrSrS\4SjrSS\S\\ \S\\ \S\4S jjr S\4S jr S\4S jr SS jr S\4S jrS\4SjrS\4SjrSrg)ModuleCommandsiLzC Redis Module commands. see: https://redis.io/topics/modules-intro r3c*UR"SU/UQ76$)z Loads the module from ``path``. Passes all ``*args`` to the module, during loading. Raises ``ModuleError`` if a module is not found at ``path``. For more information, see https://redis.io/commands/module-load z MODULE LOADr5)r7pathr@s r: module_loadModuleCommands.module_loadRs##M4?$??r=Nr?rqr@c/nUb"URS5 URU5 Ub"URS5 URU5 UR"SU/UQ76$)z Loads a module from a dynamic library at runtime with configuration directives. For more information, see https://redis.io/commands/module-loadex CONFIGARGSz MODULE LOADEXr)r7r?rqr@r9s r: module_loadexModuleCommands.module_loadex\s]   MM( # MM' "   MM& ! MM$ ##OTCFCCr=c&URSU5$)z Unloads the module ``name``. Raises ``ModuleError`` if ``name`` is not in loaded modules. For more information, see https://redis.io/commands/module-unload z MODULE UNLOADr5rs r: module_unloadModuleCommands.module_unloadqs##OT::r=c$URS5$)z Returns a list of dictionaries containing the name and version of all loaded modules. For more information, see https://redis.io/commands/module-list z MODULE LISTr5rs r: module_listModuleCommands.module_listzs##M22r=c[S5er'r(rs r:r*ModuleCommands.command_infor,r=c$URS5$)Nr.r5rs r:r/ModuleCommands.command_counts##O44r=c(UR"S/UQ76$)NzCOMMAND GETKEYSr5r<s r:command_getkeysModuleCommands.command_getkeyss##$5===r=c$URS5$)Nr#r5rs r:r$ModuleCommands.commands##I..r=rrr)rrrrrr&r@rrr rErHrKr*r/rRr$rrr=r:r=r=Ls @)@(,$( DD$s)$DtCy! D  D*;Y;3Y3 5y5> >//r=r=c,^\rSrSrSU4SjjrSrU=r$)AsyncModuleCommandsic(># [TU]5$7frr!rs r:r* AsyncModuleCommands.command_inforrrr)rrrrr*rr/r0s@r:rWrWs &&r=rWcB\rSrSrSrS\4SjrS\4SjrS\4SjrSr g) ClusterCommandsiz" Class for Redis Cluster commands r3cPUR"SUR53/UQ70UD6$)NzCLUSTER )r6rD)r7 cluster_argr@r8s r:clusterClusterCommands.clusters.##h{/@/@/B.C$DVtVvVVr=c &UR"S0UD6$)z Disables read queries for a connection to a Redis Cluster slave node. For more information, see https://redis.io/commands/readwrite ) READWRITEr5rSs r: readwriteClusterCommands.readwriterr=c &UR"S0UD6$)z Enables read queries for a connection to a Redis Cluster replica node. For more information, see https://redis.io/commands/readonly )READONLYr5rSs r:readonlyClusterCommands.readonlyrVr=rN) rrrrrr&r^rbrfrrr=r:r[r[s-WyW;Y;:I:r=r[c \rSrSrSrSS\S\\S\\ \\44Sjjr S\S\\ \\44Sjr SS \S\\ \\44S jjr SS\\S \\S\\ \ \ 44S jjrS \S\S\S\\ \\44SjrS\S\S\\ \\44SjrS\S\S\\ \\44SjrS\\ \\44SjrSS\S\\S\\ \\44SjjrS\\ \\44SjrS\\ \ \ 44SjrSrg)FunctionCommandsiz Redis Function commands coderr3cbU(aS/O/nURU5 UR"S/UQ76$)aP Load a library to Redis. :param code: the source code (must start with Shebang statement that provides a metadata about the library) :param replace: changes the behavior to overwrite the existing library with the new contents. Return the library name that was loaded. For more information, see https://redis.io/commands/function-load rz FUNCTION LOADr)r7rjrr9s r: function_loadFunctionCommands.function_loads1!()R d##O=f==r=libraryc&URSU5$)z Delete the library called ``library`` and all its functions. For more information, see https://redis.io/commands/function-delete zFUNCTION DELETEr5)r7rns r:function_delete FunctionCommands.function_deletes ##$5w??r=rc&URSU5$)z` Deletes all the libraries. For more information, see https://redis.io/commands/function-flush zFUNCTION FLUSHr5rs r:function_flushFunctionCommands.function_flushs ##$4d;;r=withcodec`SU/nU(aURS5 UR"S/UQ76$)z Return information about the functions and libraries. Args: library: specify a pattern for matching library names withcode: cause the server to include the libraries source implementation in the reply LIBRARYNAMEWITHCODEz FUNCTION LISTr)r7rnrur@s r: function_listFunctionCommands.function_lists3w'  KK ###O;d;;r=r$rrc*UR"XU/UQ76$rr5)r7r$functionrrs r:_fcallFunctionCommands._fcalls##GwOOOr=c*UR"SX/UQ76$)zO Invoke a function. For more information, see https://redis.io/commands/fcall FCALLr}r7r|rrs r:fcallFunctionCommands.fcalls{{7HF FFr=c*UR"SX/UQ76$)z This is a read-only variant of the FCALL command that cannot execute commands that modify data. For more information, see https://redis.io/commands/fcall_ro FCALL_ROrrs r:fcall_roFunctionCommands.fcall_ros{{:xI=IIr=c>SSKJn 0n/X!'UR"S0UD6$)zw Return the serialized payload of loaded libraries. For more information, see https://redis.io/commands/function-dump rrj)z FUNCTION DUMPrnrps r: function_dumpFunctionCommands.function_dumps( . "##?w??r=payloadpolicyc&URSX5$)z Restore libraries from the serialized ``payload``. You can use the optional policy argument to provide a policy for handling existing libraries. For more information, see https://redis.io/commands/function-restore zFUNCTION RESTOREr5)r7rrs r:function_restore!FunctionCommands.function_restores##$6HHr=c$URS5$)zq Kill a function that is currently executing. For more information, see https://redis.io/commands/function-kill z FUNCTION KILLr5rs r: function_killFunctionCommands.function_kills ##O44r=c$URS5$)z Return information about the function that's currently running and information about the available execution engines. For more information, see https://redis.io/commands/function-stats zFUNCTION STATSr5rs r:function_statsFunctionCommands.function_stats%s##$455r=rNrrl)rF)r_)rrrrrrrrrrrlrprsr ryrIrr}rrrrrrrrr=r:riris 49>>"*4.> y~s" #>"@s@uYs^S5H/I@<3tn< y$ %<"PP/2PDGP y~s" #P G!$G69G y~s" #G J!$ J69 J y~s" # J @uYs^S%89 @5= I I$,SM I y~s" # I5uYs^S%8956iot&; <6r=ric\rSrSrSrSrg)DataAccessCommandsi2z A class containing all of the implemented data access redis commands. This class is to be used as a mixin for synchronous Redis clients. rNrrrrrrrr=r:rr2r=rc\rSrSrSrSrg)AsyncDataAccessCommandsiCz A class containing all of the implemented data access redis commands. This class is to be used as a mixin for asynchronous Redis clients. rNrrr=r:rrCrr=rc\rSrSrSrSrg) CoreCommandsiTz~ A class containing all of the implemented redis commands. This class is to be used as a mixin for synchronous Redis clients. rNrrr=r:rrTr=rc\rSrSrSrSrg)AsyncCoreCommandsidz A class containing all of the implemented redis commands. This class is to be used as a mixin for asynchronous Redis clients. rNrrr=r:rrdrr=r)_rrrenumrtypingrrrrrr r r r r rrrrrrredis.exceptionsrrrr redis.typingrrrrrrrrr r!r"r#r$r%r&r'r(r)r* redis.utilsr+r,helpersr.rredisror0AsyncACLCommandsrrr2r]rrAsyncListCommandsr2r`rlAsyncSetCommandsrAsyncStreamCommandsr?AsyncSortedSetCommandsrAsyncHyperlogCommandsrrAsyncHashCommandsr{rrAsyncPubSubCommandsrrrAsyncGeoCommandsr=rWr[AsyncClusterCommandsriAsyncFunctionCommandsrrrrrr=r:rs&SR* "K<"K<\ g )g T0;00;fm5m5`yG'yGx!,!(^ #^ B !\#\~l l^o@"o@dY <%Y