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

aiohomematic/caches/persistent.py

@@ -1,478 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2021-2025 Daniel Perna, SukramJ
-"""
-Persistent caches used to persist Homematic metadata between runs.
-
-This module provides on-disk caches that complement the short‑lived, in‑memory
-caches from aiohomematic.caches.dynamic. The goal is to minimize expensive data
-retrieval from the backend by storing stable metadata such as device and
-paramset descriptions in JSON files inside a dedicated cache directory.
-
-Overview
-- BasePersistentCache: Abstract base for file‑backed caches. It encapsulates
-  file path resolution, change detection via hashing, and thread‑safe save/load
-  operations delegated to the CentralUnit looper.
-- DeviceDescriptionCache: Persists device descriptions per interface, including
-  the mapping of device/channels and model metadata.
-- ParamsetDescriptionCache: Persists paramset descriptions per interface and
-  channel, and offers helpers to query parameters, paramset keys and related
-  channel addresses.
-
-Key behaviors
-- Saves only if caches are enabled (CentralConfig.use_caches) and content has
-  changed (hash comparison), keeping I/O minimal and predictable.
-- Uses orjson for fast binary writes and json for reads with a custom
-  object_hook to rebuild nested defaultdict structures.
-- 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 cache paths and filenames and to
-optionally clean up stale cache directories.
-"""
-
-from __future__ import annotations
-
-from abc import ABC
-import asyncio
-from collections import defaultdict
-from collections.abc import Mapping
-from datetime import datetime
-import json
-import logging
-import os
-from typing import Any, Final
-
-import orjson
-from slugify import slugify
-
-from aiohomematic import central as hmcu
-from aiohomematic.const import (
-    ADDRESS_SEPARATOR,
-    CACHE_PATH,
-    FILE_DEVICES,
-    FILE_PARAMSETS,
-    INIT_DATETIME,
-    UTF_8,
-    DataOperationResult,
-    DeviceDescription,
-    ParameterData,
-    ParamsetKey,
-)
-from aiohomematic.model.device import Device
-from aiohomematic.support import (
-    check_or_create_directory,
-    delete_file,
-    get_device_address,
-    get_split_channel_address,
-    hash_sha256,
-    regular_to_default_dict_hook,
-)
-
-_LOGGER: Final = logging.getLogger(__name__)
-
-
-class BasePersistentCache(ABC):
-    """Cache for files."""
-
-    __slots__ = (
-        "_cache_dir",
-        "_central",
-        "_file_postfix",
-        "_filename",
-        "_persistent_cache",
-        "_save_load_semaphore",
-        "last_hash_saved",
-        "last_save_triggered",
-    )
-
-    _file_postfix: str
-
-    def __init__(
-        self,
-        *,
-        central: hmcu.CentralUnit,
-        persistent_cache: dict[str, Any],
-    ) -> None:
-        """Initialize the base class of the persistent cache."""
-        self._save_load_semaphore: Final = asyncio.Semaphore()
-        self._central: Final = central
-        self._cache_dir: Final = _get_cache_path(storage_folder=central.config.storage_folder)
-        self._filename: Final = _get_filename(central_name=central.name, file_name=self._file_postfix)
-        self._persistent_cache: Final = persistent_cache
-        self.last_save_triggered: datetime = INIT_DATETIME
-        self.last_hash_saved = hash_sha256(value=persistent_cache)
-
-    @property
-    def cache_hash(self) -> str:
-        """Return the hash of the cache."""
-        return hash_sha256(value=self._persistent_cache)
-
-    @property
-    def data_changed(self) -> bool:
-        """Return if the data has changed."""
-        return self.cache_hash != self.last_hash_saved
-
-    @property
-    def _file_path(self) -> str:
-        """Return the full file path."""
-        return os.path.join(self._cache_dir, self._filename)
-
-    async def save(self) -> DataOperationResult:
-        """Save current data to disk."""
-        if not self._should_save:
-            return DataOperationResult.NO_SAVE
-
-        def _perform_save() -> DataOperationResult:
-            try:
-                with open(file=self._file_path, mode="wb") as file_pointer:
-                    file_pointer.write(
-                        orjson.dumps(
-                            self._persistent_cache,
-                            option=orjson.OPT_NON_STR_KEYS,
-                        )
-                    )
-                self.last_hash_saved = self.cache_hash
-            except json.JSONDecodeError:
-                return DataOperationResult.SAVE_FAIL
-            return DataOperationResult.SAVE_SUCCESS
-
-        async with self._save_load_semaphore:
-            return await self._central.looper.async_add_executor_job(
-                _perform_save, name=f"save-persistent-cache-{self._filename}"
-            )
-
-    @property
-    def _should_save(self) -> bool:
-        """Determine if save operation should proceed."""
-        self.last_save_triggered = datetime.now()
-        return (
-            check_or_create_directory(directory=self._cache_dir)
-            and self._central.config.use_caches
-            and self.cache_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._cache_dir) or not os.path.exists(self._file_path):
-            return DataOperationResult.NO_LOAD
-
-        def _perform_load() -> DataOperationResult:
-            with open(file=self._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_cache.clear()
-                    self._persistent_cache.update(data)
-                    self.last_hash_saved = converted_hash
-                except json.JSONDecodeError:
-                    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-cache-{self._filename}"
-            )
-
-    async def clear(self) -> None:
-        """Remove stored file from disk."""
-
-        def _perform_clear() -> None:
-            delete_file(folder=self._cache_dir, file_name=self._filename)
-            self._persistent_cache.clear()
-
-        async with self._save_load_semaphore:
-            await self._central.looper.async_add_executor_job(_perform_clear, name="clear-persistent-cache")
-
-
-class DeviceDescriptionCache(BasePersistentCache):
-    """Cache for device/channel names."""
-
-    __slots__ = (
-        "_addresses",
-        "_device_descriptions",
-        "_raw_device_descriptions",
-    )
-
-    _file_postfix = FILE_DEVICES
-
-    def __init__(self, *, central: hmcu.CentralUnit) -> None:
-        """Initialize the device description cache."""
-        # {interface_id, [device_descriptions]}
-        self._raw_device_descriptions: Final[dict[str, list[DeviceDescription]]] = defaultdict(list)
-        super().__init__(
-            central=central,
-            persistent_cache=self._raw_device_descriptions,
-        )
-        # {interface_id, {device_address, [channel_address]}}
-        self._addresses: Final[dict[str, dict[str, set[str]]]] = defaultdict(lambda: defaultdict(set))
-        # {interface_id, {address, device_descriptions}}
-        self._device_descriptions: Final[dict[str, dict[str, DeviceDescription]]] = defaultdict(dict)
-
-    def add_device(self, *, interface_id: str, device_description: DeviceDescription) -> None:
-        """Add a device to the cache."""
-        # Fast-path: If the address is not yet known, skip costly removal operations.
-        if (address := device_description["ADDRESS"]) not in self._device_descriptions[interface_id]:
-            self._raw_device_descriptions[interface_id].append(device_description)
-            self._process_device_description(interface_id=interface_id, device_description=device_description)
-            return
-        # Address exists: remove old entries before adding the new description.
-        self._remove_device(
-            interface_id=interface_id,
-            addresses_to_remove=[address],
-        )
-        self._raw_device_descriptions[interface_id].append(device_description)
-        self._process_device_description(interface_id=interface_id, device_description=device_description)
-
-    def get_raw_device_descriptions(self, *, interface_id: str) -> list[DeviceDescription]:
-        """Retrieve raw device descriptions from the cache."""
-        return self._raw_device_descriptions[interface_id]
-
-    def remove_device(self, *, device: Device) -> None:
-        """Remove device from cache."""
-        self._remove_device(
-            interface_id=device.interface_id,
-            addresses_to_remove=[device.address, *device.channels.keys()],
-        )
-
-    def _remove_device(self, *, interface_id: str, addresses_to_remove: list[str]) -> None:
-        """Remove a device from the cache."""
-        # Use a set for faster membership checks
-        addresses_set = set(addresses_to_remove)
-        self._raw_device_descriptions[interface_id] = [
-            device for device in self._raw_device_descriptions[interface_id] if device["ADDRESS"] not in addresses_set
-        ]
-        addr_map = self._addresses[interface_id]
-        desc_map = self._device_descriptions[interface_id]
-        for address in addresses_set:
-            # Pop with default to avoid KeyError and try/except overhead
-            if ADDRESS_SEPARATOR not in address:
-                addr_map.pop(address, None)
-            desc_map.pop(address, None)
-
-    def get_addresses(self, *, interface_id: str | None = None) -> frozenset[str]:
-        """Return the addresses by interface as a set."""
-        if interface_id:
-            return frozenset(self._addresses[interface_id])
-        return frozenset(addr for interface_id in self.get_interface_ids() for addr in self._addresses[interface_id])
-
-    def get_device_descriptions(self, *, interface_id: str) -> Mapping[str, DeviceDescription]:
-        """Return the devices by interface."""
-        return self._device_descriptions[interface_id]
-
-    def get_interface_ids(self) -> tuple[str, ...]:
-        """Return the interface ids."""
-        return tuple(self._raw_device_descriptions.keys())
-
-    def has_device_descriptions(self, *, interface_id: str) -> bool:
-        """Return the devices by interface."""
-        return interface_id in self._device_descriptions
-
-    def find_device_description(self, *, interface_id: str, device_address: str) -> DeviceDescription | None:
-        """Return the device description by interface and device_address."""
-        return self._device_descriptions[interface_id].get(device_address)
-
-    def get_device_description(self, *, interface_id: str, address: str) -> DeviceDescription:
-        """Return the device description by interface and device_address."""
-        return self._device_descriptions[interface_id][address]
-
-    def get_device_with_channels(self, *, interface_id: str, device_address: str) -> Mapping[str, DeviceDescription]:
-        """Return the device dict by interface and device_address."""
-        device_descriptions: dict[str, DeviceDescription] = {
-            device_address: self.get_device_description(interface_id=interface_id, address=device_address)
-        }
-        children = device_descriptions[device_address]["CHILDREN"]
-        for channel_address in children:
-            device_descriptions[channel_address] = self.get_device_description(
-                interface_id=interface_id, address=channel_address
-            )
-        return device_descriptions
-
-    def get_model(self, *, device_address: str) -> str | None:
-        """Return the device type."""
-        for data in self._device_descriptions.values():
-            if items := data.get(device_address):
-                return items["TYPE"]
-        return None
-
-    def _convert_device_descriptions(self, *, interface_id: str, device_descriptions: list[DeviceDescription]) -> None:
-        """Convert provided list of device descriptions."""
-        for device_description in device_descriptions:
-            self._process_device_description(interface_id=interface_id, device_description=device_description)
-
-    def _process_device_description(self, *, interface_id: str, device_description: DeviceDescription) -> None:
-        """Convert provided dict of device descriptions."""
-        address = device_description["ADDRESS"]
-        device_address = get_device_address(address=address)
-        self._device_descriptions[interface_id][address] = device_description
-
-        # Avoid redundant membership checks; set.add is idempotent and cheaper than check+add
-        addr_set = self._addresses[interface_id][device_address]
-        addr_set.add(device_address)
-        addr_set.add(address)
-
-    async def load(self) -> 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:
-            for (
-                interface_id,
-                device_descriptions,
-            ) in self._raw_device_descriptions.items():
-                self._convert_device_descriptions(interface_id=interface_id, device_descriptions=device_descriptions)
-        return result
-
-
-class ParamsetDescriptionCache(BasePersistentCache):
-    """Cache for paramset descriptions."""
-
-    __slots__ = (
-        "_address_parameter_cache",
-        "_raw_paramset_descriptions",
-    )
-
-    _file_postfix = FILE_PARAMSETS
-
-    def __init__(self, *, central: hmcu.CentralUnit) -> None:
-        """Init the paramset description cache."""
-        # {interface_id, {channel_address, paramsets}}
-        self._raw_paramset_descriptions: Final[dict[str, dict[str, dict[ParamsetKey, dict[str, ParameterData]]]]] = (
-            defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))
-        )
-        super().__init__(
-            central=central,
-            persistent_cache=self._raw_paramset_descriptions,
-        )
-
-        # {(device_address, parameter), [channel_no]}
-        self._address_parameter_cache: Final[dict[tuple[str, str], set[int | None]]] = {}
-
-    @property
-    def raw_paramset_descriptions(
-        self,
-    ) -> Mapping[str, Mapping[str, Mapping[ParamsetKey, Mapping[str, ParameterData]]]]:
-        """Return the paramset descriptions."""
-        return self._raw_paramset_descriptions
-
-    def add(
-        self,
-        *,
-        interface_id: str,
-        channel_address: str,
-        paramset_key: ParamsetKey,
-        paramset_description: dict[str, ParameterData],
-    ) -> None:
-        """Add paramset description to cache."""
-        self._raw_paramset_descriptions[interface_id][channel_address][paramset_key] = paramset_description
-        self._add_address_parameter(channel_address=channel_address, paramsets=[paramset_description])
-
-    def remove_device(self, *, device: Device) -> None:
-        """Remove device paramset descriptions from cache."""
-        if interface := self._raw_paramset_descriptions.get(device.interface_id):
-            for channel_address in device.channels:
-                if channel_address in interface:
-                    del self._raw_paramset_descriptions[device.interface_id][channel_address]
-
-    def has_interface_id(self, *, interface_id: str) -> bool:
-        """Return if interface is in paramset_descriptions cache."""
-        return interface_id in self._raw_paramset_descriptions
-
-    def get_paramset_keys(self, *, interface_id: str, channel_address: str) -> tuple[ParamsetKey, ...]:
-        """Get paramset_keys from paramset descriptions cache."""
-        return tuple(self._raw_paramset_descriptions[interface_id][channel_address])
-
-    def get_channel_paramset_descriptions(
-        self, *, interface_id: str, channel_address: str
-    ) -> Mapping[ParamsetKey, Mapping[str, ParameterData]]:
-        """Get paramset descriptions for a channelfrom cache."""
-        return self._raw_paramset_descriptions[interface_id].get(channel_address, {})
-
-    def get_paramset_descriptions(
-        self, *, interface_id: str, channel_address: str, paramset_key: ParamsetKey
-    ) -> Mapping[str, ParameterData]:
-        """Get paramset descriptions from cache."""
-        return self._raw_paramset_descriptions[interface_id][channel_address][paramset_key]
-
-    def get_parameter_data(
-        self, *, interface_id: str, channel_address: str, paramset_key: ParamsetKey, parameter: str
-    ) -> ParameterData | None:
-        """Get parameter_data  from cache."""
-        return self._raw_paramset_descriptions[interface_id][channel_address][paramset_key].get(parameter)
-
-    def is_in_multiple_channels(self, *, channel_address: str, parameter: str) -> bool:
-        """Check if parameter is in multiple channels per device."""
-        if ADDRESS_SEPARATOR not in channel_address:
-            return False
-        if channels := self._address_parameter_cache.get((get_device_address(address=channel_address), parameter)):
-            return len(channels) > 1
-        return False
-
-    def get_channel_addresses_by_paramset_key(
-        self, *, interface_id: str, device_address: str
-    ) -> Mapping[ParamsetKey, list[str]]:
-        """Get device channel addresses."""
-        channel_addresses: dict[ParamsetKey, list[str]] = {}
-        interface_paramset_descriptions = self._raw_paramset_descriptions[interface_id]
-        for (
-            channel_address,
-            paramset_descriptions,
-        ) in interface_paramset_descriptions.items():
-            if channel_address.startswith(device_address):
-                for p_key in paramset_descriptions:
-                    if (paramset_key := ParamsetKey(p_key)) not in channel_addresses:
-                        channel_addresses[paramset_key] = []
-                    channel_addresses[paramset_key].append(channel_address)
-
-        return channel_addresses
-
-    def _init_address_parameter_list(self) -> None:
-        """
-        Initialize a device_address/parameter list.
-
-        Used to identify, if a parameter name exists is in multiple channels.
-        """
-        for channel_paramsets in self._raw_paramset_descriptions.values():
-            for channel_address, paramsets in channel_paramsets.items():
-                self._add_address_parameter(channel_address=channel_address, paramsets=list(paramsets.values()))
-
-    def _add_address_parameter(self, *, channel_address: str, paramsets: list[dict[str, Any]]) -> None:
-        """Add address parameter to cache."""
-        device_address, channel_no = get_split_channel_address(channel_address=channel_address)
-        cache = self._address_parameter_cache
-        for paramset in paramsets:
-            if not paramset:
-                continue
-            for parameter in paramset:
-                cache.setdefault((device_address, parameter), set()).add(channel_no)
-
-    async def load(self) -> 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:
-            self._init_address_parameter_list()
-        return result
-
-    async def save(self) -> DataOperationResult:
-        """Save current paramset descriptions to disk."""
-        return await super().save()
-
-
-def _get_cache_path(*, storage_folder: str) -> str:
-    """Return the cache path."""
-    return f"{storage_folder}/{CACHE_PATH}"
-
-
-def _get_filename(*, central_name: str, file_name: str) -> str:
-    """Return the cache filename."""
-    return f"{slugify(central_name)}_{file_name}"
-
-
-def cleanup_cache_dirs(*, central_name: str, storage_folder: str) -> None:
-    """Clean up the used cached directories."""
-    cache_dir = _get_cache_path(storage_folder=storage_folder)
-    for file_to_delete in (FILE_DEVICES, FILE_PARAMSETS):
-        delete_file(folder=cache_dir, file_name=_get_filename(central_name=central_name, file_name=file_to_delete))

