aiohomematic 2025.10.9__tar.gz → 2025.10.10__tar.gz

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.9
+Version: 2025.10.10
 Summary: Homematic interface for Home Assistant running on Python 3.
 Home-page: https://github.com/sukramj/aiohomematic
 Author-email: SukramJ <sukramj@icloud.com>, Daniel Perna <danielperna84@gmail.com>

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/central/__init__.py

@@ -96,8 +96,10 @@ from aiohomematic.const import (
     DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS,
     DEFAULT_INTERFACES_REQUIRING_PERIODIC_REFRESH,
     DEFAULT_MAX_READ_WORKERS,
+    DEFAULT_OPTIONAL_SETTINGS,
     DEFAULT_PERIODIC_REFRESH_INTERVAL,
     DEFAULT_PROGRAM_MARKERS,
+    DEFAULT_SESSION_RECORDER_START_FOR_SECONDS,
     DEFAULT_STORAGE_DIRECTORY,
     DEFAULT_SYS_SCAN_INTERVAL,
     DEFAULT_SYSVAR_MARKERS,
@@ -130,6 +132,7 @@ from aiohomematic.const import (
     Interface,
     InterfaceEventType,
     Operations,
+    OptionalSettings,
     Parameter,
     ParamsetKey,
     ProxyInitState,
@@ -223,7 +226,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         self._paramset_descriptions: Final = ParamsetDescriptionCache(central=self)
         self._parameter_visibility: Final = ParameterVisibilityCache(central=self)
         self._recorder: Final = SessionRecorder(
-            central=self, default_ttl_seconds=600, active=central_config.start_recorder
+            central=self, ttl_seconds=600, active=central_config.session_recorder_start
         )
         self._primary_client: hmcl.Client | None = None
         # {interface_id, client}
@@ -493,14 +496,14 @@ class CentralUnit(LogContextMixin, PayloadMixin):
             _LOGGER.debug("START: Central %s already started", self.name)
             return
 
-        if self._config.start_recorder:
+        if self._config.session_recorder_start:
             await self._recorder.deactivate(
-                delay=self._config.start_recorder_for_minutes * 60,
+                delay=self._config.session_recorder_start_for_seconds,
                 auto_save=True,
-                randomize_output=True,
-                use_ts_in_filename=False,
+                randomize_output=self._config.session_recorder_randomize_output,
+                use_ts_in_file_name=False,
             )
-            _LOGGER.debug("START: Starting Recorder for %s minutes", self._config.start_recorder_for_minutes)
+            _LOGGER.debug("START: Starting Recorder for %s seconds", self._config.session_recorder_start_for_seconds)
 
         self._state = CentralUnitState.INITIALIZING
         _LOGGER.debug("START: Initializing Central %s", self.name)
@@ -2009,10 +2012,10 @@ class CentralConfig:
         listen_ip_addr: str | None = None,
         listen_port_xml_rpc: int | None = None,
         max_read_workers: int = DEFAULT_MAX_READ_WORKERS,
+        optional_settings: tuple[OptionalSettings | str, ...] = DEFAULT_OPTIONAL_SETTINGS,
         periodic_refresh_interval: int = DEFAULT_PERIODIC_REFRESH_INTERVAL,
         program_markers: tuple[DescriptionMarker | str, ...] = DEFAULT_PROGRAM_MARKERS,
         start_direct: bool = False,
-        start_recorder_for_minutes: int = 0,
         storage_directory: str = DEFAULT_STORAGE_DIRECTORY,
         sys_scan_interval: int = DEFAULT_SYS_SCAN_INTERVAL,
         sysvar_markers: tuple[DescriptionMarker | str, ...] = DEFAULT_SYSVAR_MARKERS,
@@ -2023,6 +2026,7 @@ class CentralConfig:
     ) -> None:
         """Init the client config."""
         self._interface_configs: Final = interface_configs
+        self._optional_settings: Final = frozenset(optional_settings or ())
         self.requires_xml_rpc_server: Final = any(
             ic for ic in interface_configs if ic.rpc_server == RpcServerType.XML_RPC
         )
@@ -2048,8 +2052,15 @@ class CentralConfig:
         self.periodic_refresh_interval = periodic_refresh_interval
         self.program_markers: Final = program_markers
         self.start_direct: Final = start_direct
-        self.start_recorder_for_minutes: Final = start_recorder_for_minutes
-        self.start_recorder = start_recorder_for_minutes > 0
+        self.session_recorder_randomize_output = (
+            OptionalSettings.SR_DISABLE_RANDOMIZE_OUTPUT not in self._optional_settings
+        )
+        self.session_recorder_start_for_seconds: Final = (
+            DEFAULT_SESSION_RECORDER_START_FOR_SECONDS
+            if OptionalSettings.SR_RECORD_SYSTEM_INIT in self._optional_settings
+            else 0
+        )
+        self.session_recorder_start = self.session_recorder_start_for_seconds > 0
         self.storage_directory: Final = storage_directory
         self.sys_scan_interval: Final = sys_scan_interval
         self.sysvar_markers: Final = sysvar_markers

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/client/__init__.py

@@ -60,7 +60,6 @@ from aiohomematic.client.rpc_proxy import AioXmlRpcProxy, BaseRpcProxy
 from aiohomematic.const import (
     CALLBACK_WARN_INTERVAL,
     DATETIME_FORMAT_MILLIS,
-    DEFAULT_CUSTOM_ID,
     DEFAULT_MAX_WORKERS,
     DP_KEY_VALUE,
     DUMMY_SERIAL,
@@ -81,6 +80,7 @@ from aiohomematic.const import (
     ForcedDeviceAvailability,
     Interface,
     InterfaceEventType,
+    InternalCustomID,
     Operations,
     ParameterData,
     ParameterType,
@@ -1815,7 +1815,9 @@ async def _track_single_data_point_state_change_or_timeout(
             )
             return
         if (
-            unsub := dp.register_data_point_updated_callback(cb=_async_event_changed, custom_id=DEFAULT_CUSTOM_ID)
+            unsub := dp.register_data_point_updated_callback(
+                cb=_async_event_changed, custom_id=InternalCustomID.DEFAULT
+            )
         ) is None:
             return
 

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/const.py

@@ -19,7 +19,7 @@ import sys
 from types import MappingProxyType
 from typing import Any, Final, NamedTuple, Required, TypeAlias, TypedDict
 
-VERSION: Final = "2025.10.9"
+VERSION: Final = "2025.10.10"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -27,8 +27,6 @@ _TEST_SPEEDUP: Final = (
 )
 
 # default
-DEFAULT_STORAGE_DIRECTORY: Final = "aiohomematic_storage"
-DEFAULT_CUSTOM_ID: Final = "custom_id"
 DEFAULT_DELAY_NEW_DEVICE_CREATION: Final = False
 DEFAULT_ENABLE_DEVICE_FIRMWARE_CHECK: Final = False
 DEFAULT_ENABLE_PROGRAM_SCAN: Final = True
@@ -40,8 +38,11 @@ DEFAULT_INCLUDE_INTERNAL_SYSVARS: Final = True
 DEFAULT_MAX_READ_WORKERS: Final = 1
 DEFAULT_MAX_WORKERS: Final = 1
 DEFAULT_MULTIPLIER: Final = 1.0
+DEFAULT_OPTIONAL_SETTINGS: Final[tuple[OptionalSettings | str, ...]] = ()
 DEFAULT_PERIODIC_REFRESH_INTERVAL: Final = 15
 DEFAULT_PROGRAM_MARKERS: Final[tuple[DescriptionMarker | str, ...]] = ()
+DEFAULT_SESSION_RECORDER_START_FOR_SECONDS: Final = 120
+DEFAULT_STORAGE_DIRECTORY: Final = "aiohomematic_storage"
 DEFAULT_SYSVAR_MARKERS: Final[tuple[DescriptionMarker | str, ...]] = ()
 DEFAULT_SYS_SCAN_INTERVAL: Final = 30
 DEFAULT_TLS: Final = False
@@ -49,12 +50,6 @@ DEFAULT_UN_IGNORES: Final[frozenset[str]] = frozenset()
 DEFAULT_USE_GROUP_CHANNEL_FOR_COVER_STATE: Final = True
 DEFAULT_VERIFY_TLS: Final = False
 
-MANU_TEMP_CUSTOM_ID: Final = "manu_temp"
-INTERNAL_CUSTOM_IDS: Final[tuple[str, ...]] = (
-    DEFAULT_CUSTOM_ID,
-    MANU_TEMP_CUSTOM_ID,
-)
-
 # Default encoding for json service calls, persistent cache
 UTF_8: Final = "utf-8"
 # Default encoding for xmlrpc service calls and script files
@@ -214,6 +209,13 @@ class CommandRxMode(StrEnum):
     WAKEUP = "WAKEUP"
 
 
+class InternalCustomID(StrEnum):
+    """Enum for Homematic internal custom IDs."""
+
+    DEFAULT = "cid_default"
+    MANU_TEMP = "cid_manu_temp"
+
+
 class DataOperationResult(Enum):
     """Enum with data operation results."""
 
@@ -352,6 +354,13 @@ class Operations(IntEnum):
     EVENT = 4
 
 
+class OptionalSettings(StrEnum):
+    """Enum with aiohomematic optional settings."""
+
+    SR_DISABLE_RANDOMIZE_OUTPUT = "SR_DISABLE_RANDOMIZED_OUTPUT"
+    SR_RECORD_SYSTEM_INIT = "SR_RECORD_SYSTEM_INIT"
+
+
 class Parameter(StrEnum):
     """Enum with Homematic parameters."""
 

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/model/custom/climate.py

@@ -12,10 +12,10 @@ import logging
 from typing import Any, Final, cast
 
 from aiohomematic.const import (
-    MANU_TEMP_CUSTOM_ID,
     SCHEDULER_PROFILE_PATTERN,
     SCHEDULER_TIME_PATTERN,
     DataPointCategory,
+    InternalCustomID,
     Parameter,
     ParamsetKey,
     ProductGroup,
@@ -235,7 +235,7 @@ class BaseCustomDpClimate(CustomDataPoint):
         )
         self._unregister_callbacks.append(
             self._dp_setpoint.register_data_point_updated_callback(
-                cb=self._manu_temp_changed, custom_id=MANU_TEMP_CUSTOM_ID
+                cb=self._manu_temp_changed, custom_id=InternalCustomID.MANU_TEMP
             )
         )
 
@@ -802,7 +802,7 @@ class CustomDpRfThermostat(BaseCustomDpClimate):
 
         self._unregister_callbacks.append(
             self._dp_control_mode.register_data_point_updated_callback(
-                cb=self._manu_temp_changed, custom_id=MANU_TEMP_CUSTOM_ID
+                cb=self._manu_temp_changed, custom_id=InternalCustomID.MANU_TEMP
             )
         )
 
@@ -1047,7 +1047,7 @@ class CustomDpIpThermostat(BaseCustomDpClimate):
 
         self._unregister_callbacks.append(
             self._dp_set_point_mode.register_data_point_updated_callback(
-                cb=self._manu_temp_changed, custom_id=MANU_TEMP_CUSTOM_ID
+                cb=self._manu_temp_changed, custom_id=InternalCustomID.MANU_TEMP
             )
         )
 

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/model/data_point.py

@@ -39,11 +39,9 @@ from aiohomematic import central as hmcu, client as hmcl, support as hms, valida
 from aiohomematic.async_support import loop_check
 from aiohomematic.const import (
     CALLBACK_TYPE,
-    DEFAULT_CUSTOM_ID,
     DEFAULT_MULTIPLIER,
     DP_KEY_VALUE,
     INIT_DATETIME,
-    INTERNAL_CUSTOM_IDS,
     KEY_CHANNEL_OPERATION_MODE_VISIBILITY,
     KWARGS_ARG_CUSTOM_ID,
     KWARGS_ARG_DATA_POINT,
@@ -55,6 +53,7 @@ from aiohomematic.const import (
     DataPointUsage,
     EventKey,
     Flag,
+    InternalCustomID,
     Operations,
     Parameter,
     ParameterData,
@@ -309,11 +308,11 @@ class CallbackDataPoint(ABC, LogContextMixin):
 
     def register_internal_data_point_updated_callback(self, *, cb: Callable) -> CALLBACK_TYPE:
         """Register internal data_point updated callback."""
-        return self.register_data_point_updated_callback(cb=cb, custom_id=DEFAULT_CUSTOM_ID)
+        return self.register_data_point_updated_callback(cb=cb, custom_id=InternalCustomID.DEFAULT)
 
     def register_data_point_updated_callback(self, *, cb: Callable, custom_id: str) -> CALLBACK_TYPE:
         """Register data_point updated callback."""
-        if custom_id not in INTERNAL_CUSTOM_IDS:
+        if custom_id not in InternalCustomID:
             if self._custom_id is not None and self._custom_id != custom_id:
                 raise AioHomematicException(
                     f"REGISTER_data_point_updated_CALLBACK failed: hm_data_point: {self.full_name} is already registered by {self._custom_id}"

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/model/device.py

@@ -1293,7 +1293,7 @@ class _DefinitionExporter:
             str, dict[ParamsetKey, dict[str, ParameterData]]
         ] = await self._client.get_all_paramset_descriptions(device_descriptions=tuple(device_descriptions.values()))
         model = device_descriptions[self._device_address]["TYPE"]
-        filename = f"{model}.json"
+        file_name = f"{model}.json"
 
         # anonymize device_descriptions
         anonymize_device_descriptions: list[DeviceDescription] = []
@@ -1316,14 +1316,14 @@ class _DefinitionExporter:
         # Save device_descriptions for device to file.
         await self._save(
             directory=f"{self._storage_directory}/{DEVICE_DESCRIPTIONS_DIR}",
-            filename=filename,
+            file_name=file_name,
             data=anonymize_device_descriptions,
         )
 
         # Save device_descriptions for device to file.
         await self._save(
             directory=f"{self._storage_directory}/{PARAMSET_DESCRIPTIONS_DIR}",
-            filename=filename,
+            file_name=file_name,
             data=anonymize_paramset_descriptions,
         )
 
@@ -1332,13 +1332,13 @@ class _DefinitionExporter:
         address_parts[0] = self._random_id
         return ADDRESS_SEPARATOR.join(address_parts)
 
-    async def _save(self, *, directory: str, filename: str, data: Any) -> DataOperationResult:
+    async def _save(self, *, directory: str, file_name: str, data: Any) -> DataOperationResult:
         """Save file to disk."""
 
         def perform_save() -> DataOperationResult:
             if not check_or_create_directory(directory=directory):
                 return DataOperationResult.NO_SAVE  # pragma: no cover
-            with open(file=os.path.join(directory, filename), mode="wb") as fptr:
+            with open(file=os.path.join(directory, file_name), mode="wb") as fptr:
                 fptr.write(orjson.dumps(data, option=orjson.OPT_INDENT_2 | orjson.OPT_NON_STR_KEYS))
             return DataOperationResult.SAVE_SUCCESS
 

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/model/update.py

@@ -11,11 +11,11 @@ from typing import Final
 
 from aiohomematic.const import (
     CALLBACK_TYPE,
-    DEFAULT_CUSTOM_ID,
     HMIP_FIRMWARE_UPDATE_IN_PROGRESS_STATES,
     HMIP_FIRMWARE_UPDATE_READY_STATES,
     DataPointCategory,
     Interface,
+    InternalCustomID,
 )
 from aiohomematic.decorators import inspector
 from aiohomematic.exceptions import AioHomematicException
@@ -114,7 +114,7 @@ class DpUpdate(CallbackDataPoint, PayloadMixin):
 
     def register_data_point_updated_callback(self, *, cb: Callable, custom_id: str) -> CALLBACK_TYPE:
         """Register update callback."""
-        if custom_id != DEFAULT_CUSTOM_ID:
+        if custom_id != InternalCustomID.DEFAULT:
             if self._custom_id is not None:
                 raise AioHomematicException(
                     f"REGISTER_UPDATE_CALLBACK failed: hm_data_point: {self.full_name} is already registered by {self._custom_id}"

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic/store/persistent.py

@@ -27,7 +27,7 @@ Key behaviors
 - Save/load/clear operations are synchronized via a semaphore and executed via
   the CentralUnit looper to avoid blocking the event loop.
 
-Helper functions are provided to build content paths and filenames and to
+Helper functions are provided to build content paths and file names and to
 optionally clean up stale content directories.
 """
 
@@ -89,7 +89,7 @@ class BasePersistentFile(ABC):
         "_persistent_content",
         "_save_load_semaphore",
         "_sub_directory",
-        "_use_ts_in_filenames",
+        "_use_ts_in_file_names",
         "last_hash_saved",
         "last_save_triggered",
     )
@@ -123,27 +123,27 @@ class BasePersistentFile(ABC):
         """Return if the data has changed."""
         return self.content_hash != self.last_hash_saved
 
-    def _get_filename(
+    def _get_file_name(
         self,
         *,
-        use_ts_in_filename: bool = False,
+        use_ts_in_file_name: bool = False,
     ) -> str:
         """Return the file name."""
-        return _get_filename(
+        return _get_file_name(
             central_name=self._central.name,
             file_name=self._file_postfix,
-            ts=datetime.now() if use_ts_in_filename else None,
+            ts=datetime.now() if use_ts_in_file_name else None,
         )
 
     def _get_file_path(
         self,
         *,
-        use_ts_in_filename: bool = False,
+        use_ts_in_file_name: bool = False,
     ) -> str:
         """Return the full file path."""
-        return os.path.join(self._directory, self._get_filename(use_ts_in_filename=use_ts_in_filename))
+        return os.path.join(self._directory, self._get_file_name(use_ts_in_file_name=use_ts_in_file_name))
 
-    async def save(self, *, randomize_output: bool = False, use_ts_in_filename: bool = False) -> DataOperationResult:
+    async def save(self, *, randomize_output: bool = False, use_ts_in_file_name: bool = False) -> DataOperationResult:
         """Save current data to disk."""
         if not self._should_save:
             return DataOperationResult.NO_SAVE
@@ -154,7 +154,7 @@ class BasePersistentFile(ABC):
         def _perform_save() -> DataOperationResult:
             try:
                 with open(
-                    file=self._get_file_path(use_ts_in_filename=use_ts_in_filename),
+                    file=self._get_file_path(use_ts_in_file_name=use_ts_in_file_name),
                     mode="wb",
                 ) as file_pointer:
                     file_pointer.write(
@@ -173,7 +173,7 @@ class BasePersistentFile(ABC):
 
         async with self._save_load_semaphore:
             return await self._central.looper.async_add_executor_job(
-                _perform_save, name=f"save-persistent-content-{self._get_filename()}"
+                _perform_save, name=f"save-persistent-content-{self._get_file_name()}"
             )
 
     def _manipulate_content(self, *, content: bytes, randomize_output: bool = False) -> bytes:
@@ -197,13 +197,16 @@ class BasePersistentFile(ABC):
             and self.content_hash != self.last_hash_saved
         )
 
-    async def load(self) -> DataOperationResult:
+    async def load(self, *, file_path: str | None = None) -> DataOperationResult:
         """Load data from disk into the dictionary."""
-        if not check_or_create_directory(directory=self._directory) or not os.path.exists(self._get_file_path()):
+        if not file_path and not check_or_create_directory(directory=self._directory):
+            return DataOperationResult.NO_LOAD
+
+        if (file_path := file_path or self._get_file_path()) and not os.path.exists(file_path):
             return DataOperationResult.NO_LOAD
 
         def _perform_load() -> DataOperationResult:
-            with open(file=self._get_file_path(), encoding=UTF_8) as file_pointer:
+            with open(file=file_path, encoding=UTF_8) as file_pointer:
                 try:
                     data = json.loads(file_pointer.read(), object_hook=regular_to_default_dict_hook)
                     if (converted_hash := hash_sha256(value=data)) == self.last_hash_saved:
@@ -217,7 +220,7 @@ class BasePersistentFile(ABC):
 
         async with self._save_load_semaphore:
             return await self._central.looper.async_add_executor_job(
-                _perform_load, name=f"load-persistent-content-{self._get_filename()}"
+                _perform_load, name=f"load-persistent-content-{self._get_file_name()}"
             )
 
     async def clear(self) -> None:
@@ -358,12 +361,12 @@ class DeviceDescriptionCache(BasePersistentFile):
         addr_set.add(device_address)
         addr_set.add(address)
 
-    async def load(self) -> DataOperationResult:
+    async def load(self, *, file_path: str | None = None) -> DataOperationResult:
         """Load device data from disk into _device_description_cache."""
         if not self._central.config.use_caches:
             _LOGGER.debug("load: not caching paramset descriptions for %s", self._central.name)
             return DataOperationResult.NO_LOAD
-        if (result := await super().load()) == DataOperationResult.LOAD_SUCCESS:
+        if (result := await super().load(file_path=file_path)) == DataOperationResult.LOAD_SUCCESS:
             for (
                 interface_id,
                 device_descriptions,
@@ -495,12 +498,12 @@ class ParamsetDescriptionCache(BasePersistentFile):
             for parameter in paramset:
                 cache.setdefault((device_address, parameter), set()).add(channel_no)
 
-    async def load(self) -> DataOperationResult:
+    async def load(self, *, file_path: str | None = None) -> DataOperationResult:
         """Load paramset descriptions from disk into paramset cache."""
         if not self._central.config.use_caches:
             _LOGGER.debug("load: not caching device descriptions for %s", self._central.name)
             return DataOperationResult.NO_LOAD
-        if (result := await super().load()) == DataOperationResult.LOAD_SUCCESS:
+        if (result := await super().load(file_path=file_path)) == DataOperationResult.LOAD_SUCCESS:
             self._init_address_parameter_list()
         return result
 
@@ -511,17 +514,16 @@ class SessionRecorder(BasePersistentFile):
 
     Nested cache with TTL support.
     Structure:
-        store[rpc_type][method][params] = (ts: datetime, response: Any, ttl_s: float)
+        store[rpc_type][method][params][ts: datetime] = response: Any
 
-    - Each entry expires after its TTL (global default or per-entry override).
     - Expiration is lazy (checked on access/update).
     - Optional refresh_on_get extends TTL when reading.
     """
 
     __slots__ = (
         "_active",
-        "_default_ttl",
-        "_is_delayed",
+        "_ttl",
+        "_is_recording",
         "_refresh_on_get",
         "_store",
     )
@@ -533,20 +535,20 @@ class SessionRecorder(BasePersistentFile):
         self,
         *,
         central: hmcu.CentralUnit,
-        default_ttl_seconds: float,
         active: bool,
+        ttl_seconds: float,
         refresh_on_get: bool = False,
     ):
         """Init the cache."""
         self._active = active
-        if default_ttl_seconds <= 0:
+        if ttl_seconds < 0:
             raise ValueError("default_ttl_seconds must be positive")
-        self._default_ttl: Final = float(default_ttl_seconds)
-        self._is_delayed: bool = False
+        self._ttl: Final = float(ttl_seconds)
+        self._is_recording: bool = False
         self._refresh_on_get: Final = refresh_on_get
-        # Use nested defaultdicts: rpc_type -> method -> params -> ts(int) -> (response, ttl_s)
+        # Use nested defaultdicts: rpc_type -> method -> params -> ts(int) -> response
         # Annotate as defaultdict to match the actual type and satisfy mypy.
-        self._store: dict[str, dict[str, dict[str, dict[int, tuple[Any, float]]]]] = defaultdict(
+        self._store: dict[str, dict[str, dict[str, dict[int, Any]]]] = defaultdict(
             lambda: defaultdict(lambda: defaultdict(dict))
         )
         super().__init__(
@@ -556,6 +558,13 @@ class SessionRecorder(BasePersistentFile):
 
     # ---------- internal helpers ----------
 
+    def _is_expired(self, *, ts: int, now: int | None = None) -> bool:
+        """Check whether an entry has expired given epoch seconds."""
+        if self._ttl == 0:
+            return False
+        now = now if now is not None else _now()
+        return (now - ts) > self._ttl
+
     def _purge_expired_at(
         self,
         *,
@@ -563,7 +572,8 @@ class SessionRecorder(BasePersistentFile):
         method: str,
     ) -> None:
         """Remove expired entries for a given (rpc_type, method) bucket without creating new ones."""
-
+        if self._ttl == 0:
+            return
         if not (bucket_by_method := self._store.get(rpc_type)):
             return
         if not (bucket_by_parameter := bucket_by_method.get(method)):
@@ -571,9 +581,7 @@ class SessionRecorder(BasePersistentFile):
         now = _now()
         empty_params: list[str] = []
         for p, bucket_by_ts in bucket_by_parameter.items():
-            expired_ts = [
-                ts for ts, (_r, ttl_s) in list(bucket_by_ts.items()) if _is_expired(ts=ts, ttl_s=ttl_s, now=now)
-            ]
+            expired_ts = [ts for ts, _r in list(bucket_by_ts.items()) if self._is_expired(ts=ts, now=now)]
             for ts in expired_ts:
                 del bucket_by_ts[ts]
             if not bucket_by_ts:
@@ -597,21 +605,24 @@ class SessionRecorder(BasePersistentFile):
         return self._active
 
     async def _deactivate_after_delay(
-        self, *, delay: int, auto_save: bool, randomize_output: bool, use_ts_in_filename: bool
+        self, *, delay: int, auto_save: bool, randomize_output: bool, use_ts_in_file_name: bool
     ) -> None:
         """Change the state of the session recorder after a delay."""
-        self._is_delayed = True
+        self._is_recording = True
         await asyncio.sleep(delay)
         self._active = False
-        self._is_delayed = False
+        self._is_recording = False
         if auto_save:
-            await self.save(randomize_output=randomize_output, use_ts_in_filename=use_ts_in_filename)
-        _LOGGER.debug("Deactivated session recorder after %s minutes", {delay / 60})
+            await self.save(randomize_output=randomize_output, use_ts_in_file_name=use_ts_in_file_name)
+        _LOGGER.debug("Deactivated session recorder after %s seconds", {delay})
 
     async def activate(
-        self, *, on_time: int = 0, auto_save: bool, randomize_output: bool, use_ts_in_filename: bool
-    ) -> None:
+        self, *, on_time: int = 0, auto_save: bool, randomize_output: bool, use_ts_in_file_name: bool
+    ) -> bool:
         """Activate the session recorder. Disable after on_time(seconds)."""
+        if self._is_recording:
+            _LOGGER.info("ACTIVATE: Recording session is already running.")
+            return False
         self._store.clear()
         self._active = True
         if on_time > 0:
@@ -620,28 +631,33 @@ class SessionRecorder(BasePersistentFile):
                     delay=on_time,
                     auto_save=auto_save,
                     randomize_output=randomize_output,
-                    use_ts_in_filename=use_ts_in_filename,
+                    use_ts_in_file_name=use_ts_in_file_name,
                 ),
                 name=f"session_recorder_{self._central.name}",
             )
+        return True
 
     async def deactivate(
-        self, *, delay: int, auto_save: bool, randomize_output: bool, use_ts_in_filename: bool
-    ) -> None:
+        self, *, delay: int, auto_save: bool, randomize_output: bool, use_ts_in_file_name: bool
+    ) -> bool:
         """Deactivate the session recorder. Optionally after a delay(seconds)."""
+        if self._is_recording:
+            _LOGGER.info("DEACTIVATE: Recording session is already running.")
+            return False
         if delay > 0:
             self._central.looper.create_task(
                 target=self._deactivate_after_delay(
                     delay=delay,
                     auto_save=auto_save,
                     randomize_output=randomize_output,
-                    use_ts_in_filename=use_ts_in_filename,
+                    use_ts_in_file_name=use_ts_in_file_name,
                 ),
                 name=f"session_recorder_{self._central.name}",
             )
         else:
             self._active = False
-            self._is_delayed = False
+            self._is_recording = False
+        return True
 
     def add_json_rpc_session(
         self,
@@ -689,14 +705,11 @@ class SessionRecorder(BasePersistentFile):
         method: str,
         params: Any,
         response: Any,
-        ttl_seconds: float | None = None,
         ts: int | datetime | None = None,
     ) -> Self:
         """Insert or update an entry."""
         self._purge_expired_at(rpc_type=rpc_type, method=method)
         frozen_param = _freeze_params(params)
-        if (ttl_s := ttl_seconds if ttl_seconds is not None else self._default_ttl) <= 0:
-            raise ValueError("ttl_seconds must be positive")
         # Normalize timestamp to int epoch seconds
         if isinstance(ts, datetime):
             ts_int = int(ts.timestamp())
@@ -704,7 +717,7 @@ class SessionRecorder(BasePersistentFile):
             ts_int = ts
         else:
             ts_int = _now()
-        self._bucket(rpc_type=rpc_type, method=method)[frozen_param][ts_int] = (response, ttl_s)
+        self._bucket(rpc_type=rpc_type, method=method)[frozen_param][ts_int] = response
         return self
 
     def get(
@@ -736,9 +749,9 @@ class SessionRecorder(BasePersistentFile):
             latest_ts = max(bucket_by_ts.keys())
         except ValueError:
             return default
-        resp, ttl_s = bucket_by_ts[latest_ts]
+        resp = bucket_by_ts[latest_ts]
         if self._refresh_on_get:
-            bucket_by_ts[_now()] = (resp, ttl_s)
+            bucket_by_ts[_now()] = resp
         return resp
 
     def delete(self, *, rpc_type: str, method: str, params: Any) -> bool:
@@ -762,7 +775,7 @@ class SessionRecorder(BasePersistentFile):
                 self._store.pop(rpc_type, None)
         return True
 
-    def get_latest_fresh(self, *, rpc_type: str, method: str) -> list[tuple[Any, Any]]:
+    def get_latest_response_by_method(self, *, rpc_type: str, method: str) -> list[tuple[Any, Any]]:
         """Return latest non-expired responses for a given (rpc_type, method)."""
         # Purge expired entries first without creating any new buckets.
         self._purge_expired_at(rpc_type=rpc_type, method=method)
@@ -780,12 +793,40 @@ class SessionRecorder(BasePersistentFile):
                 latest_ts = max(bucket_by_ts.keys())
             except ValueError:
                 continue
-            resp, _ttl_s = bucket_by_ts[latest_ts]
+            resp = bucket_by_ts[latest_ts]
             params = _unfreeze_params(frozen_params=frozen_params)
 
             result.append((params, resp))
         return result
 
+    def get_latest_response_by_params(
+        self,
+        *,
+        rpc_type: str,
+        method: str,
+        params: Any,
+    ) -> Any:
+        """Return latest non-expired responses for a given (rpc_type, method, params)."""
+        # Purge expired entries first without creating any new buckets.
+        self._purge_expired_at(rpc_type=rpc_type, method=method)
+
+        # Access store safely to avoid side effects from creating buckets.
+        if not (bucket_by_method := self._store.get(rpc_type)):
+            return None
+        if not (bucket_by_parameter := bucket_by_method.get(method)):
+            return None
+        frozen_params = _freeze_params(params=params)
+
+        # For each parameter, choose the response at the latest timestamp.
+        if (bucket_by_ts := bucket_by_parameter.get(frozen_params)) is None:
+            return None
+
+        try:
+            latest_ts = max(bucket_by_ts.keys())
+            return bucket_by_ts[latest_ts]
+        except ValueError:
+            return None
+
     def cleanup(self) -> None:
         """Purge all expired entries globally."""
         for rpc_type in list(self._store.keys()):
@@ -893,6 +934,8 @@ def _unfreeze_params(frozen_params: str) -> Any:
             return {k: _walk(v) for k, v in o.items()}
         if isinstance(o, list):
             return [_walk(x) for x in o]
+        if isinstance(o, tuple):
+            return tuple(_walk(x) for x in o)
         if o.startswith("{") and o.endswith("}"):
             return ast.literal_eval(o)
         return o
@@ -905,8 +948,8 @@ def _get_file_path(*, storage_directory: str, sub_directory: str) -> str:
     return f"{storage_directory}/{sub_directory}"
 
 
-def _get_filename(*, central_name: str, file_name: str, ts: datetime | None = None) -> str:
-    """Return the content filename."""
+def _get_file_name(*, central_name: str, file_name: str, ts: datetime | None = None) -> str:
+    """Return the content file_name."""
     fn = f"{slugify(central_name)}_{file_name}"
     if ts:
         fn += f"_{ts.strftime(FILE_NAME_TS_PATTERN)}"
@@ -918,12 +961,6 @@ def _now() -> int:
     return int(datetime.now(tz=UTC).timestamp())
 
 
-def _is_expired(*, ts: int, ttl_s: float, now: int | None = None) -> bool:
-    """Check whether an entry has expired given epoch seconds."""
-    now = now if now is not None else _now()
-    return (now - ts) > ttl_s
-
-
 async def cleanup_files(*, central_name: str, storage_directory: str) -> None:
     """Clean up the used files."""
     loop = asyncio.get_running_loop()

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.9
+Version: 2025.10.10
 Summary: Homematic interface for Home Assistant running on Python 3.
 Home-page: https://github.com/sukramj/aiohomematic
 Author-email: SukramJ <sukramj@icloud.com>, Daniel Perna <danielperna84@gmail.com>

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic.egg-info/SOURCES.txt

@@ -103,6 +103,7 @@ tests/test_logging_support.py
 tests/test_number.py
 tests/test_select.py
 tests/test_sensor.py
+tests/test_session_recorder.py
 tests/test_siren.py
 tests/test_support.py
 tests/test_support_extra.py

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/aiohomematic_support/client_local.py

@@ -269,7 +269,7 @@ class ClientLocal(Client):  # pragma: no cover
                 data := await self._load_json_file(
                     anchor=self._local_resources.anchor,
                     resource=self._local_resources.paramset_description_dir,
-                    filename=file_name,
+                    file_name=file_name,
                 )
             )
         ):
@@ -329,20 +329,20 @@ class ClientLocal(Client):  # pragma: no cover
             exclude_list = []
         result: list[Any] = []
         resource_path = os.path.join(str(importlib.resources.files(anchor)), resource)
-        for filename in os.listdir(resource_path):
-            if filename not in include_list or filename in exclude_list:
+        for file_name in os.listdir(resource_path):
+            if file_name not in include_list or file_name in exclude_list:
                 continue
-            if file_content := await self._load_json_file(anchor=anchor, resource=resource, filename=filename):
+            if file_content := await self._load_json_file(anchor=anchor, resource=resource, file_name=file_name):
                 result.append(file_content)
         return result
 
-    async def _load_json_file(self, *, anchor: str, resource: str, filename: str) -> Any | None:
+    async def _load_json_file(self, *, anchor: str, resource: str, file_name: str) -> Any | None:
         """Load json file from disk into dict."""
         package_path = str(importlib.resources.files(anchor))
 
         def _perform_load() -> Any | None:
             with open(
-                file=os.path.join(package_path, resource, filename),
+                file=os.path.join(package_path, resource, file_name),
                 encoding=UTF_8,
             ) as fptr:
                 return orjson.loads(fptr.read())

{aiohomematic-2025.10.9 → aiohomematic-2025.10.10}/tests/test_central.py

@@ -599,7 +599,7 @@ async def test_add_device(
     assert len(central.get_data_points(exclude_no_create=False)) == 33
     assert len(central.device_descriptions._raw_device_descriptions.get(const.INTERFACE_ID)) == 9
     assert len(central.paramset_descriptions._raw_paramset_descriptions.get(const.INTERFACE_ID)) == 9
-    dev_desc = helper.load_device_description(central=central, filename="HmIP-BSM.json")
+    dev_desc = helper.load_device_description(central=central, file_name="HmIP-BSM.json")
     await central.add_new_devices(interface_id=const.INTERFACE_ID, device_descriptions=dev_desc)
     assert len(central._devices) == 2
     assert len(central.get_data_points(exclude_no_create=False)) == 64

aiohomematic-2025.10.10/tests/test_session_recorder.py

@@ -0,0 +1,38 @@
+"""Test the session recorder."""
+
+from __future__ import annotations
+
+import pytest
+
+from aiohomematic.const import RPCType
+
+
+@pytest.mark.enable_socket
+@pytest.mark.asyncio
+async def test_session_recorder(session_recorder_from_full_session) -> None:
+    """Test the session recorder."""
+    assert session_recorder_from_full_session
+    lm_methods = session_recorder_from_full_session.get_latest_response_by_method(
+        rpc_type=RPCType.XML_RPC, method="system.listMethods"
+    )
+    assert lm_methods
+    assert len(lm_methods) == 1
+
+    assert session_recorder_from_full_session
+    pd_methods = session_recorder_from_full_session.get_latest_response_by_method(
+        rpc_type=RPCType.XML_RPC, method="getParamsetDescription"
+    )
+    assert pd_methods
+    assert len(pd_methods) == 3561
+
+    list_methods = session_recorder_from_full_session.get_latest_response_by_params(
+        rpc_type=RPCType.XML_RPC, method="system.listMethods", params=()
+    )
+    assert list_methods
+    assert len(list_methods) == 53
+
+    dd_mestods = session_recorder_from_full_session.get_latest_response_by_params(
+        rpc_type=RPCType.JSON_RPC, method="Interface.listInterfaces", params="{'_session_id_': 'DzzhYRjWXr'}"
+    )
+    assert dd_mestods
+    assert len(dd_mestods["result"]) == 3