Voice et bot modif

venv/lib/python3.12/site-packages/redis/commands/timeseries/info.py

@@ -0,0 +1,116 @@
+from ..helpers import nativestr
+from .utils import list_to_dict
+
+# Mapping from RESP3 camelCase field names to the legacy snake_case
+# attribute names. Used so callers can fetch the same value with either
+# spelling regardless of which wire format produced the ``TSInfo``.
+_FIELD_ALIASES = {
+    "sourceKey": "source_key",
+    "chunkCount": "chunk_count",
+    "memoryUsage": "memory_usage",
+    "totalSamples": "total_samples",
+    "retentionTime": "retention_msecs",
+    "lastTimestamp": "last_timestamp",
+    "firstTimestamp": "first_timestamp",
+    "maxSamplesPerChunk": "max_samples_per_chunk",
+    "chunkSize": "chunk_size",
+    "duplicatePolicy": "duplicate_policy",
+}
+
+
+class TSInfo:
+    """
+    Hold information and statistics on the time-series.
+    Can be created using ``tsinfo`` command
+    https://redis.io/docs/latest/commands/ts.info/
+
+    Handles both RESP2 (flat list) and RESP3 (dict) responses.
+    """
+
+    rules = []
+    labels = []
+    sourceKey = None
+    chunk_count = None
+    memory_usage = None
+    total_samples = None
+    retention_msecs = None
+    last_time_stamp = None
+    first_time_stamp = None
+
+    max_samples_per_chunk = None
+    chunk_size = None
+    duplicate_policy = None
+
+    def __init__(self, args):
+        """
+        Hold information and statistics on the time-series.
+
+        The supported params that can be passed as args:
+
+        rules:
+            A list of compaction rules of the time series.
+        sourceKey:
+            Key name for source time series in case the current series
+            is a target of a rule.
+        chunkCount:
+            Number of Memory Chunks used for the time series.
+        memoryUsage:
+            Total number of bytes allocated for the time series.
+        totalSamples:
+            Total number of samples in the time series.
+        labels:
+            A list of label-value pairs that represent the metadata
+            labels of the time series.
+        retentionTime:
+            Retention time, in milliseconds, for the time series.
+        lastTimestamp:
+            Last timestamp present in the time series.
+        firstTimestamp:
+            First timestamp present in the time series.
+        maxSamplesPerChunk:
+            Deprecated.
+        chunkSize:
+            Amount of memory, in bytes, allocated for data.
+        duplicatePolicy:
+            Policy that will define handling of duplicate samples.
+
+        Can read more about on
+        https://redis.io/docs/latest/develop/data-types/timeseries/configuration/#duplicate_policy
+        """
+        if isinstance(args, dict):
+            # RESP3 wire: response is a native map.
+            response = args
+            self.rules = response.get("rules") or {}
+            self.labels = response.get("labels") or {}
+        else:
+            # RESP2 wire: flat list of alternating key-value pairs.
+            response = dict(zip(map(nativestr, args[::2]), args[1::2]))
+            self.rules = response.get("rules")
+            self.labels = list_to_dict(response.get("labels"))
+        self.source_key = response.get("sourceKey")
+        self.chunk_count = response.get("chunkCount")
+        self.memory_usage = response.get("memoryUsage")
+        self.total_samples = response.get("totalSamples")
+        self.retention_msecs = response.get("retentionTime")
+        self.last_timestamp = response.get("lastTimestamp")
+        self.first_timestamp = response.get("firstTimestamp")
+        if "maxSamplesPerChunk" in response:
+            self.max_samples_per_chunk = response["maxSamplesPerChunk"]
+            self.chunk_size = (
+                self.max_samples_per_chunk * 16
+            )  # backward compatible changes
+        if "chunkSize" in response:
+            self.chunk_size = response["chunkSize"]
+        if "duplicatePolicy" in response:
+            self.duplicate_policy = response["duplicatePolicy"]
+            if isinstance(self.duplicate_policy, bytes):
+                self.duplicate_policy = self.duplicate_policy.decode()
+
+    def get(self, item):
+        try:
+            return self.__getitem__(item)
+        except AttributeError:
+            return None
+
+    def __getitem__(self, item):
+        return getattr(self, _FIELD_ALIASES.get(item, item))