ng\j+HSSKrSSKJr SrSrSrSrSrSrS r 0S \ _S \ _S \ _S \ _S\ _S\ _S\ _S\ _S\ _S\ _S\ _S\ _S\ _S\ _S\ _S\ _S\ _\ \ \ \ \ \ S.Er Sr Sr SrSrS rS!rS"rS#rS$rS%rS&rS'rS(rS)rS*rS+rS,rS-rS.rS/rSS0jr S1r!S2r"S3r#S4r$S5r%S6r&S7r'S8r(S9r)S:r*S;r+S<r,S=r-S>r.S?r/S@r0SAr1SBr2SCr3SDr4SEr5SFr6SGr7SHr8SIr9SJr:SKr;SLrSOr?SPr@SQrASRrBSSrCSTrDSUrESVrFSWrGSXrHSYrISZrJS[rKS\rLS]rMS^rNS_rOS`rPSarQSbrRScrSSdrTSerUSfrVSgrWShrXSirYSjrZSkr[Slr\Smr]Snr^Sor_Spr`SqraSrrbSsrcStrdSureSvrfSwrgSxrhSyriSzrjS{rkS|rlS}rmS~rnSroSrpSrqSSKrJsrsJtrtJuruJvrvJwrwJxrxJyry g)N str_if_bytescU(dg[U5n[RRU5$![a gf=f)z5Converts a unix timestamp to a Python datetime objectN)int ValueErrordatetime fromtimestampresponses Q/home/edenadmin/noVNC/venv/lib/python3.13/site-packages/redis/_parsers/helpers.pytimestamp_to_datetimer sC x=    * *8 44 s 4 AAc[U5nSU-n[SUR555nSnUHnX ;dM [X5X'M U$)zDParse the results of Redis's DEBUG OBJECT command into a Python dictztype:c3B# UHoRS5v M g7f:Nsplit).0kvs r %parse_debug_object..s=,SU;a#SU;aSU;a [U5$[U5$SU;a0URS5Vs/sHo(dM T"U5PM sn$0nURS5H6nU(dM SU;a UR SS5upAT"U5X$'M2SX#'M8 U$![a Us$f=fs snf)N,=.T)floatrrrrsplit)valuevsub_dictitemk get_values r r.parse_info..get_value(s e 5 0 %< <'u:% */++c*:@*:QaLIaL*:@ @H C($;;;sA.DA"+A,HK%)HN)O   As"B0 B0 C C0 B?>B?#rr& cmdstat_hostmodulemodules__raw__)r splitlines startswithfindrr( setdefaultappend)r infolinekeyr)r.s @r parse_infor>#s DH%H.##% 4,,yy~#"ZZQ/ .(!%S!!4JC(?OOIr299)E:JK )% 0DI 2.55d;%&( Kr c [USSS9nUR5HAup4URS5(dM[U[5(dM4[USSS9X#'MC U$)z!Parse the results of MEMORY STATST) decode_keysdecode_string_valuesdb. pairs_to_dictitemsr7 isinstancelistr kwargsstatsr=r)s r parse_memory_statsrKVsW (4 PEkkm  >>% Zt%<%<&4dEJ$ Lr c [USS9nUR5H@up4URS5(dM[U[5(dM4[USS9X#'MB U$)zParse MEMORY STATS for unified RESP2 output. Unified responses decode structural keys while preserving string-like values as delivered, matching the approved RESP2/RESP3 unification shape. Tr@rBrCrHs r parse_memory_stats_unifiedrNasR ( 5Ekkm  >>% Zt%<%<&u$?EJ$ Lr c lUR5VVs0sHup#[U5U_M nnnUR5Heup#URS5(dM[U[5(dM4UR5VVs0sHupV[U5U_M snnXB'Mg U$s snnfs snnf)a$Parse the results of MEMORY STATS on RESP3 wire. Each entry arrives as a top-level ``dict`` instead of a flat list of pairs; decode the keys to ``str`` and recurse into the per-database ``db.*`` sub-dicts so the Python shape matches what :func:`parse_memory_stats` produces from RESP2 wire. rB)rErr7rFr)r rIr=r)rJr-r*s r parse_memory_stats_resp3rPns9A8H I8H*#\#  %8HE Ikkm  >>% Zt%<%<9>G,q/1,GEJ$ L JHs B*B0c UVVVs/sH1o"R5VVs0sHup4[U5U_M snnPM3 snnn$s snnfs snnnf)zParse list-of-maps responses on RESP3 wire (e.g. ``XINFO`` family). Each list entry arrives as a ``dict`` with bytes keys; decode the keys to ``str`` so the Python shape matches what :func:`parse_list_of_dicts` produces from RESP2 wire. rEr)r rIxr=r)s r parse_list_of_dicts_resp3rT}s@MU UHq B *#\#  % BH UU B UsA AA A zcan-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-epoch)) is_mastermaster)is_slaveslave)is_sdowns_down)is_odowno_down) is_sentinelsentinel)is_disconnected disconnected)is_master_down master_downc.[H up#X1;X'M g)zSet ``is_master`` / ``is_slave`` / ``is_sdown`` / ``is_odown`` / ``is_sentinel`` / ``is_disconnected`` / ``is_master_down`` on ``result`` based on membership in the ``flags`` set. N)_SENTINEL_DERIVED_BOOLEANS)resultflagsnameflags r _add_derived_sentinel_booleansrks 1 } 1r cv[U[5n[USRS55n[ X5 U$Nrhr#)pairs_to_dict_typedSENTINEL_STATE_TYPESsetrrk)r,rgrhs r parse_sentinel_staterqs5 '; T"U5$![[4a T"[U55s$f=frs)r TypeErrorr')rSscore_cast_funcs r _safe_cast)_wrap_score_cast_func.._safe_castis6 -"1% %I& -"58, , -s  !//r')rrs` r _wrap_score_cast_funcr\s %- r c U(aURS5(dU$[URS[55n[U5n[ [ U[ X#555$)zf If ``withscores`` is specified in the options, return the response as a list of (value, score) pairs withscoresr)getrr'rrGrrur rwrrs r zset_score_pairsrrsP 7;;|44+GKK8I5,QRO hB BO01 22r c U(dU$[URS[55n[U5n[ [ U[ X#555$)zRESP2-wire ZPOPMAX/ZPOPMIN -> legacy ``list[(member, score), ...]``. ZPOPMAX/ZPOPMIN always include scores, so this parser intentionally does not depend on a ``withscores`` option. r)rrr'rrGrrurs r zpop_score_pairsr~sB +GKK8I5,QRO hB BO01 22r c U(aURS5(dU$[URS[55nUSU"US5/$z] If ``withscores`` is specified in the options, return the response as a [value, score] pair withscorerrr&rrr'r rwrs r zset_score_for_rankrsH 7;;{33+GKK8I5,QRO QK!5 66r c U(aURS5(dU$URS[5nUVVs/sHup4X2"U5/PM snn$s snnf)zf If ``withscores`` is specified in the options, return the response as a list of [value, score] pairs rrrr'r rwrrivals r zset_score_pairs_resp3rsO 7;;|44kk"3U;O:B C(YTT?3' (( CC CsAc U(aURS5(dU$URS[5nUSU"US5/$rrrs r zset_score_for_rank_resp3rsC 7;;{33kk"3U;O QK!5 66r c[U[5(aU$[U[5(aUR5$[U[5(a U(aS$S$[ [ U5S5R5$)aRe-encode a score back to the bytes form Redis returns on the RESP2 wire so that custom ``score_cast_func`` callables observe the same input type they would receive on a RESP2 connection when the wire protocol is RESP3 but legacy response shapes are requested. 10z.17g)rFbytesstrencodeboolformatr')r)s r _score_to_resp2_bytesrsc % %||~%t&$& %, ' . . 00r c U(aURS5(dU$[URS[55nUVVs/sHup4X2"[U554PM snn$s snnf)zConvert RESP3 nested ``[[member, score], ...]`` to today's RESP2 ``list[(member, score)]`` shape: tuples instead of lists, scores re-encoded to bytes before being passed to ``score_cast_func`` so the cast receives the same input as on a RESP2 connection. rrrrr'rr rwrmemberscores r &zset_score_pairs_resp3_to_resp2_legacyrsi 7;;|44+GKK8I5,QRO& %MF !6u!=>?%  sA&c U(aURS5(dU$/nUH0up4URU5 UR[U55 M2 U$)aConvert RESP3 nested ``[[member, score], ...]`` to the flat raw RESP2 wire shape ``[member, score_bytes, ...]`` used by ZDIFF in v8.0.0b1. ZDIFF historically did not propagate ``withscores`` to the response callback, so the legacy RESP2 callback was a no-op and the raw flat wire response was returned to the user. This helper reproduces that shape on RESP3 wires so ``legacy_responses=True`` keeps emitting the same Python value regardless of the underlying protocol. r)rr:r)r rwflatrrs r +zset_score_pairs_resp3_to_resp2_legacy_flatrsP 7;;|44 D!  F )%01" Kr c U(aURS5(dU$[URS[55nUSU"[US55/$)u%RESP3-wire ZRANK/ZREVRANK WITHSCORE → legacy RESP2 ``[rank, score]``. The shape ``[rank, score]`` is identical between RESP2 and RESP3; only the score is re-encoded to bytes before being passed to ``score_cast_func`` so the cast observes the same input type it would on a RESP2 connection. rrrr&rrs r )zset_score_for_rank_resp3_to_resp2_legacyrsN 7;;{33+GKK8I5,QRO QK)>x{)KL MMr c U(aURS5(dU$[URS[55n[U5n[ X35VVs/sHupEXB"[U55/PM snn$s snnf)uRESP2-wire WITHSCORES → unified ``list[[member, score], ...]``. Normalises RESP2 byte-string scores through ``float`` before applying ``score_cast_func`` so the cast receives the same input type as on a RESP3 connection. rr)rrr'rrr rwrrrrs r zset_score_pairs_unifiedrse 7;;|44+GKK8I5,QRO hBCFr; O;ZSS/%,/ 0; OO OsA:c U(aURS5(dU$[URS[55nUSU"[US55/$)uRESP2-wire ZRANK/ZREVRANK WITHSCORE → unified ``[rank, score]``. Normalises the RESP2 byte-string score through ``float`` before applying ``score_cast_func`` so the cast receives the same input type as on a RESP3 connection. rrrr&rrs r zset_score_for_rank_unifiedrsM 7;;{33+GKK8I5,QRO QKx{);< ==r c U(dU$[URS[55n[U5n[ X35VVs/sHupEXB"[U55/PM snn$s snnf)uRESP2-wire ZPOPMAX/ZPOPMIN → unified ``list[[member, score], ...]``. ZPOPMAX/ZPOPMIN always include scores; no ``withscores`` gate is required. Scores are normalised through ``float`` before applying ``score_cast_func`` for parity with RESP3. r)rrr'rrrs r zpop_score_pairs_unifiedrsW +GKK8I5,QRO hBCFr; O;ZSS/%,/ 0; OO OsA$c U(dU$URS[5n[US[5(aUVVs/sHup4X2"U5/PM snn$USU"US5//$s snnf)uRESP3-wire ZPOPMAX/ZPOPMIN → unified ``list[[member, score], ...]``. Without ``count`` RESP3 returns a flat ``[member, score]``; with ``count`` it returns a nested ``[[member, score], ...]``. Both shapes are normalised to a nested list with ``score_cast_func`` applied. rrr&)rr'rFrGrs r zpop_score_pairs_resp3_unifiedrsp kk"3U;O(1+t$$>FGhs+,hGG a[/(1+6 7 88HsA'c U(dU$[URS[55n[US[5(a'UVVs/sHup4X2"[ U554PM snn$USU"[ US554/$s snnf)uERESP3-wire ZPOPMAX/ZPOPMIN → legacy RESP2 ``list[(member, score), ...]``. Both RESP3 shapes (flat without ``count``; nested with ``count``) are converted to a list of tuples. Scores are re-encoded to bytes before being passed to ``score_cast_func`` so the cast observes the same input type it would on a RESP2 connection. rrr&)rrr'rFrGrrs r &zpop_score_pairs_resp3_to_resp2_legacyr#s +GKK8I5,QRO(1+t$$"* !) _%:5%AB C!)  a[/*? *LM N OO  sBc @U(dgUSUS[US5/$)uBZPOPMAX/BZPOPMIN → unified ``[key, member, score]``. Works for both RESP2 (bytes score) and RESP3 (float score) wire shapes. Nrr&rrrvs r bzpop_score_unifiedr6(  QK!eHQK&8 99r c @U(dgUSUS[US54$)uRESP3-wire BZPOPMAX/BZPOPMIN → legacy RESP2 ``(key, member, score)``. Matches the v8.0.0b1 RESP2-wire callback shape (tuple, ``float`` score). Nrr&rrrvs r !bzpop_score_resp3_to_resp2_legacyr@rr c tU(dU$USUSVVs/sHup#U[U5/PM snn/$s snnf)uRESP3-wire ZMPOP/BZMPOP → legacy RESP2 ``[name, [[member, b"score"], ...]]``. Re-encodes RESP3 native float scores back to the bytes form Redis returns on the RESP2 wire so callers observe today's RESP2 raw shape. rr&)rr rwrrs r zmpop_resp3_to_resp2_legacyrJsC  EMa[Q[MF&'. /[Q Q4c tU(dU$USUSVVs/sHup#U[U5/PM snn/$s snnf)uZMPOP/BZMPOP → unified ``[name, [[member, float_score], ...]]``. Used for the ``legacy_responses=False`` overlay on RESP2 wire to mirror RESP3's native float-score shape. rr&rrs r zmpop_unifiedrXsA  5=a[A[MF&%, [A Arc U(aURS5(dU$[US[5(aU$[U5n[ X"5VVs/sHup4X4/PM snn$s snnf)uRESP2-wire HRANDFIELD WITHVALUES → unified ``list[[field, value], ...]``. Plain (no-values) responses — flat list of fields — pass through. The ``withvalues`` option (forwarded by the command method) selects the pairing branch so the no-values flat result is never misread. withvaluesr)rrFrGrr)r rwrrr)s r hrandfield_unifiedrfsY 7;;|44(1+t$$ hB/22{ ;{|uUN{ ;; ;sA&c U(aURS5(dU$[US[5(dU$/nUH'up4URU5 URU5 M) U$)uRESP3-wire HRANDFIELD WITHVALUES → legacy RESP2 flat ``[field, value, ...]``. Plain (no-values) responses — flat list of fields — pass through. rr)rrFrGr:)r rwrrr)s r hrandfield_resp3_to_resp2_legacyrus` 7;;|44 hqk4 ( ( D  E E! Kr c nUVs/sH#o"b[US5[US5/OSPM% sn$s snf)uGEOPOS → unified ``list[list[float, float] | None]``. Used for the ``legacy_responses=False`` overlay on RESP2 wire to mirror RESP3's native ``list[list]`` shape. Nrr&rr rwlls r parse_geopos_unifiedrs: PX XxNU2a5\5A< ( Dx XX X*2c nUVs/sH#o"b[US5[US54OSPM% sn$s snf)uRESP3-wire GEOPOS → legacy RESP2 ``list[tuple(float, float) | None]``. Matches today's RESP2-wire callback shape (tuple coordinates). Nrr&rrs r "parse_geopos_resp3_to_resp2_legacyrs: PX XxNU2a5\5A< ( Dx XX Xrc :[U[5(a5[U5n[X"5VVs0sHup4[ U5U_M snn$[U[ 5(a/UR 5VVs0sHup4[ U5U_M snn$U$s snnfs snnf)uLCS with IDX → unified ``dict``. Used for the ``legacy_responses=False`` overlay on RESP2 wire to mirror RESP3's native ``dict`` shape. Non-IDX responses (``bytes`` / ``int``) pass through unchanged. )rFrGrrrrrE)r rwrr=r)s r parse_lcs_idx_unifiedrs(D!! (^;>r;G;ZS S!5(;GG(D!!;C>>;KL;KZS S!5(;KLL OHLs B3Bc [U[5(dU$/nUR5H'up4URU5 URU5 M) U$)uRESP3-wire LCS with IDX → legacy RESP2 flat list shape. Reproduces today's RESP2 raw output (``[b"matches", [...], b"len", n]``). Non-IDX responses pass through unchanged. )rFrrEr:r rwrr=r)s r #parse_lcs_idx_resp3_to_resp2_legacyr sL h % %Cnn&  3 5' Jr c [U[5(a/UR5VVs0sHup#[U5U_M nnnO6[ USSS2USSS25VVs0sHup#[U5U_M nnnSU;a"USVs/sHn[U5PM snUS'SU;a"USVs/sHn[U5PM snUS'U$s snnfs snnfs snfs snf)uCLIENT TRACKINGINFO → unified ``dict[str, Any]``. Accepts either RESP2's flat ``[label, value, ...]`` list or RESP3's native ``dict`` and returns a ``dict`` with ``str`` keys. Nrr&rhprefixes)rFrrErr)r rwr=r)datarjprefixs r !parse_client_trackinginfo_unifiedrs (D!!;C>>;KL;KZS S!5(;KL"(3Q3-!$Q$@ @   u $@  $85)) X &&r c `URSS5(aUS$[US5US'U$)Nr!Fr&r"rvs r parse_xautoclaimr%s4{{>5)){#HQK0HQK Or c [U[5(a [USS9$UR5VVs0sHup#[ U5U_M snn$s snnfr)rFrGrDrEr)r rwr-r*s r parse_arinfor'sH(D!!X488+3>>+; <+;41LOQ +; << >a nQ&7&CDEkN&DRq aT:N&AkN$ K"(^+E16 > a!# >+DN K1AX & ?s/GG GGGG1GGc ^Uc/$UVs/sHo"S[US40UD6/PM sn$s snfr)r)r rwrs r parse_xreadr6+s; @H I1qT$QqT5W5 6 II Is*c zUc0$UR5VVs0sHup#U[U40UD6/_M snn$s snnfrsrErr rwr=r)s r parse_xread_resp3r:1sK EM^^EU EUzs11 22EU  s7c U(d0$[U[5(a0UR5VVs0sHup#U[U40UD6_M snn$UVVs0sHupEU[U40UD6_M snn$s snnfs snnf)uXREAD/XREADGROUP → unified ``dict[stream, list[tuple[id, dict]]]``. Accepts either RESP2 (``list[[stream, entries]]``) or RESP3 (``dict[stream, entries]``) wire shape. Empty result is ``{}``. )rFrrEr)r rwr=r)streamr*s r parse_xread_unifiedr=9s  (D!!GO~~GW GWC"54G4 4GW  NV MU/&!'5W55X   s A1A7c U(d/$UR5VVs/sHup#U[U40UD6/PM snn$s snnf)uRESP3-wire XREAD/XREADGROUP → legacy RESP2 ``list[[stream, entries]]``. Empty result ``{}`` is converted to ``[]`` to match today's RESP2 shape. r8r9s r !parse_xread_resp3_to_resp2_legacyr?JsG  EM^^EU EUzs112EU  s;c URSS5(a [U5$US=(d /VVs/sHup#U[U5S.PM nnnUSUSUSUS.$s snnf) N parse_detailF)ripendingrr&r)rCminmaxr+)rparse_xpending_ranger)r rwrpr+s r parse_xpendingrHVss{{>5))#H--r c Uup#URSS5nU(a U=(d /nOU=(a [U5=(d 0n[U5U4$)N no_valuesF)rrDr)r rwrdrrgpayloads r parse_hscanrisHIF K/I'r( a(.B v; r c [URS[55nUup4[U5n[ U5[ [ U[X%5554$Nr)rrr'rrrGrru)r rwrrdrrs r parse_zscanrlsH+GKK8I5,QROIF aB v;SS%=>? ??r c [URS[55nUup4[U5n[ U5[ XU5VVs/sHupgXb"[U55/PM snn4$s snnfrk)rrr'rrr)r rwrrdrrr)rs r parse_zscan_unifiedrnsi+GKK8I5,QROIF aB v;CFr;CN<5e -.; sA*c LUVs/sHo"b [U5OSPM sn$s snfrsr)r rwrs r parse_zmscorerps&EM NXE-E%L4 7X NN Ns!c ^URSS5(aSOSmU4SjnUVs/sH o2"U5PM sn$s snf)Ndecode_responsesFrX cf>US[US5[US5S.n[US[5(a8TRUS5US'[ U5S:aUSUS 'US US 'U$USUS 'TRUS5US'[ U5S :aUS US 'USUS 'U$)Nrr&r)id start_timedurationrBcommandclient_address client_name complexity)rrFrGjoinr,)r,rgspaces r parse_item%parse_slowlog_get..parse_itemsQs47|TRSWV d1gt $ $ % 47 3F9 4yA~+/7'((,Q}% $(7F< % 47 3F9 4yA~+/7'((,Q}% r )r)r rwrr,rs @r parse_slowlog_getrs?;;1599CtE.*2 2Jt  22 2s;c URSS5(a [U5$URSS5(aURSS5(a@USVs/sH/n[US5/[[[USS55-PM1 nnO,USVs/sHn[[[U55PM nn[ US5U[ US 5[US 50$[ U5$s snfs snf) a Parse the response from `STRALGO` command. Without modifiers the returned value is string. When LEN is given the command returns the length of the result (i.e integer). When IDX is given the command returns a dictionary with the LCS length and all the ranges in both the strings, start and end offset for each string, where there are matches. When WITHMATCHLEN is given, each array representing a match will also have the length of the match at the beginning of the array. r,Fidx withmatchlenr&r1NrrrB)rrrGrutupler)r rwmatchmatchess r parse_stralgors{{5%  8}{{5%  ;;~u - -&a[(EeBi."T#eU3BZ*@%AA( G =EQKHK5tCu-.KGH ! %w ! %s8A;'7    !! Is 6C2#C7c "URSS5(a [U5$URSS5(aURSS5(aEUSVVs/sH2n[US5/USSVs/sHn[U5PM sn-PM4 nnnO0USVVs/sHo"Vs/sHn[U5PM snPM nnn[US5U[US 5[US 50$[U5$s snfs snnfs snfs snnf) z Parse STRALGO into the approved unified shape. The legacy parser returns tuple ranges for IDX responses. Unified responses use list ranges so RESP2 and RESP3 produce the same value. r,Frrr&r1NrrrB)rrrGr)r rwrmrs r parse_stralgo_unifiedrs{{5%  8}{{5%  ;;~u - -&a[(EU2Y U3BZ#@ZDGZ#@@( G >Fa[I[E/AQ/[GI ! %w ! %s8A;'7    !!$A 0Is0D4C; D D 'D <D ;DD c URSS5(a [U5$URSS5(a[U[5(d [ U5$URSURS/55nURSURSS55nURSS5(aBUVVs/sH2n[US 5/US S Vs/sHn[ U5PM sn-PM4 nnnO-UVVs/sHoDVs/sHn[ U5PM snPM nnnU[U5S .$[ U5$s snfs snnfs snfs snnf) zEParse RESP3 STRALGO into the same value as ``parse_stralgo_unified``.r,Frrsmatchesslenrrr1N)rr,)rrrFrrrG)r rw raw_matchesraw_lenrrrs r parse_stralgo_resp3_unifiedrs1{{5%  8}{{5%  (D))) )ll9hll:r.JK ,,uhll61&=> ;;~u - -)(EU2Y U3BZ#@ZDGZ#@@( G >II[E/AQ/[GI"3w<88  !! $A 0Is0:ED=* E< E E E =EE c X[U5n[SUR555$)Nc3T# UHo(dM URS5v M g7frr)rr<s r r%parse_cluster_info..1s J,ADT 3,As (()rrr6rvs r parse_cluster_infor/s&H%H JH,?,?,AJ JJr c hURS5nURS5SSup#pEpgpURS5Sn SU;a,SU;a&URS5SRS5SOSn UU UUUUU//U S:XaS OS S . n [U5S :a[USS5upXsU S 'U S'X4$)NrX@rr#r& connectedTF) node_idhostnamerh master_idlast_ping_sentlast_pong_rcvdepochslots migrationsr rr)rr, _parse_slots)r< line_itemsraddrrhrpingpongrripr node_dictrrs r _parse_node_liner4sCJDHJJsOTVUVDWAG5T C B36$;3$;tzz#q!'',Q/TVH&+5T5 I :!(AB86;3 'Il3 =r cX//p!UHnSU;a-USSRSS5upEURXESS.5 M6SU;a-USSRSS5upFURXFSS.5 MiURS5Vs/sHowPM nnURU5 M X4$s snf) Nz->-r&r1 migrating)slotrrz-<- importing-)rr:) slot_rangesrrs_rangeslot_id dst_node_id src_node_idsls r rrKsB: G #*1R=#6#6ua#@ G    ;O g #*1R=#6#6ua#@ G    ;O %,MM#$67$6br$6G7 LL !  8s B'c |[U[[45(aUR5n[ SU55$)z @see: https://redis.io/commands/cluster-nodes # string / bytes @see: https://redis.io/commands/cluster-replicas # list of string / bytes c3J# UHn[[U55v M g7frs)rr)rnodes r r&parse_cluster_nodes..fsJ d!344s!#)rFrrr6rrvs r parse_cluster_nodesr_s4 (S%L))&&( JJ JJr c US(d US(aU$[U[5(dU/nOUnUS(dUS(d US(dU$[S[S.nS/nUS Vs/sHoQU(dMX5PM sn- nUVs/sH"n[[ S [ XF555PM$ sn$![a Us$f=fs snfs snf) z Parse the response of 'GEOSEARCH', GEORADIUS' and 'GEORADIUSBYMEMBER' commands according to 'withdist', 'withhash' and 'withcoord' labels. store store_distwithdist withcoordwithhashc:[US5[US54$rrrs r )parse_geosearch_generic..r!uuRU| Parse GEOSEARCH/GEORADIUS responses using tuple coordinates. rrrrrc:[US5[US54$rrrs r r1parse_geosearch_generic_unified..rr rcU$rsrrs r rrsqr rcUS"US5$rrrs r rrrr r)r rwrrfuncsrrs r parse_geosearch_generic_unifiedrs 7 w|4O 5 !+8T : :H M : w{';GJDW< D ME D SD!PQ gdgD SSEGT U}!D,c%m< =} UU T Us#B9+ C <C  )C9 CCc 0nUHn0n[US5nXTS'[US5US'USVs/sHn[U5PM snUS'USUS'US US 'US US '[U5S :a"US Vs/sHn[U5PM snUS'[U5S:aUSUS'USUS'USUS'XBU'M U$s snfs snfNrrir&arityrrhrB first_key_posrz last_key_posr| step_countryacl_categoriesrtipsrkey_specificationsr subcommandsrrr,)r rwcommandsrxcmd_dictcmd_namerjcategorys r parse_commandrsH +# Oqz*7A8 X&z*H% & w>;KL;KZS S!5(;KL\4=9:DMStK/@ABD#D$45D$v,$$ 4<(G(GLf6<NO>Ndaa,q/1>NO 1!D  rj #))#.&)Wn '"(//':R/ #d7m+DO KEM"! P!s#J )#J%J>!JJJc Ucg[U[5(a\/nUHRn[USS5nURSS5n[ U5US'[ US5US'UR U5 MT U$[U5nU$)NT client-infor age-seconds)rFrGrDrparse_client_infor'r:rS)r rwr loglog_data client_infos r parse_acl_logrs(D!!C$S$5H",,}b9K&7 &DH] #',H],C&DH] # KK ! Kx  Kr c Ucg[U[5(d [U5$/nUHn[U[5(a/UR 5VVs0sHupE[ U5U_M nnnO [ USS5nURSS5n[U5US'[US5US'URU5 M U$s snnf)uRESP3-wire ACL LOG → today's RESP2 parsed shape. Each log entry arrives as a ``dict`` on RESP3 wire instead of a flat list of pairs; convert ``client-info`` from a string blob into the parsed ``dict`` and ``age-seconds`` to ``float`` so the Python shape matches what :func:`parse_acl_log` produces from RESP2 wire. Also used as the unified callback (Set D): the legacy and unified shapes coincide for ACL LOG. NTrrr) rFrGrSrrErrDrrr'r:)r rwr rr-r*rrs r #parse_acl_log_resp3_to_resp2_legacyr .s h % %x  D c4 7:yy{C{tq Q*{HCH$S$5Hll="5 "3K"@"'(?"@ H KDsCc Ucg[U[5(d [U5$/nUHn[U[5(a/UR 5VVs0sHupE[ U5U_M nnnO [ USS5nSU;a[US5US'SU;a[US5US'[UR 55HupxUS;dM [ U5Xg'M URU5 M U$s snnf)z4Parse RESP3 ACL LOG into the approved unified shape.NTrr)rr) rFrGrSrrErrDr'rr:) r rwr r0r-r*rr=r)s r parse_acl_log_resp3_unifiedr Js h % %x  D eT " "7<{{}E}tq Q*}HEH$UD$7H H $&+H],C&DH] # H $&78O&PH] #x~~/0JC88 ,U 3 1 H KFsC9c [U40UD6nUcU$URS5nU(aM[US[5(a5UVs/sH$n[ [ USSS2USSS255PM& snUS'U$s snf)uACL GETUSER → unified shape with selectors as ``list[dict]``. On RESP2 wire each selector arrives as a flat ``[k, v, k, v, …]`` list; pair them into dicts to match the RESP3 wire shape. Nrrrr&)rrrFrGrr)r rwr rrs r parse_acl_getuser_unifiedras X 1 1D | %IZ ! d33FO FO(DXadd^Xadd^4 5i [ K s+A9c &[U40UD6nUcU$URS5nU(aZ[US[5(aBUVVVs/sH-oDR 5VVs/sH oUHofPM M snnPM/ snnnUS'U$s snnfs snnnf)uRESP3-wire ACL GETUSER → today's RESP2 selectors as flat lists. Each selector arrives as a ``dict`` on RESP3 wire; flatten back to the interleaved ``[k, v, k, v, …]`` form produced by RESP2 wire. rr)rrrFrrE)r rwr rrrr,s r 'parse_acl_getuser_resp3_to_resp2_legacyrrs X 1 1D | %IZ ! d33MV MVNN, <,bTT, dbruageoblollsubidleomempsubqbufmultitot-memargv-mem qbuf-free)rstriprr)r)rr;r=int_keys r rrsm KU#))+113ZZ_  C4   !#&{';#rKrNrPrTrrorfrkrqrxr|rrrrrrrrrrrrrrrrDrnrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrr#r%r'r4r6r:r=r?rHrFrOrSrVr^r`rbrerirlrnrprrrrrrrrrrrrrrrrrr r rrrr"r*r,r.r1r6response_callbacksr7r8r9r:r;r<r=rr r r@s?$5$0f  VsCs  C  # #scS33#3 c!" C#$/6%= PNY  @!& , 3 37D7 1 & N P > P 9P&::   <  YY  ( : 5<' = >J "  /  *,6 "  @O 3:":"0"(K .(K!RHV2.**5* (V$8.""@ 76@  7r