aiohomematic 2025.10.9__py3-none-any.whl → 2025.10.11__py3-none-any.whl

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.
 """
 
@@ -43,6 +43,7 @@ import json
 import logging
 import os
 from typing import Any, Final, Self
+import zipfile
 
 import orjson
 from slugify import slugify
@@ -89,7 +90,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 +124,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 +155,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 +174,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,27 +198,45 @@ class BasePersistentFile(ABC):
             and self.content_hash != self.last_hash_saved
         )
 
-    async def load(self) -> 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()):
+    async def load(self, *, file_path: str | None = None) -> DataOperationResult:
+        """
+        Load data from disk into the dictionary.
+
+        Supports plain JSON files and ZIP archives containing a JSON file.
+        When a ZIP archive is provided, the first JSON member inside the archive
+        will be loaded.
+        """
+        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:
-                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:
-                        return DataOperationResult.NO_LOAD
-                    self._persistent_content.clear()
-                    self._persistent_content.update(data)
-                    self.last_hash_saved = converted_hash
-                except json.JSONDecodeError:
-                    return DataOperationResult.LOAD_FAIL
+            try:
+                if zipfile.is_zipfile(file_path):
+                    with zipfile.ZipFile(file_path, mode="r") as zf:
+                        # Prefer json files; pick the first .json entry if available
+                        if not (json_members := [n for n in zf.namelist() if n.lower().endswith(".json")]):
+                            return DataOperationResult.LOAD_FAIL
+                        raw = zf.read(json_members[0]).decode(UTF_8)
+                        data = json.loads(raw, object_hook=regular_to_default_dict_hook)
+                else:
+                    with open(file=file_path, encoding=UTF_8) as file_pointer:
+                        data = json.loads(file_pointer.read(), object_hook=regular_to_default_dict_hook)
+
+                if (converted_hash := hash_sha256(value=data)) == self.last_hash_saved:
+                    return DataOperationResult.NO_LOAD
+                self._persistent_content.clear()
+                self._persistent_content.update(data)
+                self.last_hash_saved = converted_hash
+            except (json.JSONDecodeError, zipfile.BadZipFile, UnicodeDecodeError, OSError):
+                return DataOperationResult.LOAD_FAIL
             return DataOperationResult.LOAD_SUCCESS
 
         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 +377,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 +514,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 +530,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 +551,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 +574,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 +588,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 +597,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 +621,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 +647,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 +721,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 +733,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 +765,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 +791,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 +809,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 +950,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 +964,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 +977,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/support.py

@@ -582,6 +582,15 @@ def create_random_device_addresses(*, addresses: list[str]) -> dict[str, str]:
     return {adr: f"VCU{int(random.randint(1000000, 9999999))}" for adr in addresses}
 
 
+def shrink_json_file(file_name: str) -> None:
+    """Shrink a json file."""
+    with open(file_name, "rb") as f:
+        data = orjson.loads(f.read())
+
+    with open(file_name, "wb") as f:
+        f.write(orjson.dumps(data))
+
+
 # --- Structured error boundary logging helpers ---
 
 _BOUNDARY_MSG = "error_boundary"

{aiohomematic-2025.10.9.dist-info → aiohomematic-2025.10.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiohomematic
-Version: 2025.10.9
+Version: 2025.10.11
 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.dist-info → aiohomematic-2025.10.11.dist-info}/RECORD

@@ -1,6 +1,6 @@
 aiohomematic/__init__.py,sha256=Uo9CIoil0Arl3GwtgMZAwM8jhcgoBKcZEgj8cXYlswY,2258
 aiohomematic/async_support.py,sha256=01chvt-Ac_UIAWI39VeGpQV9AmxpSCbNyfPPAwX_Qqc,7865
-aiohomematic/const.py,sha256=8Reu1r01pcMN3U5VQLufSJxCcuzhcU1Utn-IKDIKTgE,27124
+aiohomematic/const.py,sha256=FeWi0VLHTN0nP61c4xZjt1TRJfn2azFchkYPHiXCPrQ,27427
 aiohomematic/context.py,sha256=hGE-iPcPt21dY-1MZar-Hyh9YaKL-VS42xjrulIVyRQ,429
 aiohomematic/converter.py,sha256=FiHU71M5RZ7N5FXJYh2CN14s63-PM-SHdb0cJ_CLx54,3602
 aiohomematic/decorators.py,sha256=cSW0aF3PzrW_qW6H0sjRNH9eqO8ysqhXZDgJ2OJTZM4,11038
@@ -8,28 +8,28 @@ aiohomematic/exceptions.py,sha256=RLldRD4XY8iYuNYVdspCbbphGcKsximB7R5OL7cYKw0,50
 aiohomematic/hmcli.py,sha256=_QZFKcfr_KJrdiyBRbhz0f8LZ95glD7LgJBmQc8cwog,4911
 aiohomematic/property_decorators.py,sha256=3Id1_rWIYnwyN_oSMgbh7XNKz9HPkGTC1CeS5ei04ZQ,17139
 aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiohomematic/support.py,sha256=R275ZIKoufMZORcBa7Tiq0MZ7KtMZiqoUXUJX4LM1qA,23083
+aiohomematic/support.py,sha256=eUbtdnrkq99o2DxJzyai5LHqrkpXC_gWQtrkI4zIgzg,23310
 aiohomematic/validator.py,sha256=qX5janicu4jLrAVzKoyWgXe1XU4EOjk5-QhNFL4awTQ,3541
-aiohomematic/central/__init__.py,sha256=9q1cl0qCVvPSd6eW7ipFdbd783SVLVz1fD_Hh8iDDv8,93519
+aiohomematic/central/__init__.py,sha256=xqlWOAKbnLzYTteVHIdxFpLCBcrTzgub8ZztJd43HTw,94122
 aiohomematic/central/decorators.py,sha256=vrujdw2QMXva-7DGXMQyittujx0q7cPuGD-SCeQlD30,6886
-aiohomematic/central/rpc_server.py,sha256=PX6idUEZ5j9fx9y__Q--Zcc2cyFMhLBie-lNvkx1bsI,10949
-aiohomematic/client/__init__.py,sha256=X7lR-A9fAYKbVoR3aNRui_-pfeR20-sehNSlXvkrIoE,73905
+aiohomematic/central/rpc_server.py,sha256=EhvBy8oMjBTR8MvH5QXo3lvlsCNJrvu6B85_CAg6sG8,10742
+aiohomematic/client/__init__.py,sha256=14lx62VvPm9yQgm5nUVdzgAKkhS8GXeAvV8gmGbldl8,73941
 aiohomematic/client/_rpc_errors.py,sha256=IaYjX60mpBJ43gDCJjuUSVraamy5jXHTRjOnutK4azs,2962
-aiohomematic/client/json_rpc.py,sha256=u25nedb3AEK54GN9F4z3oOCfoE-YTYZpL4166OsRPAg,51274
+aiohomematic/client/json_rpc.py,sha256=mrPvRR4hmc2MfMec8tjdQbF2RK1u0W1byOFUsiEP4fs,51319
 aiohomematic/client/rpc_proxy.py,sha256=T6tmfBAJJSFxzBLrhKJc6_KiHyTs5EVnStQsVJA5YkY,11604
 aiohomematic/model/__init__.py,sha256=gUYa8ROWSbXjZTWUTmINZ1bbYAxGkVpA-onxaJN2Iso,5436
-aiohomematic/model/data_point.py,sha256=7FqnFO9C0_UtUfwPIsaq61QDhjZqsmjkepzzc_9StUs,41595
-aiohomematic/model/device.py,sha256=CQ_zFRVnwmuEQzBEHlgz3DxFzDnW36FVCPlckmho2TI,52891
+aiohomematic/model/data_point.py,sha256=VdwzjRrBDaYhWyIQL4JVC9wYTFMSwvwymYSEAPxjms8,41573
+aiohomematic/model/device.py,sha256=WfnSXPahzyCptCsvoWRbrnQQEqlEbbgKb9qappMUrx4,52898
 aiohomematic/model/event.py,sha256=uO6Z2pCZEU_8MR8uRIIZjX8IL0rFh7sNhhTNT8yFoVU,6852
 aiohomematic/model/support.py,sha256=ITyxBIJ2Bv69fcwuUD2HyMKlburOnLo9NFs5VKg34ZY,19635
-aiohomematic/model/update.py,sha256=p_zyC73fERQxXF2d1O89zi9EJovzNlrYIONJfPOz5_g,5134
+aiohomematic/model/update.py,sha256=R3uUA61m-UQNNGkRod3vES66AgkPKay_CPyyrd-nqVI,5140
 aiohomematic/model/calculated/__init__.py,sha256=JNtxK4-XZeyR6MxfKVPdcF6ezQliQYTWEDoeOChumaE,2966
 aiohomematic/model/calculated/climate.py,sha256=rm9b4rCrmsZAA5_dzP6YRtahdveI97581_EnC4utqpg,10499
 aiohomematic/model/calculated/data_point.py,sha256=ESUqwolPViXPuH9hvL0q5FMvsGXjcqxeyySpNTUAMU8,11587
 aiohomematic/model/calculated/operating_voltage_level.py,sha256=99A8HvahVS4IxpgK1dsgQXHfeubU7JI2c0ObagbnSNQ,13505
 aiohomematic/model/calculated/support.py,sha256=GBD35_OR3TEAWo5ADeH_gk2Ebw9pHOtOnOS7umCkXB0,7989
 aiohomematic/model/custom/__init__.py,sha256=JxJXyr2CgKlj-jc1xQ14lbMT76vvswfLUecwj8RJCXA,6073
-aiohomematic/model/custom/climate.py,sha256=5r0zjBOhnp4QcL2p6x2UYhIMQqa0SG1Sw1cnnyY9POs,57274
+aiohomematic/model/custom/climate.py,sha256=OnkZKxJKInrP52Tqu_hPcDDZbyL0wTMaIjWuBJ3th_k,57292
 aiohomematic/model/custom/const.py,sha256=s4iqhwvt8x41h4-CtMCyXwryGHuBNbhBrcJ5zGVRFJU,4939
 aiohomematic/model/custom/cover.py,sha256=KQzLEoPkKgZ2oi2oblUrGReQnT_0WAuseWAxu_xH5_Y,29035
 aiohomematic/model/custom/data_point.py,sha256=WLKygP3SQwtG35BpOH3HNt_o-z9dfSUmuSyPDIEWF8A,14133
@@ -67,12 +67,10 @@ aiohomematic/rega_scripts/set_program_state.fn,sha256=0bnv7lUj8FMjDZBz325tDVP61m
 aiohomematic/rega_scripts/set_system_variable.fn,sha256=sTmr7vkPTPnPkor5cnLKlDvfsYRbGO1iq2z_2pMXq5E,383
 aiohomematic/store/__init__.py,sha256=PHwF_tw_zL20ODwLywHgpOLWrghQo_BMZzeiQSXN1Fc,1081
 aiohomematic/store/dynamic.py,sha256=kgZs5gJ4i8bHZKkJ883xuLecSKdjj6UwlLRJAvQcNGI,22528
-aiohomematic/store/persistent.py,sha256=yRrGgCLGQtuUAKg37UeLDnp0HcnZjl9DordbjJukLCA,38066
+aiohomematic/store/persistent.py,sha256=SBL8AhqUzpoPtJ50GkLYHwvRJS52fBWqNPjgvykxbY8,40233
 aiohomematic/store/visibility.py,sha256=0y93kPTugqQsrh6kKamfgwBkbIdBPEZpQVv_1NaLz3A,31662
-aiohomematic-2025.10.9.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
-aiohomematic_support/__init__.py,sha256=_0YtF4lTdC_k6-zrM2IefI0u0LMr_WA61gXAyeGLgbY,66
-aiohomematic_support/client_local.py,sha256=GAIg3DN4lD4H9eA3gs_CILtWR3tphXrf_Hai9rWFpM8,12817
-aiohomematic-2025.10.9.dist-info/METADATA,sha256=ezEHtzT_d_BJhX-cCb920mQK5ED0UmvdNsqAoGJrELw,7603
-aiohomematic-2025.10.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic-2025.10.9.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
-aiohomematic-2025.10.9.dist-info/RECORD,,
+aiohomematic-2025.10.11.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
+aiohomematic-2025.10.11.dist-info/METADATA,sha256=r7XE6UJklJaiC8x0NM-lKx3BSErN8oj2ajLnb2Y9mVY,7604
+aiohomematic-2025.10.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.10.11.dist-info/top_level.txt,sha256=iGUvt1N-E72vKRq7Anpp62HwkQngStrUK0JfL1zj1TE,13
+aiohomematic-2025.10.11.dist-info/RECORD,,

aiohomematic-2025.10.11.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiohomematic

aiohomematic-2025.10.9.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-aiohomematic
-aiohomematic_support

aiohomematic_support/__init__.py

@@ -1 +0,0 @@
-"""Module to support aiohomematic testing with a local client."""