Fix inner stats.0

core/basic_models/variables/mid_variables.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import time
+from functools import cached_property
 from typing import TYPE_CHECKING, Any
 
 from core.basic_models.variables.variables import Variables
@@ -16,16 +17,19 @@ def __init__(self, items: dict | None, user: User, savable: bool = True):
         self._user = user
 
     def get(self, key: Any, default: Any = None) -> Any:
-        return super().get(key=str(self._user.message.incremental_id), default={}).get(key, default)
+        return super().get(key=self._mid, default={}).get(key, default)
 
     def update(self, key: Any, value: Any, ttl: int | None = None) -> None:
-        mid = str(self._user.message.incremental_id)
-        mid_variable, old_expire_time = self._storage.get(mid, ({}, self.DEFAULT_TTL + time.time()))
+        mid_variable, old_expire_time = self._storage.get(self._mid, ({}, self.DEFAULT_TTL + time.time()))
         mid_variable[key] = value
-        self._storage[mid] = mid_variable, ttl + time.time() if ttl else old_expire_time
+        self._storage[self._mid] = mid_variable, ttl + time.time() if ttl else old_expire_time
 
     def delete_mid_variables(self) -> None:
-        del self._storage[str(self._user.message.incremental_id)]
+        self._storage.pop(self._mid, None)
 
     def set(self, key, value, ttl=None):
         raise NotImplementedError
+
+    @cached_property
+    def _mid(self) -> str:
+        return str(self._user.message.incremental_id)

core/utils/stats_timer.py

@@ -2,6 +2,7 @@
 
 import time
 import timeit
+from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
@@ -36,17 +37,17 @@ def __exit__(self, *args):
 class Stats:
     def __init__(self, start_ts: float | None = None, finish_ts: float | None = None, time: float | None = None,
                  system: str | None = None, version: str | None = None,
-                 inner_stats: list[dict[str, Any]] | list[Stats] | None = None, optional: dict | None = None, **kwargs):
+                 inner_stats: Iterable[Stats | dict[str, Any]] = (), optional: dict | None = None, **kwargs):
         self.system = system
         self.version = version
         self.optional = optional
         self.start_ts = start_ts
         self.finish_ts = finish_ts
         self.time = time or ((start_ts - finish_ts) if start_ts and finish_ts else None)
-        self._inner_stats: list[Stats] = []
-        if inner_stats:
-            self._inner_stats = ([Stats(**stats) for stats in inner_stats] if isinstance(inner_stats[0], dict)
-                                 else inner_stats)
+        self._inner_stats: list[Stats] = [
+            stats if isinstance(stats, Stats) else Stats(**stats)
+            for stats in inner_stats
+        ]
 
     def add_inner_stats(self, stats: dict[str, Any], copy_system: bool = True, copy_version: bool = True) -> None:
         self._inner_stats = [Stats(**stats)]

smart_kit/start_points/main_loop_kafka.py

@@ -779,8 +779,7 @@ def _stats_for_incoming(user: User):
                     Stats(system=((None if callback.action_params.get("answer_stats_system_copy_off")
                                    else user.message.payload.get("stats", {}).get("system")) or
                                   callback.action_params["stats_system"]),
-                          inner_stats=([user.message.payload.get("stats")] if user.message.payload.get("stats")
-                                       else []),
+                          inner_stats=([s] if (s := user.message.payload.get("stats")) else []),
                           time=(finish_ts - callback.action_params["stats_request_ts"]) * 1000,
                           version=user.message.payload.get("stats", {}).get("version"),
                           start_ts=callback.action_params["stats_request_ts"],