ng\j$tSSKJr SSKrSSKrSSKrSSKrSrSSKrSSK J r SSK J r J r JrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJr SSKJ r J!r!J"r"J#r# SS K$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r:J;r;Jr>J?r?J@r@JArAJBrBJCrCJDrDJErEJFrFJGrGJHrHJIrIJJrJJKrKJLrLJMrMJNrNJOrOJPrPJQrQJRrR SS KSJTrTJUrUJVrVJWrWJXrX S S KYJZrZ S S K[J\r\Jr SSK]J^r^J_r_ \ (aSSK`raSSKbraSSKcraSSKdra"SS\05re\erf"SS\ 5rg"SS\05rh"SS\h5ri"SS5rj"SS\ 5rk"SS\05rl"SS\l5rm"S S!\05rn\nro"S"S#\ 5rp"S$S%\ 5rq"S&S'\ 5rr"S(S)\05rs\srt"S*S+\05ru"S,S-\u5rv"S.S/\05rw\wrx"S0S1\05ry\yrz"S2S3\05r{\{r|"S4S5\05r}\}r~"S6S7\ 5r"S8S9\05r\r"S:S;5r"S<S=5r"S>S?\05r\r"S@SA\05r"SBSC\5r"SDSE\05r\r"SFSG\05r"SHSI\5r"SJSK\05r\r"SLSM5r\r"SNSO\l\}\\\n\s\u\w\y\{5 r"SPSQ\m\~\\\o\t\v\x\z\|5 r"SRSS\e\\\h\\\\5 r"STSU\f\\\i\\\\5 rg!\a SrGNf=f)V) annotationsNTF)Enum) TYPE_CHECKINGAny AsyncIterator AwaitableCallableDictIterableIteratorListLiteralMappingOptionalSequenceTupleUnionoverload)"record_streaming_lag_from_response)ConnectionError DataError NoScriptError RedisError). AbsExpiryTACLGetUserData ACLLogDataAnyKeyTAsyncClientProtocolBitfieldOffsetTBlockingListPopResponseBlockingZSetPopResponseChannelTClientTrackingInfoResponseCommandGetKeysAndFlagsResponseCommandsProtocol ConsumerT EncodableTExpiryTFieldT GeoCoordinateGeoRadiusResponseGeoSearchResponseGroupTHRandFieldResponse HScanResponseKeysTKeyTLCSCommandResponseListMultiPopResponseNumberPatternT ResponseT ScanResponse ScriptTextT SortResponseStralgoResponse StreamIdTStreamRangeResponseSyncClientProtocol TimeoutSecTXClaimResponseXPendingRangeResponseXReadGroupResponse XReadResponse ZMPopResponseZRandMemberResponse ZScanResponse ZScoreBoundTZSetRangeResponse)deprecated_functionexperimental_argsexperimental_methodextract_expire_flags str_if_bytes)PubSubDirection)record_pubsub_messager)at_most_one_value_set list_or_argsc\rSrSrSr\S/S0Sjj5r\S/S1Sjj5rS/S2Sjjr\S3Sj5r\S4Sj5rS5S jr\S6S j5r\S7S j5rS8S jr\S/S9S jj5r \S/S:Sjj5r S/S;Sjjr \SSjr \S?Sj5r \S@Sj5r SASjr \S?Sj5r \S@Sj5r SASjr \S/SBSjj5r \S/SCSjj5r S/SDSjjr \SESj5r\SFSj5rSGSjr\SESj5r\SFS j5rSGS!jr\SES"j5r\SFS#j5rSGS$jr\SHSIS%jj5r\SHSJS&jj5rSHSKS'jjr\S?S(j5r\S@S)j5rSAS*jr\SLS+j5r\SMS,j5rSNS-jrS.rg)O ACLCommandsnzL Redis Access Control List (ACL) commands. see: https://redis.io/topics/acl Nc gNselfcategorykwargss N/home/edenadmin/noVNC/venv/lib/python3.13/site-packages/redis/commands/core.pyacl_catACLCommands.acl_catt c grWrXrYs r]r^r_y(+rac 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)rZr[r\piecess r]r^r_~s*2:H:r##IAA&AAracgrWrXrZusernameargsr\s r] acl_dryrunACLCommands.acl_dryrunracgrWrXris r]rlrm"%rac0UR"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 DRYRUNreris r]rlrms!##L(LTLVLLracgrWrXrZrjr\s r] acl_deluserACLCommands.acl_deluserPSracgrWrXrss r]rtrurac.UR"S/UQ70UD6$)zr Delete the ACL for the specified ``username``\s For more information, see https://redis.io/commands/acl-deluser z ACL DELUSERrerss r]rtrus ##MGHGGGrac grWrXrZbitsr\s r] acl_genpassACLCommands.acl_genpassrnrac grWrXr{s r]r}r~rprac /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 ValueErrorappendrrf)rZr|r\rgbs r]r}r~sz   Iq5AH$$ a ##MEFEfEE  U s .A A!c grWrXrss r] acl_getuserACLCommands.acl_getuserrxrac grWrXrss r]rr%(rac *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 GETUSERrerss r]rrs##M8FvFFrac grWrXrZr\s r]acl_helpACLCommands.acl_helpKNrac grWrXrs r]rrrcrac &UR"S0UD6$)zThe ACL HELP command returns helpful text describing the different subcommands. For more information, see https://redis.io/commands/acl-help )zACL HELPrers r]rr ##9&99rac grWrXrs r]acl_listACLCommands.acl_listrrac grWrXrs r]rrrcrac &UR"S0UD6$)zg Return a list of all ACLs on the server For more information, see https://redis.io/commands/acl-list )zACL LISTrers r]rrrrac grWrXrZcountr\s r]acl_logACLCommands.acl_lograc grWrXrs r]rr !$rac /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) isinstancerrrrf)rZrr\rks r]rrsO  eS)) BCC KK ##I????rac grWrXrs r] acl_log_resetACLCommands.acl_log_reset"CFrac grWrXrs r]rr%ORrac 4S/nUR"S/UQ70UD6$)z_ Reset ACL logs. :rtype: Boolean. For more information, see https://redis.io/commands/acl-log sRESETrre)rZr\rks r]rr(s&z##I????rac grWrXrs r]acl_loadACLCommands.acl_load2>Arac grWrXrs r]rr5JMrac &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 LOADrers r]rr8##9&99rac grWrXrs r]acl_saveACLCommands.acl_saveCrrac grWrXrs r]rrFrrac &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 SAVErers r]rrIrrac grWrXrZrjenablednopass passwordshashed_passwords categoriescommandskeyschannels selectorsreset reset_keysreset_channelsreset_passwordsr\s r] acl_setuserACLCommands.acl_setuserTs$rac grWrXrs r]rrhs$rac  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>%srPN-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_encoderrrrR enumerateencode startswithdecoderf)rZrjrrrrrrrrrrrrrr\encoderrgipasswordhashed_passwordr[cmdkeychannels r]rr|s}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&##MEFEfEErac grWrXrs r] acl_usersACLCommands.acl_users;LOrac grWrXrs r]rr>rcrac &UR"S0UD6$)zuReturns a list of all registered users on the server. For more information, see https://redis.io/commands/acl-users )z ACL USERSrers r]rrCs ##:6::rac grWrXrs r] acl_whoamiACLCommands.acl_whoamiJGJrac grWrXrs r]rrMSVrac &UR"S0UD6$)zlGet the username for the current connection For more information, see https://redis.io/commands/acl-whoami )z ACL WHOAMIrers r]rrPs ##;F;;rarXrW)rZr=r[ str | Nonereturnlist[bytes | str])rZrr[rrAwaitable[list[bytes | str]])r[rr0list[bytes | str] | Awaitable[list[bytes | str]])rZr=rjstrrkr'r bytes | str)rZrrjrrkr'rAwaitable[bytes | str])rjrrkr'r$bytes | str | Awaitable[bytes | str])rZr=rjrrr)rZrrjrrAwaitable[int])rjrrint | Awaitable[int])rZr=r| int | Nonerr)rZrr|rrr)r|rrr)rZr=rjrrr)rZrrjrrzAwaitable[ACLGetUserData])rjrrz*ACLGetUserData | Awaitable[ACLGetUserData]rZr=rrrZrrrrr)rZr=rrrr)rZrrrrzAwaitable[ACLLogData])rrrz"ACLLogData | Awaitable[ACLLogData]rZr=rboolrZrrAwaitable[bool]rbool | Awaitable[bool]) FFNNNNNNNFFFF) rZr=rjrrrrrrstr | Iterable[str] | NonerrrIterable[str] | NonerrrIterable[KeyT] | NonerIterable[ChannelT] | Noner!Iterable[Tuple[str, KeyT]] | Nonerrrrrrrrrr) rZrrjrrrrrrrrrrrrrrrrrrrrrrrrrrrrr)rjrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrZr=rrrZrrrrr)__name__ __module__ __qualname____firstlineno____doc__rr^rlrtr}rrrrrrrrrr__static_attributes__rXrar]rTrTnsF 9=   ,6   :>+!+-7+ %++ &* B" B 9 B ,/8B %!%-0%9C% %%MSS !.1 H59 (2 6:%!%)3% %%F* ,/ (!(-0( "(( G G 3 GNN +!+ %++:NN +!+ %++:6: )3 7;$!$*4$ $$ #'@@ +@$FF RR@AA MM :AA MM :047;+/)-&*.27; $ %   .  5 )'$,5" #&047;+/)-&*.27; $ %!  .  5 )'$,5" #,047;+/)-&*.27; $ %}F}F}F }F . }F 5 }F)}F'}F$}F,}F5}F}F}F}F}F" #}F~OO +!+ %++;JJ VVjjr\SGSS?jj5r\SGSS@jj5rSGSSAjjr\GSSBj5r\GSSCj5rGSSDjr\GSSEj5r\GSSFj5rGSSGjr\GSSHj5r\GSSIj5rGSSJjr\GSSKj5r\GSSLj5rGS SMjrGS!SNjr\SSOj5r\SSPj5rSSQjr\GS"GS#SRjj5r \GS"GS$SSjj5r GS"GS%STjjr \GS&SUj5r!\GS'SVj5r!GS(SWjr!SXr"\GS)GS*SYjj5r#\GS)GS+SZjj5r#GS)GS,S[jjr#\GS-S\j5r$\GS.S]j5r$GS/S^jr$\GS0S_j5r%\GS1S`j5r%GS2Sajr%\GSSbj5r&\GSScj5r&GSSdjr&\SSej5r'\SSfj5r'SSgjr'\GS3Shj5r(\GS4Sij5r(GS5Sjjr(GS!Skjr)\GS6Slj5r*\GS7Smj5r*GS8Snjr*\GSGS9Sojj5r+\GSGS:Spjj5r+GSGS;Sqjjr+\GSGS9Srjj5r,\GSGS:Ssjj5r,GSGS;Stjjr,\GSSwjr-\GS?Sxj5r.\GS@Syj5r.GSASzjr.\GSBS{j5r/\GSCS|j5r/GSDS}jr/\GSES~j5r0\GSFSj5r0GSGSjr0\SGSHSjj5r1\SGSISjj5r1SGSJSjjr1\GSKSj5r2\GSLSj5r2GSMSjr2Sr3Sr4\GSNSj5r5\GSOSj5r5GSPSjr5\GSSj5r6\GSSj5r6GSSjr6\GSQGSRSjj5r7\GSQGSSSjj5r7GSQGSTSjjr7\GSUSj5r8\GSVSj5r8GSWSjr8GS!Sjr9GS!Sjr:\GSXSj5r;\GSYSj5r;GSZSjr;\GSSj5r<\GSSj5r\GS1Sj5r>GS2Sjr>Sr?\GS^Sj5r@\GS_Sj5r@GS`Sjr@\GSaSj5rA\GSbSj5rAGScSjrA\GSdSj5rB\GSeSj5rBGSfSjrB\GS0Sj5rC\GS1Sj5rCGSgSjrC\GS0Sj5rD\GS1Sj5rDGS2SjrD\GSSj5rE\GSSj5rEGSSjrE\GS0Sj5rF\GS1Sj5rFGS2SjrFGShGSiSjjrG\GSjGSkSjj5rH\GSjGSlSjj5rHGSjGSmSjjrH\SGSnSjj5rI\SGSoSjj5rISGSpSjjrI\SSj5rJ\SSj5rJSSjrJ\GS0Sj5rK\GS1Sj5rKGS2SjrK\GSqSj5rL\GSrSj5rLGSsSjrL\GStSj5rM\GSuSj5rMGSvSjrM\GSwSj5rN\GSxSj5rNGSySjrNSrOSrP\GSzGS{Sjj5rQ\GSzGS|Sjj5rQGSzGS}SjjrQ\GSSj5rR\GSSj5rRGSSjrR\GSSj5rS\GSSj5rSGSSjrS\GS~Sj5rT\GSSj5rTGSSjrTSrUg(ManagementCommandsi`z Redis management commands Nc grWrXrZrrjr\s r]authManagementCommands.authe rac grWrXrs r]rrm rac |/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 AUTHrrf)rZrrjr\rgs r]rrusB   MM( # h##F>V>v>>rac grWrXrs r] bgrewriteaofManagementCommands.bgrewriteaofrvrac grWrXrs r]rr),rac &UR"S0UD6$)zTell the Redis server to rewrite the AOF file from data in memory. For more information, see https://redis.io/commands/bgrewriteaof ) BGREWRITEAOFrers r]rr##=f==raTc grWrXrZscheduler\s r]bgsaveManagementCommands.bgsave!rac grWrXr$s r]r&r'rrac 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)rZr%r\rgs r]r&r's3  MM* %##H@v@@@racgrWrXrZs r]roleManagementCommands.roles58racgrWrXr.s r]r/r0sADrac$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 ROLErer.s r]r/r0s##F++rac grWrXrZaddressr\s r] client_killManagementCommands.client_killUXrac grWrXr5s r]r7r8rrac *UR"SU40UD6$)zqDisconnects the client at ``address`` (ip:port) For more information, see https://redis.io/commands/client-kill CLIENT KILLrer5s r]r7r8s##M7EfEErac grWrX rZ_id_typeaddrskipmeladdrusermaxager\s r]client_kill_filter%ManagementCommands.client_kill_filtersrac grWrXr>s r]rFrGsrac 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)rONOIDsADDRsLADDRsUSERsMAXAGEzVCLIENT KILL ... ... must specify at least one filterr<)rlowerrextendrrrf) rZr?r@rArBrCrDrEr\rk client_typess r]rFrGs+0  BL5z!5"B
v>>racgrWrXrZmoduler[patterns r] command_listManagementCommands.command_list*  racgrWrXrs r]rr2 (+rac/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)rSinsertrf)rZrr[rrgs r]rr:su   MM8V, -   MM8X. /   MM9g. /  MM!Z (##Nrac grWrXrs r]r,r-rrac &UR"S0UD6$)zp Returns the number of keys in the current database For more information, see https://redis.io/commands/dbsize )DBSIZErers r]r,r-s ##777rac grWrXrZrr\s r] debug_objectManagementCommands.debug_object.1rac grWrXr3s r]r4r5s9s r]r?r@rprac *UR"SU40UD6$)z` Echo the string back from the server For more information, see https://redis.io/commands/echo ECHOrer>s r]r?r@s##FESSKJn 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.clientr\rfrZr\optionss r]rVrW7s( . "##6g66racgrWrXrZ replicationidoffsets r]psyncManagementCommands.psyncCrracgrWrXrds r]rgrhFracBSSKJn 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 rr[PSYNCr_)rZrerfr\rbs r]rgrhKs, . "##G]NgNNrac grWrXrZfirstsecondr\s r]swapdbManagementCommands.swapdbXr9rac grWrXrns r]rqrr[rrac *UR"SX40UD6$)zP Swap two databases For more information, see https://redis.io/commands/swapdb SWAPDBrerns r]rqrr`s ##HeFvFFrac grWrXrZindexr\s r]selectManagementCommands.selecthHKrac grWrXrws r]ryrzkrArac *UR"SU40UD6$)zSSelect the Redis logical database at index. See: https://redis.io/commands/select SELECTrerws r]ryrzns ##He>v>>racgrWrXrZsectionrkr\s r]infoManagementCommands.infou racgrWrXrs r]rr}s %(racZUcUR"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)rrers r]rrs: ?''9&9 9''I$I&I Irac grWrXrs r]lastsaveManagementCommands.lastsaverrac grWrXrs r]rrrcrac &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 )LASTSAVErers r]rrs##9&99rac[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 rr.s r]latency_doctor!ManagementCommands.latency_doctor "   rac[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 rr.s r] latency_graph ManagementCommands.latency_graphrracgrWrXrZversion_numbersr\s r]lolwutManagementCommands.lolwutrnracgrWrXrs r]rrrprac`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)LOLWUTrers r]rrs7 ''(8U?UfU U'';F; ;racgrWrXr.s r]rManagementCommands.reset8;racgrWrXr.s r]rrrnrac$URS5$)zdPerform a full reset on the connection's server-side context. See: https://redis.io/commands/reset RESETrer.s r]rrs ##G,,rac  grWrX rZhostportrdestination_dbrcopyreplacerr\s r]migrateManagementCommands.migratesrac  grWrXrs r]rrs"%rac  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)rRrrrSrf) rZrrrrrrrrr\rgs r]rrs>D"%?@ @  MM' "  MM* %  MM' " MM$  g d## t2~ AG KQ  rac grWrXrZinfotyperr\s r]objectManagementCommands.object5r9rac grWrXrs r]rr8rxrac .UR"SX4SU0UD6$)z: Return the encoding, idletime, or refcount about the key OBJECTrrers r]rr=s,## h .6 :@  rac [S5e)Nz MEMORY DOCTOR is intentionally not implemented in the client. For more information, see https://redis.io/commands/memory-doctor rrs r] memory_doctor ManagementCommands.memory_doctorEr<rac [S5e)Nz MEMORY HELP is intentionally not implemented in the client. For more information, see https://redis.io/commands/memory-help rrs r] memory_helpManagementCommands.memory_helpNr<rac grWrXrs r] memory_statsManagementCommands.memory_statsWrrac grWrXrs r]rrZrrac &UR"S0UD6$)zg Return a dictionary of memory stats For more information, see https://redis.io/commands/memory-stats )z MEMORY STATSrers r]rr_ ##=f==rac grWrXrs r]memory_malloc_stats&ManagementCommands.memory_malloc_statsgrvrac grWrXrs r]rrjrprac &UR"S0UD6$)zu Return an internal statistics report from the memory allocator. See: https://redis.io/commands/memory-malloc-stats )zMEMORY MALLOC-STATSrers r]rros ##DVDDrac grWrXrZrsamplesr\s r] memory_usageManagementCommands.memory_usagewrrac grWrXrs r]rr|rrac /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)rrrSrf)rZrrr\rks r]rrsD gs # # KKW- .##NCI$I&IIrac grWrXrs r] memory_purgeManagementCommands.memory_purgerrac grWrXrs r]rrrrac &UR"S0UD6$)z~ Attempts to purge dirty pages for reclamation by allocator For more information, see https://redis.io/commands/memory-purge )z MEMORY PURGErers r]rrrrac[S5e)rzALATENCY HISTOGRAM is intentionally not implemented in the client.rrs r]latency_histogram$ManagementCommands.latency_histograms " O  racgrWrXrZevents r]latency_history"ManagementCommands.latency_historyrhracgrWrXrs r]rrrrac&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 HISTORYrers r]rrs##$5u==racgrWrXr.s r]latency_latest!ManagementCommands.latency_latestrracgrWrXr.s r]rr47rac$URS5$)zo Reports the latest latency events logged. For more information, see https://redis.io/commands/latency-latest zLATENCY LATESTrer.s r]rrs##$455racgrWrXrZeventss r] latency_reset ManagementCommands.latency_resetr#racgrWrXrs r]rrrhrac(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 RESETrers r]rrs ##O=f==rac grWrXrs r]pingManagementCommands.ping:=rac grWrXrs r]rrr#rac &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 )PINGrers r]rrs##5f55rac grWrXrs r]quitManagementCommands.quitrrac grWrXrs r]rrr#rac &UR"S0UD6$)zc Ask the server to close the connection. For more information, see https://redis.io/commands/quit )QUITrers r]rrs ##5f55racgrWrXrZrkr\s r] replicaofManagementCommands.replicaofrracgrWrXrs r]rrrprac.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 REPLICAOFrers r]rrs##KA$A&AArac grWrXrs r]saveManagementCommands.saverrac grWrXrs r]rrr#rac &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 )SAVErers r]rr##5f55rac 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.rrrfrrrZrnosavenowrabortr\rks r]shutdownManagementCommands.shutdown#s, FIJ J|  KK   KK !  KK   KK  KK    $ 1& 19::   sB33 C?Cc grWrXrZrrr\s r]slaveofManagementCommands.slaveofMrrac grWrXrs r]rrUrrac 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 )SLAVEOFrPsONErrers r]rr]s9 v>>rac grWrXrs r]timeManagementCommands.timeEHrac grWrXrs r]r5r6rXrac &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 )TIMErers r]r5r6rrac grWrXrZ num_replicasrr\s r]waitManagementCommands.waitrac grWrXr<s r]r>r?rxrac *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 WAITrer<s r]r>r?s##FLLVLLrac grWrXrZ num_localr=rr\s r]waitaofManagementCommands.waitaofrac grWrXrEs r]rGrH #rac ,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 WAITAOFrerEs r]rGrHs&## y ;A  rac[S5e)rz5HELLO is intentionally not implemented in the client.rr.s r]helloManagementCommands.hellos " C  rac[S5e)rz8FAILOVER is intentionally not implemented in the client.rr.s r]failoverManagementCommands.failovers " F  rac grWrXrZmetricsrduration sample_ratioslotsr\s r] hotkeys_start ManagementCommands.hotkeys_startrrac grWrXrUs r]rZr[ rrac SS/nURS[U5/5 URUVs/sHn[UR5PM sn5 UbURSU/5 UbURSU/5 UbURSU/5 Ub<UR S5 UR [U55 URU5 UR "U0UD6$s snf)a@ Start collecting hotkeys data. Returns an error if there is an ongoing collection session. Args: count: The number of keys to collect in each criteria (CPU and network consumption) metrics: List of metrics to track. Supported values: [HotkeysMetricsTypes.CPU, HotkeysMetricsTypes.NET] duration: Automatically stop the collection after `duration` seconds sample_ratio: Commands are sampled with probability 1/ratio (1 means no sampling) slots: Only track keys on the specified hash slots For more information, see https://redis.io/commands/hotkeys-start HOTKEYSSTARTMETRICSCOUNTDURATIONSAMPLESLOTS)rSrrrrrf) rZrVrrWrXrYr\rkms r]rZr[ s,(1'&: YG -. 737aS\734   KK%( )   KKX. /  # KK<0 1   KK KKE # KK ##T4V44)4sC)c grWrXrs r] hotkeys_stopManagementCommands.hotkeys_stopA ILrac grWrXrs r]rgrhD r9rac &UR"S0UD6$)z Stop the ongoing hotkeys collection session (if any). The results of the last collection session are kept for consumption with HOTKEYS GET. For more information, see https://redis.io/commands/hotkeys-stop )z HOTKEYS STOPrers r]rgrhG r"rac grWrXrs r] hotkeys_reset ManagementCommands.hotkeys_resetP rrac grWrXrs r]rmrnS rprac &UR"S0UD6$)z Discard the last hotkeys collection session results (in order to save memory). Error if there is an ongoing collection session. For more information, see https://redis.io/commands/hotkeys-reset )z HOTKEYS RESETrers r]rmrnX s##>v>>rac grWrXrs r] hotkeys_getManagementCommands.hotkeys_geta rcrac grWrXrs r]rrrsf rrac &UR"S0UD6$)al Retrieve the result of the ongoing collection session (if any), or the last collection session (if any). HOTKEYS GET response is wrapped in an array for aggregation support. Each node returns a single-element array, allowing multiple node responses to be concatenated by DMC or other aggregators. For more information, see https://redis.io/commands/hotkeys-get )z HOTKEYS GETrers r]rrrsk s ##rGrOrRrZrgrmrrr rXrar]rr`s $    $!  59 ? ?'1 ?  ?SS ,!, &,,>37! !,0! !!48,!,-1, &,, A88 DD,XX $!$,/$ $$F "!!                 "!! !               "!!4D 4D4D 4D  4D  4D4D4D 4DlTT .!. (.. = ? =!&(# ##$#  ##!&(.!..$. ) ..#'bDD3CD ?D6UU ,!, &,,@GG SSA +   %!%+% %% E0AA MM; $!#        $!#%!%%% %  %  %% %% $!#           0 & $!#        $!#%!%%% %  %  %% %% $!#           0 &#!#                #!# %! %  % % %  %  % % %  % %#!#:J :J:J :J  :J  :J:J:J 0:Jx) ) #))4!4 .44 E K ERR !),  F (+47 !),58 M@E -09= AF!.1:>  -255%)5 5 <@ +.59 =A!,/6:  )-55!%5 5<NN %!% %%@PP %!%),% %%=PP %!%),% %% =UU 3!3 -339 I9 EE QQ?"#"           "#" +!+++ + & ++"#" === = : =8- -),- '--8!8*-8 288FF SF 69+ ++3+BJ+ %++7:6!6,46CK6 066 #&LL.6L OL '   !'    P P P' P PII UUBNN %!% %%@>> JJ81 1'+1 +11<!<(,< 6<<C WW %!%*4% %%=7< 04 8=!15  A A7< 04 8=!15  @ @44 @@ 7VV !25?B  OXX !*-7: GKK WW?"&   "&(!((( # (((,J$J47J 3J&NN +!+ %++:     4E %!%5F% %% <;; GG-                 %! % % % %  %  % % % %  % %(. . .  .  .  . . . .  0. `XX !-07;    OO (!( "((>SS %!% %%ECG '+6@ DH$!$(,$7A$ $$J$EE QQ> UU )!)*-) #))>> 5>VV 7!7 1776 Q6II UU>== II 6== II6PP %!% %% B== II6 (;(;(; (;  (;  (; (;T     !  ;? E E-7 E  E48# #'1# ##59.!.(2. (.. !%55 ?5&CC OO=FF RR?HH TT6 03>A !14?B  M    #!### #  ##    ,/  :=  )    !##'"&  *  !    !##'"& %!%*%% % ! %  % %%!##'"& .5*.5.5 .5 ! .5  .5 0.5`LL XX>MM %!% %%?+ + %++6!6 066= ==rarc^\rSrSrSU4SjjrSU4SjjrSU4SjjrSU4SjjrS S SjjrSr U=r $) AsyncManagementCommandsi~ c,># [TU]"S0UD6$7fNrXsuperrrZr\ __class__s r]r$AsyncManagementCommands.command_info sw#-f--c,># [TU]"S0UD6$7fr)rr:rs r]r:&AsyncManagementCommands.debug_segfault sw%///rc,># [TU]"S0UD6$7fr)rrrs r]r%AsyncManagementCommands.memory_doctor sw$.v..rc,># [TU]"S0UD6$7fr)rrrs r]r#AsyncManagementCommands.memory_help sw",V,,rc# 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 rr rr r r r Nrrrs r]r AsyncManagementCommands.shutdown s" FIJ J|  KK   KK !  KK   KK  KK  &&77 7 79:: 8   s<BCB?-B=.B?2 C=B?? C  C C  CrXrrr) rrrrrr:rrrr  __classcell__rs@r]rr~ sl.0/-  #;#;#; #;  #;  #; #;#;rarc\rSrSrSrS SSjjrSrSSjrS SSjjrSSjr SS jr \ S 5r SS jr S rg)BitFieldOperationi z( Command builder for BITFIELD commands. NcdXlX lX0l/UlSUlUR 5 g)NWRAP)clientr_default_overflow operations_last_overflowr)rZrrdefault_overflows r]__init__BitFieldOperation.__init__ s,  !18:$ rac|/UlSUlURUR=(d UR5 g)z< Reset the state of the instance to when it was constructed rN)rroverflowrr.s r]rBitFieldOperation.reset s0$ d,,C0C0CDracUR5nXR: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)upperrrr)rZrs r]rBitFieldOperation.overflow s>>># ** *"*  OO " "J#9 : racjUbURU5 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)rrr)rZfmtrf incrementrs r]incrbyBitFieldOperation.incrby s4(   MM( # #yAB rac@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. GETrr)rZrrfs r]r'BitFieldOperation.get s  s34 racBURRSXU45 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. SETr)rZrrfrs r]setBitFieldOperation.set s" sE:; racjSUR/nURHnURU5 M U$)NBITFIELD)rrrS)rZropss r]rBitFieldOperation.command s.488$??C JJsO# raclURnUR5 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. )rrrrf)rZrs r]executeBitFieldOperation.execute s+,, {{**G44ra)rrrrrrW)r9Union['redis.client.Redis', 'redis.asyncio.client.Redis']rrrr)rr)rrrfrrrrr)rrrfr)rrrfrrr)rr6)rrrrr rrrrr'rpropertyrrr rXrar]rr s+/ I  ( E $#'      4   5rarc\rSrSrSrSrSrg)DataPersistOptionsi! NXXXrXN)rrrrrrr rXrar]rr! s B Brarc \rSrSrSr\SSj5r\SSj5rSSjr\SSSjj5r\SSSjj5rSSS jjrSSS jjr\SSS jj5r \SSS jj5r SSS jjr \SSj5r \SSj5r SSjr \SSSjj5r \SSSjj5r SSSjjr \SSSjj5r \SSSjj5r SSSjjr \SSSjj5r \SSSjj5r SSSjjr \ r\SSj5r\SSj5rSSjrSSjr\SSSjj5r\SSS jj5r\"5SSS!jj5r\SS"j5r\SS#j5rSS$jr\SS%j5r\SS&j5rSS'jr\r\SSS(jj5r\SSS)jj5rSSS*jjr\SSS+jj5r\SSS,jj5rSSS-jjr\SS.j5r\SS/j5rSS0jr\"5SS1j5r\SS2j5r\SS3j5r\"5SS4j5r\SS5j5r\SS6j5rSS7jr\SS8j5r\SS9j5rSS:jr\SSS;jj5r\SSS<jj5rSSS=jjrSS>jr\SS?j5r\SS@j5rSSAjr\SSBj5r \SSCj5r SSDjr \SSEj5r!\SSFj5r!SSGjr!\SSSHjj5r"\SSSIjj5r"SSSJjjr"\"r#\SSSKjj5r$\SGSSLjj5r$SGSSMjjr$\SSSSSSSSSSSSN. GSSOjj5r%\SSSSSSSSSSSSN. GSSPjj5r%SSSSSSSSSSSSN. GSSQjjr%\GSGSSRjj5r&\GSGSSSjj5r&GSGSSTjjr&\GS GS SUjj5r'\GS GS SVjj5r'GS GS SWjjr'\GS GS SXjj5r(\GS GSSYjj5r(GS GSSZjjr(\GSS[j5r)\GSS\j5r)GSS]jr)\GSS^j5r*\GSS_j5r*GSS`jr*\GSGSSajj5r+\GSGSSbjj5r+GSGSScjjr+\GSSdj5r,\GSSej5r,GSSfjr,\GSSgj5r-\GSShj5r-GSSijr-\GSSjj5r.\GSSkj5r.GSSljr.\SSSmjj5r/\SSSnjj5r/SSSojjr/\SSSpjj5r0\SSSqjj5r0SSSrjjr0\SSsj5r1\SStj5r1SSujr1\GS Svj5r2\GS!Swj5r2GS"Sxjr2\GS#Syj5r3\GS$Szj5r3GS%S{jr3\SGS&S|jj5r4\SGS'S}jj5r4SGS(S~jjr4\GS)Sj5r5\GS*Sj5r5GS+Sjr5\GS,Sj5r6\GS-Sj5r6GS.Sjr6\GS,Sj5r7\GS-Sj5r7GS.Sjr7\GS/GS0Sjj5r8\GS/GS1Sjj5r8GS/GS2Sjjr8\GS3GS4Sjj5r9\GS3GS5Sjj5r9\:"/SQ5GS6GS7Sjj5r9GS8Sjr;\GS9Sj5r<\GS:Sj5r"SSSS9GS>Sj5r=\GS?Sj5r?\GS@Sj5r?GSASjr?\GSBSj5r@\GSCSj5r@GSDSjr@\GSEGSFSjj5rA\GSEGSGSjj5rAGSEGSHSjjrA\GS#Sj5rB\GS$Sj5rBGS%SjrB\GSIGSJSjj5rC\GSIGSKSjj5rCGSIGSLSjjrC\GSMSj5rD\GSNSj5rDGSOSjrD\GS#Sj5rE\GS$Sj5rEGS%SjrE\GSPSj5rF\GSQSj5rFGSRSjrFGSSSjrGGSTSjrH\SSj5rI\SSj5rISSjrI\GSUGSVSjj5rJ\GSUGSWSjj5rJGSUGSXSjjrJSrKg(YBasicKeyCommandsi+ z Redis basic key-based commands cgrWrXrZrrs r]rBasicKeyCommands.append0 rracgrWrXrs r]rr3 rxrac&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 APPENDrers r]rr8 s##Hc99raNcgrWrXrZrstartendrs r]bitcountBasicKeyCommands.bitcountB racgrWrXrs r]rrK racU/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 specifiedBITCOUNTr)rrrf)rZrrrrparamss r]rrT sz   MM% MM# CKS_BC C   MM$ ##JDDseDDrac[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 )r)r)rZrrs r]bitfieldBasicKeyCommands.bitfieldk s!=MNNracgrWrXrZrencodingrfitemss r] bitfield_roBasicKeyCommands.bitfield_rox rIracgrWrXrs r]r r  rKracUSX#/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 r BITFIELD_ROrrSrf)rZrr rfr rs r]r r  sT uh/  % H MM5(3 4!&##MGFG#GGracgrWrXrZ operationdestrs r]bitopBasicKeyCommands.bitop r@racgrWrXrs r]rr rxrac*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 BITOPrers r]rr s##GYDtDDracgrWrXrZrbitrrrs r]bitposBasicKeyCommands.bitpos racgrWrXrs r]rr rac 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 )rrPzbit must be 0 or 1Nz0start argument is not set, when end is specifiedBITPOSrrrrf)rZrrrrrrs r]rr s f 01 1 T2fmmE2   MM#  ]sNO O   MM$ ##HBvBSEBBraFcgrWrXrZsource destinationrrs r]rBasicKeyCommands.copy rracgrWrXr&s r]rr) rracX/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)rSrrf)rZr'r(rrrs r]rr) sH&&  % MM40 1  MM) $##F4V44racgrWrXrZramounts r]decrbyBasicKeyCommands.decrby rracgrWrXr0s r]r2r3 rxrac&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 DECRBYrer0s r]r2r3 ##Hd;;racgrWrXrZnamess r]deleteBasicKeyCommands.delete& ?BracgrWrXr9s r]r;r<) rrac(UR"S/UQ76$)z0 Delete one or more keys specified by ``names`` DELrer9s r]r;r<, s##E2E22rac&URU5 grW)r;rZrs r] __delitem__BasicKeyCommands.__delitem__2 s DracgrWrXrZrifeqifneifdeqifdnes r]delexBasicKeyCommands.delex5 rracgrWrXrFs r]rKrL? r!racX#XE4Vs/sHofSLPM nn[U5S:a [S5eSU/nUbUSU/- nO UbUSU/- nOUbUSU/- nO UbUSU/- nUR"U6$s snf) a Conditionally removes the specified key. Warning: **Experimental** since 7.1. This API may change or be removed without notice. The API may change based on feedback. Arguments: name: KeyT - the key to delete ifeq match-valu: Optional[Union[bytes, str]] - Delete the key only if its value is equal to match-value ifne match-value: Optional[Union[bytes, str]] - Delete the key only if its value is not equal to match-value ifdeq match-digest: Optional[str] - Delete the key only if the digest of its value is equal to match-digest ifdne match-digest: Optional[str] - Delete the key only if the digest of its value is not equal to match-digest Returns: int: 1 if the key was deleted, 0 otherwise. Raises: redis.exceptions.ResponseError: if key exists but is not a string and a condition is specified. ValueError: if more than one condition is provided. Requires Redis 8.4 or greater. For more information, see https://redis.io/commands/delex NrPz2Only one of IFEQ/IFNE/IFDEQ/IFDNE may be specifiedDELEXIFEQIFNEIFDEQIFDNE)sumrrf) rZrrGrHrIrJxcondsrgs r]rKrLI sF*.U(BC(B1$(BC u:>QR R4   vtn $F   vtn $F   w& &F   w& &F##V,,Ds A.cgrWrXrBs r]dumpBasicKeyCommands.dump| rnracgrWrXrBs r]rXrY rvracBSSKJn 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 rr[DUMPr_)rZrr\rbs r]rXrY s, . "##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 rrGTLTEXPIRErdatetime timedeltar total_secondsrdrrfrZrr5rerfrgrh exp_options r]rirj s, dH.. / /t))+,DV   d #   d #   d #   d ###HdF:FFracgrWrXrZrwhenrerfrgrhs r]expireatBasicKeyCommands.expireat rkracgrWrXrys r]r{r| rmracn[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 rrrorpEXPIREATrrsr timestamprdrrfrZrrzrerfrgrhrws r]r{r| s, dH-- . .t~~'(DV   d #   d #   d #   d ###JHZHHracgrWrXrZrs r] expiretimeBasicKeyCommands.expiretime r=racgrWrXrs r]rr rrac&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 EXPIRETIMErers r]rr s##L#66rac[(d [S5e[R"U5R 5nUR 5R (dUR5nU$)a Compute the hexadecimal digest of the value locally, without sending it to the server. This is useful for conditional operations like IFDEQ/IFDNE where you need to compute the digest client-side before sending a command. Warning: **Experimental** - This API may change or be removed without notice. Arguments: - value: Union[bytes, str] - the value to compute the digest of. If a string is provided, it will be encoded using UTF-8 before hashing, which matches Redis's default encoding behavior. Returns: - (str | bytes) the XXH3 digest of the value as a hex string (16 hex characters). Returns bytes if decode_responses is False, otherwise returns str. For more information, see https://redis.io/commands/digest zXXHASH support requires the optional 'xxhash' library. Install it with 'pip install xxhash' or use this package's extra with 'pip install redis[xxhash]' to enable this feature.) HAS_XXHASHrxxhashxxh3_64 hexdigestrr%r)rZr local_digests r] digest_localBasicKeyCommands.digest_local$ s],z%F  ~~e,668 !22'..0LracgrWrXrBs r]digestBasicKeyCommands.digestJ rracgrWrXrBs r]rrM rrac&URSU5$)a Return the digest of the value stored at the specified key. Warning: **Experimental** since 7.1. This API may change or be removed without notice. The API may change based on feedback. Arguments: - name: KeyT - the key to get the digest of Returns: - None if the key does not exist - (bulk string) the XXH3 digest of the value as a hex string Raises: - ResponseError if key exists but is not a string Requires Redis 8.4 or greater. For more information, see https://redis.io/commands/digest DIGESTrerBs r]rrR s4##Hd33racgrWrXrBs r]r'BasicKeyCommands.getn riracgrWrXrBs r]r'rq r9rac$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 rrrerBs r]r'rt s ##E4f#==racgrWrXrBs r]getdelBasicKeyCommands.getdel| rracgrWrXrBs r]rr rrac&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 GETDELrerBs r]rr s##Hd33racgrWrXrZrexpxexatpxatpersists r]getexBasicKeyCommands.getex !racgrWrXrs r]rr ),rac[USLUSLUSLUSLU45(d [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 NK``ex``, ``px``, ``exat``, ``pxat``, and ``persist`` are mutually exclusive.PERSISTGETEX)rQrrKrrf)rZrrrrrr exp_optionss r]rr s:%$$D D     :  )=RT(P    y )##GT@K@@racDURU5nUbU$[U5e)zO Return the value at key ``name``, raises a KeyError if the key doesn't exist. )r'KeyErrorrZrrs r] __getitem__BasicKeyCommands.__getitem__ s&   LtnracgrWrXrZrrfs r]getbitBasicKeyCommands.getbit rracgrWrXrs r]rr rxrac&URSXU/S9$)z Returns an integer indicating the value of ``offset`` in ``name`` For more information, see https://redis.io/commands/getbit GETBITrrers r]rr s ##Hd$#HHracgrWrXrZrrrs r]getrangeBasicKeyCommands.getrange rnracgrWrXrs r]rr rprac&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 GETRANGErrers r]rr s##JCe#LLracgrWrXrs r]getsetBasicKeyCommands.getset r(racgrWrXrs r]rr rrac&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 GETSETrers r]rr s##Hd::racgrWrXr0s r]rBasicKeyCommands.incrby rracgrWrXr0s r]rr# rxrac&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 rrer0s r]rr( r7racgrWrXr0s r] incrbyfloatBasicKeyCommands.incrbyfloat3 racgrWrXr0s r]rr8 rjrac&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 INCRBYFLOATrer0s r]rr= s##M4@@ra) byfloatbyintlbounduboundsaturaterrrrrenxc grWrX rZrrrrrrrrrrrrs r]increxBasicKeyCommands.increxF s &)rac grWrXrs r]rrX s 14rac t[USLUSL45(d [S5e[USLUSLU SLU SLU 45(d [S5eU (aUcUcU cU c [S5eU/n UbU RSU45 OUbU RSU45 UbU RSU45 UbU RSU45 U(aU RS 5 U R[ XxX55 U (aU RS 5 U (aU RS 5 UR "S /U Q76$) a& Increment the numeric value at key ``name`` and return the new value and the actual increment. ``byfloat`` increments a floating point value by the provided amount. ``byint`` increments an integer value by the provided amount. If neither ``byfloat`` nor ``byint`` is specified, the value is incremented by one. ``lbound`` and ``ubound`` constrain the valid range of the result. If ``saturate`` is True, out-of-bounds results are saturated to the specified bound, or to the type limit when no bound is specified. Otherwise, out-of-bounds results are rejected, leaving the value and TTL unchanged and returning the current value and zero as the actual increment. ``enx`` applies the expiration only when the key does not already have an expiration, and requires ``ex``, ``px``, ``exat``, or ``pxat``. Nz1``byfloat`` and ``byint`` are mutually exclusive.rz>``enx`` requires one of ``ex``, ``px``, ``exat``, or ``pxat``.BYFLOATBYINTLBOUNDUBOUNDSATURATErENXINCREX)rQrrSrrKrf)rZrrrrrrrrrrrrrgs r]rrj s]L%t#T!   OP P$$$D D     :  2:"*$,P %)6   MM9g. /   MM7E* +   MM8V, -   MM8V, -  MM* % *24>?  MM) $  MM% ##H6v66rac grWrXrZrr\s r]rBasicKeyCommands.keys r`rac grWrXrs r]rr rcrac *UR"SU40UD6$)zg Returns a list of keys matching ``pattern`` For more information, see https://redis.io/commands/keys KEYSrers r]rr s##FG>v>>racgrWrXrZ first_list second_listsrcrs r]lmoveBasicKeyCommands.lmove s!racgrWrXrs r]rr ),rac0XX4/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 LMOVEre)rZrrrrrs r]rr s$35##G5f55racgrWrXrZrrrrrs r]blmoveBasicKeyCommands.blmove s!racgrWrXrs r]rr s),rac2XXEU/nUR"S/UQ76$)zX Blocking version of lmove. For more information, see https://redis.io/commands/blmove BLMOVEre)rZrrrrrrs r]rrs&3g>##H6v66racgrWrXrZrrks r]mgetBasicKeyCommands.mget$'racgrWrXrs r]rr/2racrSSKJn [X5n0nU(d/XC'X$S'UR"S/UQ70UD6$)a Returns a list of values ordered identically to ``keys`` ** Important ** When this method is used with Cluster clients, all keys must be in the same hash slot, otherwise a RedisClusterException will be raised. For more information, see https://redis.io/commands/mget r)EMPTY_RESPONSErMGET)r`r rRrf)rZrrkr rbs r]rr"sC 0D'&(G ###F=T=W==racgrWrXrZmappings r]msetBasicKeyCommands.mset7rracgrWrXrs r]rr<rrac|/nUR5HnURU5 M UR"S/UQ76$)a 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(). ** Important ** When this method is used with Cluster clients, all keys must be in the same hash slot, otherwise a RedisClusterException will be raised. For more information, see https://redis.io/commands/mset MSETr rSrfrZrr pairs r]rrAs;MMOD LL $##F3U33racgrWrXrZrdata_persist_optionrrrrkeepttls r]msetexBasicKeyCommands.msetexRsracgrWrXrs r]rr^srac[USLUSLUSLUSLU45(d [S5e/nU(aURUR5 UR [ X4XV55 U(aURS5 S[ U5/n UR5Hn U R U 5 M UR"/U QUQ76$)a Sets key/values based on the provided ``mapping`` items. ** Important ** When this method is used with Cluster clients, all keys must be in the same hash slot, otherwise a RedisClusterException will be raised. ``mapping`` accepts a dict of key/value pairs that will be added to the database. ``data_persist_option`` can be set to ``NX`` or ``XX`` to control the behavior of the command. ``NX`` will set the value for each provided key to each provided value only if all do not already exist. ``XX`` will set the value for each provided key to each provided value only if all already exist. ``ex`` sets an expire flag on the keys in ``mapping`` for ``ex`` seconds. ``px`` sets an expire flag on the keys in ``mapping`` for ``px`` milliseconds. ``exat`` sets an expire flag on the keys in ``mapping`` for ``exat`` seconds, specified in unix time. ``pxat`` sets an expire flag on the keys in ``mapping`` for ``pxat`` milliseconds, specified in unix time. ``keepttl`` if True, retain the time to live associated with the keys. Returns the number of fields that were added. Available since Redis 8.4 For more information, see https://redis.io/commands/msetex NK``ex``, ``px``, ``exat``, ``pxat``, and ``keepttl`` are mutually exclusive.KEEPTTLMSETEX) rQrrrrSrKrr rf) rZrrrrrrrrrgrs r]rrjsV%$$D D     :  )+    288 9/CD    y )CL)MMOD MM$ $##:V:k::racgrWrXrs r]msetnxBasicKeyCommands.msetnxrracgrWrXrs r]r$r%rrac|/nUR5HnURU5 M UR"S/UQ76$)a 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. ** Important ** When this method is used with Cluster clients, all keys must be in the same hash slot, otherwise a RedisClusterException will be raised. For more information, see https://redis.io/commands/msetnx MSETNXrrs r]r$r%s;MMOD LL $##H5u55racgrWrXrZrdbs r]moveBasicKeyCommands.mover7racgrWrXr*s r]r,r-rXrac&URSX5$)zw Moves the key ``name`` to a different Redis database ``db`` For more information, see https://redis.io/commands/move MOVErer*s r]r,r-s ##FD55racgrWrXrBs r]rBasicKeyCommands.persistr=racgrWrXrBs r]rr2rrac&URSU5$)z` Removes an expiration on ``name`` For more information, see https://redis.io/commands/persist rrerBs r]rr2s ##It44racgrWrXrds r]pexpireBasicKeyCommands.pexpirerkracgrWrXrds r]r6r7rmract[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 rrrorpPEXPIRErrrvs r]r6r7s, dH.. / /t))+d23DV   d #   d #   d #   d ###ItGJGGracgrWrXrys r] pexpireatBasicKeyCommands.pexpireat%rkracgrWrXrys r]r=r>0rmract[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 r:rrrorp PEXPIREATrrs r]r=r>;s, dH-- . .t~~'$./DV   d #   d #   d #   d ###KIjIIracgrWrXrs r] pexpiretimeBasicKeyCommands.pexpiretime^r+racgrWrXrs r]rCrDarrac&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 PEXPIRETIMErers r]rCrDds##M377racgrWrXrZrtime_msrs r]psetexBasicKeyCommands.psetexmrracgrWrXrIs r]rKrLrrrac[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 r:PSETEXrrsrtrrurfrIs r]rKrLwsD gx11 2 2'//1D89G##HdUCCracgrWrXrBs r]pttlBasicKeyCommands.pttlr.racgrWrXrBs r]rRrSrrac&URSU5$)z Returns the number of milliseconds until the key ``name`` will expire For more information, see https://redis.io/commands/pttl PTTLrerBs r]rRrSs ##FD11racgrWrXrZrr withvaluess r] hrandfieldBasicKeyCommands.hrandfields !racgrWrXrXs r]rZr[s ),rac/nUbURU5 U(aURS5 UR"SU/UQ7SU06$)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 HRANDFIELDrYr)rZrrrYrs r]rZr[sG    MM%  MM, '##L#VV:VVrac grWrXrs r] randomkeyBasicKeyCommands.randomkeyrrac grWrXrs r]rarbrrac &UR"S0UD6$)za Returns the name of a random key For more information, see https://redis.io/commands/randomkey ) RANDOMKEYrers r]rarbs##:6::racgrWrXrZrdsts r]renameBasicKeyCommands.renamer{racgrWrXrgs r]rirjrArac&URSX5$)z[ Rename key ``src`` to ``dst`` For more information, see https://redis.io/commands/rename RENAMErergs r]rirjs ##Hc77racgrWrXrgs r]renamenxBasicKeyCommands.renamenxrracgrWrXrgs r]rorprrac&URSX5$)z~ Rename key ``src`` to ``dst`` if ``dst`` doesn't already exist For more information, see https://redis.io/commands/renamenx RENAMENXrergs r]rorps ##J99racgrWrXrZrttlrrabsttlidletime frequencys r]restoreBasicKeyCommands.restoresracgrWrXrus r]rzr{s"%racXU/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 r-ABSTTLIDLETIMEzidletimemust be an integerFREQzfrequency must be an integerRESTORE)rrrrrf) rZrrvrrrwrxryrs r]rzr{s:U#  MM) $  MM( #   MM* % > c(m,  MM& ! @ c)n-##I777 > <== > @ >?? @s B&9B?&B<?CcgrWrXrZrrrrrerfrr'rrrGrHrIrJs r]rBasicKeyCommands.set5s"%(racgrWrXrs r]rrHs"03ra)rGrHrIrJc [USLUSLU SLU SLU45(d [S5e[UUU SLU SLU SLUSL45(d [S5eX/n0nU(aURS5 OtU(aURS5 O[U bURSU 45 ODU bURSU 45 O-U bURSU 45 OUbURS U45 U(aURS 5 S US 'UR[ X4X55 U(aURS 5 UR "S/UQ70UD6$)u Set the value at key ``name`` to ``value`` Warning: **Experimental** since 7.1. The usage of the arguments ``ifeq``, ``ifne``, ``ifdeq``, and ``ifdne`` is experimental. The API or returned results when those parameters are used may change based on feedback. ``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. ``ifeq`` set the value at key ``name`` to ``value`` only if the current value exactly matches the argument. If key doesn’t exist - it won’t be created. (Requires Redis 8.4 or greater) ``ifne`` set the value at key ``name`` to ``value`` only if the current value does not exactly match the argument. If key doesn’t exist - it will be created. (Requires Redis 8.4 or greater) ``ifdeq`` set the value at key ``name`` to ``value`` only if the current value XXH3 hex digest exactly matches the argument. If key doesn’t exist - it won’t be created. (Requires Redis 8.4 or greater) ``ifdne`` set the value at key ``name`` to ``value`` only if the current value XXH3 hex digest does not exactly match the argument. If key doesn’t exist - it will be created. (Requires Redis 8.4 or greater) For more information, see https://redis.io/commands/set Nr zP``nx``, ``xx``, ``ifeq``, ``ifne``, ``ifdeq``, ``ifdne`` are mutually exclusive.rrrPrQrRrSrTr'r!r)rQrrrSrKrf)rZrrrrrerfrr'rrrGrHrIrJrgrbs r]rr[svR%$$D D     :  %D D T!T!     b %)=  MM$   MM$    MM64. )   MM64. )   MM7E* +   MM7E* +  MM% !GEN *24>?  MM) $##E>F>g>>rac&URX5 grW)rrs r] __setitem__BasicKeyCommands.__setitem__s racgrWrXrZrrfrs r]setbitBasicKeyCommands.setbitr@racgrWrXrs r]rrrxracPU=(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 rPrSETBITrers r]rrs' ! q##HdEBBracgrWrXrZrr5rs r]setexBasicKeyCommands.setexrracgrWrXrs r]rrrraz2.6.12zUse 'set' instead.rversionreasonrc[U[R5(a[UR 55nUR SXU5$)a5 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. As per Redis 2.6.12, SETEX is considered deprecated. Please use SET with EX parameter in new code. For more information, see https://redis.io/commands/setex SETEXrPrs r]rrs?$ dH.. / /t))+,D##GT??racgrWrXrs r]setnxBasicKeyCommands.setnxrvracgrWrXrs r]rrrrac&URSX5$)z| Set the value of key ``name`` to ``value`` if key doesn't exist For more information, see https://redis.io/commands/setnx SETNXrers r]rrs ##GT99racgrWrXrs r]setrangeBasicKeyCommands.setrange$r@racgrWrXrs r]rr)rxrac(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 SETRANGErers r]rr.s##JeDDrac  grWrX rZalgovalue1value2specific_argumentridx minmatchlen withmatchlenr\s r]stralgoBasicKeyCommands.stralgo?srac  grWrXrs r]rrMs&)rac  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 LCSz, zThe supported algorithms are: )rstringsz-specific_argument can be only keys or stringsz(len and idx cannot be provided together.sLENsIDXs MINMATCHLENs WITHMATCHLENSTRALGO)rrrr)joinrrrrrS TypeErrorrf) rZrrrrrrrrr\supported_algosupported_algos_strrgs r]rr[s @   %"&))N"; <=P;7 8  MM/ *##   #%       sC&& C32C3cgrWrXrBs r]strlenBasicKeyCommands.strlenrYracgrWrXrBs r]rrrirac$URSX/S9$)zx Return the number of bytes stored in the value of ``name`` For more information, see https://redis.io/commands/strlen STRLENrrerBs r]rrs ##Hd#@@racgrWrXrZrrrs r]substrBasicKeyCommands.substrrnracgrWrXrs r]rrrprac&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. SUBSTRrrers r]rrs##Hd3V#LLracgrWrXrs r]touchBasicKeyCommands.touchrYracgrWrXrs r]rrrirac(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 TOUCHrers r]rrs##G3d33racgrWrXrBs r]rvBasicKeyCommands.ttlrracgrWrXrBs r]rvrr#rac&URSU5$)z{ Returns the number of seconds until the key ``name`` will expire For more information, see https://redis.io/commands/ttl TTLrerBs r]rvrs ##E400racgrWrXrBs r]typeBasicKeyCommands.typerracgrWrXrBs r]rrrrac$URSX/S9$)z\ Returns the type of key ``name`` For more information, see https://redis.io/commands/type TYPErrerBs r]rr ##FDv#>>racB[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 objectNwarningswarnDeprecationWarningr9s r]watchBasicKeyCommands.watchs  ()LMNracB[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 objectNrr.s r]unwatchBasicKeyCommands.unwatchs  ()NOPracgrWrXr9s r]unlinkBasicKeyCommands.unlinkr=racgrWrXr9s r]rrrrac(UR"S/UQ76$)zl Unlink one or more keys specified by ``names`` For more information, see https://redis.io/commands/unlink UNLINKrer9s r]rrs ##H5u55racgrWrXrZkey1key2rrrrs r]lcsBasicKeyCommands.lcsrracgrWrXrs r]rrrracX/nU(aURS5 U(aURS5 UbUS: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 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 WITHMATCHLENrrrrSrf)rZrrrrrrrgs r]rrss$$(,  MM%  MM%  "{a'7 MM=+6 7  MM. )##EFFF$FFrarX)rZr=rr1rr'rr)rZrrr1rr'rr)rr1rr'rrr) rZr=rr1rrrrrrrr) rZrrr1rrrrrrrr) rr1rrrrrrrrrW)rZrrr1rrrr) rZr=rr1r rrfrr (list[tuple[str, BitfieldOffsetT]] | Nonerr) rZrrr1r rrfrr rrr) rZrrr1r rrfrr rrr) rZr=rrrr1rr1rr) rZrrrrr1rr1rr)rrrr1rr1rr)rZr=rr1rrrrrrrrrr)rZrrr1rrrrrrrrrr) rr1rrrrrrrrrrNF) rZr=r'rr(rrrrrrr) rZrr'rr(rrrrrrr) r'rr(rrrrrrrrP)rZr=rr1r1rrr)rZrrr1r1rrr)rr1r1rrr)rZr=r:r1rr)rZrr:r1rr)r:r1rrrr1r)rZr=rr1rGrrHrrIrrJrrr)rZrrr1rGrrHrrIrrJrrr) rr1rGrrHrrIrrJrrr)rZr=rr1rz bytes | None)rZrrr1rzAwaitable[bytes | None])rr1rz&bytes | None | Awaitable[bytes | None])FFFF)rZr=rr1r5r(rerrfrrgrrhrrr)rZrrr1r5r(rerrfrrgrrhrrr)rr1r5r(rerrfrrgrrhrrr)rZr=rr1rzrrerrfrrgrrhrrr)rZrrr1rzrrerrfrrgrrhrrr)rr1rzrrerrfrrgrrhrrr)rZr=rrrr)rZrrrrr)rrrr)rrrr)rZr=rr1rzstr | bytes | None)rZrrr1rzAwaitable[str | bytes | None])rr1rz2str | bytes | None | Awaitable[str | bytes | None])rZr=rr1rr)rZrrr1rr)rr1rr)NNNNF)rZr=rr1rExpiryT | NonerrrAbsExpiryT | Nonerrrrrr)rZrrr1rrrrrrrrrrrr)rr1rrrrrrrrrrrr)rZr=rr1rfrrr)rZrrr1rfrrr)rr1rfrrr) rZr=rr1rrrrrr) rZrrr1rrrrrr)rr1rrrrrr)rZr=rr1rr'rr)rZrrr1rr'rr)rr1rr'rrg?)rZr=rr1r1floatrr)rZrrr1r1rrAwaitable[float])rr1r1rrfloat | Awaitable[float])rZr=rr1rEncodableT | Nonerrrrrrrrrrrrrrrrrrrrrzlist[Number | bytes | str])rZrrr1rrrrrrrrrrrrrrrrrrrrrrrz%Awaitable[list[Number | bytes | str]])rr1rrrrrrrrrrrrrrrrrrrrrrrzBlist[Number | bytes | str] | Awaitable[list[Number | bytes | str]]rrZr=rr5rrrZrrr5rrrr5rr)LEFTRIGHT) rZr=rrrrrrrrrr) rZrrrrrrrrrrr) rrrrrrrrrr)rZr=rrrrrrrrrrrr)rZrrrrrrrrrrrrr) rrrrrrrrrrrr)rZr=rr0rkr'rlist[bytes | str | None])rZrrr0rkr'r#Awaitable[list[bytes | str | None]])rr0rkr'r>list[bytes | str | None] | Awaitable[list[bytes | str | None]])rZr=rMapping[AnyKeyT, EncodableT]rr)rZrrr rr)rr rr)NNNNNF)rZr=rr rDataPersistOptions | Nonerrrrrrrrrrrr)rZrrr rr rrrrrrrrrrrr)rr rr rrrrrrrrrrrr)rZr=rr1r+rrr)rZrrr1r+rrr)rr1r+rrr)rZr=rr1rr)rZrrr1rr)rr1rr) rZr=rr1rJr(rr'rr) rZrrr1rJr(rr'rr)rr1rJr(rr'rrrZr=rr1rrrZrrr1rrrr1rr) rZr=rr1rrrYrrr.) rZrrr1rrrYrrzAwaitable[HRandFieldResponse])rr1rrrYrrz2HRandFieldResponse | Awaitable[HRandFieldResponse]r~rr)rZr=rr1rhr1rr)rZrrr1rhr1rr)rr1rhr1rr)FFNN)rZr=rr1rvrrr'rrrwrrxrryrrr)rZrrr1rvrrr'rrrwrrxrryrrr)rr1rvrrr'rrrwrrxrryrrr) ............) rZr=rr1rr'rrrrrerrfrrrr'rrrrrrGrrHrrIrrJrrzbool | str | bytes | None) rZrrr1rr'rrrrrerrfrrrr'rrrrrrGrrHrrIrrJrrz$Awaitable[bool | str | bytes | None]) NNFFFFNNNNNN)rr1rr'rrrrrerrfrrrr'rrrrrrGrrHrrIrrJrrz@bool | str | bytes | None | Awaitable[bool | str | bytes | None]rr1rr') rZr=rr1rfrrrrr) rZrrr1rfrrrrr)rr1rfrrrrr) rZr=rr1r5r(rr'rr) rZrrr1r5r(rr'rr)rr1r5r(rr'rr)rZr=rr1rr'rr)rZrrr1rr'rr)rr1rr'rr) rZr=rr1rfrrr'rr) rZrrr1rfrrr'rr)rr1rfrrr'rr)rFFNF)rZr=rLiteral['LCS']rr1rr1r$Literal['strings'] | Literal['keys']rrrrrrrrrr:)rZrrrrr1rr1rrrrrrrrrrrzAwaitable[StralgoResponse])rrrr1rr1rrrrrrrrrrrz,StralgoResponse | Awaitable[StralgoResponse])) rZr=rr1rrrrrr) rZrrr1rrrrrr)rr1rrrrrr)rZr=rkr1rr)rZrrkr1rr)rkr1rr)rZr=rr1rr)rZrrr1rr)rr1rrr:r1rrr)FFrF)rZr=rrrrrr|rr|rrrr|rr2)rZrrrrrrr|rr|rrrr|rzAwaitable[LCSCommandResponse])rrrrrr|rr|rrrr|rz2LCSCommandResponse | Awaitable[LCSCommandResponse])Lrrrrr rrrrr rrrr2decrr;rCrKrJrXr^ __contains__rir{rrrr'rrrrrrrincrrrrrrrrrr$r,rr6r=rCrKrRrZrarirorzrrIrrrrHrrrrrrrvrrrrrr rXrar]rr+ s#RR !(,5? :!       ! !      ! E EE E  E  E4(, OG O  O% O  O ;?     8    ;? #!# ## # 8 #  ##;? HGH HH H 8 H * H. -08<EI !.19=FJ E !          ! !       ! C CC C  C  C C> &*  #      &* !#     &* 555# 5  5 54QQ =>!)-7: < D BB NN3 $(#'   !!      $(#'  !!!      $(#'  0-0-!0-! 0-  0-  0- 0-0-dGG SS =BB NNBL           !        #G#G#G  #G  #G  #G #G #GJ           !        #I#I#I  #I  #I  #I #I #IJBB NN7##JOO ,!,)-, &,,446LL XX>OO ,!,)-, &,, 4"!"&"&! !! !  !  !  !! !!"!"&"&,!,, ,  ,  ,  ,, ',,"!"&"&0A0A 0A  0A  0A  0A0A >0AdMM !)-7: I '+47>A %!%(,%58%?B% %% M! !(,!5?! !!,!,)-,6@, &,, ;QQ =>!)-7: < D >A (,6; ?B!)-7< A &*#'$($(!!"&"&) ))# ) ! ) " )")) ) ) ) ))) $))" &*#'$($(!!"&"&4!44# 4 ! 4 " 4"44 4 4 4 444 /44*&*#'$($(!!"&"&U7U7# U7 ! U7 " U7"U7U7 U7 U7 U7 U7U7U7 LU7n69   +3   7:+!+,4+ %++ #&?? 9?  ! !!! !  !  !!  ,!,,, ,  , ' ,,QX 6 6,/ 669 6JM 6 = 6  ! !!! !  !  ! !!  ,!,,, ,  ,  , ',, 777 7  7  7 >7 ' '(-'6@' !''2!2).27A2 ,22>>",> G>* +G !,H 4":>!!"&"&   - 7             :>!!"&"& ! - 7             :>!!"&"&G;-G;7G;  G;  G;  G; G;G; G;R +G !,H 6$HH TT6BB NN5           !        "H"H"H  "H  "H  "H "H "HH           !        !J!J!J  !J  !J  !J !J !JFCC OO8 (,7>GQ !)-8?HR  D D#* D3= D  D>> JJ2! ! ! !! !  !!! ,!, ,, , ' ,,GLWW *W?CW ;W0PP ,!, &,,;KK WW8MM !(,37 : # $                # $ %! % % % %  %  % % %  % % # $080808 08  08  080808 008d ! "%"%#&#&( (((  (  (  ( ((( ( (!(!((( #!(($ ! "%"%#&#&3!333  3  3  3 333 3 3!3!333 .!33$9: "!"&"&#'#'  ???  ?  ?  ? ??? ? ?!?!??? L!?;?B (,69BE !)-7:CF C (,4;DN !)-5<EO #  @@ '@0:@ @  @"SS !)-6@ : (,69BL !)-7:CM EE"%E.8E E" CL"&"       @           CL"&" )! ) ) ) ) @ )  ) )  ) ) $ ) )$CL"&"> > >  > @ >  > >  > >  6> @@@ LLAEG (,58?B FH%!%)-%69%@C% %%MM@@ LL4== II1FF RR?OQBB NN6 ! "#$)! !!! !  !  !"! !! ! "#$),!,,, ,  ,  ,", ',,! "#$)GGG G  G  G"G <GGrarcd^\rSrSrS SjrS SjrS SjrS SjrS U4SjjrS U4Sjjr Sr U=r $) AsyncBasicKeyCommandsi9c[S5e)Nz2Async Redis client does not support class deletionrrBs r]rC!AsyncBasicKeyCommands.__delitem__:sLMMrac[S5e)Nz3Async Redis client does not support class inclusionrrBs r]r"AsyncBasicKeyCommands.__contains__=MNNrac[S5e)Nz3Async Redis client does not support class retrievalrrBs r]r!AsyncBasicKeyCommands.__getitem__@rrac[S5e)Nz4Async Redis client does not support class assignmentrrs r]r!AsyncBasicKeyCommands.__setitem__CsNOOrac&># [TU]"U6$7frW)rr)rZr:rs r]rAsyncBasicKeyCommands.watchFsw}e$$sc(># [TU]5$7frW)rrrZrs r]rAsyncBasicKeyCommands.unwatchIsw  rXrrrr) rrrrrCrrrrrr rrs@r]rr9s*NOOP%!!rarc \rSrSrSr\SISJSjj5r\SISKSjj5rSISLSjjr\SISJSjj5r\SISKSjj5rSISLSjjr\SISMS jj5r\SISNS jj5rSISOS jjr\S S .SPSjj5r \S S .SQSjj5r S S .SRSjjr \S S .SSSjj5r \S S .STSjj5r S S .SUSjjr \SVSj5r \SWSj5r SXSjr \SYSj5r \SZSj5r S[Sjr \S\Sj5r \S]Sj5r S^Sjr \S_S`Sjj5r\S_SaSjj5rS_SbS jjr\ScS!j5r\SdS"j5rSeS#jr\ScS$j5r\SdS%j5rSeS&jr\SfS'j5r\SgS(j5rShS)jr\SiS*j5r\SjS+j5rSkS,jr\SlS-j5r\SmS.j5rSnS/jr\SoS0j5r\SpS1j5rSqS2jr\S_S`S3jj5r\S_SaS4jj5rS_SbS5jjr\SrS6j5r\SsS7j5rStS8jr\ScS9j5r\SdS:j5rSeS;jr\SuS<j5r\SvS=j5rSwS>jr\SxSyS?jj5r\SxSzS@jj5rSxS{SAjjr\S|S}SBjj5r\S|S~SCjj5rS|SSDjjr\SSSEjj5r\SSSFjj5rSSSGjjrSHrg) ListCommandsiMzR Redis commands for List data type. see: https://redis.io/topics/data-types#lists cgrWrXrZrrs r]blpopListCommands.blpopS#&racgrWrXr,s r]r-r.Xr6raclUcSn[US5nURU5 UR"S/UQ76$)a7 LPOP a value off of the first non-empty list named in ``keys``. 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 NrBLPOPrRrrfr,s r]r-r.]< ?GD$' G##G3d33racgrWrXr,s r]brpopListCommands.brpoprr/racgrWrXr,s r]r6r7wr6raclUcSn[US5nURU5 UR"S/UQ76$)a7 RPOP a value off of the first non-empty list named in ``keys``. 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 NrBRPOPr3r,s r]r6r7|r4racgrWrXrZrrhrs r] brpoplpushListCommands.brpoplpushr(racgrWrXr<s r]r=r>rrac2UcSnURSXU5$)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 BRPOPLPUSHrer<s r]r=r>s# ?G##L#GDDrarP)rcgrWrXrZrnumkeys directionrrks r]blmpopListCommands.blmpops #racgrWrXrCs r]rFrGs+.rac>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 raBLMPOPre)rZrrDrErrkcmd_argss r]rFrGs6"GtGYGGG##H8x88racgrWrXrZnum_keysrErrks r]lmpopListCommands.lmpoprKracgrWrXrMs r]rOrPs+.racU/[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 rPraLMPOP)rdrSrf)rZrNrErrkrKs r]rOrPsI:T *i[8 A: OOWe, -##G7h77racgrWrXrZrrxs r]lindexListCommands.lindexr(racgrWrXrUs r]rVrWrrac&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 LINDEXrrerUs r]rVrWs##Hd#GGracgrWrXrZrwhererefvaluers r]linsertListCommands.linsertr@racgrWrXr\s r]r_r`rxrac(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 LINSERTrer\s r]r_r`s##ItHLLracgrWrXrBs r]llenListCommands.llen)r.racgrWrXrBs r]rerf,rrac$URSX/S9$)zb Return the length of the list ``name`` For more information, see https://redis.io/commands/llen LLENrrerBs r]rerf/rraNcgrWrXrZrrs r]lpopListCommands.lpop7 25racgrWrXrks r]rlrm> =@racPUbURSX5$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 LPOPrerks r]rlrmE0  ''< <''5 5racgrWrXrZrvaluess r]lpushListCommands.lpushZrracgrWrXrus r]rwrx]rxrac*UR"SU/UQ76$)zo Push ``values`` onto the head of the list ``name`` For more information, see https://redis.io/commands/lpush LPUSHrerus r]rwrxb ##GT;F;;racgrWrXrus r]lpushxListCommands.lpushxjrracgrWrXrus r]r~rmrxrac*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 LPUSHXrerus r]r~rr ##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 LREMrers r]rrs##FD??racgrWrXrZrrxrs r]lsetListCommands.lsetrAracgrWrXrs r]rrrrac(URSXU5$)zr Set element at ``index`` of list ``name`` to ``value`` For more information, see https://redis.io/commands/lset LSETrers r]rrs ##FD??racgrWrXrs r]ltrimListCommands.ltrimrracgrWrXrs r]rrrrac(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 LTRIMrers r]rrs##GT#>>racgrWrXrks r]rpopListCommands.rpoprnracgrWrXrks r]rrrpracPUbURSX5$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 RPOPrerks r]rrrsracgrWrXrgs r] rpoplpushListCommands.rpoplpushr(racgrWrXrgs r]rrrrac&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 RPOPLPUSHrergs r]rrs##K::racgrWrXrus r]rpushListCommands.rpushrracgrWrXrus r]rrrxrac*UR"SU/UQ76$)zo Push ``values`` onto the tail of the list ``name`` For more information, see https://redis.io/commands/rpush RPUSHrerus r]rr r|racgrWrXrus r]rpushxListCommands.rpushxrracgrWrXrus r]rrrxrac*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 RPUSHXrerus r]rrrracgrWrXrZrrrankrmaxlens r]lposListCommands.lpos$s"%racgrWrXrs r]rr.s-0racX/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 RANKraMAXLENLPOSrr)rZrrrrrrgs r]rr8smB%)=   MM64. )   MM7E* +   MM8V, -##FAVA4&AArac grWrX rZrrrbyr'descalphastoregroupss r]sortListCommands.sortesrac grWrXrs r]rrss#&rac 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 specifiedsBYLIMITsGETDESCsALPHASTORErMzVwhen using "groups" the "get" argument must be specified and contain at least two keysrrSORT)rrSrrrrrrf) rZrrrrr'rrrrrggrbs r]rrs=J  #+3?u}JK K$(6 > MM5"+ &   MM8U0 1 ? #s|,, vsm,AMM61+.  MM' "  MM( #   MM8U+ , *S5#,773s8a< SXT:&##F?V?w??racgrWrXrZrrrrr'rrs r]sort_roListCommands.sort_ro racgrWrXrs r]rr(+rac &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 )rrrr'rr)rrs r]rrs#:yy ##  rarXr)rZr=rr0r Number | Nonerr )rZrrr0rrrz"Awaitable[BlockingListPopResponse])rr0rrrz> JJ?!5 555 0 55 !@!@@@ ; @@!666  6*PP !)-8> <QQ !)-8> =   (, 58 ?B   +!+)-+69+@C+ %++ M M!$ M+. M 9 MVV !)-69BE  @WW !)-69BE @VV !)-69@C  ?!5 555 0 55 !@!@@@ ; @@!666  6*! !'+!26! !!,!,(,,37, &,, ;PP !)-8> <NN !)-8; =   ! % %%% %  %  % %%   ! 0!000 0  0  0 +00  ! +B+B+B +B  +B  +B F+BZ! $ #                 ! $ # &! & & & &  &  & & & & & ! & & ! $ #G@G@G@ G@  G@  G@G@G@G@G@ 0G@R! $                        ! $ +! +  + + +  +  + + + & + +! $            :  rar*c4\rSrSrSrSrSrSrSrSr Sr S r S r g ) ArrayAggregateOperationsiSUMMINMAXANDORXORMATCHUSEDrXN) rrrrrrrrrrrrr rXrar]rrs* C C C C B C E Drarc$\rSrSrSrSrSrSrSrg)ArrayPredicateTypeiEXACTrGLOBRErXN) rrrrrrrrr rXrar]rrs E E D Brarc\rSrSrSrSrSrg)ArrayPredicateCombinatorirrrXN)rrrrrrr rXrar]rrs C Brarc\rSrSrSr\S;Sj5r\SSj5r\S?Sj5rS@Sjr\SAS j5r\SBS j5rSCS jr\SDS j5r \SES j5r SFSjr \SGSj5r \SHSj5r SISjr \SJSKSjj5r \SJSLSjj5r SJSMSjjr \SNSOSjj5r \SNSPSjj5r SNSQSjjr \SRSj5r \SSSj5r STSjr \SUSj5r\SVSj5rSWSjr\SXSj5r\SYS j5rSZS!jr\SXS"j5r\SYS#j5rSZS$jr\S[S\S%jj5r\S[S]S&jj5rS[S^S'jjr\S_S(j5r\S`S)j5rSaS*jr\SbS+j5r\ScS,j5rSdS-jr\SeS.j5r\SfS/j5rSgS0jr\ShS1j5r\SiS2j5rSjS3jr\S[SkS4jj5r\S[SlS5jj5rS[SmS6jjr\SJSnS7jj5r\SJSoS8jj5rSJSpS9jjrS:rg)q ArrayCommandsiz% Redis commands for Array data type. cgrWrXrZrrxrvs r]arsetArrayCommands.arset#r@racgrWrXrs r]rr(rxrac*UR"SX/UQ76$)a> Set one or more contiguous ``values`` in the array stored at ``name`` starting at ``index``. When multiple values are provided, they are stored at consecutive indices beginning at ``index``. Returns the number of new slots that were set (previously empty). For more information, see https://redis.io/commands/arset ARSETrers r]rr-s##GTB6BBracgrWrXrZrrs r]armsetArrayCommands.armset9r@racgrWrXrs r]rr>rxrac~/nUR5HnURU5 M UR"SU/UQ76$)a3 Set multiple index/value pairs in the array stored at ``name``. ``mapping`` is a dictionary of zero-based integer indices to values. Pairs may be non-contiguous and in any order. Returns the number of new slots that were set (previously empty). For more information, see https://redis.io/commands/armset ARMSETrrZrrr rs r]rrCs=MMOD LL $##Hd;U;;racgrWrXrUs r]argetArrayCommands.argetRr(racgrWrXrUs r]r r Wrrac&URSX5$)z Return the value at ``index`` in the array stored at ``name``. Returns ``None`` if ``name`` does not exist or no value is set at ``index``. For more information, see https://redis.io/commands/arget ARGETrerUs r]r r \s##GT99racgrWrXrZrindicess r]armgetArrayCommands.armgetirracgrWrXrs r]rrnr rac*UR"SU/UQ76$)a Return the values at the specified ``indices`` in the array stored at ``name``. The reply preserves the order of the requested indices and returns ``None`` for any index that is not set or when ``name`` does not exist. For more information, see https://redis.io/commands/armget ARMGETrers r]rrss##Hd=W==racgrWrXrs r] argetrangeArrayCommands.argetrangerracgrWrXrs r]rrr rac(URSXU5$)z Return the values in the inclusive index range [``start``, ``end``] in the array stored at ``name``. If ``start`` is greater than ``end``, elements are returned in reverse index order. For more information, see https://redis.io/commands/argetrange ARGETRANGErers r]rrs##L$sCCraNcgrWrXrZrrrlimits r]arscanArrayCommands.arscanrracgrWrXrs r]r!r"s47rac\XU/nUbURSU/5 UR"S/UQ76$)a Iterate populated elements of the array stored at ``name`` in the inclusive range [``start``, ``end``] and return a list of ``[index, value]`` pairs in traversal order: ``[[idx1, val1], [idx2, val2], ...]``. Empty slots are skipped. If ``start`` is greater than ``end``, the iteration is reversed. ``limit`` caps the number of populated elements returned. When omitted, all populated elements in range are returned. For more information, see https://redis.io/commands/arscan rARSCANr)rZrrrr rgs r]r!r"s;&S)   MM8U+ ,##H6v66rac grWrX rZrrr predicates combinatorr rYnocases r]argrepArrayCommands.argreps58rac grWrXr's r]r+r,s @Crac HXU/n UH"upU RU RU /5 M$ UbU RUR5 UbU RSU/5 U(aU RS5 U(aU RS5 UR"S/U Q76$)a} Search elements of the array stored at ``name`` within the inclusive index range [``start``, ``end``] using one or more textual ``predicates``. Each predicate is a ``(type, value)`` tuple where ``type`` is a member of ``ArrayPredicateType`` (``EXACT``, ``MATCH``, ``GLOB``, ``RE``). Multiple predicates are combined via ``combinator`` (``ArrayPredicateCombinator.AND`` or ``OR``); the server defaults to OR when omitted. ``limit`` caps the number of matches. ``withvalues=True`` returns a list of ``[index, value]`` pairs (``[[idx, val], ...]``) instead of a flat list of indices. ``nocase=True`` makes all comparisons case-insensitive. Without ``withvalues``, returns a flat list of matching indices in traversal order. With ``withvalues``, returns a list of ``[index, value]`` pairs in traversal order. Empty slots are skipped. For more information, see https://redis.io/commands/argrep rs WITHVALUESsNOCASEARGREP)rSrrrf) rZrrrr(r)r rYr*rgpredicate_typers r]r+r,sHS)%/ !N MM>//7 8&0  ! MM*** +   MM8U+ ,  MM- (  MM) $##H6v66racgrWrXrs r]ardelArrayCommands.ardel rracgrWrXrs r]r2r3rxrac*UR"SU/UQ76$)a Delete elements at the specified ``indices`` in the array stored at ``name``. Deleting an index that does not exist counts as zero elements deleted and does not modify the array. Returns the number of elements deleted. For more information, see https://redis.io/commands/ardel ARDELrers r]r2r3s##GTv>>racgrWrXrZrsizervs r]arringArrayCommands.arringr@racgrWrXrhs r]rjrkrxrac*UR"SX/UQ76$)a Insert one or more ``values`` into the array stored at ``name`` as a fixed-size ring buffer of ``size`` slots. Each value is placed at ``insert_idx % size``, wrapping back to index 0 once the end is reached and overwriting older values when full. If ``size`` is smaller than the current window, the array is truncated to fit. Returns the last index where a value was inserted. For more information, see https://redis.io/commands/arring ARRINGrerhs r]rjrks##HdB6BBracgrWrXrZrrrevs r] arlastitemsArrayCommands.arlastitemsrracgrWrXrps r]rrrsr rac^X/nU(aURS5 UR"S/UQ76$)a{ Return up to ``count`` most recently inserted elements from the array stored at ``name``. If the array contains fewer elements than ``count``, all elements are returned. When ``rev`` is ``True``, elements are returned in reverse chronological order (most recent first) instead of the default oldest-first order. For more information, see https://redis.io/commands/arlastitems sREV ARLASTITEMSr)rZrrrqrgs r]rrrss0}  MM& !##M;F;;racgrWrXrZrrrrrs r]aropArrayCommands.arop$'racgrWrXrxs r]ryrzs/2raclXX4R/nUbURU5 UR"S/UQ76$)a Perform an aggregate ``operation`` on elements of the array stored at ``name`` in the inclusive index range [``start``, ``end``]. The range is always scanned from the lower to the higher index regardless of argument order. ``operation`` is one of the members of ``ArrayAggregateOperations``. ``value`` is required when ``operation`` is ``ArrayAggregateOperations.MATCH`` and specifies the value to compare against. Returns a bulk string for ``SUM``, ``MIN`` and ``MAX``, an integer for ``AND``, ``OR``, ``XOR``, ``MATCH`` and ``USED``, or ``None`` when no elements match the operation. For more information, see https://redis.io/commands/arop AROP)rrrf)rZrrrrrrgs r]ryrzs:2S//:   MM% ##F4V44rarX) rZr=rr1rxrrvr)rr) rZrrr1rxrrvr)rr)rr1rxrrvr)rr)rZr=rr1rMapping[int, FieldT]rr)rZrrr1rrrr)rr1rrrrrrr)rZr=rr1rrrr)rZrrr1rrrr)rr1rrrr ) rZr=rr1rrrrrr) rZrrr1rrrrrr)rr1rrrrrr rW) rZr=rr1rrrrr rrzlist[list[int | bytes | str]]) rZrrr1rrrrr rrz(Awaitable[list[list[int | bytes | str]]]) rr1rrrrr rrzHlist[list[int | bytes | str]] | Awaitable[list[list[int | bytes | str]]])NNFF)rZr=rr1rrrrr(+list[tuple[ArrayPredicateType, EncodableT]]r)ArrayPredicateCombinator | Noner rrYrr*rrz)list[int] | list[list[int | bytes | str]])rZrrr1rrrrr(rr)rr rrYrr*rrz4Awaitable[list[int] | list[list[int | bytes | str]]])rr1rrrrr(rr)rr rrYrr*rrz`list[int] | list[list[int | bytes | str]] | Awaitable[list[int] | list[list[int | bytes | str]]])rZr=rr1rrrr)rZrrr1rrrr)rr1rrrr)rZr=rr1r9rrr)rZrrr1r9rrr)rr1r9rrrr r rr)rZr=rr1rNrrzdict[str, int])rZrrr1rNrrzAwaitable[dict[str, int]])rr1rNrrz*dict[str, int] | Awaitable[dict[str, int]])rZr=rr1rr)rZrrr1rr)rr1rr)rZr=rr1rxrrr)rZrrr1rxrrr)rr1rxrrrrrr) rZr=rr1rirrvr)rr) rZrrr1rirrvr)rr)rr1rirrvr)rr) rZr=rr1rrrqrrr) rZrrr1rrrqrrr)rr1rrrqrrr )rZr=rr1rrrrrrrrrzbytes | str | int | None)rZrrr1rrrrrrrrrz#Awaitable[bytes | str | int | None]) rr1rrrrrrrrrz>bytes | str | int | None | Awaitable[bytes | str | int | None])rrrrr rrrr rrr!r+r2r:r@rFrOrVr\rbrjrrryr rXrar]rrs  (,58CI !)-69DJ  C (,7K !)-8L  <! !(,!58! !!,!,)-,69, &,, :' '(,'8;' !''2!2)-29<2 ,22 > >$' > G >' '(,'58'?B' !''2!2)-2692@C2 ,22 D D!$ D+. D G D ! , ,,, ,  , ' ,, ! 7!777 7  7 2 77! 777 7  7 R 707;   8  8 8 8 8 @ 8 4 8 8 8 8 3 8 87;   C! C C C C @ C 4 C C C C > C C$7;  /7/7/7 /7 @ /7 4 /7/7/7/7 ?/7bNN !)-9<  = (,7F !)-8G ;"AA MM5?? KK3;@ (,48   ? (,47BH !)-58CI  CFK' '(,'58'?C' !''GL2!2)-2692@D2 ,22 38<V>v>>rac+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)rrrr@NrXr)rZrrr@r\rdatas r] scan_iterScanCommands.scan_iterSsL*k99%HNLFOO k s%86 88cgrWrXrZrrrrs r]sscanScanCommands.sscanoracgrWrXrs r]rrx#&racX/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 rrSSCANr)rZrrrrrgs r]rrsO"%)>   MM8U+ ,   MM8U+ ,##G5f55rac#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 rr)rrrNr)rZrrrrrs r] sscan_iterScanCommands.sscan_iters:k::d:TLFOOk s 31 33cgrWrXrZrrrr no_valuess r]hscanScanCommands.hscanracgrWrXrs r]rrr{racX/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 rrsNOVALUESHSCANrr)rZrrrrrrgs r]rrsh(%)>   MM8U+ ,   MM8U+ ,  MM;- (##GJfJ JJrac## 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 rr)rrrrNrr )rZrrrrrrs r] hscan_iterScanCommands.hscan_iters["k::5&LF::<''k  's'(AAAA AAAcgrWrXrZrrrrscore_cast_funcs r]zscanScanCommands.zscanrracgrWrXrs r]rrr{racX/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 rrrZSCANr)rZrrrrrrgrbs r]rr s^(   MM8U+ ,   MM8U+ ,$o6##G@f@@@rac#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 rr)rrrrNr)rZrrrrrrs r] zscan_iterScanCommands.zscan_iter(sN"k:: / &LFOOk s#64 66rX)rNNN) rZr=rrrPatternT | Nonerrr@rrr7) rZrrrrrrrr@rrAwaitable[ScanResponse]) rrrrrrr@rr&ScanResponse | Awaitable[ScanResponse]r)rUnion[PatternT, None]r Optional[int]r@rrr )rNN) rZr=rr1rrrrrrrr7) rZrrr1rrrrrrrr) rr1rrrrrrrrr)rr1rrrrrr )rZr=rr1rrrrrrrr|rr/)rZrrr1rrrrrrrr|rzAwaitable[HScanResponse]) rr1rrrrrrrr|rz(HScanResponse | Awaitable[HScanResponse]) rr1rrrrrUnion[bool, None]rr )rZr=rr1rrrrrrrtype | CallablerrE)rZrrr1rrrrrrrrrzAwaitable[ZScanResponse]) rr1rrrrrrrrrz(ZScanResponse | Awaitable[ZScanResponse]) rr1rrrrrUnion[type, Callable]rr )rrrrr rrrrrrrrrrr rXrar]rrs !%       !%  &!&&& &  & !&&!%  ??? ?  ? 0?F(,## $   8!%       !% &!&&& &  & ! &&!% 666 6  6 0 66(,# %   &!% !%        !% !% '!''' '  '  ' "''!% !% KKK K  K  K 2K@(,#'+ ((%( ( % (  (6!% +0      )  !% +0 '!''' '  ' ) ' "''!% +0 AAA A  A ) A 2A>(,#16 %  /   rarc\rSrSrSS SjjrS S SjjrSS SjjrSS\4S SjjrSr g)AsyncScanCommandsiENc # SnUS:wa6UR"SXQX#S.UD6IShvN upVUHnU7v M US:waM5ggN7frr)rZrrr@r\rrds r]rAsyncScanCommands.scan_iterFsY*k!%"%"HN"LF ks!AAAAc# SnUS:wa1URXX#S9IShvN upEUHnU7v M US:waM0ggN7frr)rZrrrrrrs r]rAsyncScanCommands.sscan_itercsQk!%5","LF ks?=??c# SnUS:waVURXX#US9IShvN upVU(aUHnU7v M OUR5HnU7v M US:waMUggNB7frr)rZrrrrrrits r]rAsyncScanCommands.hscan_iterysm"k!%5","LFBH**,BH'ksA$A">A$ A$c# SnUS:wa4URUUUUUS9IShvN upVUHnU7v M US:waM3ggN7frr)rZrrrrrrrs r]rAsyncScanCommands.zscan_iters["k!% / ","LFksAAAArXr)rrrrr@rrrr)rr1rrrrrr) rr1rrrrrrrr) rr1rrrrrrrr) rrrrrrrrrr rXrar]rrEs(,## $   @(,# %   2(,#'+ %  %   @(,#16 %  /   rarch\rSrSrSr\S5Sj5r\S6Sj5rS7Sjr\S8Sj5r\S9Sj5rS:Sjr\S;S j5r\SS j5r \S?S j5r S@Sjr \S;Sj5r \Sd>>>racgrWrXrZrrrks r] sdiffstoreSetCommands.sdiffstorer@racgrWrXrs r]rrrxrac@[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 SDIFFSTORErrs r]rrs&D'##L$>>>racgrWrXrs r]sinterSetCommands.sinterrjracgrWrXrs r]rrrracD[X5nUR"S/UQ7SU06$)zs Return the intersection of sets specified by ``keys`` For more information, see https://redis.io/commands/sinter SINTERrrrs r]rr )D'##H?t?$??racgrWrXrZrDrr s r] sintercardSetCommands.sintercardr@racgrWrXrs r]rrrxrac@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 SINTERCARDrrerZrDrr rks r]rr 6/$///##LC4CdCCracgrWrXrs r] sinterstoreSetCommands.sinterstore/r@racgrWrXrs r]rr4rxrac@[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 SINTERSTORErrs r]rr9&D'##M4?$??racgrWrXrs r] sismemberSetCommands.sismemberCr/racgrWrXrs r]r r Hr6rac&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 SISMEMBERrrers r]r r Ms##KD6#JJracgrWrXrBs r]smembersSetCommands.smembersYrracgrWrXrBs r]rr\rrac$URSX/S9$)zf Return all members of the set ``name`` For more information, see https://redis.io/commands/smembers SMEMBERSrrerBs r]rras ##J6#BBracgrWrXrZrrvrks r] smismemberSetCommands.smismemberirracgrWrXrs r]rrnrracH[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 SMISMEMBERrrrs r]rrss-F)##L$KKTFKKracgrWrXrZrrhrs r]smoveSetCommands.smoverracgrWrXrs r]rr rrac(URSXU5$)zv Move ``value`` from set ``src`` to set ``dst`` atomically For more information, see https://redis.io/commands/smove SMOVErers r]rr s ##GSu==raNcgrWrXrks r]spopSetCommands.spoprracgrWrXrks r]r%r&s ;?? KK@ (,59 *!*)-*6:* $** ? ?!% ? 7 ? (+37@D !),48AE ? (,59 *!*)-*6:* $** @ @!% @ 7 @OP +.6@IL PQ!,/7AJM  <= D D", D58 D  D (,48AE !)-59BF @& &(,&58& &&1!1)-1691 +11 KOO *!*)-* $**C, ,(,,6:,CG, &,,7!7)-77;7DH7 177 L L"& L/3 L Q LVV !(,37@C >BF4 4(,45?4 .44CG?!?)-?6@? 9?? 9CG5 5(,56@5 /55DH@!@)-@7A@ :@@ @OO !)-8> ; (,59 *!*)-*6:* $** @ @!% @ 7 @ (,48AE !)-59BF @rarc \rSrSrSr\STSj5r\SUSj5rSVSjr\SS.SWSjj5r\SS.SXS jj5rSS.SYS jjr\SZS[S jj5r\SZS\Sjj5rSZS]Sjjr\S^S_Sjj5r \S^S`Sjj5r S^SaSjjr \SbScSjj5r \SbSdSjj5r SbSeSjjr \SfSgSjj5r \SfShSjj5r SfSiSjjr \SjSj5r \SkSj5r SlSjr \SS.SmSjj5r \SS.SnSjj5r SS.SoSjjr \SpSqSjj5r\SpSrS jj5rSpSsS!jjr\StS"j5r\SuS#j5rSvS$jr\SwS%j5r\SxS&j5rSyS'jr\StS(j5r\SuS)j5rSvS*jr\SzS{S+jj5r\SzS|S,jj5rSzS}S-jjr\S~S.j5r\SS/j5rSS0jr\SS1j5r\SS2j5rSS3jr\SSS4jj5r\SSS5jj5rSSS6jjr\SS7j5r\SS8j5rSS9jr\S S S:.SS;jj5r\S S S:.SS<jj5rS S S:.SS=jjr\SS>j5r\SS?j5rSS@jr\S^SSAjj5r\S^SSBjj5rS^SSCjjr\SSSDjj5r\SSSEjj5rSSSFjjr\S^SSGjj5r\S^SSHjj5rS^SSIjjr\SSSJjj5r\SSSKjj5rSSSLjjr\SSSMjj5r\SSSNjj5rSSSOjjr\SSSPjj5r\SSSQjj5rSSSRjjrSSrg )StreamCommandsizQ Redis commands for Stream data type. see: https://redis.io/topics/streams-intro cgrWrXrZr groupnameidss r]xackStreamCommands.xackr@racgrWrXrKs r]rNrOrxrac*UR"SX/UQ76$)z Acknowledges the successful processing of one or more messages. Args: name: name of the stream. groupname: name of the consumer group. *ids: message ids to acknowledge. For more information, see https://redis.io/commands/xack XACKrerKs r]rNrO s##FDBcBBraKEEPREF) ref_policycgrWrXrZrrLrTrMs r]xackdelStreamCommands.xackdelrracgrWrXrVs r]rWrX$rracU(d [S5eUS;a [S5eXUS[U5/nURU5 UR"S/UQ76$)z Combines the functionality of XACK and XDEL. Acknowledges the specified message IDs in the given consumer group and simultaneously attempts to delete the corresponding entries from the stream. z(XACKDEL requires at least one message IDACKEDDELREFrSz9XACKDEL ref_policy must be one of: KEEPREF, DELREF, ACKEDIDSXACKDELrrrSrf)rZrrLrTrMrgs r]rWrX-s\FG G ; ;WX X:uc#h? c##I777raNFc grWrX rZrfieldsidr approximate nomkstreamminidr rTidmpautoidmps r]xaddStreamCommands.xaddCsrac grWrXrbs r]rjrkSs"%rac 2/n UbUb [S5eU bU b [S5eU cU bUS:wa [S5eU bU S;a [S5eU(aU RS5 U bU RU 5 U bU RSU /5 U bI[U [5(a[ U 5S :wa [S 5eU RS U S U S /5 Ubi[U[ 5(aUS :a [S5eU RS5 U(aU RS5 U R[U55 Ub:U RS5 U(aU RS5 U RU5 UbU RSU/5 U RU5 [U[5(a[ U5S :Xa [S5eUR5Hn U RU 5 M UR"SU/U Q76$)ap Add to a stream. name: name of the stream fields: dict of field/value pairs to insert into the stream id: Location to insert this record. By default it is appended. maxlen: truncate old stream members beyond this size. Can't be specified with minid. approximate: actual stream length may be slightly more than maxlen nomkstream: When set to true, do not make a stream 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 when trimming: - KEEPREF (default): When trimming, preserves references in consumer groups' PEL - DELREF: When trimming, removes all references from consumer groups' PEL - ACKED: When trimming, only removes entries acknowledged by all consumer groups idmpauto: Producer ID for automatic idempotent ID calculation. Automatically calculates an idempotent ID based on entry content to prevent duplicate entries. Can only be used with id='*'. Creates an IDMP map if it doesn't exist yet. The producer ID must be unique per producer and consistent across restarts. idmp: Tuple of (producer_id, idempotent_id) for explicit idempotent ID. Uses a specific idempotent ID to prevent duplicate entries. Can only be used with id='*'. The producer ID must be unique per producer and consistent across restarts. The idempotent ID must be unique per message and per producer. Shorter idempotent IDs require less memory and allow faster processing. Creates an IDMP map if it doesn't exist yet. For more information, see https://redis.io/commands/xadd z8Only one of ```maxlen``` or ```minid``` may be specifiedz9Only one of ```idmpauto``` or ```idmp``` may be specifiedrz.IDMPAUTO and IDMP can only be used with id='*'r[z6XADD ref_policy must be one of: KEEPREF, DELREF, ACKEDs NOMKSTREAMsIDMPAUTOrMz9XADD idmp must be a tuple of (producer_id, idempotent_id)sIDMPrrPz(XADD maxlen must be non-negative integerMAXLENrMINIDrz$XADD fields must be a non-empty dictXADD) rrrSrtuplerrrdictr rf)rZrrcrdrrerfrgr rTrhrirgrs r]rjrkcsX$&  %"3VW W  D$4WX X  D$4")LM M  !j8V&VTU U  MM- (  ! MM* %   MM;1 2  dE**c$i1nO MM7DGT!W5 6  fc**fqj JKK MM) $ d# MM#f+ &   MM( # d# MM%   MM8U+ , b&$''3v;!+;BC CLLND MM$ ###FD:6::racgrWrXrZr idmp_duration idmp_maxsizes r]xcfgsetStreamCommands.xcfgset racgrWrXrts r]rwrx "%racXUcUc [S5e/nUb?[U[5(a US:dUS:a [S5eURSU/5 Ub?[U[5(a US:dUS:a [S5eURSU/5 UR"S U/UQ76$) u Configure the idempotency parameters for a stream's IDMP map. Sets how long Redis remembers each idempotent ID (iid) and the maximum number of iids to track. This command clears the existing IDMP map (Redis forgets all previously stored iids), but only if the configuration value actually changes. Args: name: The name of the stream. idmp_duration: How long Redis remembers each iid in seconds. Default: 100 seconds (or value set by stream-idmp-duration config). Minimum: 1 second, Maximum: 300 seconds. Redis won't forget an iid for this duration (unless maxsize is reached). Should accommodate application crash recovery time. idmp_maxsize: Maximum number of iids Redis remembers per producer ID (pid). Default: 100 iids (or value set by stream-idmp-maxsize config). Minimum: 1 iid, Maximum: 1,000,000 (1M) iids. Should be set to: mark-delay [in msec] × (messages/msec) + margin. Example: 10K msgs/sec (10 msgs/msec), 80 msec mark-delay → maxsize = 10 × 80 + margin = 1000 iids. Returns: OK on success. For more information, see https://redis.io/commands/xcfgset z>XCFGSET requires at least one of idmp_duration or idmp_maxsizerPi,z:XCFGSET idmp_duration must be an integer between 1 and 300s IDMP-DURATIONi@Bz?XCFGSET idmp_maxsize must be an integer between 1 and 1,000,000s IDMP-MAXSIZEXCFGSET)rrrrSrf)rZrrurvrgs r]rwrxsB  \%9P $&  $}c22 1$ 3&P MM+]; <  #|S11!#')U MM?L9 :##It=f==racgrWrXrZrrL consumername min_idle_timestart_idrjustids r] xautoclaimStreamCommands.xautoclaim racgrWrXrs r]rr #racJ[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 >= 0rJUSTIDT parse_justid XAUTOCLAIM)rrrrSrrf) rZrrLrrrrrr\rgs r]rr%s8 =!A%L&<I 5zA~ GHH MM8U+ ,  MM) $%)F> "##LD6DVDD!      s"B-B BB B"!B"c grWrX rZrrLrr message_idsidler5 retrycountrrs r]xclaimStreamCommands.xclaimXsrac grWrXrs r]rrgs%(rac [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 integer RETRYCOUNTzXCLAIM force must be a booleanFORCEzXCLAIM justid must be a booleanrTrXCLAIM) rrrrdrqrrSrrrf) rZrrLrrrrr5rrrr\rgs r]rrvs^---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@@@racgrWrXrZrrMs r]xdelStreamCommands.xdelrracgrWrXrs r]rrrxrac*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 XDELrers r]rrs##FD7377racgrWrXrZrrTrMs r]xdelexStreamCommands.xdelex racgrWrXrs r]rrrracU(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 IDr[z8XDELEX ref_policy must be one of: KEEPREF, DELREF, ACKEDr^XDELEXr`)rZrrTrMrgs r]rrsZEF F ; ;VW WE3s84 c##H6v66racgrWrXrZrrLrdmkstream entries_reads r] xgroup_createStreamCommands.xgroup_createsracgrWrXrs r]rr sracSXU/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)rZrrLrdrrrgs r]rrsG %4Tb#I  MM+ &  # MM=,7 8##V,,racgrWrXrZrrLrs r]xgroup_delconsumer!StreamCommands.xgroup_delconsumer-r@racgrWrXrs r]rr2rrac(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 DELCONSUMERrers r]rr:s##$8$<XXracgrWrXrZrrLs r]xgroup_destroyStreamCommands.xgroup_destroyIrracgrWrXrs r]rrNrrac&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 DESTROYrers r]rrSs##$4dFFracgrWrXrs r]xgroup_createconsumer$StreamCommands.xgroup_createconsumer]r@racgrWrXrs r]rrbrrac(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 CREATECONSUMERrers r]rrjs## #Tl  racgrWrXrZrrLrdrs r] xgroup_setidStreamCommands.xgroup_setid{rracgrWrXrs r]rrrrac\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 SETIDr)rZrrLrdrrgs r]rrs;2&  # MM=,7 8##N= 0. Overrides the mode's implicit delivery counter adjustment with an exact value. force: if True, creates a new unowned PEL entry for any ID not already in the group's PEL. Returns: The number of messages successfully NACKed. For more information, see https://redis.io/commands/xnack z&XNACK requires at least one message ID>FAILFATALSILENTz.XNACK mode must be one of: SILENT, FAIL, FATALr^rzXNACK retrycount must be >= 0rrXNACK)rrrSrrf)rZrrLrrrrMrgs r]rr s>DE E 2 2LM Muc#h? c  !A~ ?@@ MM=*5 6  MM( ###G5f55racgrWrXrs r]xpendingStreamCommands.xpending;rxracgrWrXrs r]rr@rrac&URSXU/S9$)z Returns information about pending messages of a group. name: name of the stream. groupname: name of the consumer group. For more information, see https://redis.io/commands/xpending XPENDINGrrers r]rrEs##Jtf#MMracgrWrXrZrrLminmaxrrrs r]xpending_rangeStreamCommands.xpending_rangeQs!$racgrWrXrs r]rr]s,/racX4U1S1:Xa"UcUb [S5eURX5$X/nUbUbUc [S5e[U5S:a [S5eURSU/5 [U5S:a [S5eURX4U/5 U(aUR U5 UR "S/UQ7S S 06$![a Nhf=f![a NJf=f) aq Returns information about pending messages, in a range. name: name of the stream. groupname: name of the consumer group. idle: available from version 6.2. filter entries by their idle-time, given in milliseconds (optional). min: minimum stream ID. max: maximum stream ID. count: number of messages to return consumername: name of a consumer to filter by (optional). Nznif XPENDING is provided with idle time or consumername, it must be provided with min, max and count parameterszNXPENDING must be provided with min, max and count parameters, or none of them.rz$XPENDING idle must be a integer >= 0IDLErr parse_detailT)rrrrSrrrf) rZrrLrrrrrrgs r]rris, e  &<#;: ==1 1" ;#+9   4y1} FGG MM64. ) 5zA~ GHH MM3U+ ,  MM, '##JKKdKK      s$-C 2-C CC C*)C*cgrWrXrZrrrrs r]xrangeStreamCommands.xrange&)racgrWrXrs r]rr14racX#/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 rPz'XRANGE count must be a positive integerrXRANGErrrrrrrf)rZrrrrrgs r]rrsk.  eS))UQY IJJ MM( # MM#e* %##HdIVI4&IIracgrWrXrZstreamsrblocks r]xreadStreamCommands.xreads racgrWrXr s r]r r  $'rac^/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 U06m[R"T5(a U4S jnU"5$[TS 9 T$) 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 integerBLOCKrPz&XREAD count must be a positive integerrz&XREAD streams must be a non empty dictSTREAMSXREADrcN># TIShvN n[US9IShvN U$NN7f)Nresponseasync_record_streaming_lag)actual_responser s r]_record_and_return0StreamCommands.xread.._record_and_return s)(0.0/JJJ&&#1Js%!%#%%r )rrrrrrrrzipr rSrfinspect iscoroutiner) rZr rr rgrrvr r s @r]r r s0&  eS))UQY LMM MM( # MM#e* %  eS))UQY HII MM( # MM#e* %'4((CLA,=DE E j!GMMO,  d f''D&DtD   x ( ( ' &' ' / AOracgrWrXrZrLrr rr noackclaim_min_idle_times r] xreadgroupStreamCommands.xreadgroups!racgrWrXr s r]r r $s),rac^^ 0nSTU/n UbQ[U[5(aUS:a [S5eU RS5 U R[ U55 UbQ[U[5(aUS:a [S5eU RS5 U R[ U55 U(aU RS5 UbL[U[5(aUS:a [S 5eU RS 5 U RU5 XxS '[U[ 5(a[ U5S:Xa [S 5eU RS 5 U RUR55 U RUR55 UR"S/U Q70UD6m [R"T 5(aUU 4Sjn U "5$[T TS9 T $)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 claim_min_idle_time: accepts an integer type and represents a time interval in milliseconds For more information, see https://redis.io/commands/xreadgroup sGROUPrPz+XREADGROUP count must be a positive integerrrz/XREADGROUP block must be a non-negative integerr sNOACKz=XREADGROUP claim_min_idle_time must be a non-negative integersCLAIMr z+XREADGROUP streams must be a non empty dictr XREADGROUPcP># TIShvN n[UTS9IShvN U$NN7f)Nr consumer_groupr )r rLr s r]r 5StreamCommands.xreadgroup.._record_and_returnns7(0.0,#,'& #1s&"&$&&r% )rrrrrrrrrSrrvrfr r r) rZrLrr rr r r rbrgr r s ` @r]r r 0s>$,i#F  eS))UQY MNN MM( # MM#e* %  eS))UQY QRR MM( # MM#e* %  MM( #  *1377;NQR;RS MM( # MM- .-@) *'4((CLA,=IJ J j! glln% gnn&''' IvII   x ( ( '&' ' /!( OracgrWrXrZrrrrs r] xrevrangeStreamCommands.xrevrangerracgrWrXr) s r]r* r+ r racX#/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 rPz*XREVRANGE count must be a positive integerr XREVRANGErr )rZrrrrrgs r]r* r+ sk.%(:  eS))UQY LMM MM( # MM#e* %##KLLdVLLracgrWrXrZrrrergr rTs r]xtrimStreamCommands.xtrimrracgrWrXr0 s r]r1 r2 rrac/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 specifiedr[z7XTRIM ref_policy must be one of: KEEPREF, DELREF, ACKEDrnrorrXTRIMr$)rZrrrergr rTrgs r]r1 r2 s2$&  %"3RS S >emNO O  !j8V&VUV V   MM) $   MM( #  MM$    MM& !   MM%   MM( # MM%  ! MM* %##GT;F;;rarX) rZr=rr1rLr-rMr;rr) rZrrr1rLr-rMr;rr)rr1rLr-rMr;rr) rZr=rr1rLr-rMr;rT%Literal['KEEPREF', 'DELREF', 'ACKED']rr) rZrrr1rLr-rMr;rTr6 rr) rr1rLr-rMr;rTr6 rr) rNTFNNNNN)rZr=rr1rcDict[FieldT, EncodableT]rdr;rrrerrfrrgStreamIdT | Noner rrT,Literal['KEEPREF', 'DELREF', 'ACKED'] | Nonerhrrituple[str, bytes] | Nonerr)rZrrr1rcr7 rdr;rrrerrfrrgr8 r rrTr9 rhrrir: rr)rr1rcr7 rdr;rrrerrfrrgzUnion[StreamIdT, None]r rrTr9 rhrrir: rrr) rZr=rr1rurrvrrr) rZrrr1rurrvrrr)rr1rurrvrrr)z0-0NF)rZr=rr1rLr-rr&rrrr;rrrrrry)rZrrr1rLr-rr&rrrr;rrrrrrz)rr1rLr-rr&rrrr;rrrrrr{)NNNFF)rZr=rr1rLr-rr&rrr(Union[List[StreamIdT], Tuple[StreamIdT]]rrr5rrrrrrrrr?)rZrrr1rLr-rr&rrrr; rrr5rrrrrrrrzAwaitable[XClaimResponse])rr1rLr-rr&rrrr; rrr5rrrrrrrrz*XClaimResponse | Awaitable[XClaimResponse])rZr=rr1rMr;rr)rZrrr1rMr;rr)rr1rMr;rr) rZr=rr1rMr;rTr6 rr) rZrrr1rMr;rTr6 rr)rr1rMr;rTr6 rr)$FN)rZr=rr1rLr-rdr;rrrrrr)rZrrr1rLr-rdr;rrrrrr) rr1rLr-rdr;rrrrrr) rZr=rr1rLr-rr&rr) rZrrr1rLr-rr&rr)rr1rLr-rr&rr)rZr=rr1rLr-rr)rZrrr1rLr-rr)rr1rLr-rrrW) rZr=rr1rLr-rdr;rrrr) rZrrr1rLr-rdr;rrrr) rr1rLr-rdr;rrrr)rZr=rr1rLr-rr)rZrrr1rLr-rr)rr1rLr-rr)rZr=rr1rr)rZrrr1rr)rr1rrr)rZr=rr1rNrrr)rZrrr1rNrrr)rr1rNrrrr r r)rZr=rr1rLr-r"Literal['SILENT', 'FAIL', 'FATAL']rMr;rrrrrr)rZrrr1rLr-rr= rMr;rrrrrr)rr1rLr-rr= rMr;rrrrrr)rZr=rr1rLr-rr)rZrrr1rLr-rr)rr1rLr-rr)rZr=rr1rLr-rr;rr;rrrConsumerT | Nonerrrr@)rZrrr1rLr-rr;rr;rrrr> rrrz Awaitable[XPendingRangeResponse])rr1rLr-rr;rr;rrrr> rrrz8XPendingRangeResponse | Awaitable[XPendingRangeResponse])-+N) rZr=rr1rr;rr;rrrStreamRangeResponse | None) rZrrr1rr;rr;rrr%Awaitable[StreamRangeResponse | None]) rr1rr;rr;rrrBStreamRangeResponse | None | Awaitable[StreamRangeResponse | None]) rZr=r Dict[KeyT, StreamIdT]rrr rrrB) rZrr rD rrr rrzAwaitable[XReadResponse])r rD rrr rrz(XReadResponse | Awaitable[XReadResponse])NNFN)rZr=rLrrrr rD rrr rr rr rrrA)rZrrLrrrr rD rrr rr rr rrzAwaitable[XReadGroupResponse])rLrrrr rD rrr rr rr rrz2XReadGroupResponse | Awaitable[XReadGroupResponse])r@ r? N) rZr=rr1rr;rr;rrrrA ) rZrrr1rr;rr;rrrrB ) rr1rr;rr;rrrrC )NTNNN)rZr=rr1rrrerrgr8 r rrTr9 rr)rZrrr1rrrerrgr8 r rrTr9 rr)rr1rrrerrgr8 r rrTr9 rr) rrrrr rrNrWrjrwrrrrrrrrrrrrrrrrrr r r* r1 r rXrar]rIrIs  (,9?GP !)-:@HQ  C C%+ C3< C  C =F    :   =F !  :   =F 888 8 : 8  8, !  "& CG#)-    )           A  '     !  "& CG#)- %! % %) %  %  %  % %  % %A % %' %  % %& $  (, CG#)-X;X;)X;  X;  X;  X;X;&X;X;AX;X;'X; 0X;t%)#'  "!   %)#' %!%%"%! % %%%)#' >>>>">>! >> 0 >>@$                $  #! # # # #  #  # # #  # #"$ 1E1E1E 1E  1E  1E1E1E *1Ef !%         >          !% (! ( ( ( (  ( > ( ( ( ( ( ( # ( (* !%QAQAQA QA  QA > QAQAQAQAQAQA 4QAfOO !)-5>  8 =F  :   =F !:   =F 777: 7  7( #'       !   #' !     !  #' ---  -  - ! - -0 (,9?OX !    Y Y%+ Y;D Y  Y (,9? !)-:@ G (,9?OX !     %+ ;D  " $(     !    $( !   !   $( ===  = ! = =(# #(,#9?# ##.!.)-.:@. (.. H H%+ H ? HWW .!.)-. (.. : : ? :;@ (,48 > JJ?"& 1      "&!1       "&0606061 06  06  0606 06d (,9? (!()-(:@( "(( N N%+ N 3 N*. $  $ $ $ $  $  $' $ $  $ $*. /! / / / /  /  /' / / * / /$*.7L7L7L 7L  7L  7L'7L7L B7Lr ) ))) )  ) $ )) 4!444 4  4 / 44 JJJ J  J N J@!  &   ! '!'&'' ' " ''! 2&22 2 2 2h ! *. !  ! ! !' !  !  ! !( !  ! ! ! *. ,! , , ,' ,  ,  , ,( , ' , , ! *.NNN' N  N  NN(N <N` ) ))) )  ) $ )) 4!444 4  4 / 44 MMM M  M N M@" "& CG      A " "& CG!     A " "& CG3<3<3< 3<  3<  3<A3< 3<3jjr\SSS?jj5r\SSS@jj5rSSSAjjr\SSSBjj5r\SSSCjj5rSSSDjjr\SSSEjj5r\SSSFjj5rSSSGjjr\SSS\4SSHjj5r\SSS\4SSIjj5rSSS\4SSJjjr\SSS\4SSKjj5r\SSS\4SSLjj5rSSS\4SSMjjr\S\4SSNjj5r \S\4SSOjj5r S\4SSPjjr \SSQj5r!\SSRj5r!SSSjr!\SSTj5r"\SSUj5r"SSVjr"\SSWj5r#\SSXj5r#SSYjr#\SuSZj5r$\SvS[j5r$SwS\jr$\S\4SS]jj5r%\S\4SS^jj5r%S\4SS_jjr%\SS`j5r&\SSaj5r&SSbjr&\SS\4SScjj5r'\SS\4SSdjj5r'SS\4SSejjr'\SSSfjj5r(\SSSgjj5r(SSShjjr(\SSij5r)\SSjj5r)SSkjr)SSSljjr*Smr+g)SortedSetCommandsizk Redis commands for Sorted Sets data type. see: https://redis.io/topics/data-types-intro#redis-sorted-sets Fc grWrX rZrrrerfchrrgrhs r]zaddSortedSetCommands.zadds!rac grWrXrH s r]rJ rK s),rac 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 bothrPzFZADD option 'incr' only works when passing a single element/score pairz/Only one of 'nx', 'lt', or 'gr' may be defined.sNXsXXsCHsINCRTas_scoresGTsLTrZADD)rrrr rf) rZrrrerfrI rrgrhrgrbrs r]rJ rK !s&XKL L "GH H "GH H CLA%X  2MN N#% MM% MM% MM%  MM' ""&GJ  MM% MM% MMOD MM$q' " MM$q' "$##FDE6EWEEracgrWrXrBs r]zcardSortedSetCommands.zcardnrHracgrWrXrBs r]rQ rR qr{rac$URSX/S9$)zu Return the number of elements in the sorted set ``name`` For more information, see https://redis.io/commands/zcard ZCARDrrerBs r]rQ rR trracgrWrXrZrrrs r]zcountSortedSetCommands.zcount|r@racgrWrXrW s r]rX rY rxrac&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 ZCOUNTrrerW s r]rX rY s##Hd6#JJracgrWrXrZr withscoress r]zdiffSortedSetCommands.zdiffr`racgrWrXr^ s r]r` ra rcracz[U5/UQnU(aURS5 UR"S/UQ7XS.6$)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 WITHSCORESZDIFF)rr_ )rrrf)rZrr_ rgs r]r` ra s?d)#d#  MM, '##GWfW4WWracgrWrXrZrrs r] zdiffstoreSortedSetCommands.zdiffstorerracgrWrXrg s r]rh ri rxracF[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)rrf)rZrrrgs r]rh ri s-d)#d###L$@@@racgrWrXrZrr1rs r]zincrbySortedSetCommands.zincrbyracgrWrXrn s r]ro rp r/rac(URSXU5$)z Increment the score of ``value`` in sorted set ``name`` by ``amount`` For more information, see https://redis.io/commands/zincrby ZINCRBYrern s r]ro rp s##ItUCCraNcgrWrXrZr aggregater_ s r]zinterSortedSetCommands.zinterrracgrWrXrv s r]rx ry rrac&URSSXUS9$)uS Return the intersect of multiple sorted sets specified by ``keys``. With the ``aggregate`` option, it is possible to specify how the results of the intersection are aggregated. Available aggregation modes: - ``SUM`` (default): the score of an element is summed across the inputs where it exists. Score = SUM(score₁×weight₁, score₂×weight₂, ...) - ``MIN``: the resulting set will contain the minimum score of an element across the inputs where it exists. Score = MIN(score₁×weight₁, score₂×weight₂, ...) - ``MAX``: the resulting set will contain the maximum score of an element across the inputs where it exists. Score = MAX(score₁×weight₁, score₂×weight₂, ...) - ``COUNT``: ignores the original scores and counts weighted set membership. Each element's score is the sum of the weights of the input sets that contain it. Score = SUM(weight₁, weight₂, ...) for sets containing the element. When all weights are 1 (default), the score equals the number of input sets containing the element. For more information, see https://redis.io/commands/zinter ZINTERN)r_  _zaggregaterv s r]rx ry s8$JWWracgrWrXrZrrrw s r] zinterstoreSortedSetCommands.zinterstorerracgrWrXr s r]r r  rrac(URSXU5$)uF Intersect multiple sorted sets specified by ``keys`` into a new sorted set, ``dest``. Scores in the destination will be aggregated based on the ``aggregate``. Available aggregation modes: - ``SUM`` (default): the score of an element is summed across the inputs where it exists. Score = SUM(score₁×weight₁, score₂×weight₂, ...) - ``MIN``: the resulting set will contain the minimum score of an element across the inputs where it exists. Score = MIN(score₁×weight₁, score₂×weight₂, ...) - ``MAX``: the resulting set will contain the maximum score of an element across the inputs where it exists. Score = MAX(score₁×weight₁, score₂×weight₂, ...) - ``COUNT``: ignores the original scores and counts weighted set membership. Each element's score is the sum of the weights of the input sets that contain it. Score = SUM(weight₁, weight₂, ...) for sets containing the element. When all weights are 1 (default), the score equals the number of input sets containing the element. For more information, see https://redis.io/commands/zinterstore ZINTERSTOREr} r s r]r r > t9EEracgrWrXrs r] zintercardSortedSetCommands.zintercard. r@racgrWrXrs r]r r 3 rxrac@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 ZINTERCARDrrers r]r r 8 rracgrWrXrW s r] zlexcountSortedSetCommands.zlexcountG r@racgrWrXrW s r]r r L rxrac&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 ZLEXCOUNTrrerW s r]r r Q s##KCf#MMracgrWrXrks r]zpopmaxSortedSetCommands.zpopmax\ r`racgrWrXrks r]r r a rcracfUSL=(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 Nr_ TZPOPMAXrerZrrrkrbs r]r r f AT!.w4"&##ItFdFgFFracgrWrXrks r]zpopminSortedSetCommands.zpopmins r`racgrWrXrks r]r r x rcracfUSL=(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 Nr_ TZPOPMINrer s r]r r } r racgrWrXrZrrr_ s r] zrandmemberSortedSetCommands.zrandmember s "racgrWrXr s r]r r s *-rac/nUbURU5 U(aURS5 UR"SU/UQ7SU06$)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 rd ZRANDMEMBERr_ r)rZrrr_ rs r]r r sG$   MM%  MM, '##M3WWJWWracgrWrXr,s r]bzpopmaxSortedSetCommands.bzpopmax r/racgrWrXr,s r]r r r6raclUcSn[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 NrBZPOPMAXr3r,s r]r r s< ?GD$' G##J666racgrWrXr,s r]bzpopminSortedSetCommands.bzpopmin r/racgrWrXr,s r]r r r6raclUcSn[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 NrBZPOPMINr3r,s r]r r s< ?G!-dD!9 G##J666racgrWrXrZrNrrrrs r]zmpopSortedSetCommands.zmpop rracgrWrXr s r]r r r{racU/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 rrrPraZMPOPrrrSrf)rZrNrrrrrks r]r r !sgzD  CSO  KK  KK  A: KK%( )##G3d33racgrWrXrZrrDrrrrs r]bzmpopSortedSetCommands.bzmpop!sracgrWrXr s r]r r *!s$'racX/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 setrrraBZMPOPr )rZrrDrrrrrks r]r r 5!sh*(4( CSIJ J  KK  KK  We$%##H4t44rac 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``.BYSCOREBYLEXREVrrd r_ rrr )rZrrrrrrbyscorebylexr_ rrfrrgrbs r]_zrangeSortedSetCommands._zrangeU!s uVW W  3;COLM M ZM   MM$  tC()  MM) $  MM' "  MM%  #/ MM7F0 1  MM, '!+P&##V7w77rac grWrX rZrrrrr_ rr r rfrs r]zrangeSortedSetCommands.zrange~!s rac grWrXr s r]r r !s(+rac 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 r s r]r r !s\Vu&.S[d>>$sP P||              racgrWrXrZrrrr_ rs r]r SortedSetCommands.zrevrange! racgrWrXr s r]r r !(+racpSXU/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 WITHSCORESr rr)rZrrrr_ rrgrbs r]r r !sD*tC0  MM- (!+P##V7w77rac grWrX rZrrrrr r rrfrs r] zrangestoreSortedSetCommands.zrangestore "srac grWrXr s r]r r "srac :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 r s r]r r %"s:F||              racgrWrXrZrrrrrs r] zrangebylexSortedSetCommands.zrangebylexW"r racgrWrXr s r]r r a"r racUbUbUbUc [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 ZRANGEBYLEXrrrrSrf)rZrrrrrrgs r]r r k"sa"  #+3?u}JK KC0   MM8U0 1##V94&99racgrWrXrZrrrrrs r]zrevrangebylex SortedSetCommands.zrevrangebylex"r racgrWrXr s r]r r "r racUbUbUbUc [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 rZREVRANGEBYLEXrrr )rZrrrrrrgs r]r r "sa"  #+3?u}JK K"Ds3   MM7E/ 0##V94&99racgrWrXrZrrrrrr_ rs r] zrangebyscoreSortedSetCommands.zrangebyscore"rracgrWrXr s r]r r "rracUbUbUbUc [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 ZRANGEBYSCORErrd r rrrSrrf) rZrrrrrr_ rrgrbs r]r r "s0  #+3?u}JK K!4c2   MM7E/ 0  MM, '!+P&##V7w77racgrWrXrZrrrrrr_ rs r]zrevrangebyscore"SortedSetCommands.zrevrangebyscore"rracgrWrXr s r]r r "rracUbUbUbUc [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 rZREVRANGEBYSCORErrd r rr ) rZrrrrrr_ rrgrbs r]r r #s0  #+3?u}JK K$d5   MM7E/ 0  MM, '!+P&##V7w77racgrWrXrZrr withscorers r]zrankSortedSetCommands.zrank%#"%racgrWrXr s r]r r .#-0racfSX/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 WITHSCOREr rrrZrrr rrgrbs r]r r 7#s;"4'  MM+ & )N##V7w77racgrWrXrus r]zremSortedSetCommands.zremP#rracgrWrXrus r]r r S#rxrac*UR"SU/UQ76$)zm Remove member ``values`` from sorted set ``name`` For more information, see https://redis.io/commands/zrem ZREMrerus r]r r X#rracgrWrXrW s r]zremrangebylex SortedSetCommands.zremrangebylex`#r@racgrWrXrW s r]r r e#rxrac(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 ZREMRANGEBYLEXrerW s r]r r j#s##$4dEEracgrWrXrW s r]zremrangebyrank!SortedSetCommands.zremrangebyrankw#r@racgrWrXrW s r]r r |#rxrac(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 ZREMRANGEBYRANKrerW s r]r r #s##$5t#FFracgrWrXrW s r]zremrangebyscore"SortedSetCommands.zremrangebyscore#r@racgrWrXrW s r]r" r# #rxrac(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 ZREMRANGEBYSCORErerW s r]r" r# #s##$63GGracgrWrXr s r]zrevrankSortedSetCommands.zrevrank#r racgrWrXr s r]r( r) #r racfSX/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 ZREVRANKr r rr s r]r( r) #s;"d*  MM+ & )N##V7w77racgrWrXrs r]zscoreSortedSetCommands.zscore#rq racgrWrXrs r]r. r/ #r/rac&URSXU/S9$)zz Return the score of element ``value`` in sorted set ``name`` For more information, see https://redis.io/commands/zscore ZSCORErrers r]r. r/ #s##Hd#GGracgrWrXrZrrw r_ rs r]zunionSortedSetCommands.zunion#s racgrWrXr4 s r]r5 r6 #s(+rac *URSSUUUUS9$)u 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. Available aggregation modes: - ``SUM`` (default): the score of an element is summed across the inputs where it exists. Score = SUM(score₁×weight₁, score₂×weight₂, ...) - ``MIN``: the resulting set will contain the minimum score of an element across the inputs where it exists. Score = MIN(score₁×weight₁, score₂×weight₂, ...) - ``MAX``: the resulting set will contain the maximum score of an element across the inputs where it exists. Score = MAX(score₁×weight₁, score₂×weight₂, ...) - ``COUNT``: ignores the original scores and counts weighted set membership. Each element's score is the sum of the weights of the input sets that contain it. Score = SUM(weight₁, weight₂, ...) for sets containing the element. When all weights are 1 (default), the score equals the number of input sets containing the element. ``score_cast_func`` a callable used to cast the score return value For more information, see https://redis.io/commands/zunion ZUNIONNr r} r4 s r]r5 r6 #s/F    !+    racgrWrXr s r] zunionstoreSortedSetCommands.zunionstore$rracgrWrXr s r]r; r< &$rrac(URSXU5$)u^ 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. Available aggregation modes: - ``SUM`` (default): the score of an element is summed across the inputs where it exists. Score = SUM(score₁×weight₁, score₂×weight₂, ...) - ``MIN``: the resulting set will contain the minimum score of an element across the inputs where it exists. Score = MIN(score₁×weight₁, score₂×weight₂, ...) - ``MAX``: the resulting set will contain the maximum score of an element across the inputs where it exists. Score = MAX(score₁×weight₁, score₂×weight₂, ...) - ``COUNT``: ignores the original scores and counts weighted set membership. Each element's score is the sum of the weights of the input sets that contain it. Score = SUM(weight₁, weight₂, ...) for sets containing the element. When all weights are 1 (default), the score equals the number of input sets containing the element. For more information, see https://redis.io/commands/zunionstore ZUNIONSTOREr} r s r]r; r< .$r racgrWrXrZrmemberss r]zmscoreSortedSetCommands.zmscoreO$r(racgrWrXrA s r]rC rD T$rrac`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 listZMSCORErr{)rZrrB rgs r]rC rD Y$s;FG G##ICCcUCCrac 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)rrrras AGGREGATEz(aggregate can be sum, min, max or count.r_ Fr r) rrrrrrrvrSrrr'rf)rZrrrrw rbrgweightss r]r~ SortedSetCommands._zaggregatek$s%,9   MM$  c$i dD ! ! IIK'G d  MM* % MM' "  $BB l+ i( JKK ;;|U + + MM- (##V7w77rarX)FFFFFF)rZr=rr1rr rerrfrrI rrrrgrrhrrzint | float | None)rZrrr1rr rerrfrrI rrrrgrrhrrzAwaitable[int | float | None])rr1rr rerrfrrI rrrrgrrhrrz2int | float | None | Awaitable[int | float | None]r r r) rZr=rr1rrFrrFrr) rZrrr1rrFrrFrr)rr1rrFrrFrrr)rZr=rr0r_ rrrG)rZrrr0r_ rrAwaitable[ZSetRangeResponse])rr0r_ rr0ZSetRangeResponse | Awaitable[ZSetRangeResponse])rZr=rr1rr0rr)rZrrr1rr0rr)rr1rr0rr) rZr=rr1r1rrr'r float | None) rZrrr1r1rrr'rAwaitable[float | None])rr1r1rrr'r&float | None | Awaitable[float | None]r) rZr=rr0rw rr_ rrrG) rZrrr0rw rr_ rrrK )rr0rw rr_ rrrL rW)rr1r(Sequence[KeyT] | Mapping[AnyKeyT, float]rw rrr) rZrrr1rrP rw rrr)rr1rrP rw rrrr) rZr=rDrr List[str]r rrr) rZrrDrrrQ r rrr)rDrrrQ r rrr) rZr=rr1rr'rr'rr) rZrrr1rr'rr'rr)rr1rr'rr'rr)rZr=rr1rrrrG)rZrrr1rrrrK )rr1rrrrL ) rZr=rr1rrr_ rrrD) rZrrr1rrr_ rrzAwaitable[ZRandMemberResponse])rr1rrr_ rrz4ZRandMemberResponse | Awaitable[ZRandMemberResponse])rZr=rr0rr>rr!)rZrrr0rr>rz"Awaitable[BlockingZSetPopResponse])rr0rr>rzKFZ?? KK@ (,3?FR !)-4@GS  K K+ K2> K  KBG   (- ;?   CH+!+).+<@+ %++ /4 X X'+ X 9 XQQ !)-5: A (,6;DN &!&)-&7<&EO& &&D!%           !% +!+++ + & ++MRXX&0XEIX 9X< !% 7   !% !7   !% FF7F F  FBNO +.6?HK OP!,/7@IL  ;< D D"+ D47 D  D (,3=DN !)-4>EO  N N) N0: N  NBF   (, 5?   CG+!+)-+6@+ %++ /3 G G!+ G 9 GBF   (, 5?   CG+!+)-+6@+ %++ /3 G G!+ G 9 G! " " "" "  ""! -!- -- - ( --GLXX *X?CX =X4FG& &(-&8C& &&GH1!1).19D1 +11 3477$/7 E7*FG& &(-&8C& &&GH1!1).19D1 +11 3477$/7 E7* !          !  '!''' '  '  ' "''!  444 4  4  4 242 !         ! '!''' '  '  '' "''! 555 5  5  55 25N 7< $!'8 '8 '8  '8  '8'8'8'8'85'8'8'8 '8R  +0!               )                 +0! +! + + + +  +  +) + + + + + & + +& +0!; ; ;  ;  ;  ; ); ; ; ; ;  :; z !+0          )      !+0 +!+++ +  + ) + &++!+0 888 8  8 ) 8 :88!                 ! !               &!0 0 0  0  0  0 0 0 0 0  0 d !                ! +!+++ +  +  + &++! ::: :  :  : ::0 !                ! +!+++ +  +  + &++! ::: :  :  : ::0 ! +0                 )        ! +0 +! + + + +  +  + +) + & + + ! +0!8!8!8 !8  !8  !8!8)!8 :!8F ! +0                 )        ! +0 +! + + + +  +  + +) + & + + ! +0!8!8!8 !8  !8  !8!8)!8 :!8F  +0 % %%% % ) % %%  +0 0!000 0 ) 0 + 00 +0 888 8 ) 8 F 82OO !)-8> ; (,3=DN !)-4>EO  F F) F0: F  F (,36=@ !)-47>A  G (,3?FR !)-4@GS  H H+ H2> H  H  +0 % %%% % ) % %%  +0 0!000 0 ) 0 + 00 +0 888 8 ) 8 F 82 (,5? &!&)-&6@& &&H!% +0    6    )     !% +0 +!+6++ + ) + & ++!% +0 * 6* *  * ) * : * X !%  7   !% !7   !% FF7F F  FB! !'+!6?! !!,!,(,,7@, &,,DD"+D ;D.$( 88 8= 8 ! 8 88rarF c\rSrSrSr\SSj5r\SSj5rSSjr\SSj5r\SSj5rSSjr\SS j5r\SS j5rSS jrS r g )HyperlogCommandsi$zf Redis commands of HyperLogLogs data type. see: https://redis.io/topics/data-types-intro#hyperloglogs cgrWrXrus r]pfaddHyperlogCommands.pfadd$rracgrWrXrus r]rX rY $rxrac*UR"SU/UQ76$)zv Adds the specified elements to the specified HyperLogLog. For more information, see https://redis.io/commands/pfadd PFADDrerus r]rX rY $r|racgrWrXrZsourcess r]pfcountHyperlogCommands.pfcount$rracgrWrXr^ s r]r` ra $rrac(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 PFCOUNTrer^ s r]r` ra $s##I888racgrWrXrZrr_ s r]pfmergeHyperlogCommands.pfmerge$rracgrWrXrf s r]rg rh $rrac*UR"SU/UQ76$)zp Merge N different HyperLogLogs into a single one. For more information, see https://redis.io/commands/pfmerge PFMERGErerf s r]rg rh $s ##It>g>>rarXNrrr)rZr=r_ r1rr)rZrr_ r1rr)r_ r1rr)rZr=rr1r_ r1rr)rZrrr1r_ r1rr)rr1r_ r1rr) rrrrr rrX r` rg r rXrar]rV rV $s PP !)-8> <EE QQ9RR !)-9= ?rarV c\rSrSrSrSrSrg)HashDataPersistOptionsi$FNXFXXrXN)rrrrrn ro r rXrar]rm rm $s C Crarm c \rSrSrSr\SZSj5r\S[Sj5rS\Sjr\S]Sj5r\S^Sj5rS_Sjr\S`S j5r\SaS j5rSbS jr\ScS j5r \SdS j5r SeSjr \SfSj5r \SgSj5r ShSjr \SSSSSS.SiSjj5r \SSSSSS.SjSjj5r SSSSSS.SkSjjr \SlSmSjj5r \SlSnSjj5r SlSoSjjr \SpSqSjj5r \SpSrSjj5r SpSsSjjr \StSj5r\SuSj5rSvS jr\SwS!j5r\SxS"j5rSyS#jr\SzS{S$jj5r\SzS|S%jj5rSzS}S&jjr\S~SS'jj5r\S~SS(jj5rS~SS)jjr\SS*j5r\SS+j5rSS,jr\SS-j5r\SS.j5r\"S/S0S1S29SS3j5r\SS4j5r\SS5j5rSS6jr\StS7j5r\SuS8j5rSvS9jr\SS:j5r\SS;j5rSS<jr\SSSSS=.SS>jj5r\SSSSS=.SS?jj5rSSSSS=.SS@jjr\SSSSS=.SSAjj5r\SSSSS=.SSBjj5rSSSSS=.SSCjjr\SSSSS=.SSDjj5r\SSSSS=.SSEjj5rSSSSS=.SSFjjr\SSSSS=.SSGjj5r\SSSSS=.SSHjj5rSSSSS=.SSIjjr\SSJj5r\SSKj5rSSLjr\SSMj5r\SSNj5rSSOjr\SSPj5r\SSQj5rSSRjr\SSSj5r\SSTj5rSSUjr\SSVj5r \SSWj5r SSXjr SYr!g) HashCommandsi$z_ Redis commands for Hash data type. see: https://redis.io/topics/data-types-intro#redis-hashes cgrWrXrZrrs r]hdelHashCommands.hdel$rracgrWrXrs s r]rt ru $rxrac*UR"SU/UQ76$)z^ Delete ``keys`` from hash ``name`` For more information, see https://redis.io/commands/hdel HDELrers s r]rt ru $s ##FD8488racgrWrXrZrrs r]hexistsHashCommands.hexists$rracgrWrXrz s r]r{ r| $rrac&URSXU/S9$)z Returns a boolean indicating if ``key`` exists within hash ``name`` For more information, see https://redis.io/commands/hexists HEXISTSrrerz s r]r{ r| $s ##Itv#FFracgrWrXrz s r]hgetHashCommands.hget$r(racgrWrXrz s r]r r $rrac&URSXU/S9$)zp Return the value of ``key`` within the hash ``name`` For more information, see https://redis.io/commands/hget HGETrrerz s r]r r %s##FDTF#CCracgrWrXrBs r]hgetallHashCommands.hgetall %r racgrWrXrBs r]r r %r rac$URSX/S9$)zr Return a Python dict of the hash's name/value pairs For more information, see https://redis.io/commands/hgetall HGETALLrrerBs r]r r %s##It&#AAracgrWrXrs s r]hgetdelHashCommands.hgetdel%rracgrWrXrs s r]r r $%r ract[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)rrrfrs s r]r r )%s; t9>MN N##ItXs4yP4PPraNF)rrrrrcgrWrXrZrrrrrrrs r]hgetexHashCommands.hgetex:%s$'racgrWrXr s r]r r F%s/2racU(d [S5e[USLUSLUSLUSLU45(d [S5e[X#XE5nU(aURS5 UR"SU/UQSP[ 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 providedNrrHGETEXr )rrQrKrrfr) rZrrrrrrrrs r]r r R%s:LM M$$$D D     :  )=RT(P    y )##       I     racgrWrXrZrrr1s r]hincrbyHashCommands.hincrby%r@racgrWrXr s r]r r %rxrac(URSXU5$)z| Increment the value of ``key`` in hash ``name`` by ``amount`` For more information, see https://redis.io/commands/hincrby HINCRBYrer s r]r r %s ##It&AAracgrWrXr s r] hincrbyfloatHashCommands.hincrbyfloat%rracgrWrXr s r]r r %rjrac(URSXU5$)z Increment the value of ``key`` in hash ``name`` by floating ``amount`` For more information, see https://redis.io/commands/hincrbyfloat HINCRBYFLOATrer s r]r r %s##NDvFFracgrWrXrBs r]hkeysHashCommands.hkeys%rracgrWrXrBs r]r r %rcrac$URSX/S9$)zi Return the list of keys within hash ``name`` For more information, see https://redis.io/commands/hkeys HKEYSrrerBs r]r r %rracgrWrXrBs r]hlenHashCommands.hlen%r.racgrWrXrBs r]r r %rrac$URSX/S9$)zj Return the number of elements in hash ``name`` For more information, see https://redis.io/commands/hlen HLENrrerBs r]r r %rracgrWrXrZrrrrr s r]hsetHashCommands.hset%rracgrWrXr s r]r r %r!racUcU(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)rrSr rf)rZrrrrr rgrs r]r r %sy& ;wu<= =  MM% ? MM3, '   d#(##FD:6::rac grWrX rZrrrrr rrrrrrs r]hsetexHashCommands.hsetex&srac grWrXr s r]r r &srac xUcU(dU(d [S5eU(a[U5S-S:wa [S5e[USLUSLUSLU SLU 45(d [S5e[XgX5n U (aU R U R 5 U (aU R S5 /n U(aU R U5 UbU R X#45 U(a(UR5HnU R U5 M UR"SU/U QS P[[U 5S- 5PU Q76$) 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 Nz 'hsetex' with no key value pairsrMrzR'hsetex' with odd number of items. 'items' must contain a list of key/value pairs.r r!HSETEXr ) rrrQrKrrrSr rfr)rZrrrrr rrrrrrrrgrs r]r r '&sL^ ;wu>? ? SZ!^q(B  %$$D D     :  )=RT(P    288 9    y )  MM% ? MM3, '   d#(## d ( *2 47F a4H KQ  racgrWrXrZrrrs r]hsetnxHashCommands.hsetnx&r@racgrWrXr s r]r r &rxrac(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 HSETNXrer s r]r r &s##Hd??racgrWrXrs r]hmsetHashCommands.hmset&rracgrWrXrs r]r r &s raz4.0.0zUse 'hset' instead.r rcU(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)rr rSrfr s r]r r &sL@A AMMOD LL $##GT:E::racgrWrXrZrrrks r]hmgetHashCommands.hmget&r racgrWrXr s r]r r &s /2racH[X#5nUR"SU/UQ7SU/06$)zu Returns a list of values ordered identically to ``keys`` For more information, see https://redis.io/commands/hmget HMGETrrr s r]r r &s-D'##GTFDFvFFracgrWrXrBs r]hvalsHashCommands.hvals&rracgrWrXrBs r]r r &rcrac$URSX/S9$)zk Return the list of values within hash ``name`` For more information, see https://redis.io/commands/hvals HVALSrrerBs r]r r &rracgrWrXrz s r]hstrlenHashCommands.hstrlen&rracgrWrXrz s r]r r &rxrac&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 HSTRLENrrerz s r]r r &s##Itv#FFra)rerfrgrhcgrWrXrZrsecondsrerfrgrhrcs r]hexpireHashCommands.hexpire&rracgrWrXr s r]r r &rracX4XV/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. rP4Only one of 'nx', 'xx', 'gt', 'lt' can be specified.rrrorpHEXPIREr rTrrrsrtrrurrfr) rZrr rerfrgrhrc conditionsrbs r]r r 'sNb% z?Q ST T gx11 2 2'//12G NN4 NN4 NN4 NN4 ## t '. 08 :=f+ HN  racgrWrXrZr millisecondsrerfrgrhrcs r]hpexpireHashCommands.hpexpireG'rracgrWrXr s r]r r S'rracX4XV/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. rPr r:rrrorpHPEXPIREr r ) rZrr rerfrgrhrcr rbs r]r r _'sNb% z?Q ST T lH$6$6 7 7|99;dBCL NN4 NN4 NN4 NN4 ##  -4 6> @CF  NT  racgrWrXrZrunix_time_secondsrerfrgrhrcs r] hexpireatHashCommands.hexpireat'rracgrWrXr s r]r r 'rracX4XV/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. rPr rrrorp HEXPIREATr rTrrrsrrrrfr) rZrr rerfrgrhrcr rbs r]r r 'sNb% z?Q ST T '):): ; ; #$5$?$?$A B  NN4 NN4 NN4 NN4 ##        K    racgrWrXrZrunix_time_millisecondsrerfrgrhrcs r] hpexpireatHashCommands.hpexpireat'rracgrWrXr s r]r r (rracX4XV/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. rPr r:rrrorp HPEXPIREATr r ) rZrr rerfrgrhrcr rbs r]r r (sNb% z?Q ST T ,h.?.? @ @%()?)I)I)Kd)R%S " NN4 NN4 NN4 NN4 ##   "     K    racgrWrXrZrrcs r]hpersistHashCommands.hpersistO(racgrWrXr s r]r r T(r"rac@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. HPERSISTr rfrr s r]r r Y(s$"##JhF UfUUracgrWrXrZrrcs r] hexpiretimeHashCommands.hexpiretimel(r racgrWrXr s r]r r q(r"racHUR"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. HEXPIRETIMEr rr r s r]r r v(s6(## 3#f+ 8> FIU  racgrWrXr s r] hpexpiretimeHashCommands.hpexpiretime(r racgrWrXr s r]r r (r"racHUR"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. HPEXPIRETIMEr rr r s r]r r (s6(## C3v; 9? GJe  racgrWrXr s r]httlHashCommands.httl(rXracgrWrXr s r]r r (r"racHUR"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. HTTLr rr r s r]r r (s6$## C3v; 17 ?Be  racgrWrXr s r]hpttlHashCommands.hpttl(rhracgrWrXr s r]r" r# (r"racHUR"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. HPTTLr rr r s r]r" r# (s6$## S(CK 28 @Cu  rarX)rZr=rr1rr)rr)rZrrr1rr)rr)rr1rr)rr)rZr=rr1rr)rr)rZrrr1rr)rr)rr1rr)rr)rZr=rr1rr)rr)rZrrr1rr)rr)rr1rr)rr)rZr=rr1rzdict[bytes | str, bytes | str])rZrrr1rz)Awaitable[dict[bytes | str, bytes | str]])rr1rzJdict[bytes | str, bytes | str] | Awaitable[dict[bytes | str, bytes | str]])rZr=rr1rr)rr)rZrrr1rr)rr)rr1rr)rr )rZr=rr1rr)rrrrrrrrrrrr)rZrrr1rr)rrrrrrrrrrrr)rr1rr)rrrrrrrrrrrr r) rZr=rr1rr)r1rrr) rZrrr1rr)r1rrr)rr1rr)r1rrrr) rZr=rr1rr)r1rrr) rZrrr1rr)r1rrr)rr1rr)r1rrr)rZr=rr1rr)rZrrr1rr)rr1rrr r rr)rZr=rr1r FieldT | Nonerrr"Mapping[FieldT, EncodableT] | Noner Sequence[EncodableT] | Nonerr)rZrrr1rr' rrrr( r r) rr) rr1rr' rrrr( r r) rr) NNNNNNNNNF)rZr=rr1rr' rrrr( r r) rrrrrrrrrHashDataPersistOptions | Nonerrrr)rZrrr1rr' rrrr( r r) rrrrrrrrrr* rrrr)rr1rr' rrrr( r r) rrrrrrrrrr* rrrr) rZr=rr1rr)rr'rr) rZrrr1rr)rr'rr)rr1rr)rr'rr)rZr=rr1rMapping[FieldT, EncodableT]rr)rZrrr1rr+ rr)rr1rr+ rr) rZr=rr1rFieldT | Iterable[FieldT]rkr)rr) rZrrr1rr, rkr)rr)rr1rr, rkr)rr )rZr=rr1rr)rr)rZrrr1rr)rr)rr1rr)rr)rZr=rr1r r(rcr)rerrfrrgrrhrrr)rZrrr1r r(rcr)rerrfrrgrrhrrr)rr1r r(rcr)rerrfrrgrrhrrr)rZr=rr1r r(rcr)rerrfrrgrrhrrr)rZrrr1r r(rcr)rerrfrrgrrhrrr)rr1r r(rcr)rerrfrrgrrhrrr)rZr=rr1r rrcr)rerrfrrgrrhrrr)rZrrr1r rrcr)rerrfrrgrrhrrr)rr1r rrcr)rerrfrrgrrhrrr)rZr=rr1r rrcr)rerrfrrgrrhrrr)rZrrr1r rrcr)rerrfrrgrrhrrr)rr1r rrcr)rerrfrrgrrhrrr)rZr=rr1rcr)rr)rZrrr1rcr)rr)rr1rcr)rr)rZr=rr1rcr)rr)rZrrr1rcr)rr)rr1rcr)rr)"rrrrr rrt r{ r r r r r r r r r r r r rHr r r r r r r r r r r r" r rXrar]rq rq $s MM !)-6< 9OO !)-4: G! !(,!39! !!,!,)-,4:, &,,D- -(,- '--8!8)-8 288BB SB' '(,'5;' !''2!2)-26<2 ,22QQ!'Q GQ" "!"&"& '  ' ' '  '  '  '  ' ' " ' ' "!"&"& 2! 2 2 2  2  2  2  2 2 - 2 2"!"&"&: : :   :  :  :  : :  H: xIJ (,39CF JK!)-4:DG BKN (,39CH LO!)-4:DI  8;GG%G/4G !GMM +!+)-+ %++@>> JJ?"#'6:-1  !  4  +  "#'6:-1 !!  4  +  "#'6:-1 ;;;! ; 4 ; + ; ;B"#'6:-1!!"&"&=A     !  4  +         ;     "#'6:-1!!"&"&=A !   !  4  +         ;     $"#'6:-1!!"&"&=AX X X ! X 4 X + X  X  X  X  X ;X X  X t (,39BL !)-4:CM  @ @% @.8 @  @ (,7R !-   $  ;;#>; ;  ; ' ''(' ' " ''2!22(2 2 - 22 G G 9 GBH G G GMM +!+)-+ %++@NN !)-4: G                    #! # # # #  #  #  #  #  # # : : :  :  :  :  :  :  *: x                    #! # # # #  #  #  #  #  # # : : :  :  :  :  :  :  *: x     &               #! # #& # #  #  #  #  #  # # @ @ &@  @  @  @  @  @  *@ D     !+               #! # #!+ # #  #  #  #  #  # # @ @ !+@  @  @  @  @  @  *@ D (,7= #!#)-#8># ##V& '+6< #!#(,#7=# ##  "( ) 0 '+6< #!#(,#7=# ##  "( ) 0TT #!#(,#7=# ## ,UU #!#(,#7=# ## rarq cN\rSrSrSrSSjrS S SjjrSrSrg) Scripti(A An executable Lua script object returned by ``register_script`` cXlX l[U[5(a!UR 5nUR U5n[ R"U5R5Ul grW) registered_clientscriptrrrrhashlibsha1rsharZr1 r2 rs r]rScript.__init__(sU "3  fc " "&&(G^^F+F<<'113raNcU=(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) r1 rqr`r; rscriptsaddevalshar5 rr script_loadr2 rZrrkrr; s r]__call__Script.__call__)szrzr >++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.)r1 rAttributeErrorconnection_poolr.s r]rScript.get_encoder )sK H))557 7 H))99EEG G Hs.A  A r1 r2 r5 )r1 9Union['redis.client.Redis', 'redis.cluster.RedisCluster']r2 r8r)rUnion[Sequence[KeyT], None]rk!Union[Iterable[EncodableT], None]rz?Union['redis.client.Redis', 'redis.cluster.RedisCluster', None]) rrrrr rrA rr rXrar]r. r. (sQ4T44$-126RV >)>0>P >6Hrar. cH\rSrSrSrSSjrSS SjjrSrg) AsyncScripti3)r/ c0XlX l[U[5(a,URR 5nURU5n[R"U5R5Ul g![ a UR 5nNWf=frW) r1 r2 rrrE rrD rr3 r4 rr5 r6 s r]rAsyncScript.__init__8)s"3  fc " " :+;;GGI^^F+F<<'113 " :+779 :sA88BBNc# 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)r9 Nrr: ) r1 rqredis.asyncio.clientr; rr< r= r> r5 rrr? r2 r@ s r]rA AsyncScript.__call__N)szrzr >++FT{U4[(1 f ' ' NN  t $ D#d)CdCC CC D$// <<H !,4?I *4   19DN !2:EO %0: "69   +3   7:+!+,4+ %++ #&JJ 9J69   +3   7:+!+,4+ %++ #&OO 9OEE QQ?, ,)1, &,,7!7*27 177 F F Q F, ,)1, &,,7!7*27 177 K K Q KrarT c(\rSrSrSrS!Sjr\S"Sj5r\S#Sj5rS$Sjr\S"Sj5r\S#Sj5rS$S jrS%S jr \S&S j5r \S'S j5r S(S jr \S&Sj5r \S'Sj5r S(Sjr \S)Sj5r \S*Sj5r S+Sjr S,Sjr \S-S.Sjj5r\S-S/Sjj5rS-S0Sjjr\S1Sj5r\S2Sj5rS3Sjr\S4Sj5r\S5Sj5rS6SjrS7SjrS rg)8ScriptCommandsi *zo Redis Lua script commands. see: https://redis.io/ebook/part-3-next-steps/chapter-11-scripting-redis-with-lua/ c*UR"XU/UQ76$rWre)rZrr2 rD keys_and_argss r]_evalScriptCommands._eval*s##GWM}MMracgrWrXrZr2 rDr s r]evalScriptCommands.eval*rracgrWrXr s r]r r "*rrac*UR"SX/UQ76$)a[ Execute the Lua ``script``, specifying the ``numkeys`` the script will touch and the key names and argument values in ``keys_and_args``. Returns the result of the script. In practice, use the object returned by ``register_script``. This function exists purely for Redis API completion. For more information, see https://redis.io/commands/eval EVALr r s r]r r **szz&&BMBBracgrWrXr s r]eval_roScriptCommands.eval_ro9*rracgrWrXr s r]r r A*rrac*UR"SX/UQ76$)a The read-only variant of the EVAL command Execute the read-only Lua ``script`` specifying the ``numkeys`` the script will touch and the key names and argument values in ``keys_and_args``. Returns the result of the script. For more information, see https://redis.io/commands/eval_ro EVAL_ROr r s r]r r I*szz)VE}EErac*UR"XU/UQ76$rWre)rZrr5 rDr s r]_evalshaScriptCommands._evalshaW*s##G'JMJJracgrWrXrZr5 rDr s r]r> ScriptCommands.evalsha`*rracgrWrXr s r]r> r h*rrac*UR"SX/UQ76$)a Use the ``sha`` to execute a Lua script already registered via EVAL or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the key names and argument values in ``keys_and_args``. Returns the result of the script. In practice, use the object returned by ``register_script``. This function exists purely for Redis API completion. For more information, see https://redis.io/commands/evalsha EVALSHAr r s r]r> r p*s}}YE}EEracgrWrXr s r] evalsha_roScriptCommands.evalsha_ro*rracgrWrXr s r]r r *rrac*UR"SX/UQ76$)aZ The read-only variant of the EVALSHA command Use the ``sha`` to execute a read-only Lua script already registered via EVAL or SCRIPT LOAD. Specify the ``numkeys`` the script will touch and the key names and argument values in ``keys_and_args``. Returns the result of the script. For more information, see https://redis.io/commands/evalsha_ro EVALSHA_ROr r s r]r r *s}}\3H-HHracgrWrXrs r] script_existsScriptCommands.script_exists*rracgrWrXrs r]r r *rrac(UR"S/UQ76$)a Check if a script exists in the script cache by specifying the SHAs of each script as ``args``. Returns a list of boolean values indicating if if each already script exists in the cache_data. For more information, see https://redis.io/commands/script-exists z SCRIPT EXISTSrers r]r r *s##O;d;;rac[S5e)Nz