aiohomematic-2025.10.7.dist-info/RECORD

@@ -1,78 +0,0 @@
-aiohomematic/__init__.py,sha256=ngULK_anZQwwUUCVcberBdVjguYfboiuG9VoueKy9fA,2283
-aiohomematic/async_support.py,sha256=BeNKaDrFsRA5-_uAFzmyyKPqlImfSs58C22Nqd5dZAg,7887
-aiohomematic/const.py,sha256=0akDDWSDmPgfp-ynHluHHIKL3_1RamHINEec2jE9qC0,26643
-aiohomematic/context.py,sha256=M7gkA7KFT0dp35gzGz2dzKVXu1PP0sAnepgLlmjyRS4,451
-aiohomematic/converter.py,sha256=gaNHe-WEiBStZMuuRz9iGn3Mo_CGz1bjgLtlYBJJAko,3624
-aiohomematic/decorators.py,sha256=M4n_VSyqmsUgQQQv_-3JWQxYPbS6KEkhCS8OzAfaVKo,11060
-aiohomematic/exceptions.py,sha256=8Uu3rADawhYlAz6y4J52aJ-wKok8Z7YbUYUwWeGMKhs,5028
-aiohomematic/hmcli.py,sha256=qNstNDX6q8t3mJFCGlXlmRVobGabntrPtFi3kchf1Eg,4933
-aiohomematic/property_decorators.py,sha256=56lHGATgRtaFkIK_IXcR2tBW9mIVITcCwH5KOw575GA,17162
-aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiohomematic/support.py,sha256=7FTIDvRZvGFMfN3i_zBnHtJQd-vDqTMTq2i1G5GmW3Y,22834
-aiohomematic/validator.py,sha256=HUikmo-SFksehFBAdZmBv4ajy0XkjgvXvcCfbexnzZo,3563
-aiohomematic/caches/__init__.py,sha256=_gI30tbsWgPRaHvP6cRxOQr6n9bYZzU-jp1WbHhWg-A,470
-aiohomematic/caches/dynamic.py,sha256=0hOu-WoYUc9_3fofMeg_OjlYS-quD4uTyDI6zd5W4Do,22553
-aiohomematic/caches/persistent.py,sha256=xUMjvu5Vthz9W0LLllSbcqTADZvVV025b4VnPzrPnis,20604
-aiohomematic/caches/visibility.py,sha256=8lTO-jfAUzd90atUOK8rKMrzRa__m083RAoEovg0Q0o,31676
-aiohomematic/central/__init__.py,sha256=_ft-2HXfn0pF_LTrNyV_mZ7cHkHuRgeprBJZx5MlK0I,92659
-aiohomematic/central/decorators.py,sha256=NUMSsQ_Or6gno4LzagrNMXeBtmbBbYyoIlMI0TFp1_E,6908
-aiohomematic/central/rpc_server.py,sha256=wf2KG-cj_wIdgfRHY3GIFFzOenJbz8MfUGLdF1drd3k,10971
-aiohomematic/client/__init__.py,sha256=w7ns0JZNroKNy9Yw1YM1ssxhPwXUoVNpPo5RLAbgK7E,73857
-aiohomematic/client/_rpc_errors.py,sha256=-NPtGvkQPJ4V2clDxv1tKy09M9JZm61pUCeki9DDh6s,2984
-aiohomematic/client/json_rpc.py,sha256=7p8j6uhS0y2LuJVtobQqwtpOA_AsC5HqEdGB0T8ZSu4,50177
-aiohomematic/client/rpc_proxy.py,sha256=v0YyhfQ_qylQpqGvGtylJtG3_tIk9PN6tWMHkki4D48,10705
-aiohomematic/model/__init__.py,sha256=KO7gas_eEzm67tODKqWTs0617CSGeKKjOWOlDbhRo_Q,5458
-aiohomematic/model/data_point.py,sha256=Ml8AOQ1RcRezTYWiGBlIXwcTLolQMX5Cyb-O7GtNDm4,41586
-aiohomematic/model/device.py,sha256=15z5G2X3jSJaj-yz7jX_tnirzipRIGBJPymObY3Dmjk,52942
-aiohomematic/model/event.py,sha256=82H8M_QNMCCC29mP3R16alJyKWS3Hb3aqY_aFMSqCvo,6874
-aiohomematic/model/support.py,sha256=l5E9Oon20nkGWOSEmbYtqQbpbh6-H4rIk8xtEtk5Fcg,19657
-aiohomematic/model/update.py,sha256=5F39xNz9B2GKJ8TvJHPMC-Wu97HfkiiMawjnHEYMnoA,5156
-aiohomematic/model/calculated/__init__.py,sha256=UGLePgKDH8JpLqjhPBgvBzjggI34omcaCPsc6tcM8Xs,2811
-aiohomematic/model/calculated/climate.py,sha256=GXBsC5tnrC_BvnFBkJ9KUqE7uVcGD1KTU_6-OleF5H4,8545
-aiohomematic/model/calculated/data_point.py,sha256=oTN8y3B9weh7CX3ZFiDyZFgvX77iUwge-acg49pd1sI,11609
-aiohomematic/model/calculated/operating_voltage_level.py,sha256=ZrOPdNoWQ5QLr4yzMRsoPG3UuJKRkBUHfchIrpKZU4o,13527
-aiohomematic/model/calculated/support.py,sha256=vOxTvWe8SBCwJpLzcVA8ibtfw4eP8yTUZj4Jt9hWt9k,6695
-aiohomematic/model/custom/__init__.py,sha256=UzczqjsUqWvS9ZaqKeb6elbjb2y5W3cgFPB0YQUHaeM,6095
-aiohomematic/model/custom/climate.py,sha256=zSLQUY_tU7tDlbM-vW15BGuyWRjcR_DyqOwSg1_Vmfw,57217
-aiohomematic/model/custom/const.py,sha256=Kh1pnab6nmwbaY43CfXQy3yrWpPwsrQdl1Ea2aZ6aw0,4961
-aiohomematic/model/custom/cover.py,sha256=hlIeQD0cZpq7X222J7ygm6kD4AE6h5IN-wcqzvZCLFA,29057
-aiohomematic/model/custom/data_point.py,sha256=l2pTz7Fu5jGCstXHK1cWCFfBWIJeKmtt37qdGLmrQhA,14155
-aiohomematic/model/custom/definition.py,sha256=9kSdqVOHQs65Q2Op5QknNQv5lLmZkZlGCUUCRGicOaw,35662
-aiohomematic/model/custom/light.py,sha256=2UxQOoupwTpQ-5iwY51gL_B815sgDXNW-HG-QhAFb9E,44448
-aiohomematic/model/custom/lock.py,sha256=ndzZ0hp7FBohw7T_qR0jPobwlcwxus9M1DuDu_7vfPw,11996
-aiohomematic/model/custom/siren.py,sha256=DT8RoOCl7FqstgRSBK-RWRcY4T29LuEdnlhaWCB6ATk,9785
-aiohomematic/model/custom/support.py,sha256=UvencsvCwgpm4iqRNRt5KRs560tyw1NhYP5ZaqmCT2k,1453
-aiohomematic/model/custom/switch.py,sha256=tIAd501_yqQB9dd1pcTTmF7tEhFqqj3gfcSgBYN_2_8,6963
-aiohomematic/model/custom/valve.py,sha256=u9RYzeJ8FNmpFO6amlLElXTQdAeqac5yo7NbZYS6Z9U,4242
-aiohomematic/model/generic/__init__.py,sha256=-ho8m9gFlORBGNPn2i8c9i5-GVLLFvTlf5FFpaTJbFw,7675
-aiohomematic/model/generic/action.py,sha256=niJPvTs43b9GiKomdBaBKwjOwtmNxR_YRhj5Fpje9NU,997
-aiohomematic/model/generic/binary_sensor.py,sha256=U5GvfRYbhwe0jRmaedD4LVZ_24SyyPbVr74HEfZXoxE,887
-aiohomematic/model/generic/button.py,sha256=6jZ49woI9gYJEx__PjguDNbc5vdE1P-YcLMZZFkYRCg,740
-aiohomematic/model/generic/data_point.py,sha256=2NvdU802JUo4NZh0v6oMI-pVtlNluSFse7ISMGqo70g,6084
-aiohomematic/model/generic/number.py,sha256=nJgOkMZwNfPtzBrX2o5RAjBt-o8KrKuqtDa9LBj0Jw0,2678
-aiohomematic/model/generic/select.py,sha256=vWfLUdQBjZLG-q-WZMxHk9Klawg_iNOEeSoVHrvG35I,1538
-aiohomematic/model/generic/sensor.py,sha256=wCnQ8IoC8uPTN29R250pfJa4x6y9sh4c3vxQ4Km8Clg,2262
-aiohomematic/model/generic/switch.py,sha256=VIMwIVok9kSRoSb-s5saYRHeiZcNWH4J5FyMSxUAbpw,1842
-aiohomematic/model/generic/text.py,sha256=vtNV7YxZuxF6LzNRKRAeOtSQtPQxPaEd560OFaVR13U,854
-aiohomematic/model/hub/__init__.py,sha256=g2m-5rba6SNCfGrlxwqYa8mlP5-N2obFAvyHJV8i4FY,13525
-aiohomematic/model/hub/binary_sensor.py,sha256=Z4o-zghHSc83ZHUUCtHqWEGueD9K1Fe0JEt_xJNdx_Y,752
-aiohomematic/model/hub/button.py,sha256=XMnoImnz5vDybxfrP4GWDp2M5gEMG71d8ba1YzVYAnE,890
-aiohomematic/model/hub/data_point.py,sha256=E6qn1gVhZ4meti-Tpd03f-YyfKnkUh-FpLbwBaa-d1c,10653
-aiohomematic/model/hub/number.py,sha256=12BK6mBOJn4aP7DWuWvMYfiaLmDX7ejd5tDCoHa2bUk,1237
-aiohomematic/model/hub/select.py,sha256=C9ke_8U_pzI0fctIeOZHwq-fvWj5s64jW6-DcZT-SrU,1674
-aiohomematic/model/hub/sensor.py,sha256=cIr-7bsbOLBxnH33EHQ6D42vc61abO4QYLWLzkm1T10,1192
-aiohomematic/model/hub/switch.py,sha256=510Vrlyak5TRsMvURrGYMkad-CbGUKWh20jjHQGOios,1390
-aiohomematic/model/hub/text.py,sha256=JOy-hfDSu95NbxP5JeGgga9NGrR8JLNmz_h4k8J1GXU,999
-aiohomematic/rega_scripts/fetch_all_device_data.fn,sha256=7uxhHoelAOsH6yYr1n1M1XwIRgDmItiHnWIMhDYEimk,4373
-aiohomematic/rega_scripts/get_program_descriptions.fn,sha256=pGmj377MkqbZi6j-UBKQAsXTphwh1kDwDKqXij8zUBE,835
-aiohomematic/rega_scripts/get_serial.fn,sha256=t1oeo-sB_EuVeiY24PLcxFSkdQVgEWGXzpemJQZFybY,1079
-aiohomematic/rega_scripts/get_system_variable_descriptions.fn,sha256=UKXvC0_5lSApdQ2atJc0E5Stj5Zt3lqh0EcliokYu2c,849
-aiohomematic/rega_scripts/set_program_state.fn,sha256=0bnv7lUj8FMjDZBz325tDVP61m04cHjVj4kIOnUUgpY,279
-aiohomematic/rega_scripts/set_system_variable.fn,sha256=sTmr7vkPTPnPkor5cnLKlDvfsYRbGO1iq2z_2pMXq5E,383
-aiohomematic-2025.10.7.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=nFeYkoX_EXXIwbrpL_5peYQG-934D0ASN6kflYp0_4I,12819
-aiohomematic-2025.10.7.dist-info/METADATA,sha256=EP3Y37kiLdfx6DP4M988pY_gDoL3lKF_9LE3miXFxro,7603
-aiohomematic-2025.10.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic-2025.10.7.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
-aiohomematic-2025.10.7.dist-info/RECORD,,