o ݭhw @sddlZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZddlmZmZddl m!Z!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ee6ejfZ7ee6ej8fZ9ee:e;fZe;e?fZ@e@ZAe@ZBe#ZCeeAeeAfZDe@ZEe@ZFe@ZGee6e@fZHe@ZIee6e:e@fZJede>e;e?ZKed e>e;e?ZLeEZMe ee;e;fgdfZNd ZOd ZPed eAd ZQedeAe#ZReddd ZSedeeEeTfd ZUdeeQeeQfdeeeRdeeeQeRffddZVddZWddZXGdddeYZZddZ[dd Z\d!d"Z]d#d$Z^id%e6d&e6d'e6d(e6d)e6d*e6d+e6d,e6d-e6d.e6d/e6d0e6d1e6d2e6d3e6d4e6d5e6e6e6e6e6e6e6d6Z_d7d8Z`d9d:Zad;d<Zbd=d>Zcd?d@ZdddBdCZedDdEZfdFdGZgdHdIZhdJdKZidLdMZjdNdOZkdPdQZldRdSZmdTdUZndVdWZodXdYZpdZd[Zqd\d]Zrd^d_Zsd`daZtdbdcZudddeZvdfdgZwdhdiZxdjdkZydldmZzdndoZ{dpdqZ|drdsZ}dtduZ~dvdwZdxdyZdzd{Zd|d}Zd~dZddZGdddeZGdddeZeeefZedZGdddZeZGdddeZGdddZGdddZGdddeZGdddeZeeefZeeee;e>fdfee;e ffZeeZGdddeZGdddZGdddZdS)N) AbstractSetAny AsyncIterator AwaitableCallableDictIterableListMappingMutableMappingNoReturnOptionalSequenceSetTupleTypeTypeVarUnion ValuesViewcast)Protocol TypedDict) ConnectionConnectionPool EncodableT SSLConnectionUnixDomainSocketConnection) ConnectionError DataErrorExecAbortError ModuleError NoScriptError PubSubError RedisError ResponseError TimeoutError WatchErrorLock)safe_str str_if_bytesAnyKeyT AnyFieldTEMPTY_RESPONSE_KeyT)bound_ArgT_RedisTRedis_NormalizeKeysTkeysargsreturncCsjzt|ttt|}t|ttfr|g}nt|}Wnty+tt |g}Ynw|r3| ||SN) iterrrr/ isinstancebytesstrlist TypeError memoryviewextend)r5r6key_listrBT/var/www/html/stock_analysis/be/venv/lib/python3.10/site-packages/aioredis/client.py list_or_argsXs  rDcCs6|sdSzt|}Wn tyYdSwtj|S)z5Converts a unix timestamp to a Python datetime objectN)int ValueErrordatetime fromtimestampresponserBrBrCtimestamp_to_datetimems   rKcCst||Sr8)dictfromkeyssplit) key_stringcallbackrBrBrCstring_keys_to_dictxrQcsfeZdZdZddZfddZfddZfdd Zdfd d Zfd dZ fddZ Z S)CaseInsensitiveDictz?Case insensitive dict implementation. Assumes string keys only.cCs"|D] \}}|||<qdSr8)itemsupper)selfdatakvrBrBrC__init__szCaseInsensitiveDict.__init__ct|Sr8)super __contains__rUrVrX __class__rBrCr]rRz CaseInsensitiveDict.__contains__cst|dSr8)r\ __delitem__rUr^r_rBrCraszCaseInsensitiveDict.__delitem__cr[r8)r\ __getitem__rUr^r_rBrCrbrRzCaseInsensitiveDict.__getitem__Ncst||Sr8)r\getrU)rVrXdefaultr_rBrCrcszCaseInsensitiveDict.getcst||dSr8)r\ __setitem__rU)rVrXrYr_rBrCrezCaseInsensitiveDict.__setitem__cst|}t|dSr8)rSr\updaterVrWr_rBrCrgszCaseInsensitiveDict.updater8) __name__ __module__ __qualname____doc__rZr]rarbrcrerg __classcell__rBrBr_rCrS|s    rScCsPt|}d|}tdd|D}d}|D]}||vr%t||||<q|S)zDParse the results of Redis's DEBUG OBJECT command into a Python dictztype:css|]}|dVqdS:NrN).0kvrBrBrC sz%parse_debug_object..)refcountserializedlengthlrulru_seconds_idle)r*rLrNrE)rJ int_fieldsfieldrBrBrCparse_debug_objectsrzcCs|dvrt|S|S)z&Parse the results of an OBJECT command)idletimert) int_or_none)rJinfotyperBrBrC parse_objectsr~csi}t|}fdd|D]D}|rT|dsT|ddkrK|dd\}}|dkr4|dd\}}|dkrD|d g|q|||<q|d g|q|S) z;Parse the result of Redis's INFO command into a Python dictcsxd|vsd|vr"zd|vrt|WSt|WSty!|YSwi}|dD]}|dd\}}|||<q)|S)N,=.)floatrErFrNrsplit)valuesub_dictitemrXrY get_valuerBrCrs   zparse_info..get_value#ror cmdstat_hostmodulemodules__raw__)r* splitlines startswithfindrNr setdefaultappend)rJinfolinekeyrrBrrC parse_infos  rcKs@t|ddd}|D]\}}|drt|ddd||<q |S)z!Parse the results of MEMORY STATST) decode_keysdecode_string_valueszdb.) pairs_to_dictrTr)rJkwargsstatsrrrBrBrCparse_memory_statss  rzcan-failover-its-masterz config-epochzdown-after-millisecondszfailover-timeoutz info-refreshzlast-hello-messagezlast-ok-ping-replyzlast-ping-replyzlast-ping-sentzmaster-link-down-timez master-portznum-other-sentinelsz num-slavesz o-down-timezpending-commandszparallel-syncsport)quorumzrole-reported-timez s-down-timezslave-priorityzslave-repl-offsetzvoted-leader-epochcCs:t|t}t|dd}dD] \}}||v||<q|S)Nflagsr)) is_mastermaster)is_slaveslave)is_sdowns_down)is_odowno_down) is_sentinelsentinel)is_disconnected disconnected)is_master_down master_down)pairs_to_dict_typedSENTINEL_STATE_TYPESsetrN)rresultrnameflagrBrBrCparse_sentinel_states   rcCttt|Sr8rmapr*rIrBrBrCparse_sentinel_masterrcCs,i}|D]}ttt|}|||d<q|S)Nrr)rJrrstaterBrBrCparse_sentinel_masterss rcCdd|DS)NcSsg|] }ttt|qSrBrrqrrBrBrC z7parse_sentinel_slaves_and_sentinels..rBrIrBrBrC#parse_sentinel_slaves_and_sentinelsrrcCs|r |dt|dfp dSNrrrErIrBrBrCparse_sentinel_get_master"rFcCsp|duriS|s |r-|ddd}|rtt|}|ddd}|r&tt|}tt||St|}tt||S)z-Create a dict given a list of key/value pairsNr)rr*rLzipr9)rJrrr5valuesitrBrBrCr&s  rc CsXt|}i}t||D]\}}||vr%z|||}Wn ty$Ynw|||<q |Sr8)r9r Exception)rJ type_inforrrrrBrBrCr9s  rcKs:|r|ds |S|dt}t|}tt|t||S)zr If ``withscores`` is specified in the options, return the response as a list of (value, score) pairs withscoresscore_cast_func)rcrr9r=rr)rJoptionsrrrBrBrCzset_score_pairsHs  rc s:r|ds S|dttfddtDS)z If ``groups`` is specified, return the response as a list of n-element tuples with n being the value found in options['groups'] groupsc3s|] }|dVqdSr8rBrqinrJrBrCrs\z%sort_return_tuples..)rcr=rrangerJrrBrrCsort_return_tuplesTs rcC|durdSt|Sr8rrIrBrBrCr|_r|cCsL|durdSg}|D]}|dur||dt|dfq |dq |S)NrrNN)rr)rJrWrrBrBrCparse_stream_listes rcCs t|ddS)NTrrrIrBrBrCpairs_to_dict_with_str_keysq rcCrr8)r=rrrIrBrBrCparse_list_of_dictsurrcKs|ddr|St|S)N parse_justidF)rcrrrBrBrC parse_xclaimys rcCs`t|dd}|d}|dur|dt|df|d<|d}|dur.|dt|df|d<|S)NTrz first-entryrrz last-entryr)rJrWfirstlastrBrBrCparse_xinfo_streams rcCs|durgSdd|DS)NcSs g|] }|dt|dgqSrr)rrqrrBrBrCr zparse_xread..rBrIrBrBrC parse_xreadsrcKsD|ddr t|Sdd|dpgD}|d|d|d|d S) N parse_detailFcSsg|] \}}|t|dqS))rpendingr)rqrprBrBrCrz"parse_xpending..rrr)rminmax consumers)rcparse_xpending_range)rJrrrBrBrCparse_xpendings rcsdfdd|DS)N) message_idconsumertime_since_deliveredtimes_deliveredcsg|] }tt|qSrB)rLrrrXrBrCrrz(parse_xpending_range..rBrIrBrrCrsrcCrr8rrIrBrBrC float_or_nonerrcC t|dkSNOKr*rIrBrBrCbool_okrrcKs&|durdS|drt|St|S)Nas_score)rcrrErrBrBrC parse_zadds  rcKs8g}t|D]}|tdd|dDq|S)Ncss|] }|ddVqdS)rrNrp)rqpairrBrBrCrssz$parse_client_list.. )r*rrrLrN)rJrclientscrBrBrCparse_client_lists r cKsdd|D}|r t|piS)NcSs g|] }|dur t|ndqSr8rrrBrBrCrrz$parse_config_get..rrrBrBrCparse_config_getsr cKs|\}}t||fSr8rrJrcursorrrBrBrC parse_scans r cKs |\}}t||r t|pifSr8)rErr rBrBrC parse_hscansrcKs8|dt}|\}}t|}t|tt|t||fS)Nr)rcrr9rEr=rr)rJrrr rrrBrBrC parse_zscans rc s&|ddrdndfdd|DS)Ndecode_responsesFr c sTg|]&}|dt|dt|dt|dtr|dn|ddqS)rrrr)id start_timedurationcommand)rEr:r=joinrspacerBrCrs    z%parse_slowlog_get..)rcrrBrrCparse_slowlog_gets rcKst|}tdd|DS)Ncss|] }|r|dVqdSrnrprqrrBrBrCrsrz%parse_cluster_info..)r*rLrrrBrBrCparse_cluster_infosrc Csl|d}|ddd\}}}}}}}} dd|ddD} ||||||| | dkr.dndd} || fS) NrcSsg|]}|dqS)-rp)rqslrBrBrCrsz$_parse_node_line.. connectedTF)node_idr master_idlast_ping_sentlast_pong_rcvdepochslotsr rp) r line_itemsr!addrrr"pingpongr%r r& node_dictrBrBrC_parse_node_lines " r,cKst|}tdd|DS)Ncss|]}t|VqdSr8)r,rrBrBrCrssz&parse_cluster_nodes..)r*rrL)rJr raw_linesrBrBrCparse_cluster_nodess r.c sdsdr |St|tkr|g}n|}ds$ds$ds$|Stddtdd dgfd d d D7fd d |DS)Nstore store_distwithdist withcoordwithhashcSt|dt|dfSrrllrBrBrCz)parse_georadius_generic..)r1r2r3cSs|Sr8rBxrBrBrCr7csg|] }|r|qSrBrB)rqo)rrrBrCrsz+parse_georadius_generic..)r1r3r2cs$g|]}ttddt|qS)cSs|d|dSrrB)fvrBrBrCr7z4parse_georadius_generic...)r=rrr)frBrCr$)typer=rrE)rJr response_listrB)rr?rrCparse_georadius_generics  rCcKs"tt|ddd|dddS)Nrrr)r=rrrBrBrCparse_pubsub_numsubs"rDcKst|tr|St|dkSrr:rEr*rrBrBrCparse_client_kill s  rFcKs|durdSt|dd}ttt|d|d<ttt|d|d<t|d|d<gg}}|ddD]}d|vrB||q6||q6||d<||d<d |dv|d <|S) NTrr passwordscommandsr@ categoriesonenabled)rr=rr*rNr)rJrrWrHrJrrBrBrCparse_acl_getuser&s    rMcKsr|durdSt|tr3g}|D]!}t|dd}|dd}t||d<t|d|d<||q|St|}|S)NTz client-infoz age-seconds)r:r=rrcparse_client_inforrr)rJrrWloglog_data client_inforBrBrC parse_acl_log>s     rScCsLi}|d}|D] }|d\}}|||<q dD] }t||||<q|S)zg Parsing client-info in ACL Log in following format. "key1=value1 key2=value2 key3=value3" rr> qbuf-freedbrageoblollsubidleomempsubqbufmulti)rNrE)rrRinfosrrint_keyrBrBrCrOPs  rOcCst|tr|dSNT)r:r rIrBrBrCparse_module_resultns rbc@eZdZdefddZdS)ResponseCallbackProtocolrJcKdSr8rBrVrJrrBrBrC__call__uz!ResponseCallbackProtocol.__call__NrirjrkrrgrBrBrBrCrdtrdc@rc)AsyncResponseCallbackProtocolrJcdSr8rBrfrBrBrCrgzz&AsyncResponseCallbackProtocol.__call__NrirBrBrBrCrkyrjrk_Rc4@s$eZdZUdZiedeedeedeedddedeed e ed e ed d ded ddede edddede ede edeedddiddddedededddde ded e d!e d"d#dd$ed%ed&ed'ed(ed)e d*d+did,e d-e d.d/dd0d1dd2e d3e d4e d5ed6d7dd8e d9ed:e d;e de d?eid@edAe dBe dCedDdEddFdGddHedIedJdKddLedMedNedOe dPedQe dRedSeidTdUddVedWdXddYedZd[dd\e d]d^dd_e d`e daedbe!dce"dde#dee dfe dge$dhe idie$djdkddle%dmedne doe dpdqddre&dse dteduedve dwe'dxe'dye(dze)d{e*d|e+iZ,e-e.e/e0fe1fe2d}<e3d~e/fddZ4ddddddddddddddddddddddddddde/dede.e/efde5e/de5ede5ede5ede5e6ee.ee0ffde5e7de5e/de/de/dededede5e/de5e/de/de5e/dede5ededede5e/de5e/f2ddZ8ddZ9ddZ:de;de;fddZddddde?dge.e@eAe@ffdeBde5e/dede5ef ddZC d'deBde5edede5ede5eDeEdeEf ddńZFd(ddȄZGd)dd˄ZHd*dd̈́ZIde;de;fddτZJddфZKdZLeMfde@ddfddՄZNddׄZOddلZPdeQde.e/e0ffdd݄ZRd+de5e/deAfddZSde/deAfddZTdeAfddZUde/deAfddZVdeAfddZWd+de5edeAfddZXdeAfddZYdeAfddZZdeAfddZ[ d,de/dedede5e.e/e\e/fde5e.e/e\e/fde5e\e/de5e\e/de5e\eBdedededeAfddZ]deAfddZ^deAfddZ_deAfddZ`deAfddZade/deAfddZb d-d e5e/d e5e/d e5e/d e5edeAf d dZcd+d e5e/deAfddZddeAfddZedeAfddZfde/deAfddZgd.dededeAfddZhdedeAfddZideAfddZjdeAfdd Zkd/d"e/deAfd#d$Zlde/d%emdeAfd&d'ZndeAfd(d)ZodeAfd*d+ZpdeAfd,d-Zqd.eBdeAfd/d0Zrd%emdeAfd1d2Zsd.d3edeAfd4d5Ztd.d3edeAfd6d7Zud8ed9edeAfd:d;Zvd+dZwdeAfd?d@Zx d0de/dedeydAededBedCedDe5e/deAfdEdFZzdGe/d.eBdeAfdHdIZ{deAfdJdKZ|d+d.eBdLe5edeAfdMdNZ}deAfdOdPZ~deAfdQdRZdeAfdSdTZdUe/deAfdVdWZdUe/deAfdXdYZdeAfdZd[Zde/d\e/ded]edeAf d^d_Zde/deAfd`daZdUe/deAfdbdcZde/dde/d%emdeAfdedfZdUe/deAfdgdhZd1diedjeddfdkdlZ d2de5e/de5edeAfdmdnZd+doe5edeAfdpdqZdeAfdrdsZdeAfdtduZdeAfdvdwZdxededeAfdydzZd.eBd%emdeAfd{d|Z d2d.eBd}e5ed~e5edeAfddZ d+d.eBde5e/ddfddZde/deBdeBdeAfddZ d2d.eBded}e5ed~e5edeAf ddZd3deBdedeAfddZd3deBdedeAfddZdeBdeAfddZdeBdeAfddZdeBdeAfddZdeBdedeAfddZdeBdedeAfddZdeBdeAfddZdeBdedeAfddZd.eBd}ed~edeAfddZdeBd%emdeAfddZd3deBdedeAfddZd3deBdedeAfddZd4deBdedeAfddZd/d"edeAfddZdeydemdeAfddZde6eemfdeAfddZde6eemfdeAfddZdeBdedeAfddZdeBdeAfddZdeBdedeAfddZdeBdedeAfddZdeBded%emdeAfddÄZdeBdeAfdĐdńZdeAfdƐdDŽZdeBdeBdeAfdʐd˄ZdeBdeBdeAfd̐d̈́Z d1deBded%emdCededeAf dАdфZ d5deBd%emde5ede5ededededeAfdאd؄ZdeBded%edeAfdِdڄZdeBde.eejfd%emdeAfdېd܄ZdeBd%emdeAfdݐdބZdeBded%emdeAfdߐdZdeBdeAfddZd6deBd}ed~edeAfddZdeBdeAfddZdeBdeAfddZdeBdeAfddZdeBdeAfddZd7deydedeAfddZÐd7deydedeAfddZĐd7deBdeBdedeAfddZdeBdedeAfddZdeBde/demd%emdeAf ddZdeBdeAfddZdeBdeAfddZdeBdemdeAfddZdeBd%emdeAfddZdeBd}ed~edeAfddZdeBded%emdeAfddZdeBded%emdeAfdd ZdeBd}ed~edeAfd d ZdeBdeAfd d ZАdeBdeBdeAfddZdeBdemdeAfddZdeBd%emdeAfddZ d8deBd%emde5ede5ede5edeAf ddZ d9deBd}e5edoe5ede5eBde5eydedede5eBdedeAfddZ d:d ed!e5ede5ed e5e/deAf d"d#Z d8d!e5ede5ed e5e/defd$d%Z d;deBd ed!e5ede5edeAf d&d'Z d2deBd!e5ede5edefd(d)Z d;deBd ed!e5ede5edeAf d*d+Z d2de/d!e5ede5edefd,d-ZdddefdeBd ed!e5ede5ed.e.eDe?fdeAf d/d0ZddefdeBd!e5ede5ed.e.eDe?fdef d1d2ZdeBdemdeAfd3d4ZdeBdeAfd5d6ZdeydemdeAfd7d8ZdeBdeydemdeAfd9d:ZdeydemdeAfd;d<ZdeBdeydemdeAfd=d>ZdeBd%emdeAfd?d@ZdeBdeAfdAdBZdeBdeBd%emdeAfdCdDZd+deBde5edeAfdEdFZd+deBdGe5edeAfdHdIZdeBdemdeAfdJdKZdeydemdeAfdLdMZdeBdeydemdeAfdNdOZdeBdPedQedeAfdRdSZ ! ddeBdPedUedeedeAf dfdgZdeBdPedYedeAfdhdiZdeBdPedeAfdjdkZdeBdPedUedeAfdldmZdeBdPedeAfdndoZdeBdeAfdpdqZdeBdeAfdrdsZdeBdeAfdtduZdeBdPedeAfdvdwZ d+deBdPedxe5edye5ede5edYe5edeAfdzd{Z | } d?deBdxedyede5edeAf d~dZ d2deeBefde5ede5edeAfddZ d@dPe/dYe/deeBefde5ede5ededeAfddZ } | dAdeBdyedxede5edeAf ddZdBdeBdedVedeAfddZ dCdeBde6eemfdededededeAfddZdeBdeAfddZdeBdxe dye deAfddZ deBded%emdeAfddZ d+deBde.e eBe6eeffde5e/deAfddZ deBdxemdyemdeAfddZd+deBde5edeAfddZd+deBde5edeAfddZd7deydedeAfddZd7deydedeAfddZddefdeBd}ed~ededed.e.eDe?fdeAfddZ d2deBdxemdyemd}e5edoe5edeAf ddZ d2deBdyemdxemd}e5edoe5edeAf ddZdddefdeBdxe dye d}e5edoe5eded.e.eDe?fdeAfddZdeBd%emdeAfddZdeBdemdeAfddZdeBdxemdyemdeAfddZdeBdxedyedeAfddZdeBdxe dye deAfddZdefdeBd}ed~eded.e.eDe?fdeAf ddZdddefdeBdxe dye d}e5edoe5eded.e.eDe?fdeAfddZdeBd%emdeAfddZde/d%emdeAfddZ d+deBde.e eBe6eeffde5e/deAfddZ d+de/deBde.e eBe6eeffde5e/deAf ddZ!deBdemdeAfdd„Z"deBdeAfdĐdńZ#deBdeBdeAfdƐdDŽZ$deBdedeAfdȐdɄZ%deBd.edeAfdʐd˄Z&deBd.edeAfd̐d̈́Z'deBdeAfdΐdτZ(d3deBd.ededeAfdАdфZ)d4deBd.ededeAfdҐdӄZ*deBdeAfdԐdՄZ+deBdeAfd֐dׄZ, d8deBd.e5ed%e5emde5e6e-emfdeAf dؐdلZ.deBd.ed%emdeAfdڐdۄZ/deBde6e-emfdeAfdܐd݄Z0deBde eBdedeAfdސd߄Z1deBdeAfddZ2deBd.edeAfddZ3de4demdeAfddZ5d/d"edeAfddZ6deAfddZ7de4deAfddZ8de/de/deAfddZ9de:dedemdeAfddZ;de/dedemdeAfddZ<de/deAfddZ=deAfddZ>deAfddZ?de:deAfddZ@de:ddfddZAdeBdemdeAfddZB d+deBdedede5e/deAf d d ZCdeBdedeAfd d ZDdeBdedeAfd dZE dDdeBdededede5e/dededede5ede5e/de5eBde5eBdeAfddZF dDdeBdedede5e/dededede5ede5e/de5eBde5eBdeAfddZGde/demde5emdeAfddZHde/deAfd d!ZIde/deAfd"d#ZJdeAfd$d%ZKdS(Er3a& Implementation of the Redis protocol. This abstract class provides a Python interface to all Redis commands and an implementation of the Redis protocol. Connection and Pipeline derive from this, implementing how the commands are sent and received to the Redis server zbAUTH EXPIRE EXPIREAT HEXISTS HMSET MOVE MSETNX PERSIST PSETEX RENAMENX SISMEMBER SMOVE SETEX SETNXaBITCOUNT BITPOS DECRBY DEL EXISTS GEOADD GETBIT HDEL HLEN HSTRLEN INCRBY LINSERT LLEN LPUSHX PFADD PFCOUNT RPUSHX SADD SCARD SDIFFSTORE SETBIT SETRANGE SINTERSTORE SREM STRLEN SUNIONSTORE UNLINK XACK XDEL XLEN XTRIM ZCARD ZLEXCOUNT ZREM ZREMRANGEBYLEX ZREMRANGEBYRANK ZREMRANGEBYSCOREzINCRBYFLOAT HINCRBYFLOATz LPUSH RPUSHcCst|tr|p t|dkSrrErrBrBrCr7rzRedis.SORTzZSCORE ZINCRBY GEODISTzuFLUSHALL FLUSHDB LSET LTRIM MSET PFMERGE READONLY READWRITE RENAME SAVE SELECT SHUTDOWN SLAVEOF SWAPDB WATCH UNWATCH z BLPOP BRPOPcCs|rt|pdSr8)tuplerorBrBrCr7r>zSDIFF SINTER SMEMBERS SUNIONcCs|rt|ptSr8)rrorBrBrCr7z?ZPOPMAX ZPOPMIN ZRANGE ZRANGEBYSCORE ZREVRANGE ZREVRANGEBYSCOREzBZPOPMIN BZPOPMAXcCs"|r|d|dt|dfpdS)NrrrrrorBrBrCr7s"zZRANK ZREVRANKzXREVRANGE XRANGEzXREAD XREADGROUPzBGREWRITEAOF BGSAVEcCdSrarBrorBrBrCr7r;ACL CATcCrr8r=rr*rorBrBrCr7 ACL DELUSER ACL GENPASS ACL GETUSERACL LISTcCrr8rurorBrBrCr7rvACL LOADACL LOGACL SAVE ACL SETUSER ACL USERScCrr8rurorBrBrCr7rv ACL WHOAMICLIENT GETNAME CLIENT ID CLIENT KILL CLIENT LISTCLIENT SETNAMECLIENT UNBLOCKcCs|rt|dkp dS)NrFrrorBrBrCr7 CLIENT PAUSEzCLUSTER ADDSLOTSzCLUSTER COUNT-FAILURE-REPORTScCt|Sr8rr9rBrBrCr7zCLUSTER COUNTKEYSINSLOTcCrr8rr9rBrBrCr7rzCLUSTER DELSLOTSzCLUSTER FAILOVERzCLUSTER FORGETz CLUSTER INFOzCLUSTER KEYSLOTcCrr8rr9rBrBrCr7rz CLUSTER MEETz CLUSTER NODESzCLUSTER REPLICATEz CLUSTER RESETzCLUSTER SAVECONFIGzCLUSTER SET-CONFIG-EPOCHzCLUSTER SETSLOTzCLUSTER SLAVES CONFIG GETCONFIG RESETSTAT CONFIG SET DEBUG OBJECTGEOHASHcCrr8rurorBrBrCr7rvGEOPOScCsttdd|S)NcSs$|durt|dt|dfSdSrrr5rBrBrCr7r@z Redis...)r=rrorBrBrCr7s  GEORADIUSGEORADIUSBYMEMBERHGETALLcCs|rt|piSr8rrorBrBrCr7r>HSCANINFOLASTSAVE MEMORY PURGE MEMORY STATS MEMORY USAGE MODULE LOAD MODULE UNLOAD MODULE LISTcCr)NcSsg|]}t|qSrBr)rqmrBrBrCrrz"Redis...rBrorBrBrCr7rvOBJECTPINGcCr)NPONGrrorBrBrCr7 PUBSUB NUMSUB RANDOMKEYcCs |r|pdSr8rBrorBrBrCr7rSCAN SCRIPT EXISTScCrr8)r=rboolrorBrBrCr7rv SCRIPT FLUSH SCRIPT KILL SCRIPT LOAD SENTINEL GET-MASTER-ADDR-BY-NAMESENTINEL MASTERSENTINEL MASTERSSENTINEL MONITORSENTINEL REMOVESENTINEL SENTINELS SENTINEL SETSENTINEL SLAVESSETcCs|ot|dkSrrrorBrBrCr7r> SLOWLOG GET SLOWLOG LEN SLOWLOG RESETSSCANTIMEcCr4rrr9rBrBrCr7r8XCLAIM XGROUP CREATEXGROUP DELCONSUMERXGROUP DESTROY XGROUP SETIDXINFO CONSUMERS XINFO GROUPS XINFO STREAMXPENDINGZADDZSCANresponse_callbacksurlcKstj|fi|}||dS)a Return a Redis client object configured from the given URL For example:: redis://[[username]:[password]]@localhost:6379/0 rediss://[[username]:[password]]@localhost:6379/0 unix://[[username]:[password]]@/path/to/socket.sock?db=0 Three URL schemes are supported: - `redis://` creates a TCP socket connection. See more at: - `rediss://` creates a SSL wrapped TCP socket connection. See more at: - ``unix://``: creates a Unix Domain Socket connection. The username, password, hostname, path and all querystring values are passed through urllib.parse.unquote in order to replace any percent-encoded values with their corresponding characters. There are several ways to specify a database number. The first value found will be used: 1. A ``db`` querystring option, e.g. redis://localhost?db=0 2. If using the redis:// or rediss:// schemes, the path argument of the url, e.g. redis://localhost/0 3. A ``db`` keyword argument to this function. If none of these options are specified, the default db=0 is used. All querystring options are cast to their appropriate Python types. Boolean arguments can be specified with string values "True"/"False" or "Yes"/"No". Values that cannot be properly cast cause a ``ValueError`` to be raised. Once parsed, the querystring arguments and keyword arguments are passed to the ``ConnectionPool``'s class initializer. In the case of conflicting arguments, querystring arguments always win. )connection_pool)rfrom_url)clsrrrrBrBrCrs) zRedis.from_url localhostirNzutf-8strictFrequired)hostrrUpasswordsocket_timeoutsocket_connect_timeoutsocket_keepalivesocket_keepalive_optionsrunix_socket_pathencodingencoding_errorsrretry_on_timeoutssl ssl_keyfile ssl_certfile ssl_cert_reqs ssl_ca_certsssl_check_hostnamemax_connectionssingle_connection_clienthealth_check_interval client_nameusernamerrrUrrrrrrrrrrrrrrrrrrrrrrc Cs| s=||||| | | ||||d }| dur|| tdn||||||d|r6|t|||||dtdi|} | |_||_d|_t|jj |_ dS)N) rUrrrrrrrrrr)pathconnection_class)rrrrr)rrrrrrrB) rgrrrrr connectionrSr`RESPONSE_CALLBACKSr)rVrrrUrrrrrrrrrrrrrrrrrrrrrrrrBrBrCrZAsT  zRedis.__init__cCs|jjd|jdS)N<>)r`rirrVrBrBrC__repr__rfzRedis.__repr__cC |Sr8) initialize __await__rrBrBrCrrzRedis.__await__rVr7cs*|jr|jdur|jdIdH|_|S)N_)rrrget_connectionrrBrBrCrszRedis.initializerrPcCs||j|<dS)zSet a custom Response CallbackN)r)rVrrPrBrBrCset_response_callbackzRedis.set_response_callbackT transaction shard_hintPipelinecCst|j|j||S)a_ Return a new pipeline object that can queue multiple commands for later execution. ``transaction`` indicates whether all commands should be executed atomically. Apart from making a group of operations atomic, pipelines are useful for reducing the back-and-forth overhead between the client and server. )rrr)rVrrrBrBrCpipelines zRedis.pipeline)rvalue_from_callable watch_delayfuncwatchesrrc s|d|4IdHL} z0|r|j|IdH||}t|r&|IdH}|IdH}|r1|n|WWdIdHStyV|durT|dkrTt|IdHYq w1IdHs]wYdS)z Convenience method for executing the callable `func` as a transaction while watching all keys specified in `watches`. The 'func' callable should expect a single argument which is a Pipeline object. TNr)rwatchinspect isawaitableexecuter&asynciosleep) rVrrrrrpipe func_value exec_valuerBrBrCrs$    zRedis.transaction皙?rtimeoutrblocking_timeout lock_classcCs |durt}|||||||dS)a Return a new Lock object using key ``name`` that mimics the behavior of threading.Lock. If specified, ``timeout`` indicates a maximum life for the lock. By default, it will remain locked until release() is called. ``sleep`` indicates the amount of time to sleep per loop iteration when the lock is in blocking mode and another client is currently holding the lock. ``blocking_timeout`` indicates the maximum amount of time in seconds to spend trying to acquire the lock. A value of ``None`` indicates continue trying forever. ``blocking_timeout`` can be specified as a float or integer, both representing the number of seconds to wait. ``lock_class`` forces the specified lock implementation. ``thread_local`` indicates whether the lock token is placed in thread-local storage. By default, the token is placed in thread local storage so that a thread only sees its token, not a token set by another thread. Consider the following timeline: time: 0, thread-1 acquires `my-lock`, with a timeout of 5 seconds. thread-1 sets the token to "abc" time: 1, thread-2 blocks trying to acquire `my-lock` using the Lock instance. time: 5, thread-1 has not yet completed. redis expires the lock key. time: 5, thread-2 acquired `my-lock` now that it's available. thread-2 sets the token to "xyz" time: 6, thread-1 finishes its work and calls release(). if the token is *not* stored in thread local storage, then thread-1 would see the token value as "xyz" and would be able to successfully release the thread-2's lock. In some use cases it's necessary to disable thread local storage. For example, if you have code where one thread acquires a lock and passes that lock instance to a worker thread to release later. If thread local storage isn't disabled in this case, the worker thread won't see the token set by the thread that acquired the lock. Our assumption is that these cases aren't common and as such default to using thread local storage.N)rrr thread_localr')rVrrrrrrrBrBrClocks4z Redis.lockPubSubcKst|jfi|S)z Return a Publish/Subscribe object. With this object, you can subscribe to channels and listen for messages that get published to them. )rr)rVrrBrBrCpubsub z Redis.pubsubMonitorcC t|jSr8)r rrrBrBrCmonitor z Redis.monitorcCs|j|jddS)NT)rr)r`rrrBrBrCclientsz Redis.clientcs|IdHSr8)rrrBrBrC __aenter__szRedis.__aenter__c|IdHdSr8)closerVexc_type exc_value tracebackrBrBrC __aexit__zRedis.__aexit__zUnclosed Redis client _warningscCsB|jdur|jd|t|d||jd}t|dSdS)NzUnclosed client session )source)r message)rwarnResourceWarning _DEL_MESSAGErget_event_loopcall_exception_handler)rVrcontextrBrBrC__del__$s  z Redis.__del__cs,|j}|rd|_|j|IdHdSdSr8)rrreleaserVconnrBrBrCr.s z Redis.closec s,|IdH|j}|d}|jp|j|fi|IdH}zjz#|j|IdH|j||fi|IdHWW|jsB||IdHSSttfy}z8| IdH|j r[t |ts\|j|IdH|j||fi|IdHWYd}~W|js||IdHSSd}~ww|js||IdHww)z.Execute a command and return a parsed responseNr) rrrr send_commandparse_responser!rr% disconnectrr:)rVr6rpool command_namer#erBrBrCexecute_command5s2&zRedis.execute_commandrr(csz |IdH}Wntyt|vr|tYSw||jvr>tt|}|j||fi|}t|r<|IdHS|S|S)z'Parses a response from the Redis serverN) read_responser$r.rrr<rr)rVrr(rrJretvalrBrBrCr%Hs    zRedis.parse_responsecategorycCs |r|gng}|jdg|RS)z 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. rtr*)rVr-piecesrBrBrCacl_cat\sz Redis.acl_catcC |d|S)z-Delete the ACL for the specified ``username``rwr.rVrrBrBrC acl_deluserg zRedis.acl_delusercC |dS)z Generate a random password valuerxr.rrBrBrC acl_genpassk zRedis.acl_genpasscCr1)zz Get the ACL details for the specified ``username``. If ``username`` does not exist, return None ryr.r2rBrBrC acl_getuseros zRedis.acl_getusercCr5)z'Return a list of all ACLs on the serverrzr.rrBrBrCacl_listwr7zRedis.acl_listcountcCs:g}|durt|tstd|||jdg|RS)zl Get ACL logs as a list. :param int count: Get logs[0:count]. :rtype: List. Nz ACL LOG count must be an integerr|)r:rErrr*)rVr:r6rBrBrCacl_log{s   z Redis.acl_logcCsdg}|jdg|RS)z: Reset ACL logs. :rtype: Boolean. sRESETr|r.rVr6rBrBrC acl_log_resetszRedis.acl_log_resetcCr5)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. r{r.rrBrBrCacl_load zRedis.acl_loadcCr5)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. r}r.rrBrBrCacl_saver?zRedis.acl_saverLnopassrGhashed_passwordsrJrHr5reset reset_keysreset_passwordsc Cs|j} |g} | r| d| r| d| r| d|r%| dn| d|s.|r4|r4td|rpt|g}t|D]0\}}| |}|drY| d|d d q?|d rj| d |d d q?td ||rt|g}t|D]0\}}| |}|dr| d|d d q{|d r| d|d d q{td||r| d|r|D]K}| |}|dr| |q|dr| d|d d q|dr| |q|d r| d|d d qtd| j|ddd|r0|D]&}| |}|ds)|d s)td| j|ddd| |q |rE|D]}| |}| d|q5|j dg| RS)aA 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. ``enabled`` is a boolean indicating whether the user should be allowed to authenticate or not. Defaults to ``False``. ``nopass`` is a boolean indicating whether the can authenticate without a password. This cannot be True if ``passwords`` are also specified. ``passwords`` if specified is 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, the value of ``passwords`` can be a simple prefixed string when adding or removing a single password. ``hashed_passwords`` if specified is 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, the value of ``hashed_passwords`` can be a simple prefixed string when adding or removing a single password. ``categories`` if specified is 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`` if specified is 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`` if specified is a list of key patterns to grant the user access to. Keys 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`` is a boolean indicating 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 this is False, the user's existing passwords, flags and privileges will be kept and any new specified rules will be applied on top. ``reset_keys`` is a boolean indicating whether the user's key permissions should be reset prior to applying any new key permissions specified in ``keys``. If this is False, the user's existing key permissions will be kept and any new specified key permissions will be applied on top. ``reset_passwords`` is a boolean indicating 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 this is 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 resetpasssonsoffz@Cannot set 'nopass' and supply 'passwords' or 'hashed_passwords'+s>%srN-s<%szBPassword %d must be prefixeed with a "+" to add or a "-" to removes#%ss!%szIHashed %d password must be prefixeed with a "+" to add or a "-" to removesnopasss+@s+@%ss-@s-@%sz Category "Tforcez"" must be prefixed with "+" or "-"z Command "s~%sr~) r get_encoderrrrD enumerateencoderdecoder*)rVrrLrArGrBrJrHr5rCrDrEencoderr/converted_passwordsr raw_passwordrparsed_hashed_passwordsraw_hashed_passwordhashed_password raw_categoryr-raw_cmdcmdraw_keyrrBrBrC acl_setusers I                        zRedis.acl_setusercCr5)z5Returns a list of all registered users on the server.rr.rrBrBrC acl_usersGr7zRedis.acl_userscCr5)z+Get the username for the current connectionrr.rrBrBrC acl_whoamiKr7zRedis.acl_whoamicCr5)zBTell the Redis server to rewrite the AOF file from data in memory. BGREWRITEAOFr.rrBrBrC bgrewriteaofOr7zRedis.bgrewriteaofcCr5)z Tell the Redis server to save its data to disk. Unlike save(), this method is asynchronous and returns immediately. BGSAVEr.rrBrBrCbgsaveS z Redis.bgsaveaddresscCr1)z/Disconnects the client at ``address`` (ip:port)rr.)rVr`rBrBrC client_killZr4zRedis.client_kill_id_typer(skipmecCsg}|durd}t||vrtd||d|f|dur8t|ts+td|r3|dn|d|durC|d|f|durN|d |f|sTtd |jd g|RS) 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 N)normalrrrz CLIENT KILL type must be one of TYPEz!CLIENT KILL skipme must be a bool)SKIPMEsYES)rgNOsIDsADDRzVCLIENT KILL ... ... must specify at least one filterr)r<lowerrr@r:rr*)rVrbrcr(rdr6 client_typesrBrBrCclient_kill_filter^s*   zRedis.client_kill_filtercCsD |durd}t||vrtd||dd|S|dS)z Returns a list of currently connected clients. If type of client specified, only that type will be returned. :param _type: optional. one of the client types (normal, master, replica, pubsub) N)rerreplicarz!CLIENT LIST _type must be one of rrf)r<rirr*)rVrcrjrBrBrC client_lists zRedis.client_listcCr5)z#Returns the current connection namerr.rrBrBrCclient_getnamer7zRedis.client_getnamecCr5)z!Returns the current connection idrr.rrBrBrC client_idr7zRedis.client_idcCr1)z Sets the current connection namerr.rVrrBrBrCclient_setnamer4zRedis.client_setnameroerrorcCs$dt|g}|r |d|j|S)z Unblocks a connection by its client id. If ``error`` is True, unblocks the client with a special error message. If ``error`` is False (default), the client is unblocked using the regular timeout mechanism. rsERROR)rErr*)rVrorrr6rBrBrCclient_unblocks   zRedis.client_unblockcCs"t|ts td|dt|S)z Suspend all the Redis clients for the specified amount of time :param timeout: milliseconds to pause clients z'CLIENT PAUSE timeout must be an integerr)r:rErr*r<)rVrrBrBrC client_pauses zRedis.client_pausecCr5)zDDisables read queries for a connection to a Redis Cluster slave node READWRITEr.rrBrBrC readwriter7zRedis.readwritecCr5)zEEnables read queries for a connection to a Redis Cluster replica nodeREADONLYr.rrBrBrCreadonlyr7zRedis.readonly*patterncCr1)z=Return a dictionary of configuration based on the ``pattern``rr.rVrzrBrBrC config_getr4zRedis.config_getrcC|d||S)z'Set config item ``name`` with ``value``rr.rVrrrBrBrC config_setrzRedis.config_setcCr5)zReset runtime statisticsrr.rrBrBrCconfig_resetstatr7zRedis.config_resetstatcCr5)zERewrite config file with the minimal change to reflect running configzCONFIG REWRITEr.rrBrBrCconfig_rewriter7zRedis.config_rewritecCr5)z2Returns the number of keys in the current databaseDBSIZEr.rrBrBrCdbsizer7z Redis.dbsizercCr1)z;Returns version specific meta information about a given keyrr.)rVrrBrBrC debug_objectr4zRedis.debug_objectcCr1)z$Echo the string back from the serverECHOr.)rVrrBrBrCechor4z Redis.echo asynchronouscC$g}|r |d|jdg|RS)z Delete all keys in all databases on the current host. ``asynchronous`` indicates whether the operation is executed asynchronously by the server. ASYNCFLUSHALLrr*rVrr6rBrBrCflushall zRedis.flushallcCr)z Delete all keys in the current database. ``asynchronous`` indicates whether the operation is executed asynchronously by the server. rFLUSHDBrrrBrBrCflushdbrz Redis.flushdbrsecondcCr})zSwap two databasesSWAPDBr.)rVrrrBrBrCswapdbrz Redis.swapdbsectioncCs|dur |dS|d|S)a, 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 Nrr.)rVrrBrBrCrs  z Redis.infocCr5)zy Return a Python datetime object representing the last time the Redis database was saved to disk rr.rrBrBrClastsaver_zRedis.lastsavedestination_dbcopyreplaceauthc Cs~t|g}|s tdg} |r| d|r| d|r'| d| || d| ||jd||d||g| RS)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. z!MIGRATE requires at least one keysCOPYsREPLACEsAUTHsKEYSMIGRATErN)rDrrr@r*) rVrrr5rrrrrr/rBrBrCmigrate s$        z Redis.migrater}cCs|jd|||dS)z8Return the encoding, idletime, or refcount about the keyr)r}r.)rVr}rrBrBrCobject:z Redis.objectcCr5)z#Return a dictionary of memory statsrr.rrBrBrC memory_stats>r7zRedis.memory_statssamplescCs0g}t|tr|d|g|jd|g|RS)a' 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. sSAMPLESr)r:rEr@r*)rVrrr6rBrBrC memory_usageBs zRedis.memory_usagecCr5)z:Attempts to purge dirty pages for reclamation by allocatorrr.rrBrBrC memory_purgePr7zRedis.memory_purgecCr5)zPing the Redis serverrr.rrBrBrCr)Tr7z Redis.pingcCr5)zm Tell the Redis server to save its data to disk, blocking until the save is complete SAVEr.rrBrBrCsaveXr_z Redis.save service_namecCr1)z:Returns a (host, port) pair for the given ``service_name``rr.rVrrBrBrC sentinel_get_master_addr_by_name_r4z&Redis.sentinel_get_master_addr_by_namecCr1)zReturns a list of dictionaries containing each master's state.rr.rrBrBrCsentinel_mastersgr7zRedis.sentinel_mastersiprcC|d||||S)z,Add a new master to Sentinel to be monitoredrr.)rVrrrrrBrBrCsentinel_monitorkrzRedis.sentinel_monitorcCr1)z*Remove a master from Sentinel's monitoringrr.rprBrBrCsentinel_removeor4zRedis.sentinel_removecCr1)z0Returns a list of sentinels for ``service_name``rr.rrBrBrCsentinel_sentinelssr4zRedis.sentinel_sentinelsoptioncC|d|||S)z5Set Sentinel monitoring parameters for a given masterrr.)rVrrrrBrBrC sentinel_setwzRedis.sentinel_setcCr1)z-Returns a list of slaves for ``service_name``rr.rrBrBrCsentinel_slaves{r4zRedis.sentinel_slavesrnosavecCs\|r|rtddg}|r|d|r|dz |j|Wtdty-YdSw)anShutdown 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. z+SHUTDOWN save and nosave cannot both be setSHUTDOWNrNOSAVENzSHUTDOWN seems to have failed.)rrr*rr#)rVrrr6rBrBrCshutdowns    zRedis.shutdowncCs,|dur|dur|dddS|d||S)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. NSLAVEOFrhsONEr.)rVrrrBrBrCslaveofsz Redis.slaveofnumcCs8dg}|dur |||jjdd}|j|d|iS)zw Get the entries from the slowlog. If ``num`` is specified, get the most recent ``num`` items. rNrF)rrconnection_kwargsrcr*)rVrr6rrBrBrC slowlog_gets zRedis.slowlog_getcCr5)z&Get the number of items in the slowlogrr.rrBrBrC slowlog_lenr7zRedis.slowlog_lencCr5)zRemove all items in the slowlogrr.rrBrBrC slowlog_resetr7zRedis.slowlog_resetcCr5)z Returns the server time as a 2-item tuple of ints: (seconds since epoch, microseconds into this second). rr.rrBrBrCtimer_z Redis.time num_replicascCr})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. WAITr.)rVrrrBrBrCwaitz Redis.waitcCr})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``. APPENDr.)rVrrrBrBrCrz Redis.appendstartendcCsf|g}|dur|dur||||n|dur|dus&|dur*|dur*td|jdg|RS)z Returns the count of set bits in the value of ``key``. Optional ``start`` and ``end`` paramaters indicate which bytes to consider Nz$Both start and end must be specifiedBITCOUNT)rrr*)rVrrrparamsrBrBrCbitcounts   zRedis.bitcountdefault_overflowBitFieldOperationcCst|||dS)z Return a BitFieldOperation instance to conveniently construct one or more bitfield operations on ``key``. )r)r)rVrrrBrBrCbitfieldrzRedis.bitfield operationdestcG|jd||g|RS)z| Perform a bitwise operation using ``operation`` between ``keys`` and store the result in ``dest``. BITOPr.)rVrrr5rBrBrCbitopsz Redis.bitopbitcCs`|dvrtd||g}|dur|||dur||n|dur'td|jdg|RS)a Return the position of the first bit set to 1 or 0 in a string. ``start`` and ``end`` difines 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. rzbit must be 0 or 1Nz0start argument is not set, when end is specifiedBITPOSrrr*)rVrrrrrrBrBrCbitposs   z Redis.bitposramountcC |||S) Decrements the value of ``key`` by ``amount``. If no key exists, the value will be initialized as 0 - ``amount`` )decrbyrVrrrBrBrCdecrs z Redis.decrcCr})rDECRBYr.rrBrBrCrz Redis.decrbynamescG|jdg|RS)z.Delete one or more keys specified by ``names``DELr.rVrrBrBrCdeleterz Redis.deletecCr1)z Return a serialized version of the value stored at the specified key. If key does not exist a nil bulk reply is returned. DUMPr.rprBrBrCdump z Redis.dumpcGr)z*Returns the number of ``names`` that existEXISTSr.rrBrBrCexists!rz Redis.existsrcCs&t|tjr t|}|d||S)z Set an expire flag on key ``name`` for ``time`` seconds. ``time`` can be represented by an integer or a Python timedelta object. EXPIREr:rG timedeltarE total_secondsr*rVrrrBrBrCexpire%s  z Redis.expirewhencCs,t|tjrtt|}|d||S)z Set an expire flag on key ``name``. ``when`` can be represented as an integer indicating unix time or a Python datetime object. EXPIREAT)r:rGrEmod_timemktime timetupler*)rVrrrBrBrCexpireat.s zRedis.expireatcCr1)zT Return the value at key ``name``, or None if the key doesn't exist GETr.rprBrBrCrc7 z Redis.getoffsetcCr})z@Returns a boolean indicating the value of ``offset`` in ``name``GETBITr.)rVrrrBrBrCgetbit=rz Redis.getbitcCr)z Returns the substring of the string value stored at ``key``, determined by the offsets ``start`` and ``end`` (both are inclusive) GETRANGEr.)rVrrrrBrBrCgetrangeAzRedis.getrangecCr})z{ Sets the value at key ``name`` to ``value`` and returns the old value at key ``name`` atomically. GETSETr.r~rBrBrCgetsetHrz Redis.getsetcCr) Increments the value of ``key`` by ``amount``. If no key exists, the value will be initialized as ``amount`` )incrbyrrBrBrCincrOrz Redis.incrcCr})rINCRBYr.rrBrBrCrVrz Redis.incrby?cCr})z Increments the value at key ``name`` by floating ``amount``. If no key exists, the value will be initialized as ``amount`` INCRBYFLOATr.rrBrBrC incrbyfloat_rzRedis.incrbyfloatcCr1)z+Returns a list of keys matching ``pattern``KEYSr.r{rBrBrCr5fr4z Redis.keysr6cGs2t||}i}|s g|t<|jdg|Ri|S)zJ Returns a list of values ordered identically to ``keys`` MGET)rDr.r*)rVr5r6 encoded_argsrrBrBrCmgetjs z Redis.mgetmappingcC.g}|D]}||q|jdg|RS)z Sets key/values based on a mapping. Mapping is a dictionary of key/value pairs. Both keys and values should be strings or types that can be cast to a string via str(). MSETrTr@r*rVr rTrrBrBrCmsetts  z Redis.msetcCr )a3 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. MSETNXr r rBrBrCmsetnxs  z Redis.msetnxcCr})z;Moves the key ``name`` to a different Redis database ``db``MOVEr.)rVrrUrBrBrCmoverz Redis.movecCr1)z!Removes an expiration on ``name``PERSISTr.rprBrBrCpersistr4z Redis.persistcCs*t|tjrt|d}|d||S)z Set an expire flag on key ``name`` for ``time`` milliseconds. ``time`` can be represented by an integer or a Python timedelta object. PEXPIRErrrBrBrCpexpires z Redis.pexpirecCsBt|tjrt|jd}tt|d|}|d||S)z Set an expire flag on key ``name``. ``when`` can be represented as an integer representing unix time in milliseconds (unix time * 1000) or a Python datetime object. r PEXPIREAT)r:rGrE microsecondrrrr*)rVrrmsrBrBrC pexpireats zRedis.pexpireattime_mscCs,t|tjrt|d}|d|||S)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 rPSETEXr)rVrrrrBrBrCpsetexs z Redis.psetexcCr1)zEReturns the number of milliseconds until the key ``name`` will expirePTTLr.rprBrBrCpttlr4z Redis.pttlcCr5)z Returns the name of a random keyrr.rrBrBrC randomkeyr7zRedis.randomkeysrcdstcCr})z/ Rename key ``src`` to ``dst`` RENAMEr.rVr"r#rBrBrCrenamesz Redis.renamecCr})z>Rename key ``src`` to ``dst`` if ``dst`` doesn't already existRENAMENXr.r%rBrBrCrenamenxrzRedis.renamenxttlabsttlcCs8|||g}|r |d|r|d|jdg|RS)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). REPLACEABSTTLRESTOREr)rVrr)rrr*rrBrBrCrestores   z Redis.restoreexpxnxxxkeepttlc Cs||g}|dur|dt|tjrt|}|||dur:|dt|tjr5t|d}|||rA|d|rH|d|rO|d|jdg|RS) a, Set the value at key ``name`` to ``value`` ``ex`` sets an expire flag on key ``name`` for ``ex`` seconds. ``px`` sets an expire flag on key ``name`` for ``px`` milliseconds. ``nx`` if set to True, set the value at key ``name`` to ``value`` only if it does not exist. ``xx`` if set to True, set the value at key ``name`` to ``value`` only if it already exists. ``keepttl`` if True, retain the time to live associated with the key. (Available since Redis 6.0) NEXPXrNXXXKEEPTTLr)rr:rGrrErr*) rVrrr/r0r1r2r3r/rBrBrCrs$          z Redis.setcCs|rdpd}|d|||S)z Flag the ``offset`` in ``name`` as ``value``. Returns a boolean indicating the previous value of ``offset``. rrSETBITr.rVrrrrBrBrCsetbits z Redis.setbitcCs(t|tjr t|}|d|||S)z Set the value of key ``name`` to ``value`` that expires in ``time`` seconds. ``time`` can be represented by an integer or a Python timedelta object. SETEXr)rVrrrrBrBrCsetexs  z Redis.setexcCr})z?Set the value of key ``name`` to ``value`` if key doesn't existSETNXr.r~rBrBrCsetnx"rz Redis.setnxcCr)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. SETRANGEr.r:rBrBrCsetrange& zRedis.setrangecCr1)z:Return the number of bytes stored in the value of ``name``STRLENr.rprBrBrCstrlen3r4z Redis.strlenrcCr)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. SUBSTRr.rVrrrrBrBrCsubstr7rz Redis.substrcGr)zs Alters the last access time of a key(s) ``*args``. A key is ignored if it does not exist. TOUCHr.r<rBrBrCtouch>z Redis.touchcCr1)z@Returns the number of seconds until the key ``name`` will expireTTLr.rprBrBrCr)Er4z Redis.ttlcCr1)z Returns the type of key ``name``TYPEr.rprBrBrCrAIr4z Redis.typecGr)z.Unlink one or more keys specified by ``names``UNLINKr.rrBrBrCunlinkMrz Redis.unlinkcC|jdgt||fRS)a= LPOP a value off of the first non-empty list named in the ``keys`` list. If none of the lists in ``keys`` has a value to LPOP, then block for ``timeout`` seconds, or until a value gets pushed on to one of the lists. If timeout is 0, then block indefinitely. BLPOPr*rDrVr5rrBrBrCblpopR z Redis.blpopcCrO)a= RPOP a value off of the first non-empty list named in the ``keys`` list. If none of the lists in ``keys`` has a value to RPOP, then block for ``timeout`` seconds, or until a value gets pushed on to one of the lists. If timeout is 0, then block indefinitely. BRPOPrQrRrBrBrCbrpop_rTz Redis.brpopcCr)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. BRPOPLPUSHr.)rVr"r#rrBrBrC brpoplpushls zRedis.brpoplpushindexcCr})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 LINDEXr.)rVrrYrBrBrClindexwrz Redis.lindexwhererefvaluecCr)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. LINSERTr.)rVrr\r]rrBrBrClinserts z Redis.linsertcCr1)z&Return the length of the list ``name``LLENr.rprBrBrCllenr4z Redis.llencCr1)z5Remove and return the first item of the list ``name``LPOPr.rprBrBrClpopr4z Redis.lpoprcG|jd|g|RS)z2Push ``values`` onto the head of the list ``name``LPUSHr.rVrrrBrBrClpushz Redis.lpushcCr})zDPush ``value`` onto the head of the list ``name`` if ``name`` existsLPUSHXr.r~rBrBrClpushxrz Redis.lpushxcCr)z Return a slice of the list ``name`` between position ``start`` and ``end`` ``start`` and ``end`` can be negative numbers just like Python slicing notation LRANGEr.rFrBrBrClrangez Redis.lrangecCr)a Remove the first ``count`` occurrences of elements equal to ``value`` from the list stored at ``name``. The count argument influences the operation in the following ways: count > 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. LREMr.)rVrr:rrBrBrClrems z Redis.lremcCr)z.Set ``position`` of list ``name`` to ``value``LSETr.)rVrrYrrBrBrClsetrz Redis.lsetcCr)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 LTRIMr.rFrBrBrCltrimrmz Redis.ltrimcCr1)z4Remove and return the last item of the list ``name``RPOPr.rprBrBrCrpopr4z Redis.rpopcCr})z RPOP a value off of the ``src`` list and atomically LPUSH it on to the ``dst`` list. Returns the value. RPOPLPUSHr.r%rBrBrC rpoplpushrzRedis.rpoplpushcGrd)z2Push ``values`` onto the tail of the list ``name``RPUSHr.rfrBrBrCrpushrhz Redis.rpushcCr})zDPush ``value`` onto the tail of the list ``name`` if ``name`` existsRPUSHXr.r~rBrBrCrpushxrz Redis.rpushxrankmaxlencCs\||g}|dur|d|g|dur|d|g|dur%|d|g|jdg|RS)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. NRANKCOUNTMAXLENLPOSr@r*)rVrrr|r:r}r/rBrBrClpossz Redis.lposbyrcdescalphar/rc CsR|dur|dus|dur|durtd|g} |dur%| d| ||dur<|dur<| d| || ||durat|ttfrR| d| |n|D] } | d| | qT|rh| d|ro| d|dur}| d| || r|rt|ttfst|d krtd d t|i} nd di} |jd g| Ri| S) a 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``. N,``start`` and ``num`` must both be specifiedsBYLIMITsGETDESCsALPHASTORErzVwhen using "groups" the "get" argument must be specified and contain at least two keysrrp)rrr:r;r<lenr*) rVrrrrrcrrr/rr/grrBrBrCsorts@ $             z Redis.sortr matchcCsZ|g}|dur|d|g|dur|d|g|dur$|d|g|jdg|RS)a Incrementally return lists of key names. Also return a cursor indicating the scan position. ``match`` allows for filtering the keys by pattern ``count`` provides a hint to Redis about the number of keys to return per batch. ``_type`` filters the returned values by a particular Redis type. Stock Redis instances allow for the following types: HASH, LIST, SET, STREAM, STRING, ZSET Additionally, Redis modules can expose other types as well. NMATCHCOUNTrfrr)rVr rr:rcr/rBrBrCscanO sz Redis.scancCsNd}|dkr%|j|p d|||dIdH\}}|D]}|Vq|dksdSdS)a* 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. Nr)r rr:rc)r)rVrr:rcr rWdrBrBrC scan_iterm s zRedis.scan_itercCF||g}|dur|d|g|dur|d|g|jdg|RS)z 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 NrrrrrVrr rr:r/rBrBrCsscan z Redis.sscancCsNd}|dkr%|j||p d||dIdH\}}|D]}|Vq|dksdSdS)a 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 Nrr rr:)r)rVrrr:r rWrrBrBrC sscan_iter s  zRedis.sscan_itercCr)z 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 NrrrrrrBrBrChscan rz Redis.hscancCsRd}|dkr'|j||p d||dIdH\}}|D]}|Vq|dksdSdS)a 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 Nrr)rrT)rVrrr:r rWrrBrBrC hscan_iter s   zRedis.hscan_iterrcCsT||g}|dur|d|g|dur|d|gd|i}|jdg|Ri|S)aM 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 Nrrrrr)rVrr rr:rr/rrBrBrCzscan sz Redis.zscancCsPd}|dkr&|j||p d|||dIdH\}}|D]}|Vq|dksdSdS)aL 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 Nr)r rr:r)r)rVrrr:rr rWrrBrBrC zscan_iter szRedis.zscan_itercGrd)z Add ``value(s)`` to set ``name``SADDr.rfrBrBrCsadd rhz Redis.saddcCr1)z-Return the number of elements in set ``name``SCARDr.rprBrBrCscard r4z Redis.scardcGt||}|jdg|RS)z3Return the difference of sets specified by ``keys``SDIFFrDr*rVr5r6 parsed_argsrBrBrCsdiff  z Redis.sdiffcGt||}|jd|g|RS)z Store the difference of sets specified by ``keys`` into a new set named ``dest``. Returns the number of keys in the new set. SDIFFSTORErrVrr5r6rrBrBrC sdiffstore  zRedis.sdiffstorecGr)z5Return the intersection of sets specified by ``keys``SINTERrrrBrBrCsinter( rz Redis.sintercGr)z Store the intersection of sets specified by ``keys`` into a new set named ``dest``. Returns the number of keys in the new set. SINTERSTORErrrBrBrC sinterstore- rzRedis.sinterstorecCr})zDReturn a boolean indicating if ``value`` is a member of set ``name`` SISMEMBERr.r~rBrBrC sismember5 rzRedis.sismembercCr1)z&Return all members of the set ``name``SMEMBERSr.rprBrBrCsmembers9 r4zRedis.smemberscCr)z9Move ``value`` from set ``src`` to set ``dst`` atomicallySMOVEr.)rVr"r#rrBrBrCsmove= rz Redis.smovecC&|dur|gpg}|jd|g|RS)z1Remove and return a random member of set ``name``NSPOPr.)rVrr:r6rBrBrCspopA sz Redis.spopnumbercCr)z If ``number`` is None, returns a random member of set ``name``. If ``number`` is supplied, returns a list of ``number`` random members of set ``name``. Note this is only available when running Redis 2.6+. N SRANDMEMBERr.)rVrrr6rBrBrC srandmemberF szRedis.srandmembercGrd)z#Remove ``values`` from set ``name``SREMr.rfrBrBrCsremQ rhz Redis.sremcGr)z.Return the union of sets specified by ``keys``SUNIONrrrBrBrCsunionU rz Redis.sunioncGr)z Store the union of sets specified by ``keys`` into a new set named ``dest``. Returns the number of keys in the new set. SUNIONSTORErrrBrBrC sunionstoreZ rzRedis.sunionstore groupnameidscGr)z Acknowledges the successful processing of one or more messages. name: name of the stream. groupname: name of the consumer group. *ids: message ids to acknowlege. XACKr.)rVrrrrBrBrCxackc sz Redis.xackfieldsr approximatecCsg}|dur&t|tr|dkrtd|d|r|d|t|||t|tr6t|dkr:td|D]}||q>|j d|g|RS) aW 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 approximate: actual stream length may be slightly more than maxlen Nrz&XADD maxlen must be a positive integerMAXLEN~rz$XADD fields must be a non-empty dictXADD) r:rErrr<rLrrTr@r*)rVrrrr}rr/rrBrBrCxaddl s     z Redis.xadd consumername min_idle_time message_idsrZ retrycountrIjustidc Cs:t|tr |dkr tdt|ttfr|stdi} |||t|g} | t||durAt|ts8td| dt|f|durWt|tsNtd| dt|f|durmt|tsdtd | d t|f| r}t| tsxtd | d | rt| tstd | dd| d<|j dg| Ri| S)a 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 rz3XCLAIM min_idle_time must be a non negative integerzLXCLAIM message_ids must be a non empty list or tuple of message IDs to claimNzXCLAIM idle must be an integersIDLEzXCLAIM time must be an integersTIMEz$XCLAIM retrycount must be an integers RETRYCOUNTzXCLAIM force must be a booleansFORCEzXCLAIM justid must be a booleansJUSTIDTrr) r:rErr=rqr<r@rrr*) rVrrrrrrZrrrIrrr/rBrBrCxclaim s>#       z Redis.xclaimcGrd)z Deletes one or more messages from a stream. name: name of the stream. *ids: message ids to delete. XDELr.)rVrrrBrBrCxdel z Redis.xdel$mkstreamcCs$d|||g}|r |d|j|S)z 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. rsMKSTREAMr)rVrrrrr/rBrBrC xgroup_create s   zRedis.xgroup_createcCr)a) 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 rr.)rVrrrrBrBrCxgroup_delconsumer rBzRedis.xgroup_delconsumercCr})z| Destroy a consumer group. name: name of the stream. groupname: name of the consumer group. rr.rVrrrBrBrCxgroup_destroy rzRedis.xgroup_destroycCr)z 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. rr.)rVrrrrBrBrC xgroup_setid zRedis.xgroup_setidcCr})z Returns general information about the consumers in the group. name: name of the stream. groupname: name of the consumer group. rr.rrBrBrCxinfo_consumers rzRedis.xinfo_consumerscCr1)zx Returns general information about the consumer groups of the stream. name: name of the stream. rr.rprBrBrC xinfo_groups rzRedis.xinfo_groupscCr1)za Returns general information about the stream. name: name of the stream. rr.rprBrBrC xinfo_stream rzRedis.xinfo_streamcCr1)zC Returns the number of elements in a given stream. XLENr.rprBrBrCxlen rz Redis.xlencCr})z Returns information about pending messages of a group. name: name of the stream. groupname: name of the consumer group. rr.rrBrBrCxpending# rzRedis.xpendingrrcCs||g}|dus|dus|dur7|dus|dus|dur tdt|tr)|dkr-td|||t|f|durP|dusG|dusG|durKtd|||jdg|RddiS) aH Returns information about pending messages, in a range. name: name of the stream. groupname: name of the consumer group. min: minimum stream ID. max: maximum stream ID. count: number of messages to return consumername: name of a consumer to filter by (optional). NzOXPENDING must be provided with min, max and count parameters, or none of them. rz&XPENDING count must be a integer >= -1zaif XPENDING is provided with consumername, it must be provided with min, max and count parametersrrT)rr:rEr@r<rr*)rVrrrrr:rr/rBrBrCxpending_range+ s  zRedis.xpending_ranger+cCV||g}|dur!t|tr|dkrtd|d|t||jd|g|RS)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. Nrz'XRANGE count must be a positive integerrXRANGEr:rErrr<r*)rVrrrr:r/rBrBrCxrangeQ  z Redis.xrangestreamsblockcCsg}|durt|tr|dkrtd|d|t||dur|dd |d <|D]} || d|| d qB|jd |g|Ri|S) 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. 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. z-ZADD requires at least one element/score pairz)ZADD allows either 'nx' or 'xx', not bothrzFZADD option 'incr' only works when passing a single element/score pairsNXsXXsCHsINCRTrrr)rrrrTr*) rVrr r1r2rrr/rrrBrBrCzadd s.      z Redis.zaddcCr1)z8Return the number of elements in the sorted set ``name``ZCARDr.rprBrBrCzcard r4z Redis.zcardcCr)z Returns the number of elements in the sorted set at key ``name`` with a score between ``min`` and ``max``. ZCOUNTr.rVrrrrBrBrCzcount rz Redis.zcountcCr)zEIncrement the score of ``value`` in sorted set ``name`` by ``amount``ZINCRBYr.)rVrrrrBrBrCzincrby rz Redis.zincrby aggregatecCr)z Intersect 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. ZINTERSTORE _zaggregaterVrr5rrBrBrC zinterstore$ rBzRedis.zinterstorecCr)z Return the number of items in the sorted set ``name`` between the lexicographical range ``min`` and ``max``. ZLEXCOUNTr.rrBrBrC zlexcount1 rzRedis.zlexcountcC4|dur|gpg}ddi}|jd|g|Ri|S)zy Remove and return up to ``count`` members with the highest scores from the sorted set ``name``. NrTZPOPMAXr.rVrr:r6rrBrBrCzpopmax8 z Redis.zpopmaxcCr )zx Remove and return up to ``count`` members with the lowest scores from the sorted set ``name``. NrTZPOPMINr.r rBrBrCzpopminA rz Redis.zpopmincCst||f}|jdg|RS)aR 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. BZPOPMAXr)rVr5r parsed_keysrBrBrCbzpopmaxJ s zRedis.bzpopmaxcCs&t|d}|||jdg|RS)aR 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. NBZPOPMIN)rDrr*)rVr5rklistrBrBrCbzpopminX s zRedis.bzpopminrc CsJ|r ||||||Sd|||g}|r|d||d}|j|i|S)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 descendingly ``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 ZRANGE WITHSCORESrr) zrevrangerr*) rVrrrrrrr/rrBrBrCzrangeg s   z Redis.zrangecC^|dur|dus|dur|durtdd|||g}|dur*|dur*|d||g|j|S)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. Nr ZRANGEBYLEXrrr@r*)rVrrrrrr/rBrBrC zrangebylex   zRedis.zrangebylexcCr)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. NrZREVRANGEBYLEXrr)rVrrrrrr/rBrBrCzrevrangebylex r zRedis.zrevrangebylexc C||dur|dus|dur|durtdd|||g}|dur*|dur*|d||g|r1|d||d} |j|i| S)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 Nr ZRANGEBYSCORErrrrr@rr* rVrrrrrrrr/rrBrBrC zrangebyscore     zRedis.zrangebyscorecCr})zi Returns a 0-based value indicating the rank of ``value`` in sorted set ``name`` ZRANKr.r~rBrBrCzrank rz Redis.zrankcGrd)z1Remove member ``values`` from sorted set ``name``ZREMr.rfrBrBrCzrem rhz Redis.zremcCr)z Remove all elements in the sorted set ``name`` between the lexicographical range specified by ``min`` and ``max``. Returns the number of elements removed. ZREMRANGEBYLEXr.rrBrBrCzremrangebylex rzRedis.zremrangebylexcCr)a 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 ZREMRANGEBYRANKr.rrBrBrCzremrangebyrank rzRedis.zremrangebyrankcCr)z Remove all elements in the sorted set ``name`` with scores between ``min`` and ``max``. Returns the number of elements removed. ZREMRANGEBYSCOREr.rrBrBrCzremrangebyscore rzRedis.zremrangebyscorecCs4d|||g}|r |d||d}|j|i|S)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 ZREVRANGErrr)rVrrrrrr/rrBrBrCr s   zRedis.zrevrangec Cr#)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 NrZREVRANGEBYSCORErrrr%r&rBrBrCzrevrangebyscore r(zRedis.zrevrangebyscorecCr})zt Returns a 0-based value indicating the descending rank of ``value`` in sorted set ``name`` ZREVRANKr.r~rBrBrCzrevrank0 rzRedis.zrevrankcCr})z|||g}|r|dvrtd|r|||jdg|RS)z Return the distance between ``place1`` and ``place2`` members of the ``name`` key. The units must be one of the following : m, km mi, ft. By default meters are used. rkmmiftzGEODIST invalid unitGEODISTr)rVrr~rrr/rBrBrCgeodist3s  z Redis.geodistcGrd)z Return the geo hash string for each item of ``values`` members of the specified key identified by the ``name`` argument. rr.rfrBrBrCgeohashCsz Redis.geohashcGrd)z Return the positions of each item of ``values`` as members of the specified key identified by the ``name`` argument. Each position is represented by the pairs lon and lat. rr.rfrBrBrCgeoposJrz Redis.geopos longitudelatituderadiusr1r2r3rr0c Cs$|jd||||||||| | | | d S)a Return the members of the specified key identified by the ``name`` argument which are within the borders of the area specified with the ``latitude`` and ``longitude`` location and the maximum distance from the center specified by the ``radius`` value. The units must be one of the following : m, km mi, ft. By default ``withdist`` indicates to return the distances of each place. ``withcoord`` indicates to return the latitude and longitude of each place. ``withhash`` indicates to return the geohash string of each place. ``count`` indicates to return the number of elements up to N. ``sort`` indicates to return the places in a sorted way, ASC for nearest to fairest and DESC for fairest to nearest. ``store`` indicates to save the places names in a sorted set named with a specific key, each element of the destination sorted set is populated with the score got from the original geo sorted set. ``store_dist`` indicates to save the places names in a sorted set named with a specific key, instead of ``store`` the sorted set destination score is set with the distance. rrr1r2r3r:rr/r0_georadiusgeneric) rVrrrrrr1r2r3r:rr/r0rBrBrC georadiusRs+zRedis.georadiusmemberc Cs"|jd||||||||| | | d S)a3 This command is exactly like ``georadius`` with the sole difference that instead of taking, as the center of the area to query, a longitude and latitude value, it takes the name of a member already existing inside the geospatial index represented by the sorted set. rrr) rVrrrrr1r2r3r:rr/r0rBrBrCgeoradiusbymemberszRedis.georadiusbymemberrcOs$t|}|dr|ddvrtd|dr||dn|ddD] \}}||r2||q%|dr@|d|dg|dr`|dd krP|d n|dd kr\|d ntd |drl|drltd|dry|d|dg|dr|d|dg|j|g|Ri|S)NrrzGEORADIUS invalid unitr))r1sWITHDIST)r2s WITHCOORD)r3sWITHHASHr:rrASCsASCDESCrzGEORADIUS invalid sortr/r0z3GEORADIUS store and store_dist cant be set togetherrs STOREDIST)r=rrr@r*)rVrr6rr/arg_name byte_reprrBrBrCrs6      zRedis._georadiusgenericrcCr1)zv Loads the module from ``path``. Raises ``ModuleError`` if a module is not found at ``path``. rr.)rVrrBrBrC module_loadrzRedis.module_loadcCr1)zs Unloads the module ``name``. Raises ``ModuleError`` if ``name`` is not in loaded modules. rr.rprBrBrC module_unloadrzRedis.module_unloadcCr5)zo Returns a list of dictionaries containing the name and version of all loaded modules. rr.rrBrBrC module_listr_zRedis.module_list)TN)NrNNT)r7r)r7r )r7r3r8) FFNNNNNFFF)NNNNF)ry)FFNFFr)r)r)NNFFF)r)rNNN)NNNNFFNF)rNNN)rNN)ryNT)NNNFF)rF)rrN)NNF)rrNT)FFFF)NFFFNNNN(LrirjrkrlrQrrErrrrrr|rrr*rMrSrFr rr.r rzrCrrrKrrbr~rDr rrrrrrrrrrrrr rr<r;ResponseCallbackT__annotations__ classmethodrr r rrZrrr2rrrrrrKeyTrrr(rrr r rrrr\r rr*rr%r0r3r6r8r9r;r=r>r@rrXrYrZr\r^rarkrmrnrorqrsrtrvrxr|rrrrrrrrrrrrKeysTrrrrrr)rrrrrrrrrrrrrrrrrrrrrrrrrrExpiryTr AbsExpiryTrrcrrrrrrPatternTr5rr+rrrrrrrr r!r&r(r.rr;rGrr=r?rArDrGrIr)rArN TimeoutSecTrSrVrXr[r_rarcrgrjrlrorqrsrurwryr{rrrrrrrrrrrrrrrrrrrrrrrrrGroupT StreamIdTrrFieldTr ConsumerTr rrrrrrrrrrrrrrrrrrrr ZScoreBoundTrrrrr r rrrrrr"r'r*r,r.r0r2rr5r7r9r;rr?rBrDrFrIrKrLrOrQrSrUr,rWrYr^r`rbrdChannelTrgrhrirjrl ScriptTextTrqrtrurvrwryr{r}rrrrrrrrrrBrBrBrCr3s   #&'( )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.       R     ?               % )"      -&&""    "      $      "    "0  " & &    " " " .   S   ""$"$ ""   '    G  " ) & +( 9($$ $$  #   $$       (($((" &         @     #,c@s>eZdZUeed<eed<eed<eed<eed<eed<dS)MonitorCommandInforrUclient_address client_port client_typerN)rirjrkrrrEr<rBrBrBrCrs  rc@sjeZdZdZedZedZdefddZ ddZ d d Z d d Z d e fddZd ee fddZdS)r z Monitor is useful for handling the MONITOR command to the redis server. next_command() method returns one command from monitor listen() method yields commands from monitor. z\[(\d+) (.*)\] (.*)z"(.*?)(?      zMonitor.next_commandcCs |IdHVq)z)Listen for commands coming to the server.TN)rrrBrBrClistenGszMonitor.listenN)rirjrkrlrecompilerrrrZrrrrrrrrBrBrBrCr s   (r c@speZdZdZdZdZdZ  dEdedee d e fd d Z d d Z ddZ ddZddZdeefddZdefddZeddZdefddZdd ZdFd#e d$efd%d&Zd'd(Zd)edefd*d+Zded,e fd-d.Z!dedefd/d0Z"ded,e#fd1d2Z$defd3d4Z%de&fd5d6Z' 7dGd e d$efd8d9Z(dHdefd:d;Z)dIdd?d@edAdBeddfdCdDZ+dS)Jra* PubSub provides publish, subscribe and listen support to Redis channels. After subscribing to one or more channels, the listen() method will block until a message arrives on one of the subscribed channels. That message will be returned and it's safe to start listening again. )rpmessage) unsubscribe punsubscribezaioredis-py-health-checkNFrrignore_subscribe_messagescCsx||_||_||_d|_|j|_|jjrd|jg|_n d|j |jg|_i|_ t |_ i|_ t |_t|_dS)Nr*spong)rrrrrJrNrHEALTH_CHECK_MESSAGEhealth_check_responserLchannelsrpending_unsubscribe_channelspatternspending_unsubscribe_patternsrr(_lock)rVrrrrBrBrCrZZs"  zPubSub.__init__c|Sr8rBrrBrBrCrwrmzPubSub.__aenter__crr8rCrrBrBrCrzrzPubSub.__aexit__cCs|jr |jdSdSr8)rclear_connect_callbacksrrBrBrCr }szPubSub.__del__c s|j4IdH7|jr&|jIdH|j|j|jIdHd|_i|_t|_i|_ t|_ WdIdHdS1IdHsEwYdSr8) rrr&rrr!rrrrrrrBrBrCrCs  .z PubSub.resetr7cCs|Sr8rrrBrBrCrsz PubSub.closercs|j|j|jr/i}|jD]\}}|||jj|dd<q|jdi|IdH|jrUi}|jD]\}}|||jj|dd<q9|j di|IdHdSdS)zBRe-subscribe to any channels and patterns previously subscribed toTrHNrB) rclearrrrTrNrM subscriber psubscribe)rVrrrXrYrrBrBrC on_connects  zPubSub.on_connectcCst|jp|jS)z@Indicates if there are subscriptions to any channels or patterns)rrrrrBrBrC subscribedszPubSub.subscribedr6csj|jdur|jd|jIdH|_|j|j|j}d|j i}|j||jg|Ri|IdHdS)z#Execute a publish/subscribe commandNr check_health) rrrrregister_connect_callbackrr_executer$)rVr6rrrBrBrCr*s   &zPubSub.execute_commandc sz ||i|IdHWSttfyA}z'|IdH|jr%t|ts&|IdH||i|IdHWYd}~Sd}~wwr8)rr%r&rr:r)rVrrr6rr)rBrBrCrs zPubSub._executeTrrrcsl|j}|dur td|IdH|s |j|dIdHs dS|||jIdH}|jr4||jkr4dS|S)z3Parse the response from a publish/subscribe commandNNpubsub connection not set: did you forget to call subscribe() or psubscribe()?)r)r RuntimeErrorrcan_readrr+rr)rVrrr#rJrBrBrCr%szPubSub.parse_responsecsT|j}|dur td|jr&t|jkr(|jd|jddIdHdSdSdS)NrrF)r) rrrrrrnext_health_checkr$rr"rBrBrCrszPubSub.check_healthrWcs(|jj|jjfdd|DS)z normalize channel/pattern names to be either bytes or strings based on whether responses are automatically decoded. this saves us from coercing the value for each message coming in. csi|] \}}||qSrBrB)rqrXrYrMrLrBrC rz*PubSub._normalize_keys..)rNrLrMrTrhrBrrC_normalize_keysszPubSub._normalize_keysrcsx|rt|df|ddn|}t|}|||jdg|RIdH}||}|j||j ||S)aE Subscribe to channel patterns. Patterns supplied as keyword arguments expect a pattern name as the key and a callable as the value. A pattern's callable will be invoked automatically when a message is received on that pattern rather than producing a message via ``listen()``. rrN PSUBSCRIBE) rDrLrMrgr*r5rrrdifference_update)rVr6rr new_patternsret_valrBrBrCr      zPubSub.psubscribecGsZ|rt|df|dd}|t|}ng}|j}|j||jdg|RS)zj Unsubscribe from the supplied patterns. If empty, unsubscribe from all patterns. rrN PUNSUBSCRIBE) rDrrLrMr5rrrgr*)rVr6rrrBrBrCr s zPubSub.punsubscribecsx|rt|df|ddnd}t|}|||jdg|RIdH}||}|j||j ||S)aR Subscribe to channels. Channels supplied as keyword arguments expect a channel name as the key and a callable as the value. A channel's callable will be invoked automatically when a message is received on that channel rather than producing a message via ``listen()`` or ``get_message()``. rrNrB SUBSCRIBE) rDrLrMrgr*r5rrrr)rVr6rr new_channelsrrBrBrCrrzPubSub.subscribecGsT|rt|d|dd}|t|}ng}|j}|j||jdg|RS)zi Unsubscribe from the supplied channels. If empty, unsubscribe from all channels rrN UNSUBSCRIBE)rDrrLrMrrrgr*)rVr6rrrBrBrCr/s zPubSub.unsubscribecCs<|jr||jddIdH}|dur|V|jsdSdS)zBListen for messages on channels this client has been subscribed toT)rN)rhandle_messager%rrBrBrCr=s z PubSub.listencs*|jd|dIdH}|r|||SdS)z Get the next message if one is available, otherwise None. If timeout is specified, the system will wait for `timeout` seconds before returning. Timeout should be specified as a floating point number. F)rrN)r%r)rVrrrJrBrBrC get_messageDs   zPubSub.get_messagecCs|durdn|}|d|S)z' Ping the Redis server NrNrr.)rVrrBrBrCr)Ss z PubSub.pingcCs4t|d}|dkr||d|d|dd}n|dkr&|dd|dd}n |d|d|dd}||jvrg|d krQ|d}||jvrP|j||j|dn|d}||jvrg|j||j|d||jvr|dkrz|j |d d}n |j |d d}|r||dS|S|dkr|s|j rdS|S) z Parses a pub/sub message. If the channel or pattern was subscribed to with a message handler, the handler is invoked instead of a parsed message being returned. rrrrr)rArzrerWr*Nrrzre) r*UNSUBSCRIBE_MESSAGE_TYPESrremoverpoprrPUBLISH_MESSAGE_TYPESrcr)rVrJr message_typerrzrehandlerrBrBrCrZsR        zPubSub.handle_messager)exception_handler poll_timeoutrPSWorkerThreadExcHandlerTrc s|jD]\}}|durtd|dq|jD]\}}|dur,td|dq z |jd|dIdHWn.tjyCtyh}z|durO|||}t |r^|IdHWYd}~nd}~wwt dIdHq.)aProcess pub/sub messages using registered callbacks. This is the equivalent of :py:meth:`redis.PubSub.run_in_thread` in redis-py, but it is a coroutine. To launch it as a separate task, use ``asyncio.create_task``: >>> task = asyncio.create_task(pubsub.run()) To shut it down, use asyncio cancellation: >>> task.cancel() >>> await task Nz Channel: 'z' has no handler registeredz Pattern: 'T)rrr) rrTr"rrrCancelledError BaseExceptionrrr)rVrrrerrzr)resrBrBrCruns4   z PubSub.runNF)Tr)Frr8r),rirjrkrlrrrrr r<rrZrrr rCrr rrrpropertyrrr*rrr%rr4rr PubSubHandlerrrrrrrrrr)rrrBrBrBrCrMsb      >rc@eZdZdedefddZdS)PubsubWorkerExceptionHandlerr)rcCrer8rBrVr)rrBrBrCrgrhz%PubsubWorkerExceptionHandler.__call__NrirjrkrrrgrBrBrBrCrrc@r)!AsyncPubsubWorkerExceptionHandlerr)rcrlr8rBrrBrBrCrgrmz*AsyncPubsubWorkerExceptionHandler.__call__NrrBrBrBrCrrr.c sjeZdZdZhdZdedeeee fe fde de efddZ d ed efd d Zd dZddZdZddZddZddZddZddZd ededffddZddZd d!Zd"ed#efd$d%Zd"ed#ed&e fd'd(Zd#ed)e e!fd*d+Z"d,e#d-e$d.e e%d d/fd0d1Z&d"ed2eee fffd3d4 Z'd5d6Z(d?d&e fd8d9Z)d:e*fd;d<Z+d=d>Z,Z-S)@ra_ Pipelines provide a way to transmit multiple commands to the Redis server in one transmission. This is convenient for batch processing, such as saving all the values in a list to Redis. All commands executed within a pipeline are wrapped with MULTI and EXEC calls. This guarantees all commands executed in the pipeline will be executed atomically. Any command raising an exception does *not* halt the execution of subsequent commands in the pipeline. Instead, the exception is caught and its instance is placed into the response list returned by execute(). Code iterating over the response list should be able to deal with an instance of an exception as a potential value. In general, these will be ResponseError exceptions, such as those raised when issuing a command on a key of a different datatype. >EXECDISCARDUNWATCHrrrrcCs<||_d|_||_||_||_d|_g|_t|_d|_ dSr) rrris_transactionrwatching command_stackrscriptsexplicit_transaction)rVrrrrrBrBrCrZs zPipeline.__init__rVr7crr8rBrrBrBrCrrmzPipeline.__aenter__crr8rrrBrBrCrrzPipeline.__aexit__cCrr8) _async_selfrrrBrBrCrrzPipeline.__await__zUnclosed Pipeline clientcCr r8)rrrrBrBrC__len__r zPipeline.__len__cCrs)z1Pipeline instances should always evaluate to TrueTrBrrBrBrC__bool__szPipeline.__bool__crr8rBrrBrBrCr  rmzPipeline._async_selfcsg|_t|_|jr6|jr6z|jdIdH|jIdHWnty5|jr3|jIdHYnwd|_d|_ |jrN|j |jIdHd|_dSdS)NrF) rrrrrr$r+rr&r rr!rrBrBrCrCs$   zPipeline.resetcCs&|jrtd|jrtdd|_dS)z Start a transactional block of the pipeline after WATCH commands are issued. End the transactional block with `execute`. z"Cannot issue nested calls to MULTIz:Commands without an initial WATCH have already been issuedTN)r r#rrrBrBrCr^'s zPipeline.multicOs8|js |ddkr|js|j|i|S|j|i|S)NrWATCH)rr immediate_execute_commandpipeline_execute_command)rVr6rrBrBrCr*4szPipeline.execute_commandc sD|d}|j}|s|j||jIdH}||_tt|}z|j|IdH|j||fi|IdHWStt fy}zQ| IdH|j rS| IdHt d||jr[t|t sc| IdHz|j|IdH|j||fi|WWYd}~Stt fy| IdHwd}~wtjy| IdHw)z Execute a command immediately, but don't auto-retry on a ConnectionError if we're already WATCHing a variable. Used when issuing WATCH or subsequent commands retrieving their values but before MULTI is called. rN=A ConnectionError occurred on while watching one or more keys)rrrrrrr$r%rr%r&rrCr&rr:rr)rVr6rr(r#r)rBrBrCr;sH  "z"Pipeline.immediate_execute_commandcOs|j||f|S)ar Stage a command to be executed when execute() is next called Returns the current Pipeline object back so commands can be chained together, such as: pipe = pipe.set('foo', 'bar').incr('baz').decr('bang') At some other point, you can then run: pipe.execute(), which will execute all commands queued in the pipe. )rr)rVr6rrBrBrCrks z!Pipeline.pipeline_execute_commandrrHc sXdif}dif}|g||R}|dd|D}||IdHg}z ||dIdHWntyI} z |d| fWYd} ~ nd} ~ wwt|D]E\} } t| dvrd|| | dtfqNz ||dIdHWqNty} z|| | d| d|| | fWYd} ~ qNd} ~ wwz ||dIdH} Wnty} z |r|dd| d} ~ wwd|_ | durt d d|D] \} } | | | qt | t |kr|j r|j IdHtd d|r||| g}t| |D]3\}}t|ts$|\}}|d}||jvr$|j||fi|}t|r$|IdH}||q|S) N)MULTI)rcss |] \}}t|vr|VqdSr8)r.)rqr6rrBrBrCrss   z0Pipeline._execute_transaction..rrrFzWatched variable changed.z6Wrong number of response items from pipeline execution) pack_commandssend_packed_commandr%r$rrKr.annotate_exceptionrrr&insertrrr&raise_first_errorrr:rrrr)rVrrHraise_on_errorprepostcmdsall_cmdserrorserrrrrJr)rWrrVr6rr(rBrBrC_execute_transactionzsv          zPipeline._execute_transactionrc s|dd|D}||IdHg}|D]/\}}z||j||dfi|IdHWqtyF}z ||WYd}~qd}~ww|rO||||S)NcSsg|]\}}|qSrBrB)rqr6rrBrBrCrrz.Pipeline._execute_pipeline..r)rrrr%r$r) rVrrHrrrJr6rr)rBrBrC_execute_pipelines   zPipeline._execute_pipelinerJcCs>t|D]\}}t|tr|||d||d|qdS)Nrr)rKr:r$r)rVrHrJrrrBrBrCrs  zPipeline.raise_first_error exceptionrrNcCsBdtt|}d|d|d|j}|f|jdd|_dS)Nrz Command # z (z) of pipeline caused error: r)rrr)r6)rVr rrrVmsgrBrBrCrszPipeline.annotate_exceptionr(c s<tj||fi|}||jvrd|_|S|dkrd|_|S)NFr T)r\r%UNWATCH_COMMANDSr)rVrr(rrr_rBrCr%s zPipeline.parse_responsecsrt|j}|j}dd|D}|dg|RIdH}t|s5t||D]\}}|s4|d|jIdH|_q$dSdS)NcSsg|]}|jqSrB)rr)rqsrBrBrCrrrz)Pipeline.load_scripts..rr)r=rrallrrmrr)rVr immediateshasrr#existrBrBrC load_scriptss zPipeline.load_scriptsTc s&|j}|s |js gS|jr|IdH|js|jr|j}n|j}|j}|s5|j d|j IdH}||_t t |}zPz||||IdHWW|IdHSttfy}z/|IdH|jrftd||jrnt|tso||||IdHWYd}~W|IdHSd}~ww|IdHw)z0Execute all the commands in the current pipelineNrr)rrrr(rr rrrrrrrrrCrr%r&r&rr:)rVrstackrr#r)rBrBrCrs@   zPipeline.executercs(|jrtd|jdg|RIdHS)z$Watches the values at keys ``names``z"Cannot issue a WATCH after a MULTIr N)r r#r*rrBrBrCr$szPipeline.watchcs|jr |dIdHp dS)z'Unwatches all previously specified keysrNT)rr*rrBrBrCunwatch*szPipeline.unwatchr).rirjrkrlr"rr rr<r;rrr rZr2rrrrr r r rCr^rr*rrr CommandStackTrrrrrrrErrr%r(rrrr*rmrBrBr_rCrsr   0 J     (rc@sTeZdZdZdedefddZ   d deee dee e d eefd d Z dS) rzz?An executable Lua script object returned by ``register_script``registered_clientrmcCsD||_||_t|tr|j}||}n|}t| |_ dSr8) r,rmr:r<rrJrLhashlibsha1 hexdigestrr)rVr,rmrN script_bytesrBrBrCrZ2s   zScript.__init__Nr5r6r cs|pg}|pg}|dur|j}t|t|}t|tr0|j||j|jt|g|RSz|j|jt|g|RIdHWSt yd| |j IdH|_|j|jt|g|RIdHYSw)z1Execute the script, passing any required ``args``N) r,rqr:rraddrtrrrr!ryrm)rVr5r6r rBrBrCrg@s  " $zScript.__call__r) rirjrkrlr3rrZr rrrrrgrBrBrBrCrz/s  rzc @seZdZdZ ddededeefddZdd Z d efd d Z dd ede de d eefddZ d ede fddZd ede de fddZeddZddZdS)rz0 Command builder for BITFIELD commands. Nr rrcCs*||_||_||_g|_d|_|dS)NWRAP)r r_default_overflow operations_last_overflowrC)rVr rrrBrBrCrZ`s  zBitFieldOperation.__init__cCs"g|_d|_||jp |jdS)zL Reset the state of the instance to when it was constructed r2N)r4r5overflowr3rrBrBrCrCjszBitFieldOperation.resetr6cCs,|}||jkr||_|jd|f|S)a 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)rUr5r4r)rVr6rBrBrCr6rs  zBitFieldOperation.overflowfmtr incrementcCs*|dur |||jd|||f|S)a 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. Nr)r6r4r)rVr8rr9r6rBrBrCrs zBitFieldOperation.incrbycCs|jd||f|S)a 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. rr4r)rVr8rrBrBrCrcs zBitFieldOperation.getrcCs|jd|||f|S)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. rr:)rVr8rrrBrBrCrs zBitFieldOperation.setcCs$d|jg}|jD]}||q|S)NBITFIELD)rr4r@)rVrVopsrBrBrCrs   zBitFieldOperation.commandcCs|j}||jj|S)a# 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. )rrCr r*)rVrrBrBrCrs zBitFieldOperation.executer8)rirjrkrlr3rr r<rZrCr6BitfieldOffsetTrErrcrrrrrBrBrBrCr[s6      rr)rrGr-rrrrr\typingrrrrrrrr r r r r rrrrrrrraioredis.compatrraioredis.connectionrrrrraioredis.exceptionsrrrr r!r"r#r$r%r& aioredis.lockr(aioredis.utilsr)r*rErrrrr<rr=r;r? _StringLikeTrrrrrrrrrrr+r, AnyChannelTr SYM_EMPTYr.r/r1r2rr4rDrKrQrLrSrzr~rrrrrrrrrrrrr|rrrrrrrrrrrr r r rrrrr,r.rCrDrFrMrSrOrbrdrkrrnr3 StrictRedisrr rrrrCommandTr+rrzrrBrBrBrCsfX0          ,              Ov$],