1593 lines
61 KiB
Python
1593 lines
61 KiB
Python
|
from typing import Any, Awaitable, Dict, List, Tuple, overload
|
||
|
|
|
||
|
|
from redis.exceptions import DataError
|
||
|
|
from redis.typing import (
|
||
|
|
AsyncClientProtocol,
|
||
|
|
EncodableT,
|
||
|
|
KeyT,
|
||
|
|
Number,
|
||
|
|
SyncClientProtocol,
|
||
|
|
TimeSeriesMRangeResponse,
|
||
|
|
TimeSeriesRangeResponse,
|
||
|
|
TimeSeriesSample,
|
||
|
|
)
|
||
|
|
|
||
|
|
from .info import TSInfo
|
||
|
|
|
||
|
|
ADD_CMD = "TS.ADD"
|
||
|
|
ALTER_CMD = "TS.ALTER"
|
||
|
|
CREATERULE_CMD = "TS.CREATERULE"
|
||
|
|
CREATE_CMD = "TS.CREATE"
|
||
|
|
DECRBY_CMD = "TS.DECRBY"
|
||
|
|
DELETERULE_CMD = "TS.DELETERULE"
|
||
|
|
DEL_CMD = "TS.DEL"
|
||
|
|
GET_CMD = "TS.GET"
|
||
|
|
INCRBY_CMD = "TS.INCRBY"
|
||
|
|
INFO_CMD = "TS.INFO"
|
||
|
|
MADD_CMD = "TS.MADD"
|
||
|
|
MGET_CMD = "TS.MGET"
|
||
|
|
MRANGE_CMD = "TS.MRANGE"
|
||
|
|
MREVRANGE_CMD = "TS.MREVRANGE"
|
||
|
|
QUERYINDEX_CMD = "TS.QUERYINDEX"
|
||
|
|
RANGE_CMD = "TS.RANGE"
|
||
|
|
REVRANGE_CMD = "TS.REVRANGE"
|
||
|
|
|
||
|
|
|
||
|
|
class TimeSeriesCommands:
|
||
|
|
"""RedisTimeSeries Commands."""
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def create(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> bool: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def create(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> Awaitable[bool]: ...
|
||
|
|
|
||
|
|
def create(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> bool | Awaitable[bool]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = [key]
|
||
|
|
self._append_retention(params, retention_msecs)
|
||
|
|
self._append_uncompressed(params, uncompressed)
|
||
|
|
self._append_chunk_size(params, chunk_size)
|
||
|
|
self._append_duplicate_policy(params, duplicate_policy)
|
||
|
|
self._append_labels(params, labels)
|
||
|
|
self._append_insertion_filters(
|
||
|
|
params, ignore_max_time_diff, ignore_max_val_diff
|
||
|
|
)
|
||
|
|
|
||
|
|
return self.execute_command(CREATE_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def alter(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> bool: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def alter(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> Awaitable[bool]: ...
|
||
|
|
|
||
|
|
def alter(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> bool | Awaitable[bool]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = [key]
|
||
|
|
self._append_retention(params, retention_msecs)
|
||
|
|
self._append_chunk_size(params, chunk_size)
|
||
|
|
self._append_duplicate_policy(params, duplicate_policy)
|
||
|
|
self._append_labels(params, labels)
|
||
|
|
self._append_insertion_filters(
|
||
|
|
params, ignore_max_time_diff, ignore_max_val_diff
|
||
|
|
)
|
||
|
|
|
||
|
|
return self.execute_command(ALTER_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def add(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
timestamp: int | str,
|
||
|
|
value: Number | str,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
on_duplicate: str | None = None,
|
||
|
|
) -> int: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def add(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
timestamp: int | str,
|
||
|
|
value: Number | str,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
on_duplicate: str | None = None,
|
||
|
|
) -> Awaitable[int]: ...
|
||
|
|
|
||
|
|
def add(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
timestamp: int | str,
|
||
|
|
value: Number | str,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
on_duplicate: str | None = None,
|
||
|
|
) -> int | Awaitable[int]:
|
||
|
|
"""
|
||
|
|
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`.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = [key, timestamp, value]
|
||
|
|
self._append_retention(params, retention_msecs)
|
||
|
|
self._append_uncompressed(params, uncompressed)
|
||
|
|
self._append_chunk_size(params, chunk_size)
|
||
|
|
self._append_duplicate_policy(params, duplicate_policy)
|
||
|
|
self._append_labels(params, labels)
|
||
|
|
self._append_insertion_filters(
|
||
|
|
params, ignore_max_time_diff, ignore_max_val_diff
|
||
|
|
)
|
||
|
|
self._append_on_duplicate(params, on_duplicate)
|
||
|
|
|
||
|
|
return self.execute_command(ADD_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def madd(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
ktv_tuples: List[Tuple[KeyT, int | str, Number | str]],
|
||
|
|
) -> list[int]: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def madd(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
ktv_tuples: List[Tuple[KeyT, int | str, Number | str]],
|
||
|
|
) -> Awaitable[list[int]]: ...
|
||
|
|
|
||
|
|
def madd(
|
||
|
|
self, ktv_tuples: List[Tuple[KeyT, int | str, Number | str]]
|
||
|
|
) -> list[int] | Awaitable[list[int]]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = []
|
||
|
|
for ktv in ktv_tuples:
|
||
|
|
params.extend(ktv)
|
||
|
|
|
||
|
|
return self.execute_command(MADD_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def incrby(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
value: Number,
|
||
|
|
timestamp: int | str | None = None,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> int: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def incrby(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
value: Number,
|
||
|
|
timestamp: int | str | None = None,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> Awaitable[int]: ...
|
||
|
|
|
||
|
|
def incrby(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
value: Number,
|
||
|
|
timestamp: int | str | None = None,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> int | Awaitable[int]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = [key, value]
|
||
|
|
self._append_timestamp(params, timestamp)
|
||
|
|
self._append_retention(params, retention_msecs)
|
||
|
|
self._append_uncompressed(params, uncompressed)
|
||
|
|
self._append_chunk_size(params, chunk_size)
|
||
|
|
self._append_duplicate_policy(params, duplicate_policy)
|
||
|
|
self._append_labels(params, labels)
|
||
|
|
self._append_insertion_filters(
|
||
|
|
params, ignore_max_time_diff, ignore_max_val_diff
|
||
|
|
)
|
||
|
|
|
||
|
|
return self.execute_command(INCRBY_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def decrby(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
value: Number,
|
||
|
|
timestamp: int | str | None = None,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> int: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def decrby(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
value: Number,
|
||
|
|
timestamp: int | str | None = None,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> Awaitable[int]: ...
|
||
|
|
|
||
|
|
def decrby(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
value: Number,
|
||
|
|
timestamp: int | str | None = None,
|
||
|
|
retention_msecs: int | None = None,
|
||
|
|
uncompressed: bool | None = False,
|
||
|
|
labels: Dict[str, str] | None = None,
|
||
|
|
chunk_size: int | None = None,
|
||
|
|
duplicate_policy: str | None = None,
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
) -> int | Awaitable[int]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = [key, value]
|
||
|
|
self._append_timestamp(params, timestamp)
|
||
|
|
self._append_retention(params, retention_msecs)
|
||
|
|
self._append_uncompressed(params, uncompressed)
|
||
|
|
self._append_chunk_size(params, chunk_size)
|
||
|
|
self._append_duplicate_policy(params, duplicate_policy)
|
||
|
|
self._append_labels(params, labels)
|
||
|
|
self._append_insertion_filters(
|
||
|
|
params, ignore_max_time_diff, ignore_max_val_diff
|
||
|
|
)
|
||
|
|
|
||
|
|
return self.execute_command(DECRBY_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def delete(
|
||
|
|
self: SyncClientProtocol, key: KeyT, from_time: int, to_time: int
|
||
|
|
) -> int: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def delete(
|
||
|
|
self: AsyncClientProtocol, key: KeyT, from_time: int, to_time: int
|
||
|
|
) -> Awaitable[int]: ...
|
||
|
|
|
||
|
|
def delete(self, key: KeyT, from_time: int, to_time: int) -> int | Awaitable[int]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
return self.execute_command(DEL_CMD, key, from_time, to_time)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def createrule(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
source_key: KeyT,
|
||
|
|
dest_key: KeyT,
|
||
|
|
aggregation_type: str,
|
||
|
|
bucket_size_msec: int,
|
||
|
|
align_timestamp: int | None = None,
|
||
|
|
) -> bool: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def createrule(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
source_key: KeyT,
|
||
|
|
dest_key: KeyT,
|
||
|
|
aggregation_type: str,
|
||
|
|
bucket_size_msec: int,
|
||
|
|
align_timestamp: int | None = None,
|
||
|
|
) -> Awaitable[bool]: ...
|
||
|
|
|
||
|
|
def createrule(
|
||
|
|
self,
|
||
|
|
source_key: KeyT,
|
||
|
|
dest_key: KeyT,
|
||
|
|
aggregation_type: str,
|
||
|
|
bucket_size_msec: int,
|
||
|
|
align_timestamp: int | None = None,
|
||
|
|
) -> bool | Awaitable[bool]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = [source_key, dest_key]
|
||
|
|
self._append_aggregation(params, aggregation_type, bucket_size_msec)
|
||
|
|
if align_timestamp is not None:
|
||
|
|
params.append(align_timestamp)
|
||
|
|
|
||
|
|
return self.execute_command(CREATERULE_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def deleterule(
|
||
|
|
self: SyncClientProtocol, source_key: KeyT, dest_key: KeyT
|
||
|
|
) -> bool: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def deleterule(
|
||
|
|
self: AsyncClientProtocol, source_key: KeyT, dest_key: KeyT
|
||
|
|
) -> Awaitable[bool]: ...
|
||
|
|
|
||
|
|
def deleterule(self, source_key: KeyT, dest_key: KeyT) -> bool | Awaitable[bool]:
|
||
|
|
"""
|
||
|
|
Delete a compaction rule from `source_key` to `dest_key`.
|
||
|
|
|
||
|
|
For more information see https://redis.io/commands/ts.deleterule/
|
||
|
|
"""
|
||
|
|
return self.execute_command(DELETERULE_CMD, source_key, dest_key)
|
||
|
|
|
||
|
|
def __range_params(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
count: int | None,
|
||
|
|
aggregation_type: str | list[str] | None,
|
||
|
|
bucket_size_msec: int | None,
|
||
|
|
filter_by_ts: List[int] | None,
|
||
|
|
filter_by_min_value: int | None,
|
||
|
|
filter_by_max_value: int | None,
|
||
|
|
align: int | str | None,
|
||
|
|
latest: bool | None,
|
||
|
|
bucket_timestamp: str | None,
|
||
|
|
empty: bool | None,
|
||
|
|
):
|
||
|
|
"""Create TS.RANGE and TS.REVRANGE arguments."""
|
||
|
|
params: list[EncodableT] = [key, from_time, to_time]
|
||
|
|
self._append_latest(params, latest)
|
||
|
|
self._append_filer_by_ts(params, filter_by_ts)
|
||
|
|
self._append_filer_by_value(params, filter_by_min_value, filter_by_max_value)
|
||
|
|
self._append_count(params, count)
|
||
|
|
self._append_align(params, align)
|
||
|
|
self._append_aggregation(params, aggregation_type, bucket_size_msec)
|
||
|
|
self._append_bucket_timestamp(params, bucket_timestamp)
|
||
|
|
self._append_empty(params, empty)
|
||
|
|
|
||
|
|
return params
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def range(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesRangeResponse: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def range(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> Awaitable[TimeSeriesRangeResponse]: ...
|
||
|
|
|
||
|
|
def range(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesRangeResponse | Awaitable[TimeSeriesRangeResponse]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params = self.__range_params(
|
||
|
|
key,
|
||
|
|
from_time,
|
||
|
|
to_time,
|
||
|
|
count,
|
||
|
|
aggregation_type,
|
||
|
|
bucket_size_msec,
|
||
|
|
filter_by_ts,
|
||
|
|
filter_by_min_value,
|
||
|
|
filter_by_max_value,
|
||
|
|
align,
|
||
|
|
latest,
|
||
|
|
bucket_timestamp,
|
||
|
|
empty,
|
||
|
|
)
|
||
|
|
return self.execute_command(RANGE_CMD, *params, keys=[key])
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def revrange(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesRangeResponse: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def revrange(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
key: KeyT,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> Awaitable[TimeSeriesRangeResponse]: ...
|
||
|
|
|
||
|
|
def revrange(
|
||
|
|
self,
|
||
|
|
key: KeyT,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesRangeResponse | Awaitable[TimeSeriesRangeResponse]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params = self.__range_params(
|
||
|
|
key,
|
||
|
|
from_time,
|
||
|
|
to_time,
|
||
|
|
count,
|
||
|
|
aggregation_type,
|
||
|
|
bucket_size_msec,
|
||
|
|
filter_by_ts,
|
||
|
|
filter_by_min_value,
|
||
|
|
filter_by_max_value,
|
||
|
|
align,
|
||
|
|
latest,
|
||
|
|
bucket_timestamp,
|
||
|
|
empty,
|
||
|
|
)
|
||
|
|
return self.execute_command(REVRANGE_CMD, *params, keys=[key])
|
||
|
|
|
||
|
|
def __mrange_params(
|
||
|
|
self,
|
||
|
|
aggregation_type: str | list[str] | None,
|
||
|
|
bucket_size_msec: int | None,
|
||
|
|
count: int | None,
|
||
|
|
filters: List[str],
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
with_labels: bool | None,
|
||
|
|
filter_by_ts: List[int] | None,
|
||
|
|
filter_by_min_value: int | None,
|
||
|
|
filter_by_max_value: int | None,
|
||
|
|
groupby: str | None,
|
||
|
|
reduce: str | None,
|
||
|
|
select_labels: List[str] | None,
|
||
|
|
align: int | str | None,
|
||
|
|
latest: bool | None,
|
||
|
|
bucket_timestamp: str | None,
|
||
|
|
empty: bool | None,
|
||
|
|
):
|
||
|
|
"""Create TS.MRANGE and TS.MREVRANGE arguments."""
|
||
|
|
if (
|
||
|
|
groupby is not None
|
||
|
|
and isinstance(aggregation_type, list)
|
||
|
|
and len(aggregation_type) > 1
|
||
|
|
):
|
||
|
|
raise DataError(
|
||
|
|
"GROUPBY is not allowed when multiple aggregators are specified"
|
||
|
|
)
|
||
|
|
params: list[EncodableT] = [from_time, to_time]
|
||
|
|
self._append_latest(params, latest)
|
||
|
|
self._append_filer_by_ts(params, filter_by_ts)
|
||
|
|
self._append_filer_by_value(params, filter_by_min_value, filter_by_max_value)
|
||
|
|
self._append_with_labels(params, with_labels, select_labels)
|
||
|
|
self._append_count(params, count)
|
||
|
|
self._append_align(params, align)
|
||
|
|
self._append_aggregation(params, aggregation_type, bucket_size_msec)
|
||
|
|
self._append_bucket_timestamp(params, bucket_timestamp)
|
||
|
|
self._append_empty(params, empty)
|
||
|
|
params.extend(["FILTER"])
|
||
|
|
params += filters
|
||
|
|
self._append_groupby_reduce(params, groupby, reduce)
|
||
|
|
return params
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def mrange(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
filters: List[str],
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
groupby: str | None = None,
|
||
|
|
reduce: str | None = None,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesMRangeResponse: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def mrange(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
filters: List[str],
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
groupby: str | None = None,
|
||
|
|
reduce: str | None = None,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> Awaitable[TimeSeriesMRangeResponse]: ...
|
||
|
|
|
||
|
|
def mrange(
|
||
|
|
self,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
filters: List[str],
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
groupby: str | None = None,
|
||
|
|
reduce: str | None = None,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesMRangeResponse | Awaitable[TimeSeriesMRangeResponse]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params = self.__mrange_params(
|
||
|
|
aggregation_type,
|
||
|
|
bucket_size_msec,
|
||
|
|
count,
|
||
|
|
filters,
|
||
|
|
from_time,
|
||
|
|
to_time,
|
||
|
|
with_labels,
|
||
|
|
filter_by_ts,
|
||
|
|
filter_by_min_value,
|
||
|
|
filter_by_max_value,
|
||
|
|
groupby,
|
||
|
|
reduce,
|
||
|
|
select_labels,
|
||
|
|
align,
|
||
|
|
latest,
|
||
|
|
bucket_timestamp,
|
||
|
|
empty,
|
||
|
|
)
|
||
|
|
|
||
|
|
return self.execute_command(
|
||
|
|
MRANGE_CMD, *params, aggregation_type=aggregation_type
|
||
|
|
)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def mrevrange(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
filters: List[str],
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
groupby: str | None = None,
|
||
|
|
reduce: str | None = None,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesMRangeResponse: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def mrevrange(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
filters: List[str],
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
groupby: str | None = None,
|
||
|
|
reduce: str | None = None,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> Awaitable[TimeSeriesMRangeResponse]: ...
|
||
|
|
|
||
|
|
def mrevrange(
|
||
|
|
self,
|
||
|
|
from_time: int | str,
|
||
|
|
to_time: int | str,
|
||
|
|
filters: List[str],
|
||
|
|
count: int | None = None,
|
||
|
|
aggregation_type: str | list[str] | None = None,
|
||
|
|
bucket_size_msec: int | None = 0,
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
filter_by_ts: List[int] | None = None,
|
||
|
|
filter_by_min_value: int | None = None,
|
||
|
|
filter_by_max_value: int | None = None,
|
||
|
|
groupby: str | None = None,
|
||
|
|
reduce: str | None = None,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
align: int | str | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
bucket_timestamp: str | None = None,
|
||
|
|
empty: bool | None = False,
|
||
|
|
) -> TimeSeriesMRangeResponse | Awaitable[TimeSeriesMRangeResponse]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params = self.__mrange_params(
|
||
|
|
aggregation_type,
|
||
|
|
bucket_size_msec,
|
||
|
|
count,
|
||
|
|
filters,
|
||
|
|
from_time,
|
||
|
|
to_time,
|
||
|
|
with_labels,
|
||
|
|
filter_by_ts,
|
||
|
|
filter_by_min_value,
|
||
|
|
filter_by_max_value,
|
||
|
|
groupby,
|
||
|
|
reduce,
|
||
|
|
select_labels,
|
||
|
|
align,
|
||
|
|
latest,
|
||
|
|
bucket_timestamp,
|
||
|
|
empty,
|
||
|
|
)
|
||
|
|
|
||
|
|
return self.execute_command(
|
||
|
|
MREVRANGE_CMD, *params, aggregation_type=aggregation_type
|
||
|
|
)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def get(
|
||
|
|
self: SyncClientProtocol, key: KeyT, latest: bool | None = False
|
||
|
|
) -> TimeSeriesSample | None: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def get(
|
||
|
|
self: AsyncClientProtocol, key: KeyT, latest: bool | None = False
|
||
|
|
) -> Awaitable[TimeSeriesSample | None]: ...
|
||
|
|
|
||
|
|
def get(self, key: KeyT, latest: bool | None = False) -> (
|
||
|
|
TimeSeriesSample | None
|
||
|
|
) | Awaitable[TimeSeriesSample | None]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = [key]
|
||
|
|
self._append_latest(params, latest)
|
||
|
|
return self.execute_command(GET_CMD, *params, keys=[key])
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def mget(
|
||
|
|
self: SyncClientProtocol,
|
||
|
|
filters: List[str],
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
) -> list[Any] | dict[str, list[Any]]: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def mget(
|
||
|
|
self: AsyncClientProtocol,
|
||
|
|
filters: List[str],
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
) -> Awaitable[list[Any] | dict[str, list[Any]]]: ...
|
||
|
|
|
||
|
|
def mget(
|
||
|
|
self,
|
||
|
|
filters: List[str],
|
||
|
|
with_labels: bool | None = False,
|
||
|
|
select_labels: List[str] | None = None,
|
||
|
|
latest: bool | None = False,
|
||
|
|
) -> (list[Any] | dict[str, list[Any]]) | Awaitable[
|
||
|
|
list[Any] | dict[str, list[Any]]
|
||
|
|
]:
|
||
|
|
"""
|
||
|
|
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.
|
||
|
|
"""
|
||
|
|
params: list[EncodableT] = []
|
||
|
|
self._append_latest(params, latest)
|
||
|
|
self._append_with_labels(params, with_labels, select_labels)
|
||
|
|
params.extend(["FILTER"])
|
||
|
|
params += filters
|
||
|
|
return self.execute_command(MGET_CMD, *params)
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def info(self: SyncClientProtocol, key: KeyT) -> TSInfo | dict[str, Any]: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def info(
|
||
|
|
self: AsyncClientProtocol, key: KeyT
|
||
|
|
) -> Awaitable[TSInfo | dict[str, Any]]: ...
|
||
|
|
|
||
|
|
def info(self, key: KeyT) -> (TSInfo | dict[str, Any]) | Awaitable[
|
||
|
|
TSInfo | dict[str, Any]
|
||
|
|
]:
|
||
|
|
"""
|
||
|
|
Get information of `key`.
|
||
|
|
|
||
|
|
For more information see https://redis.io/commands/ts.info/
|
||
|
|
"""
|
||
|
|
return self.execute_command(INFO_CMD, key, keys=[key])
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def queryindex(
|
||
|
|
self: SyncClientProtocol, filters: List[str]
|
||
|
|
) -> list[bytes | str]: ...
|
||
|
|
|
||
|
|
@overload
|
||
|
|
def queryindex(
|
||
|
|
self: AsyncClientProtocol, filters: List[str]
|
||
|
|
) -> Awaitable[list[bytes | str]]: ...
|
||
|
|
|
||
|
|
def queryindex(
|
||
|
|
self, filters: List[str]
|
||
|
|
) -> list[bytes | str] | Awaitable[list[bytes | str]]:
|
||
|
|
"""
|
||
|
|
Get all time series keys matching the `filter` list.
|
||
|
|
|
||
|
|
For more information see https://redis.io/commands/ts.queryindex/
|
||
|
|
"""
|
||
|
|
return self.execute_command(QUERYINDEX_CMD, *filters)
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_uncompressed(params: list[EncodableT], uncompressed: bool | None):
|
||
|
|
"""Append UNCOMPRESSED tag to params."""
|
||
|
|
if uncompressed:
|
||
|
|
params.extend(["ENCODING", "UNCOMPRESSED"])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_with_labels(
|
||
|
|
params: list[EncodableT],
|
||
|
|
with_labels: bool | None,
|
||
|
|
select_labels: list[str] | None,
|
||
|
|
):
|
||
|
|
"""Append labels behavior to params."""
|
||
|
|
if with_labels and select_labels:
|
||
|
|
raise DataError(
|
||
|
|
"with_labels and select_labels cannot be provided together."
|
||
|
|
)
|
||
|
|
|
||
|
|
if with_labels:
|
||
|
|
params.extend(["WITHLABELS"])
|
||
|
|
if select_labels:
|
||
|
|
params.extend(["SELECTED_LABELS", *select_labels])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_groupby_reduce(
|
||
|
|
params: list[EncodableT], groupby: str | None, reduce: str | None
|
||
|
|
):
|
||
|
|
"""Append GROUPBY REDUCE property to params."""
|
||
|
|
if groupby is not None and reduce is not None:
|
||
|
|
params.extend(["GROUPBY", groupby, "REDUCE", reduce.upper()])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_retention(params: list[EncodableT], retention: int | None):
|
||
|
|
"""Append RETENTION property to params."""
|
||
|
|
if retention is not None:
|
||
|
|
params.extend(["RETENTION", retention])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_labels(params: list[EncodableT], labels: dict[str, str] | None):
|
||
|
|
"""Append LABELS property to params."""
|
||
|
|
if labels:
|
||
|
|
params.append("LABELS")
|
||
|
|
for k, v in labels.items():
|
||
|
|
params.extend([k, v])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_count(params: list[EncodableT], count: int | None):
|
||
|
|
"""Append COUNT property to params."""
|
||
|
|
if count is not None:
|
||
|
|
params.extend(["COUNT", count])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_timestamp(params: list[EncodableT], timestamp: int | None):
|
||
|
|
"""Append TIMESTAMP property to params."""
|
||
|
|
if timestamp is not None:
|
||
|
|
params.extend(["TIMESTAMP", timestamp])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_align(params: list[EncodableT], align: int | str | None):
|
||
|
|
"""Append ALIGN property to params."""
|
||
|
|
if align is not None:
|
||
|
|
params.extend(["ALIGN", align])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_aggregation(
|
||
|
|
params: list[EncodableT],
|
||
|
|
aggregation_type: str | list[str] | None,
|
||
|
|
bucket_size_msec: int | None,
|
||
|
|
):
|
||
|
|
"""Append AGGREGATION property to params."""
|
||
|
|
if aggregation_type is not None:
|
||
|
|
if isinstance(aggregation_type, list):
|
||
|
|
params.extend(
|
||
|
|
["AGGREGATION", ",".join(aggregation_type), bucket_size_msec]
|
||
|
|
)
|
||
|
|
else:
|
||
|
|
params.extend(["AGGREGATION", aggregation_type, bucket_size_msec])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_chunk_size(params: list[EncodableT], chunk_size: int | None):
|
||
|
|
"""Append CHUNK_SIZE property to params."""
|
||
|
|
if chunk_size is not None:
|
||
|
|
params.extend(["CHUNK_SIZE", chunk_size])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_duplicate_policy(
|
||
|
|
params: list[EncodableT], duplicate_policy: str | None
|
||
|
|
):
|
||
|
|
"""Append DUPLICATE_POLICY property to params."""
|
||
|
|
if duplicate_policy is not None:
|
||
|
|
params.extend(["DUPLICATE_POLICY", duplicate_policy])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_on_duplicate(params: list[EncodableT], on_duplicate: str | None):
|
||
|
|
"""Append ON_DUPLICATE property to params."""
|
||
|
|
if on_duplicate is not None:
|
||
|
|
params.extend(["ON_DUPLICATE", on_duplicate])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_filer_by_ts(params: list[EncodableT], ts_list: list[int] | None):
|
||
|
|
"""Append FILTER_BY_TS property to params."""
|
||
|
|
if ts_list is not None:
|
||
|
|
params.extend(["FILTER_BY_TS", *ts_list])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_filer_by_value(
|
||
|
|
params: list[EncodableT], min_value: int | None, max_value: int | None
|
||
|
|
):
|
||
|
|
"""Append FILTER_BY_VALUE property to params."""
|
||
|
|
if min_value is not None and max_value is not None:
|
||
|
|
params.extend(["FILTER_BY_VALUE", min_value, max_value])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_latest(params: list[EncodableT], latest: bool | None):
|
||
|
|
"""Append LATEST property to params."""
|
||
|
|
if latest:
|
||
|
|
params.append("LATEST")
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_bucket_timestamp(
|
||
|
|
params: list[EncodableT], bucket_timestamp: str | None
|
||
|
|
):
|
||
|
|
"""Append BUCKET_TIMESTAMP property to params."""
|
||
|
|
if bucket_timestamp is not None:
|
||
|
|
params.extend(["BUCKETTIMESTAMP", bucket_timestamp])
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_empty(params: list[EncodableT], empty: bool | None):
|
||
|
|
"""Append EMPTY property to params."""
|
||
|
|
if empty:
|
||
|
|
params.append("EMPTY")
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _append_insertion_filters(
|
||
|
|
params: list[EncodableT],
|
||
|
|
ignore_max_time_diff: int | None = None,
|
||
|
|
ignore_max_val_diff: Number | None = None,
|
||
|
|
):
|
||
|
|
"""Append insertion filters to params."""
|
||
|
|
if (ignore_max_time_diff is None) != (ignore_max_val_diff is None):
|
||
|
|
raise ValueError(
|
||
|
|
"Both ignore_max_time_diff and ignore_max_val_diff must be set."
|
||
|
|
)
|
||
|
|
|
||
|
|
if ignore_max_time_diff is not None and ignore_max_val_diff is not None:
|
||
|
|
params.extend(
|
||
|
|
["IGNORE", str(ignore_max_time_diff), str(ignore_max_val_diff)]
|
||
|
|
)
|