o LjIT@sddlmZmZmZmZmZmZmZddlm Z ddl m Z m Z m Z mZmZmZmZmZmZddlmZdZdZdZd Zd Zd Zd Zd ZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)dZ*GdddZ+dS))Any AwaitableDictIterableListTupleoverload) DataError) AsyncClientProtocol EncodableTKeyTNumberSyncClientProtocolTimeSeriesMRangeResponseTimeSeriesNRangeResponseTimeSeriesRangeResponseTimeSeriesSample)TSInfozTS.ADDzTS.ALTERz TS.CREATERULEz TS.CREATEz TS.DECRBYz TS.DELETERULEzTS.DELzTS.GETz TS.INCRBYzTS.INFOzTS.MADDzTS.MGETz TS.MRANGEz TS.MREVRANGEz TS.NRANGEz TS.NREVRANGEz TS.QUERYINDEXzTS.QUERYLABELSzTS.RANGEzTS.READz TS.REVRANGEc+@seZdZdZe       ddedededBdedBde e e fdBd edBd e dBd edBd e dBd efddZ e       dde dededBdedBde e e fdBd edBd e dBd edBd e dBd eefddZ       ddededBdedBde e e fdBd edBd e dBd edBd e dBd eeeBfddZ e      ddedededBde e e fdBd edBd e dBd edBd e dBd efddZe      dde dededBde e e fdBd edBd e dBd edBd e dBd eefddZ      ddededBde e e fdBd edBd e dBd edBd e dBd eeeBfddZe        ddededee Bde e BdedBdedBde e e fdBd edBd e dBd edBd e dBde dBd efddZe        dde dedee Bde e BdedBdedBde e e fdBd edBd e dBd edBd e dBde dBd eefddZ        ddedee Bde e BdedBdedBde e e fdBd edBd e dBd edBd e dBde dBd eeeBfddZededeeeee Be e Bfd eefddZede deeeee Be e Bfd eeefd dZdeeeee Be e Bfd eeeeeBfd!dZe        ddedede dee BdBdedBdedBde e e fdBd edBd e dBd edBd e dBd efd"d#Ze        dde dede dee BdBdedBdedBde e e fdBd edBd e dBd edBd e dBd eefd$d#Z        ddede dee BdBdedBdedBde e e fdBd edBd e dBd edBd e dBd eeeBfd%d#Ze        ddedede dee BdBdedBdedBde e e fdBd edBd e dBd edBd e dBd efd&d'Ze        dde dede dee BdBdedBdedBde e e fdBd edBd e dBd edBd e dBd eefd(d'Z        ddede dee BdBdedBdedBde e e fdBd edBd e dBd edBd e dBd eeeBfd)d'Zededed*ed+ed ef d,d-Zede ded*ed+ed eef d.d-Zded*ed+ed eeeBfd/d-Ze dded0ed1ed2e d3ed4edBd efd5d6Ze dde d0ed1ed2e d3ed4edBd eefd7d6Z dd0ed1ed2e d3ed4edBd eeeBf d8d6Zeded0ed1ed efd9d:Zede d0ed1ed eefd;d:Zd0ed1ed eeeBfdeedBd?edBd@edBdAee BdBdBedBdCe dBdDedBfdEdFZe   G       ddeded*ee Bd+ee Bd=edBd2e ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd efdHdIZe   G       dde ded*ee Bd+ee Bd=edBd2e ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd eefdJdIZ   G       dded*ee Bd+ee Bd=edBd2e ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd eeeBfdKdIZe   G       ddeded*ee Bd+ee Bd=edBd2e ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd efdLdMZe   G       dde ded*ee Bd+ee Bd=edBd2e ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd eefdNdMZ   G       dded*ee Bd+ee Bd=edBd2e ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd eeeBfdOdMZe   ddededee BdPedBdQedBdRedBd efdSdTZe   dde dedee BdPedBdQedBdRedBd eefdUdTZ   ddedee BdPedBdQedBdRedBd eeeBf dVdTZdWeed*ee Bd+ee Bd=edBdXe ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBfdYdZZe   G       ddedWeed*ee Bd+ee Bd=edBdXe ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd e fd[d\Z!e   G       dde dWeed*ee Bd+ee Bd=edBdXe ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd ee fd]d\Z!   G       ddWeed*ee Bd+ee Bd=edBdXe ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd e ee Bfd^d\Z!e   G       ddedWeed*ee Bd+ee Bd=edBdXe ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd e fd_d`Z"e   G       dde dWeed*ee Bd+ee Bd=edBdXe ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd ee fdad`Z"   G       ddWeed*ee Bd+ee Bd=edBdXe ee BdBd3edBd>eedBd?edBd@edBdAee BdBdBedBdCe dBdDedBd e ee Bfdbd`Z"d2e ee BdBd3edBd=edBdcee d*ee Bd+ee BddedBd>eedBd?edBd@edBdee dBdfe dBdgee dBdAee BdBdBedBdCe dBdDedBdhedBf$didjZ#e   G            dded*ee Bd+ee Bdcee d=edBd2e ee BdBd3edBddedBd>eedBd?edBd@edBdee dBdfe dBdgee dBdAee BdBdBedBdCe dBdDedBdhedBd e$f(dkdlZ%e   G            dde d*ee Bd+ee Bdcee d=edBd2e ee BdBd3edBddedBd>eedBd?edBd@edBdee dBdfe dBdgee dBdAee BdBdBedBdCe dBdDedBdhedBd ee$f(dmdlZ%   G            dd*ee Bd+ee Bdcee d=edBd2e ee BdBd3edBddedBd>eedBd?edBd@edBdee dBdfe dBdgee dBdAee BdBdBedBdCe dBdDedBdhedBd e$ee$Bf&dndlZ%e   G            dded*ee Bd+ee Bdcee d=edBd2e ee BdBd3edBddedBd>eedBd?edBd@edBdee dBdfe dBdgee dBdAee BdBdBedBdCe dBdDedBdhedBd e$f(dodpZ&e   G            dde d*ee Bd+ee Bdcee d=edBd2e ee BdBd3edBddedBd>eedBd?edBd@edBdee dBdfe dBdgee dBdAee BdBdBedBdCe dBdDedBdhedBd ee$f(dqdpZ&   G            dd*ee Bd+ee Bdcee d=edBd2e ee BdBd3edBddedBd>eedBd?edBd@edBdee dBdfe dBdgee dBdAee BdBdBedBdCe dBdDedBdhedBd e$ee$Bf&drdpZ&e ddededBedBd e'dBfdsdtZ(e dde dedBedBd ee'dBfdudtZ(ddedBedBd e'dBee'dBBfdvdtZ(e   ddedcee ddedBdgee dBdBedBd ee)e*e ee)fBf dwdxZ+e   dde dcee ddedBdgee dBdBedBd eee)e*e ee)fBf dydxZ+   ddcee ddedBdgee dBdBedBd ee)e*e ee)fBeee)e*e ee)fBBf dzdxZ+ededed e,e*e e)fBfd{d|Z-ede ded ee,e*e e)fBfd}d|Z-ded e,e*e e)fBee,e*e e)fBBfd~d|Z-ededcee d ee.e BfddZ/ede dcee d eee.e BfddZ/dcee d ee.e Beee.e BBfddZ/e  ddede dBdce0e dBd e1e.e BfddZ2e  dde de dBdce0e dBd ee1e.e BfddZ2 dde dBdce0e dBd e1e.e Bee1e.e BBfddZ2e3dee4dce0e dBfddZ5e3dee4dedBfddZ6e3dee4ddedBdgee dBfddZ7e3dee4dee dBdfe dBfddZ8e3dee4dedBfddZ9e3dee4de*e e fdBfddZ:e3dee4d=edBfddZ;e3dee4dPedBdQedBfddZe3dee4dAee BdBfddZ?e3dee4d2e ee BdBd3edBfddZ@e3dee4dXe ee BdBd3edBdefddZAe3dee4d edBfddZBe3dee4d e dBfddZCe3dee4de dBfddZDe3dee4deedBfddZEe3dee4dedBdedBfddZFe3dee4dBedBfddZGe3dee4dCe dBfddZHe3dee4dDedBfddZIe3dee4dhedBfddZJe3  ddee4d edBd e dBfddZKdS)TimeSeriesCommandszRedisTimeSeries Commands.NFselfkeyretention_msecs uncompressedlabels chunk_sizeduplicate_policyignore_max_time_diffignore_max_val_diffreturnc CdSN rrrrrrrrrr"r"`/home/djax/ivt_ai_plugin/venv/lib/python3.10/site-packages/redis/commands/timeseries/commands.pycreate, zTimeSeriesCommands.createc Cr r!r"r#r"r"r$r%9r&c Csb|g} || ||| ||| ||| ||| ||| |||jtg| RS)a9 Create a new time-series. For more information see https://redis.io/commands/ts.create/ Args: key: The time-series key. retention_msecs: Maximum age for samples, compared to the highest reported timestamp in milliseconds. If `None` or `0` is passed, the series is not trimmed at all. uncompressed: Changes data storage from compressed (default) to uncompressed. labels: A dictionary of label-value pairs that represent metadata labels of the key. chunk_size: Memory size, in bytes, allocated for each data chunk. Must be a multiple of 8 in the range `[48..1048576]`. In earlier versions of the module the minimum value was different. duplicate_policy: Policy for handling multiple samples with identical timestamps. Can be one of: - 'block': An error will occur and the new value will be ignored. - 'first': Ignore the new value. - 'last': Override with the latest value. - 'min': Only override if the value is lower than the existing value. - 'max': Only override if the value is higher than the existing value. - 'sum': If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new). If no previous sample exists, set the updated value equal to the new value. ignore_max_time_diff: A non-negative integer value, in milliseconds, that sets an ignore threshold for added timestamps. If the difference between the last timestamp and the new timestamp is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_val_diff` is also set. Available since RedisTimeSeries version 1.12.0. ignore_max_val_diff: A non-negative floating point value, that sets an ignore threshold for added values. If the difference between the last value and the new value is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_time_diff` is also set. Available since RedisTimeSeries version 1.12.0. )_append_retention_append_uncompressed_append_chunk_size_append_duplicate_policy_append_labels_append_insertion_filtersexecute_command CREATE_CMD) rrrrrrrrrparamsr"r"r$r%Fs<     cCr r!r"rrrrrrrrr"r"r$alter zTimeSeriesCommands.altercCr r!r"r0r"r"r$r1r2c CsV|g}|||||||||||||||||jtg|RS)a Update an existing time series. For more information see https://redis.io/commands/ts.alter/ Args: key: The time-series key. retention_msecs: Maximum age for samples, compared to the highest reported timestamp in milliseconds. If `None` or `0` is passed, the series is not trimmed at all. labels: A dictionary of label-value pairs that represent metadata labels of the key. chunk_size: Memory size, in bytes, allocated for each data chunk. Must be a multiple of 8 in the range `[48..1048576]`. In earlier versions of the module the minimum value was different. Changing this value does not affect existing chunks. duplicate_policy: Policy for handling multiple samples with identical timestamps. Can be one of: - 'block': An error will occur and the new value will be ignored. - 'first': Ignore the new value. - 'last': Override with the latest value. - 'min': Only override if the value is lower than the existing value. - 'max': Only override if the value is higher than the existing value. - 'sum': If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new). If no previous sample exists, set the updated value equal to the new value. ignore_max_time_diff: A non-negative integer value, in milliseconds, that sets an ignore threshold for added timestamps. If the difference between the last timestamp and the new timestamp is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_val_diff` is also set. Available since RedisTimeSeries version 1.12.0. ignore_max_val_diff: A non-negative floating point value, that sets an ignore threshold for added values. If the difference between the last value and the new value is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_time_diff` is also set. Available since RedisTimeSeries version 1.12.0. )r'r)r*r+r,r- ALTER_CMD) rrrrrrrrr/r"r"r$r1s:     timestampvalue on_duplicatec Cr r!r" rrr4r5rrrrrrrr6r"r"r$addzTimeSeriesCommands.addc Cr r!r"r7r"r"r$r8r9c Csr|||g} || ||| ||| ||| ||| ||| | | || | |jtg| RS)a Append a sample to a time series. When the specified key does not exist, a new time series is created. For more information see https://redis.io/commands/ts.add/ Args: key: The time-series key. timestamp: Timestamp of the sample. `*` can be used for automatic timestamp (using the system clock). value: Numeric data value of the sample. retention_msecs: Maximum age for samples, compared to the highest reported timestamp in milliseconds. If `None` or `0` is passed, the series is not trimmed at all. uncompressed: Changes data storage from compressed (default) to uncompressed. labels: A dictionary of label-value pairs that represent metadata labels of the key. chunk_size: Memory size, in bytes, allocated for each data chunk. Must be a multiple of 8 in the range `[48..1048576]`. In earlier versions of the module the minimum value was different. duplicate_policy: Policy for handling multiple samples with identical timestamps. Can be one of: - 'block': An error will occur and the new value will be ignored. - 'first': Ignore the new value. - 'last': Override with the latest value. - 'min': Only override if the value is lower than the existing value. - 'max': Only override if the value is higher than the existing value. - 'sum': If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new). If no previous sample exists, set the updated value equal to the new value. ignore_max_time_diff: A non-negative integer value, in milliseconds, that sets an ignore threshold for added timestamps. If the difference between the last timestamp and the new timestamp is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_val_diff` is also set. Available since RedisTimeSeries version 1.12.0. ignore_max_val_diff: A non-negative floating point value, that sets an ignore threshold for added values. If the difference between the last value and the new value is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_time_diff` is also set. Available since RedisTimeSeries version 1.12.0. on_duplicate: Use a specific duplicate policy for the specified timestamp. Overrides the duplicate policy set by `duplicate_policy`. ) r'r(r)r*r+r,_append_on_duplicater-ADD_CMD) rrr4r5rrrrrrrr6r/r"r"r$r8 s H       ktv_tuplescCr r!r"rr<r"r"r$madd`zTimeSeriesCommands.maddcCr r!r"r=r"r"r$r>fr?cCs*g}|D]}||q|jtg|RS)ay Append new samples to one or more time series. Each time series must already exist. The method expects a list of tuples. Each tuple should contain three elements: (`key`, `timestamp`, `value`). The `value` will be appended to the time series identified by 'key', at the given 'timestamp'. For more information see https://redis.io/commands/ts.madd/ Args: ktv_tuples: A list of tuples, where each tuple contains: - `key`: The key of the time series. - `timestamp`: The timestamp at which the value should be appended. - `value`: The value to append to the time series. Returns: A list that contains, for each sample, either the timestamp that was used, or an error, if the sample could not be added. )extendr-MADD_CMD)rr<r/ktvr"r"r$r>ls c Cr r!r" rrr5r4rrrrrrrr"r"r$incrby zTimeSeriesCommands.incrbyc Cr r!r"rCr"r"r$rDrEc Cp||g} || ||| ||| ||| ||| ||| ||| | | |jtg| RS)a Increment the latest sample's of a series. When the specified key does not exist, a new time series is created. This command can be used as a counter or gauge that automatically gets history as a time series. For more information see https://redis.io/commands/ts.incrby/ Args: key: The time-series key. value: Numeric value to be added (addend). timestamp: Timestamp of the sample. `*` can be used for automatic timestamp (using the system clock). `timestamp` must be equal to or higher than the maximum existing timestamp in the series. When equal, the value of the sample with the maximum existing timestamp is increased. If it is higher, a new sample with a timestamp set to `timestamp` is created, and its value is set to the value of the sample with the maximum existing timestamp plus the addend. retention_msecs: Maximum age for samples, compared to the highest reported timestamp in milliseconds. If `None` or `0` is passed, the series is not trimmed at all. uncompressed: Changes data storage from compressed (default) to uncompressed. labels: A dictionary of label-value pairs that represent metadata labels of the key. chunk_size: Memory size, in bytes, allocated for each data chunk. Must be a multiple of 8 in the range `[48..1048576]`. In earlier versions of the module the minimum value was different. duplicate_policy: Policy for handling multiple samples with identical timestamps. Can be one of: - 'block': An error will occur and the new value will be ignored. - 'first': Ignore the new value. - 'last': Override with the latest value. - 'min': Only override if the value is lower than the existing value. - 'max': Only override if the value is higher than the existing value. - 'sum': If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new). If no previous sample exists, set the updated value equal to the new value. ignore_max_time_diff: A non-negative integer value, in milliseconds, that sets an ignore threshold for added timestamps. If the difference between the last timestamp and the new timestamp is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_val_diff` is also set. Available since RedisTimeSeries version 1.12.0. ignore_max_val_diff: A non-negative floating point value, that sets an ignore threshold for added values. If the difference between the last value and the new value is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_time_diff` is also set. Available since RedisTimeSeries version 1.12.0. Returns: The timestamp of the sample that was modified or added. ) _append_timestampr'r(r)r*r+r,r- INCRBY_CMD rrr5r4rrrrrrrr/r"r"r$rDO      c Cr r!r"rCr"r"r$decrbyrEzTimeSeriesCommands.decrbyc Cr r!r"rCr"r"r$rKrEc CrF)a Decrement the latest sample's of a series. When the specified key does not exist, a new time series is created. This command can be used as a counter or gauge that automatically gets history as a time series. For more information see https://redis.io/commands/ts.decrby/ Args: key: The time-series key. value: Numeric value to subtract (subtrahend). timestamp: Timestamp of the sample. `*` can be used for automatic timestamp (using the system clock). `timestamp` must be equal to or higher than the maximum existing timestamp in the series. When equal, the value of the sample with the maximum existing timestamp is decreased. If it is higher, a new sample with a timestamp set to `timestamp` is created, and its value is set to the value of the sample with the maximum existing timestamp minus subtrahend. retention_msecs: Maximum age for samples, compared to the highest reported timestamp in milliseconds. If `None` or `0` is passed, the series is not trimmed at all. uncompressed: Changes data storage from compressed (default) to uncompressed. labels: A dictionary of label-value pairs that represent metadata labels of the key. chunk_size: Memory size, in bytes, allocated for each data chunk. Must be a multiple of 8 in the range `[48..1048576]`. In earlier versions of the module the minimum value was different. duplicate_policy: Policy for handling multiple samples with identical timestamps. Can be one of: - 'block': An error will occur and the new value will be ignored. - 'first': Ignore the new value. - 'last': Override with the latest value. - 'min': Only override if the value is lower than the existing value. - 'max': Only override if the value is higher than the existing value. - 'sum': If a previous sample exists, add the new sample to it so that the updated value is equal to (previous + new). If no previous sample exists, set the updated value equal to the new value. ignore_max_time_diff: A non-negative integer value, in milliseconds, that sets an ignore threshold for added timestamps. If the difference between the last timestamp and the new timestamp is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_val_diff` is also set. Available since RedisTimeSeries version 1.12.0. ignore_max_val_diff: A non-negative floating point value, that sets an ignore threshold for added values. If the difference between the last value and the new value is lower than this threshold, the new entry is ignored. Only applicable if `duplicate_policy` is set to `last`, and if `ignore_max_time_diff` is also set. Available since RedisTimeSeries version 1.12.0. Returns: The timestamp of the sample that was modified or added. ) rGr'r(r)r*r+r,r- DECRBY_CMDrIr"r"r$rK#rJ from_timeto_timecCr r!r"rrrMrNr"r"r$deletezTimeSeriesCommands.deletecCr r!r"rOr"r"r$rPrQcCs|t|||S)aP Delete all samples between two timestamps for a given time series. The given timestamp interval is closed (inclusive), meaning that samples whose timestamp equals `from_time` or `to_time` are also deleted. For more information see https://redis.io/commands/ts.del/ Args: key: The time-series key. from_time: Start timestamp for the range deletion. to_time: End timestamp for the range deletion. Returns: The number of samples deleted. )r-DEL_CMDrOr"r"r$rPs source_keydest_keyaggregation_typebucket_size_msecalign_timestampcCr r!r"rrSrTrUrVrWr"r"r$ createrulezTimeSeriesCommands.createrulecCr r!r"rXr"r"r$rYrZcCs:||g}|||||dur|||jtg|RS)aT Create a compaction rule from values added to `source_key` into `dest_key`. For more information see https://redis.io/commands/ts.createrule/ Args: source_key: Key name for source time series. dest_key: Key name for destination (compacted) time series. aggregation_type: Aggregation type: One of the following: [`avg`, `sum`, `min`, `max`, `range`, `count`, `first`, `last`, `std.p`, `std.s`, `var.p`, `var.s`, `twa`, 'countNaN', 'countAll'] bucket_size_msec: Duration of each bucket, in milliseconds. align_timestamp: Assure that there is a bucket that starts at exactly align_timestamp and align all other buckets accordingly. N)_append_aggregationappendr-CREATERULE_CMD)rrSrTrUrVrWr/r"r"r$rYs  cCr r!r"rrSrTr"r"r$ deleterulerQzTimeSeriesCommands.deleterulecCr r!r"r^r"r"r$r_rQcCs|t||S)z Delete a compaction rule from `source_key` to `dest_key`. For more information see https://redis.io/commands/ts.deleterule/ )r-DELETERULE_CMDr^r"r"r$r_scount filter_by_tsfilter_by_min_valuefilter_by_max_valuealignlatestbucket_timestampemptycCsr|||g}||| ||||||| |||||| ||||||| ||| |S)z*Create TS.RANGE and TS.REVRANGE arguments.)_append_latest_append_filer_by_ts_append_filer_by_value _append_count _append_alignr[_append_bucket_timestamp _append_emptyrrrMrNrarUrVrbrcrdrerfrgrhr/r"r"r$__range_paramss       z!TimeSeriesCommands.__range_paramsrcCr r!r"rrrMrNrarUrVrbrcrdrerfrgrhr"r"r$rangezTimeSeriesCommands.rangecCr r!r"rrr"r"r$rsrtcC<|||||||||| | | | | }|jtg|Rd|giS)a Query a range in forward direction for a specific time-series. For more information see https://redis.io/commands/ts.range/ Args: key: Key name for timeseries. from_time: Start timestamp for the range query. `-` can be used to express the minimum possible timestamp (0). to_time: End timestamp for range query, `+` can be used to express the maximum possible timestamp. count: Limits the number of returned samples. aggregation_type: Optional aggregation type. Can be a single string or a list of strings for multiple aggregators (requires Redis 8.8+). Valid values: [`avg`, `sum`, `min`, `max`, `range`, `count`, `first`, `last`, `std.p`, `std.s`, `var.p`, `var.s`, `twa`, `countNaN`, `countAll`]. When a list is passed, each sample in the response contains values in the same order as the specified aggregators. bucket_size_msec: Time bucket for aggregation in milliseconds. filter_by_ts: List of timestamps to filter the result by specific timestamps. filter_by_min_value: Filter result by minimum value (must mention also `filter by_max_value`). filter_by_max_value: Filter result by maximum value (must mention also `filter by_min_value`). align: Timestamp for alignment control for aggregation. latest: Used when a time series is a compaction, reports the compacted value of the latest possibly partial bucket. bucket_timestamp: Controls how bucket timestamps are reported. Can be one of [`-`, `low`, `+`, `high`, `~`, `mid`]. empty: Reports aggregations for empty buckets. keys)!_TimeSeriesCommands__range_paramsr- RANGE_CMDrpr"r"r$rs)s <cCr r!r"rrr"r"r$revrangevrtzTimeSeriesCommands.revrangecCr r!r"rrr"r"r$ryrtcCru)aZ Query a range in reverse direction for a specific time-series. **Note**: This command is only available since RedisTimeSeries >= v1.4 For more information see https://redis.io/commands/ts.revrange/ Args: key: Key name for timeseries. from_time: Start timestamp for the range query. `-` can be used to express the minimum possible timestamp (0). to_time: End timestamp for range query, `+` can be used to express the maximum possible timestamp. count: Limits the number of returned samples. aggregation_type: Optional aggregation type. Can be a single string or a list of strings for multiple aggregators (requires Redis 8.8+). Valid values: [`avg`, `sum`, `min`, `max`, `range`, `count`, `first`, `last`, `std.p`, `std.s`, `var.p`, `var.s`, `twa`, `countNaN`, `countAll`]. When a list is passed, each sample in the response contains values in the same order as the specified aggregators. bucket_size_msec: Time bucket for aggregation in milliseconds. filter_by_ts: List of timestamps to filter the result by specific timestamps. filter_by_min_value: Filter result by minimum value (must mention also `filter_by_max_value`). filter_by_max_value: Filter result by maximum value (must mention also `filter_by_min_value`). align: Timestamp for alignment control for aggregation. latest: Used when a time series is a compaction, reports the compacted value of the latest possibly partial bucket. bucket_timestamp: Controls how bucket timestamps are reported. Can be one of [`-`, `low`, `+`, `high`, `~`, `mid`]. empty: Reports aggregations for empty buckets. rv)rwr- REVRANGE_CMDrpr"r"r$rys >block_millisecondsblock_min_count max_countcCr r!r"rrr4r{r|r}r"r"r$readrZzTimeSeriesCommands.readcCr r!r"r~r"r"r$rrZcCs<||g}||||||||jtg|Rd|giS)a Read a batch of samples with timestamps at or after `timestamp`, in ascending timestamp order. Without blocking, returns immediately with whatever qualifies (possibly an empty list). With the `block_milliseconds` group, waits until at least `block_min_count` qualifying samples exist or until the timeout elapses. This allows consuming historical and newly-appended samples continuously, in batches, without polling `TS.RANGE`. For more information see https://redis.io/commands/ts.read/ Args: key: Key name for the time series (a regular series or a compaction destination). timestamp: Inclusive cursor. Samples with `timestamp >= timestamp` qualify. A non-negative integer (Unix milliseconds, `0` reads from the beginning) or one of the sentinels `-` (earliest), `+` (latest existing sample, inclusive) or `$` (only samples added after the command is received). Sentinels are sent to the server as-is and resolved server-side; `$` is only meaningful together with `block_milliseconds`, since nothing can qualify at execution time without blocking. block_milliseconds: Opt into blocking. Maximum time to wait, in whole milliseconds; a non-negative integer where `0` means wait indefinitely. When `None` (default) the command does not block. block_min_count: The unblock threshold: the call returns once this many samples qualify. A positive integer, defaulting to `1` when blocking is requested. Only used when `block_milliseconds` is set; the value is always emitted on the wire inside the BLOCK group. max_count: Reply cap, a positive integer. When more samples qualify than `max_count`, the oldest `max_count` are returned so callers can page forward. `None` (default) means unlimited. Returns: A list of `[timestamp, value]` samples in ascending timestamp order. An empty list is a successful reply (returned when nothing qualifies, or when a blocking call times out with nothing available). .. warning:: A blocking call keeps the connection parked for up to `block_milliseconds`. The client's `socket_timeout` still applies: with the default (5 seconds) a longer block raises `TimeoutError` before the server replies. When using `block_milliseconds`, configure the client with a `socket_timeout` larger than the block window (or `None`), as with other blocking commands. This command must not be retried automatically after an empty or partial reply. rv) _append_block_append_max_countr-READ_CMD)rrr4r{r|r}r/r"r"r$rs= rv aggregatorscCs|stdt|g|||}||| ||||||| |||||| ||||t|||| | || |S)z,Create TS.NRANGE and TS.NREVRANGE arguments.z"At least one key must be provided.) r lenrirjrkrlrm_append_n_aggregationrnrorrvrMrNrarrVrbrcrdrerfrgrhr/r"r"r$__n_range_params@s      z#TimeSeriesCommands.__n_range_paramscCr r!r"rrvrMrNrarrVrbrcrdrerfrgrhr"r"r$nrangeartzTimeSeriesCommands.nrangecCr r!r"rr"r"r$rsrtcC>|||||||||| | | | | }|jtg|Rdt|iS)aQ Query an explicit list of time-series over a range in forward direction and return timestamp-major rows ordered by increasing timestamp. Each returned row is ``[timestamp, [value, ...]]``. With no aggregation -- or a single-aggregator spec per key -- the value array holds exactly one value per queried key, in the input ``keys`` order. When a per-key AGGREGATION spec lists several aggregators (e.g. ``"avg,max"``), that key contributes one value per aggregator in the order the aggregators were listed, and the row's value array is those per-key blocks concatenated in ``keys`` order. For example ``keys=[a, b]`` with ``aggregators=["avg,max", "sum"]`` yields ``[a_avg, a_max, b_sum]`` for every row. A key (or aggregator column) with no sample or aggregation bucket at a row's timestamp is reported as ``NaN``, which is indistinguishable from a stored or aggregated ``NaN``. All keys must hash to the same slot when used against a cluster; this command is routed as a single-shard, key command and is never split across shards. For more information see https://redis.io/commands/ts.nrange/ Args: keys: Explicit list of time-series keys. Order and duplicate keys are significant: the output column order maps to the input key order, and duplicate keys produce repeated value columns. from_time: Start timestamp for the range query. `-` can be used to express the minimum possible timestamp (0). to_time: End timestamp for range query, `+` can be used to express the maximum possible timestamp. count: Limits the number of returned rows, applied after the merge in increasing-timestamp order. aggregators: Optional aggregation, with exactly one spec token per key (a single aggregator is never broadcast across keys). Each per-key spec is a string and may list several comma-separated aggregators, e.g. ``["avg,max", "sum"]`` builds ``AGGREGATION avg,max sum`` for two keys. A bare string is the spec for a single-key query; a number of specs that differs from ``keys`` raises ``DataError``. Valid aggregators: [`avg`, `sum`, `min`, `max`, `range`, `count`, `first`, `last`, `std.p`, `std.s`, `var.p`, `var.s`, `twa`, `countNaN`, `countAll`]. bucket_size_msec: Time bucket for aggregation in milliseconds. Shared by all keys. filter_by_ts: List of timestamps to keep before merging. filter_by_min_value: Keep only values greater than or equal to this value before merging (must also set `filter_by_max_value`). filter_by_max_value: Keep only values less than or equal to this value before merging (must also set `filter_by_min_value`). align: Timestamp for alignment control for aggregation. latest: Used when a time series is a compaction, reports the compacted value of the latest possibly partial bucket. bucket_timestamp: Controls how bucket timestamps are reported. Can be one of [`-`, `low`, `+`, `high`, `~`, `mid`]. empty: Reports aggregations for empty buckets. rv)#_TimeSeriesCommands__n_range_paramsr- NRANGE_CMDlistrr"r"r$r ScCr r!r"rr"r"r$ nrevrangertzTimeSeriesCommands.nrevrangecCr r!r"rr"r"r$rrtcCr)aT Query an explicit list of time-series over a range in reverse direction and return timestamp-major rows ordered by decreasing timestamp. Each returned row is ``[timestamp, [value, ...]]``. With no aggregation -- or a single-aggregator spec per key -- the value array holds exactly one value per queried key, in the input ``keys`` order. When a per-key AGGREGATION spec lists several aggregators (e.g. ``"avg,max"``), that key contributes one value per aggregator in the order the aggregators were listed, and the row's value array is those per-key blocks concatenated in ``keys`` order. For example ``keys=[a, b]`` with ``aggregators=["avg,max", "sum"]`` yields ``[a_avg, a_max, b_sum]`` for every row. A key (or aggregator column) with no sample or aggregation bucket at a row's timestamp is reported as ``NaN``, which is indistinguishable from a stored or aggregated ``NaN``. All keys must hash to the same slot when used against a cluster; this command is routed as a single-shard, key command and is never split across shards. For more information see https://redis.io/commands/ts.nrevrange/ Args: keys: Explicit list of time-series keys. Order and duplicate keys are significant: the output column order maps to the input key order, and duplicate keys produce repeated value columns. from_time: Start timestamp for the range query. `-` can be used to express the minimum possible timestamp (0). to_time: End timestamp for range query, `+` can be used to express the maximum possible timestamp. count: Limits the number of returned rows, applied after the merge in decreasing-timestamp order. aggregators: Optional aggregation, with exactly one spec token per key (a single aggregator is never broadcast across keys). Each per-key spec is a string and may list several comma-separated aggregators, e.g. ``["avg,max", "sum"]`` builds ``AGGREGATION avg,max sum`` for two keys. A bare string is the spec for a single-key query; a number of specs that differs from ``keys`` raises ``DataError``. Valid aggregators: [`avg`, `sum`, `min`, `max`, `range`, `count`, `first`, `last`, `std.p`, `std.s`, `var.p`, `var.s`, `twa`, `countNaN`, `countAll`]. bucket_size_msec: Time bucket for aggregation in milliseconds. Shared by all keys. filter_by_ts: List of timestamps to keep before merging. filter_by_min_value: Keep only values greater than or equal to this value before merging (must also set `filter_by_max_value`). filter_by_max_value: Keep only values less than or equal to this value before merging (must also set `filter_by_min_value`). align: Timestamp for alignment control for aggregation. latest: Used when a time series is a compaction, reports the compacted value of the latest possibly partial bucket. bucket_timestamp: Controls how bucket timestamps are reported. Can be one of [`-`, `low`, `+`, `high`, `~`, `mid`]. empty: Reports aggregations for empty buckets. rv)rr- NREVRANGE_CMDrrr"r"r$r rfilters with_labelsgroupbyreduce select_labels exclude_emptycCs| durt|trt|dkrtd|r| durtd||g}||||||||| | |||| |||| ||| |||| ||| ||| |||dg||7}||| | |S)z,Create TS.MRANGE and TS.MREVRANGE arguments.Nrz>GROUPBY is not allowed when multiple aggregators are specifiedz(EXCLUDEEMPTY is not allowed with GROUPBYFILTER) isinstancerrr rirjrk_append_with_labelsrlrmr[rnro_append_exclude_emptyr@_append_groupby_reduce)rrUrVrarrMrNrrbrcrdrrrrerfrgrhrr/r"r"r$__mrange_paramsqs0          z"TimeSeriesCommands.__mrange_paramscCr r!r"rrMrNrrarUrVrrbrcrdrrrrerfrgrhrr"r"r$mrangezTimeSeriesCommands.mrangecCr r!r"rr"r"r$rrcCD|||||||||| | | | | |||||}|jtg|Rd|iS)ay Query a range across multiple time-series by filters in forward direction. For more information see https://redis.io/commands/ts.mrange/ Args: from_time: Start timestamp for the range query. `-` can be used to express the minimum possible timestamp (0). to_time: End timestamp for range query, `+` can be used to express the maximum possible timestamp. filters: Filter to match the time-series labels. count: Limits the number of returned samples. aggregation_type: Optional aggregation type. Can be a single string or a list of strings for multiple aggregators (requires Redis 8.8+). Valid values: [`avg`, `sum`, `min`, `max`, `range`, `count`, `first`, `last`, `std.p`, `std.s`, `var.p`, `var.s`, `twa`, `countNaN`, `countAll`]. When a list is passed, each sample in the response contains values in the same order as the specified aggregators. Note: GROUPBY is not allowed when multiple aggregators are specified. bucket_size_msec: Time bucket for aggregation in milliseconds. with_labels: Include in the reply all label-value pairs representing metadata labels of the time series. filter_by_ts: List of timestamps to filter the result by specific timestamps. filter_by_min_value: Filter result by minimum value (must mention also `filter_by_max_value`). filter_by_max_value: Filter result by maximum value (must mention also `filter_by_min_value`). groupby: Grouping by fields the results (must mention also `reduce`). reduce: Applying reducer functions on each group. Can be one of [`avg` `sum`, `min`, `max`, `range`, `count`, `std.p`, `std.s`, `var.p`, `var.s`]. select_labels: Include in the reply only a subset of the key-value pair labels of a series. align: Timestamp for alignment control for aggregation. latest: Used when a time series is a compaction, reports the compacted value of the latest possibly partial bucket. bucket_timestamp: Controls how bucket timestamps are reported. Can be one of [`-`, `low`, `+`, `high`, `~`, `mid`]. empty: Reports aggregations for empty buckets. exclude_empty: Omit matching series whose reported samples array is empty for the queried range and options. Must not be combined with `groupby`. rU)"_TimeSeriesCommands__mrange_paramsr- MRANGE_CMDrrMrNrrarUrVrrbrcrdrrrrerfrgrhrr/r"r"r$r6PcCr r!r"rr"r"r$ mrevrange8rzTimeSeriesCommands.mrevrangecCr r!r"rr"r"r$rOrcCr)a| Query a range across multiple time-series by filters in reverse direction. For more information see https://redis.io/commands/ts.mrevrange/ Args: from_time: Start timestamp for the range query. '-' can be used to express the minimum possible timestamp (0). to_time: End timestamp for range query, '+' can be used to express the maximum possible timestamp. filters: Filter to match the time-series labels. count: Limits the number of returned samples. aggregation_type: Optional aggregation type. Can be a single string or a list of strings for multiple aggregators (requires Redis 8.8+). Valid values: [`avg`, `sum`, `min`, `max`, `range`, `count`, `first`, `last`, `std.p`, `std.s`, `var.p`, `var.s`, `twa`, `countNaN`, `countAll`]. When a list is passed, each sample in the response contains values in the same order as the specified aggregators. Note: GROUPBY is not allowed when multiple aggregators are specified. bucket_size_msec: Time bucket for aggregation in milliseconds. with_labels: Include in the reply all label-value pairs representing metadata labels of the time series. filter_by_ts: List of timestamps to filter the result by specific timestamps. filter_by_min_value: Filter result by minimum value (must mention also `filter_by_max_value`). filter_by_max_value: Filter result by maximum value (must mention also `filter_by_min_value`). groupby: Grouping by fields the results (must mention also `reduce`). reduce: Applying reducer functions on each group. Can be one of [`avg` `sum`, `min`, `max`, `range`, `count`, `std.p`, `std.s`, `var.p`, `var.s`]. select_labels: Include in the reply only a subset of the key-value pair labels of a series. align: Timestamp for alignment control for aggregation. latest: Used when a time series is a compaction, reports the compacted value of the latest possibly partial bucket. bucket_timestamp: Controls how bucket timestamps are reported. Can be one of [`-`, `low`, `+`, `high`, `~`, `mid`]. empty: Reports aggregations for empty buckets. exclude_empty: Omit matching series whose reported samples array is empty for the queried range and options. Must not be combined with `groupby`. rU)rr- MREVRANGE_CMDrr"r"r$rfrcCr r!r"rrrfr"r"r$getrQzTimeSeriesCommands.getcCr r!r"rr"r"r$rrQcCs,|g}||||jtg|Rd|giS)a$ Get the last sample of `key`. For more information see https://redis.io/commands/ts.get/ Args: latest: Used when a time series is a compaction, reports the compacted value of the latest (possibly partial) bucket. rv)rir-GET_CMD)rrrfr/r"r"r$rs cCr r!r"rrrrrfr"r"r$mgetzTimeSeriesCommands.mgetcCr r!r"rr"r"r$rrcCsDg}||||||||dg||7}|jtg|RS)a Get the last samples matching the specific `filter`. For more information see https://redis.io/commands/ts.mget/ Args: filters: Filter to match the time-series labels. with_labels: Include in the reply all label-value pairs representing metadata labels of the time series. select_labels: Include in the reply only a subset of the key-value pair labels o the time series. latest: Used when a time series is a compaction, reports the compacted value of the latest possibly partial bucket. r)rirr@r-MGET_CMD)rrrrrfr/r"r"r$rs   cCr r!r"rrr"r"r$infoszTimeSeriesCommands.infocCr r!r"rr"r"r$r!rQcCs|jt||gdS)zp Get information of `key`. For more information see https://redis.io/commands/ts.info/ )rv)r-INFO_CMDrr"r"r$r&cCr r!r"rrr"r"r$ queryindex0rQzTimeSeriesCommands.queryindexcCr r!r"rr"r"r$r5rQcCs|jtg|RS)z Get all time series keys matching the `filter` list. For more information see https://redis.io/commands/ts.queryindex/ )r-QUERYINDEX_CMDrr"r"r$r:rlabelcCr r!r"rrrr"r"r$ querylabelsDzTimeSeriesCommands.querylabelscCr r!r"rr"r"r$rKrcCs6|durdg}nd|g}||||jtg|RS)a Get label metadata for the time series matching `filters`. The single `TS.QUERYLABELS` request is built from the supplied arguments: - When `label` is omitted (``None``), the ``LABELS`` form is issued and the reply is the set of all label names present on the matching (and readable) series, including the label names used in the filter itself. - When `label` is given, the ``VALUES`` form is issued and the reply is the set of all values assigned to `label` across the matching series. `label` is matched byte-exactly and is passed to the server without any normalization; a series that does not carry `label`, and a `label` that matches no series, contribute nothing (an empty reply, not an error). The reply is unordered and already deduplicated by the server, so it is returned as a Python ``set``. When `filters` is omitted (``None``), all indexed series are queried; filter expressions use the same language as `TS.QUERYINDEX` and are passed verbatim, while an explicitly empty collection raises a `DataError`. For more information see https://redis.io/commands/ts.querylabels/ NLABELSVALUES)_append_filter_expressionsr-QUERYLABELS_CMD)rrrr/r"r"r$rRs  r/cCs8|durdSt|}|std|d||dS)aAppend the optional FILTER clause for TS.QUERYLABELS. ``None`` omits ``FILTER`` entirely (the documented all-series query); an explicitly empty collection is a local usage error, since silently widening to all series would be surprising. Any iterable is accepted and materialized once so single-pass iterators are handled correctly. Expressions are passed through verbatim, without parsing, reordering, or normalizing. NzMfilters cannot be an empty collection; pass None to query all indexed series.r)rr r\r@)r/rr"r"r$rus  z-TimeSeriesCommands._append_filter_expressionscCs|r |ddgdSdS)z"Append UNCOMPRESSED tag to params.ENCODING UNCOMPRESSEDNr@)r/rr"r"r$r(sz'TimeSeriesCommands._append_uncompressedcCs<|r|rtd|r|dg|r|dg|dSdS)z!Append labels behavior to params.z:with_labels and select_labels cannot be provided together. WITHLABELSSELECTED_LABELSNr r@)r/rrr"r"r$rs z&TimeSeriesCommands._append_with_labelscCs2|dur|dur|d|d|gdSdSdS)z)Append GROUPBY REDUCE property to params.NGROUPBYREDUCE)r@upper)r/rrr"r"r$rsz)TimeSeriesCommands._append_groupby_reduce retentioncC|dur |d|gdSdS)z$Append RETENTION property to params.N RETENTIONr)r/rr"r"r$r'z$TimeSeriesCommands._append_retentioncCs6|r|d|D] \}}|||gq dSdS)z!Append LABELS property to params.rN)r\itemsr@)r/rkvr"r"r$r+s  z!TimeSeriesCommands._append_labelscCr)z Append COUNT property to params.NCOUNTr)r/rar"r"r$rlrz TimeSeriesCommands._append_countcCs@|dur|dur tddS|durdn|}|d||gdS)a<Append the BLOCK group to params. The BLOCK group is all-or-nothing: when blocking is requested (`block_milliseconds` is set), both `milliseconds` and `min_count` are always emitted, with `min_count` defaulting to 1. There is no standalone MIN_COUNT keyword in this command. NzYblock_min_count requires block_milliseconds to be set; the BLOCK group is all-or-nothing.rBLOCKr)r/r{r| min_countr"r"r$rs z TimeSeriesCommands._append_blockcCr)z$Append MAX_COUNT property to params.N MAX_COUNTr)r/r}r"r"r$rrz$TimeSeriesCommands._append_max_countcCr)z$Append TIMESTAMP property to params.N TIMESTAMPr)r/r4r"r"r$rGrz$TimeSeriesCommands._append_timestampcCr)z Append ALIGN property to params.NALIGNr)r/rer"r"r$rmrz TimeSeriesCommands._append_aligncCsD|dur t|tr|dd||gdS|d||gdSdS)z&Append AGGREGATION property to params.N AGGREGATION,)rrr@join)r/rUrVr"r"r$r[s z&TimeSeriesCommands._append_aggregationnumkeyscCsb|durdSt|tr|gnt|}t||kr%td|dt|d|dg||dS)aAppend the AGGREGATION clause for TS.NRANGE / TS.NREVRANGE. These commands take exactly one aggregation spec token per queried key; a single aggregator is never broadcast across keys. A spec token may hold several comma-separated aggregators, so the wire form is e.g. ``AGGREGATION avg,max sum 1000`` for two keys -- key 0 aggregated by both ``avg`` and ``max``, key 1 by ``sum``. Pass one spec string per key, each optionally comma-joined (``["avg,max", "sum"]``); a bare string is the spec for a single-key query. (Matches RedisTimeSeries PR #2079, which replaced the earlier single comma-joined / broadcast token.) NzDAGGREGATION requires exactly one aggregation spec per key (expected z, got z8); a spec may list multiple comma-separated aggregators.r)rstrrrr r@)r/rrVrspecsr"r"r$rs z(TimeSeriesCommands._append_n_aggregationcCr)z%Append CHUNK_SIZE property to params.N CHUNK_SIZEr)r/rr"r"r$r)rz%TimeSeriesCommands._append_chunk_sizecCr)z+Append DUPLICATE_POLICY property to params.NDUPLICATE_POLICYr)r/rr"r"r$r*z+TimeSeriesCommands._append_duplicate_policycCr)z'Append ON_DUPLICATE property to params.N ON_DUPLICATEr)r/r6r"r"r$r:#rz'TimeSeriesCommands._append_on_duplicatets_listcCs |dur|dg|dSdS)z'Append FILTER_BY_TS property to params.N FILTER_BY_TSr)r/rr"r"r$rj)sz&TimeSeriesCommands._append_filer_by_ts min_value max_valuecCs,|dur|dur|d||gdSdSdS)z*Append FILTER_BY_VALUE property to params.NFILTER_BY_VALUEr)r/rrr"r"r$rk/sz)TimeSeriesCommands._append_filer_by_valuecC|r |ddSdS)z!Append LATEST property to params.LATESTNr\)r/rfr"r"r$ri7z!TimeSeriesCommands._append_latestcCr)z+Append BUCKET_TIMESTAMP property to params.NBUCKETTIMESTAMPr)r/rgr"r"r$rn=rz+TimeSeriesCommands._append_bucket_timestampcCr)z Append EMPTY property to params.EMPTYNr)r/rhr"r"r$roErz TimeSeriesCommands._append_emptycCr)z'Append EXCLUDEEMPTY property to params. EXCLUDEEMPTYNr)r/rr"r"r$rKrz(TimeSeriesCommands._append_exclude_emptycCsL|du|dukr td|dur"|dur$|dt|t|gdSdSdS)z#Append insertion filters to params.Nz>Both ignore_max_time_diff and ignore_max_val_diff must be set.IGNORE) ValueErrorr@r)r/rrr"r"r$r,Qsz,TimeSeriesCommands._append_insertion_filters)NFNNNNN)NNNNNN)NFNNNNNN)NNFNNNNNr!) NNrNNNNFNF)NNN)NNrFNNNNNNNFNFF)F)FNF)NN)L__name__ __module__ __qualname____doc__rrr intboolrrr r%r rr1r8rrrr>rDrKrPrYr_rwrrsryrrrrrrrrrrrrdictrrrbytesrrsetr staticmethodr rr(rrr'r+rlrrrGrmr[rr)r*r:rjrkrirnrorr,r"r"r"r$r)s        H    E               U                   \               \  "     #                               M                      O      C       !                      d                      d        0                         i                         i            "$              #     $        rN),typingrrrrrrrredis.exceptionsr redis.typingr r r r rrrrrrrr;r3r]r.rLr`rRrrHrrArrrrrrrrxrrzrr"r"r"r$s4$ ,