aiohomematic 2025.10.3__py3-none-any.whl → 2025.10.5__py3-none-any.whl

aiohomematic/async_support.py

@@ -15,7 +15,8 @@ from typing import Any, Final, cast
 
 from aiohomematic.const import BLOCK_LOG_TIMEOUT
 from aiohomematic.exceptions import AioHomematicException
-from aiohomematic.support import debug_enabled, extract_exc_args
+import aiohomematic.support as hms
+from aiohomematic.support import extract_exc_args
 
 _LOGGER: Final = logging.getLogger(__name__)
 
@@ -46,7 +47,13 @@ class Looper:
                     _LOGGER.warning("Shutdown timeout reached; task still pending: %s", task)
                 break
 
-            await self._await_and_log_pending(pending=tasks)
+            pending_after_wait = await self._await_and_log_pending(pending=tasks, deadline=deadline)
+
+            # If deadline has been reached and tasks are still pending, log and break
+            if deadline is not None and monotonic() >= deadline and pending_after_wait:
+                for task in pending_after_wait:
+                    _LOGGER.warning("Shutdown timeout reached; task still pending: %s", task)
+                break
 
             if start_time is None:
                 # Avoid calling monotonic() until we know
@@ -63,16 +70,35 @@ class Looper:
                 for task in tasks:
                     _LOGGER.debug("Waiting for task: %s", task)
 
-    async def _await_and_log_pending(self, *, pending: Collection[asyncio.Future[Any]]) -> None:
-        """Await and log tasks that take a long time."""
-        wait_time = 0
-        while pending:
-            _, pending = await asyncio.wait(pending, timeout=BLOCK_LOG_TIMEOUT)
-            if not pending:
-                return
-            wait_time += BLOCK_LOG_TIMEOUT
-            for task in pending:
+    async def _await_and_log_pending(
+        self, *, pending: Collection[asyncio.Future[Any]], deadline: float | None
+    ) -> set[asyncio.Future[Any]]:
+        """
+        Await and log tasks that take a long time, respecting an optional deadline.
+
+        Returns the set of pending tasks if the deadline has been reached (or zero timeout),
+        allowing the caller to decide about timeout logging. Returns an empty set if no tasks are pending.
+        """
+        wait_time = 0.0
+        pending_set: set[asyncio.Future[Any]] = set(pending)
+        while pending_set:
+            if deadline is None:
+                timeout = BLOCK_LOG_TIMEOUT
+            else:
+                remaining = int(max(0.0, deadline - monotonic()))
+                if (timeout := min(BLOCK_LOG_TIMEOUT, remaining)) == 0.0:
+                    # Deadline reached; return current pending to caller for warning log
+                    return pending_set
+            done, still_pending = await asyncio.wait(pending_set, timeout=timeout)
+            if not (pending_set := set(still_pending)):
+                return set()
+            wait_time += timeout
+            for task in pending_set:
                 _LOGGER.debug("Waited %s seconds for task: %s", wait_time, task)
+            # If the deadline was reached during the wait, let caller handle warning
+            if deadline is not None and monotonic() >= deadline:
+                return pending_set
+        return set()
 
     def create_task(self, *, target: Coroutine[Any, Any, Any], name: str) -> None:
         """Add task to the executor pool."""
@@ -134,7 +160,12 @@ def cancelling(*, task: asyncio.Future[Any]) -> bool:
 
 
 def loop_check[**P, R](func: Callable[P, R]) -> Callable[P, R]:
-    """Annotation to mark method that must be run within the event loop."""
+    """
+    Annotation to mark method that must be run within the event loop.
+
+    Always wraps the function, but only performs loop checks when debug is enabled.
+    This allows tests to monkeypatch aiohomematic.support.debug_enabled at runtime.
+    """
 
     _with_loop: set = set()
 
@@ -143,17 +174,22 @@ def loop_check[**P, R](func: Callable[P, R]) -> Callable[P, R]:
         """Wrap loop check."""
         return_value = func(*args, **kwargs)
 
-        try:
-            asyncio.get_running_loop()
-            loop_running = True
-        except Exception:
-            loop_running = False
-
-        if not loop_running and func not in _with_loop:
-            _with_loop.add(func)
-            _LOGGER.warning("Method %s must run in the event_loop. No loop detected.", func.__name__)
+        # Only perform the (potentially expensive) loop check when debug is enabled.
+        if hms.debug_enabled():
+            try:
+                asyncio.get_running_loop()
+                loop_running = True
+            except Exception:
+                loop_running = False
+
+            if not loop_running and func not in _with_loop:
+                _with_loop.add(func)
+                _LOGGER.warning(
+                    "Method %s must run in the event_loop. No loop detected.",
+                    func.__name__,
+                )
 
         return return_value
 
     setattr(func, "_loop_check", True)
-    return cast(Callable[P, R], wrapper_loop_check) if debug_enabled() else func
+    return cast(Callable[P, R], wrapper_loop_check)

aiohomematic/caches/dynamic.py

@@ -400,15 +400,15 @@ class PingPongCache:
 
     @property
     def low_pending_pongs(self) -> bool:
-        """Return the pending pong count is low."""
+        """Return True when pending pong count is at or below the allowed delta (i.e., not high)."""
         self._cleanup_pending_pongs()
-        return len(self._pending_pongs) < (self._allowed_delta / 2)
+        return len(self._pending_pongs) <= self._allowed_delta
 
     @property
     def low_unknown_pongs(self) -> bool:
-        """Return the unknown pong count is low."""
+        """Return True when unknown pong count is at or below the allowed delta (i.e., not high)."""
         self._cleanup_unknown_pongs()
-        return len(self._unknown_pongs) < (self._allowed_delta / 2)
+        return len(self._unknown_pongs) <= self._allowed_delta
 
     @property
     def pending_pong_count(self) -> int:
@@ -430,10 +430,14 @@ class PingPongCache:
     def handle_send_ping(self, *, ping_ts: datetime) -> None:
         """Handle send ping timestamp."""
         self._pending_pongs.add(ping_ts)
-        self._check_and_fire_pong_event(
-            event_type=InterfaceEventType.PENDING_PONG,
-            pong_mismatch_count=self.pending_pong_count,
-        )
+        # Throttle event emission to every second ping to avoid spamming callbacks,
+        # but always emit when crossing the high threshold.
+        count = self.pending_pong_count
+        if (count > self._allowed_delta) or (count % 2 == 0):
+            self._check_and_fire_pong_event(
+                event_type=InterfaceEventType.PENDING_PONG,
+                pong_mismatch_count=count,
+            )
         _LOGGER.debug(
             "PING PONG CACHE: Increase pending PING count: %s - %i for ts: %s",
             self._interface_id,
@@ -473,8 +477,8 @@ class PingPongCache:
         """Cleanup too old pending pongs."""
         dt_now = datetime.now()
         for pong_ts in list(self._pending_pongs):
-            delta = dt_now - pong_ts
-            if delta.seconds > self._ttl:
+            # Only expire entries that are actually older than the TTL.
+            if (dt_now - pong_ts).total_seconds() > self._ttl:
                 self._pending_pongs.remove(pong_ts)
                 _LOGGER.debug(
                     "PING PONG CACHE: Removing expired pending PONG: %s - %i for ts: %s",
@@ -487,8 +491,8 @@ class PingPongCache:
         """Cleanup too old unknown pongs."""
         dt_now = datetime.now()
         for pong_ts in list(self._unknown_pongs):
-            delta = dt_now - pong_ts
-            if delta.seconds > self._ttl:
+            # Only expire entries that are actually older than the TTL.
+            if (dt_now - pong_ts).total_seconds() > self._ttl:
                 self._unknown_pongs.remove(pong_ts)
                 _LOGGER.debug(
                     "PING PONG CACHE: Removing expired unknown PONG: %s - %i or ts: %s",
@@ -519,11 +523,20 @@ class PingPongCache:
             )
 
         if self.low_pending_pongs and event_type == InterfaceEventType.PENDING_PONG:
-            _fire_event(mismatch_count=0)
-            self._pending_pong_logged = False
+            # In low state:
+            # - If we previously logged a high state, emit a reset event (mismatch=0) exactly once.
+            # - Otherwise, throttle emission to every second ping (even counts > 0) to avoid spamming.
+            if self._pending_pong_logged:
+                _fire_event(mismatch_count=0)
+                self._pending_pong_logged = False
+                return
+            if pong_mismatch_count > 0 and pong_mismatch_count % 2 == 0:
+                _fire_event(mismatch_count=pong_mismatch_count)
             return
 
         if self.low_unknown_pongs and event_type == InterfaceEventType.UNKNOWN_PONG:
+            # For unknown pongs, only reset the logged flag when we drop below the threshold.
+            # We do not emit an event here since there is no explicit expectation for a reset notification.
             self._unknown_pong_logged = False
             return
 

aiohomematic/caches/persistent.py

@@ -250,14 +250,24 @@ class DeviceDescriptionCache(BasePersistentCache):
                 addr_map.pop(address, None)
             desc_map.pop(address, None)
 
-    def get_addresses(self, *, interface_id: str) -> frozenset[str]:
+    def get_addresses(self, *, interface_id: str | None = None) -> frozenset[str]:
         """Return the addresses by interface as a set."""
-        return frozenset(self._addresses[interface_id])
+        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)

aiohomematic/central/__init__.py

@@ -92,6 +92,7 @@ from aiohomematic.const import (
     CONNECTION_CHECKER_INTERVAL,
     DATA_POINT_EVENTS,
     DATETIME_FORMAT_MILLIS,
+    DEFAULT_DELAY_NEW_DEVICE_CREATION,
     DEFAULT_ENABLE_DEVICE_FIRMWARE_CHECK,
     DEFAULT_ENABLE_PROGRAM_SCAN,
     DEFAULT_ENABLE_SYSVAR_SCAN,
@@ -136,6 +137,7 @@ from aiohomematic.const import (
     Parameter,
     ParamsetKey,
     ProxyInitState,
+    SourceOfDeviceCreation,
     SystemInformation,
 )
 from aiohomematic.decorators import inspector
@@ -164,6 +166,7 @@ from aiohomematic.support import (
     LogContextMixin,
     PayloadMixin,
     check_config,
+    extract_device_addresses_from_device_descriptions,
     extract_exc_args,
     get_channel_no,
     get_device_address,
@@ -506,7 +509,9 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         if self._config.start_direct:
             if await self._create_clients():
                 for client in self._clients.values():
-                    await self._refresh_device_descriptions(client=client)
+                    await self._refresh_device_descriptions_and_create_missing_devices(
+                        client=client, refresh_only_existing=False
+                    )
         else:
             self._clients_started = await self._start_clients()
             if self._config.enable_server:
@@ -576,11 +581,15 @@ class CentralUnit(LogContextMixin, PayloadMixin):
     async def refresh_firmware_data(self, *, device_address: str | None = None) -> None:
         """Refresh device firmware data."""
         if device_address and (device := self.get_device(address=device_address)) is not None and device.is_updatable:
-            await self._refresh_device_descriptions(client=device.client, device_address=device_address)
+            await self._refresh_device_descriptions_and_create_missing_devices(
+                client=device.client, refresh_only_existing=True, device_address=device_address
+            )
             device.refresh_firmware_data()
         else:
             for client in self._clients.values():
-                await self._refresh_device_descriptions(client=client)
+                await self._refresh_device_descriptions_and_create_missing_devices(
+                    client=client, refresh_only_existing=True
+                )
             for device in self._devices.values():
                 if device.is_updatable:
                     device.refresh_firmware_data()
@@ -595,9 +604,12 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         ]:
             await self.refresh_firmware_data(device_address=device.address)
 
-    async def _refresh_device_descriptions(self, *, client: hmcl.Client, device_address: str | None = None) -> None:
-        """Refresh device descriptions."""
+    async def _refresh_device_descriptions_and_create_missing_devices(
+        self, *, client: hmcl.Client, refresh_only_existing: bool, device_address: str | None = None
+    ) -> None:
+        """Refresh device descriptions and create missing devices."""
         device_descriptions: tuple[DeviceDescription, ...] | None = None
+
         if (
             device_address
             and (device_description := await client.get_device_description(device_address=device_address)) is not None
@@ -606,10 +618,25 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         else:
             device_descriptions = await client.list_devices()
 
+        if (
+            device_descriptions
+            and refresh_only_existing
+            and (
+                existing_device_descriptions := tuple(
+                    dev_desc
+                    for dev_desc in list(device_descriptions)
+                    if dev_desc["ADDRESS"]
+                    in self.device_descriptions.get_device_descriptions(interface_id=client.interface_id)
+                )
+            )
+        ):
+            device_descriptions = existing_device_descriptions
+
         if device_descriptions:
             await self._add_new_devices(
                 interface_id=client.interface_id,
                 device_descriptions=device_descriptions,
+                source=SourceOfDeviceCreation.REFRESH,
             )
 
     async def _start_clients(self) -> bool:
@@ -618,13 +645,15 @@ class CentralUnit(LogContextMixin, PayloadMixin):
             return False
         await self._load_caches()
         if new_device_addresses := self._check_for_new_device_addresses():
-            await self._create_devices(new_device_addresses=new_device_addresses)
+            await self._create_devices(new_device_addresses=new_device_addresses, source=SourceOfDeviceCreation.CACHE)
         await self._init_hub()
         await self._init_clients()
         # Proactively fetch device descriptions if none were created yet to avoid slow startup
         if not self._devices:
             for client in self._clients.values():
-                await self._refresh_device_descriptions(client=client)
+                await self._refresh_device_descriptions_and_create_missing_devices(
+                    client=client, refresh_only_existing=False
+                )
         return True
 
     async def _stop_clients(self) -> None:
@@ -934,7 +963,9 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         await self._data_cache.load()
         return True
 
-    async def _create_devices(self, *, new_device_addresses: Mapping[str, set[str]]) -> None:
+    async def _create_devices(
+        self, *, new_device_addresses: Mapping[str, set[str]], source: SourceOfDeviceCreation
+    ) -> None:
         """Trigger creation of the objects that expose the functionality."""
         if not self._clients:
             raise AioHomematicException(
@@ -988,6 +1019,7 @@ class CentralUnit(LogContextMixin, PayloadMixin):
                 system_event=BackendSystemEvent.DEVICES_CREATED,
                 new_data_points=new_dps,
                 new_channel_events=new_channel_events,
+                source=source,
             )
 
     async def delete_device(self, *, interface_id: str, device_address: str) -> None:
@@ -1014,15 +1046,45 @@ class CentralUnit(LogContextMixin, PayloadMixin):
         for address in addresses:
             if device := self._devices.get(address):
                 self.remove_device(device=device)
-        await self.save_caches()
+        await self.save_caches(save_device_descriptions=True, save_paramset_descriptions=True)
 
     @callback_backend_system(system_event=BackendSystemEvent.NEW_DEVICES)
     async def add_new_devices(self, *, interface_id: str, device_descriptions: tuple[DeviceDescription, ...]) -> None:
         """Add new devices to central unit."""
-        await self._add_new_devices(interface_id=interface_id, device_descriptions=device_descriptions)
+        source = (
+            SourceOfDeviceCreation.NEW
+            if self._device_descriptions.has_device_descriptions(interface_id=interface_id)
+            else SourceOfDeviceCreation.INIT
+        )
+        await self._add_new_devices(interface_id=interface_id, device_descriptions=device_descriptions, source=source)
+
+    async def add_new_device_manually(self, *, interface_id: str, address: str) -> None:
+        """Add new devices manually triggered to central unit."""
+        if interface_id not in self._clients:
+            _LOGGER.warning(
+                "ADD_NEW_DEVICES_MANUALLY failed: Missing client for interface_id %s",
+                interface_id,
+            )
+            return
+        client = self._clients[interface_id]
+        if (device_descriptions := await client.get_all_device_description(device_address=address)) is None:
+            _LOGGER.warning(
+                "ADD_NEW_DEVICES_MANUALLY failed: No device description found for address %s on interface_id %s",
+                address,
+                interface_id,
+            )
+            return
+
+        await self._add_new_devices(
+            interface_id=interface_id,
+            device_descriptions=device_descriptions,
+            source=SourceOfDeviceCreation.MANUAL,
+        )
 
     @inspector(measure_performance=True)
-    async def _add_new_devices(self, *, interface_id: str, device_descriptions: tuple[DeviceDescription, ...]) -> None:
+    async def _add_new_devices(
+        self, *, interface_id: str, device_descriptions: tuple[DeviceDescription, ...], source: SourceOfDeviceCreation
+    ) -> None:
         """Add new devices to central unit."""
         if not device_descriptions:
             _LOGGER.debug(
@@ -1045,57 +1107,96 @@ class CentralUnit(LogContextMixin, PayloadMixin):
             return
 
         async with self._device_add_semaphore:
-            # Use mapping membership to avoid rebuilding known addresses and allow O(1) checks.
-            existing_map = self._device_descriptions.get_device_descriptions(interface_id=interface_id)
+            if not (
+                new_device_descriptions := self._identify_new_device_descriptions(
+                    device_descriptions=device_descriptions, interface_id=interface_id
+                )
+            ):
+                _LOGGER.debug("ADD_NEW_DEVICES: Nothing to add for interface_id %s", interface_id)
+                return
+
+            # Here we block the automatic creation of new devices, if required
+            if (
+                self._config.delay_new_device_creation
+                and source == SourceOfDeviceCreation.NEW
+                and (
+                    new_addresses := extract_device_addresses_from_device_descriptions(
+                        device_descriptions=new_device_descriptions
+                    )
+                )
+            ):
+                self.fire_backend_system_callback(
+                    system_event=BackendSystemEvent.DEVICES_DELAYED,
+                    new_addresses=new_addresses,
+                    interface_id=interface_id,
+                    source=source,
+                )
+                return
+
             client = self._clients[interface_id]
-            save_paramset_descriptions = False
-            save_device_descriptions = False
-            for dev_desc in device_descriptions:
+            save_descriptions = False
+            for dev_desc in new_device_descriptions:
                 try:
-                    address = dev_desc["ADDRESS"]
-                    # Check existence before mutating cache to ensure we detect truly new addresses.
-                    is_new_address = address not in existing_map
                     self._device_descriptions.add_device(interface_id=interface_id, device_description=dev_desc)
-                    save_device_descriptions = True
-                    if is_new_address:
-                        await client.fetch_paramset_descriptions(device_description=dev_desc)
-                        save_paramset_descriptions = True
+                    await client.fetch_paramset_descriptions(device_description=dev_desc)
+                    save_descriptions = True
                 except Exception as exc:  # pragma: no cover
-                    save_device_descriptions = False
-                    save_paramset_descriptions = False
+                    save_descriptions = False
                     _LOGGER.error(
-                        "ADD_NEW_DEVICES failed: %s [%s]",
+                        "UPDATE_CACHES_WITH_NEW_DEVICES failed: %s [%s]",
                         type(exc).__name__,
                         extract_exc_args(exc=exc),
                     )
 
             await self.save_caches(
-                save_device_descriptions=save_device_descriptions,
-                save_paramset_descriptions=save_paramset_descriptions,
+                save_device_descriptions=save_descriptions,
+                save_paramset_descriptions=save_descriptions,
             )
-            if new_device_addresses := self._check_for_new_device_addresses():
-                await self._device_details.load()
-                await self._data_cache.load()
-                await self._create_devices(new_device_addresses=new_device_addresses)
 
-    def _check_for_new_device_addresses(self) -> Mapping[str, set[str]]:
+        if new_device_addresses := self._check_for_new_device_addresses(interface_id=interface_id):
+            await self._device_details.load()
+            await self._data_cache.load(interface=client.interface)
+            await self._create_devices(new_device_addresses=new_device_addresses, source=source)
+
+    def _identify_new_device_descriptions(
+        self, *, device_descriptions: tuple[DeviceDescription, ...], interface_id: str | None = None
+    ) -> tuple[DeviceDescription, ...]:
+        """Identify devices whose ADDRESS isn't already known on any interface."""
+        known_addresses = self._device_descriptions.get_addresses(interface_id=interface_id)
+        return tuple(
+            dev_desc
+            for dev_desc in device_descriptions
+            if (dev_desc["ADDRESS"] if not (parent_address := dev_desc.get("PARENT")) else parent_address)
+            not in known_addresses
+        )
+
+    def _check_for_new_device_addresses(self, *, interface_id: str | None = None) -> Mapping[str, set[str]]:
         """Check if there are new devices that need to be created."""
         new_device_addresses: dict[str, set[str]] = {}
-        for interface_id in self.interface_ids:
-            if not self._paramset_descriptions.has_interface_id(interface_id=interface_id):
+
+        # Cache existing device addresses once to avoid repeated mapping lookups
+        existing_addresses = set(self._devices.keys())
+
+        def _check_for_new_device_addresses_helper(*, iid: str) -> None:
+            """Check if there are new devices that need to be created."""
+            if not self._paramset_descriptions.has_interface_id(interface_id=iid):
                 _LOGGER.debug(
                     "CHECK_FOR_NEW_DEVICE_ADDRESSES: Skipping interface %s, missing paramsets",
-                    interface_id,
+                    iid,
                 )
-                continue
-
+                return
             # Build the set locally and assign only if non-empty to avoid add-then-delete pattern
-            new_set: set[str] = set()
-            for device_address in self._device_descriptions.get_addresses(interface_id=interface_id):
-                if device_address not in self._devices:
-                    new_set.add(device_address)
-            if new_set:
-                new_device_addresses[interface_id] = new_set
+            # Use set difference for speed on large collections
+            addresses = set(self._device_descriptions.get_addresses(interface_id=iid))
+            # get_addresses returns an iterable (likely tuple); convert to set once for efficient diff
+            if new_set := addresses - existing_addresses:
+                new_device_addresses[iid] = new_set
+
+        if interface_id:
+            _check_for_new_device_addresses_helper(iid=interface_id)
+        else:
+            for iid in self.interface_ids:
+                _check_for_new_device_addresses_helper(iid=iid)
 
         if _LOGGER.isEnabledFor(level=DEBUG):
             count = sum(len(item) for item in new_device_addresses.values())
@@ -1670,12 +1771,31 @@ class _Scheduler(threading.Thread):
                 _LOGGER.debug("SCHEDULER: Waiting till central %s is started", self._central.name)
                 await asyncio.sleep(SCHEDULER_NOT_STARTED_SLEEP)
                 continue
+
+            any_executed = False
             for job in self._scheduler_jobs:
                 if not self._active or not job.ready:
                     continue
                 await job.run()
                 job.schedule_next_execution()
-            if self._active:
+                any_executed = True
+
+            if not self._active:
+                break  # type: ignore[unreachable]
+
+            # If no job was executed this cycle, we can sleep until the next job is due
+            if not any_executed:
+                now = datetime.now()
+                try:
+                    next_due = min(job.next_run for job in self._scheduler_jobs)
+                    # Sleep until the next task should run, but cap to 1s to remain responsive
+                    delay = max(0.0, (next_due - now).total_seconds())
+                    await asyncio.sleep(min(1.0, delay))
+                except ValueError:
+                    # No jobs configured; fallback to default loop sleep
+                    await asyncio.sleep(SCHEDULER_LOOP_SLEEP)
+            else:
+                # When work was done, yield briefly to the loop
                 await asyncio.sleep(SCHEDULER_LOOP_SLEEP)
 
     async def _check_connection(self) -> None:
@@ -1823,6 +1943,11 @@ class _SchedulerJob:
         """Return if the job can be executed."""
         return self._next_run < datetime.now()
 
+    @property
+    def next_run(self) -> datetime:
+        """Return the next scheduled run timestamp."""
+        return self._next_run
+
     async def run(self) -> None:
         """Run the task."""
         await self._task()
@@ -1848,6 +1973,7 @@ class CentralConfig:
         callback_host: str | None = None,
         callback_port: int | None = None,
         default_callback_port: int = PORT_ANY,
+        delay_new_device_creation: bool = DEFAULT_DELAY_NEW_DEVICE_CREATION,
         enable_device_firmware_check: bool = DEFAULT_ENABLE_DEVICE_FIRMWARE_CHECK,
         enable_program_scan: bool = DEFAULT_ENABLE_PROGRAM_SCAN,
         enable_sysvar_scan: bool = DEFAULT_ENABLE_SYSVAR_SCAN,
@@ -1876,6 +2002,7 @@ class CentralConfig:
         self.central_id: Final = central_id
         self.client_session: Final = client_session
         self.default_callback_port: Final = default_callback_port
+        self.delay_new_device_creation: Final = delay_new_device_creation
         self.enable_device_firmware_check: Final = enable_device_firmware_check
         self.enable_program_scan: Final = enable_program_scan
         self.enable_sysvar_scan: Final = enable_sysvar_scan

aiohomematic/client/__init__.py

@@ -494,6 +494,29 @@ class Client(ABC, LogContextMixin):
             _LOGGER.warning("GET_DEVICE_DESCRIPTIONS failed: %s [%s]", bhexc.name, extract_exc_args(exc=bhexc))
         return None
 
+    @inspector(re_raise=False)
+    async def get_all_device_description(self, *, device_address: str) -> tuple[DeviceDescription, ...] | None:
+        """Get all device descriptions from the backend."""
+        all_device_description: list[DeviceDescription] = []
+        if main_dd := await self.get_device_description(device_address=device_address):
+            all_device_description.append(main_dd)
+        else:
+            _LOGGER.warning(
+                "GET_ALL_DEVICE_DESCRIPTIONS: No device description for %s",
+                device_address,
+            )
+
+        if main_dd:
+            for channel_address in main_dd["CHILDREN"]:
+                if channel_dd := await self.get_device_description(device_address=channel_address):
+                    all_device_description.append(channel_dd)
+                else:
+                    _LOGGER.warning(
+                        "GET_ALL_DEVICE_DESCRIPTIONS: No channel description for %s",
+                        channel_address,
+                    )
+        return tuple(all_device_description)
+
     @inspector
     async def add_link(self, *, sender_address: str, receiver_address: str, name: str, description: str) -> None:
         """Return a list of links."""

aiohomematic/client/json_rpc.py

@@ -1259,7 +1259,16 @@ class JsonRpcAioHttpClient(LogContextMixin):
             response = await self._post_script(script_name=RegaScript.GET_SERIAL)
 
             if json_result := response[_JsonKey.RESULT]:
-                serial: str = json_result[_JsonKey.SERIAL]
+                # The backend may return a JSON string which needs to be decoded first
+                # or an already-parsed dict. Support both.
+                if isinstance(json_result, str):
+                    try:
+                        json_result = orjson.loads(json_result)
+                    except Exception:
+                        # Fall back to plain string handling; return last 10 chars
+                        serial_exc = str(json_result)
+                        return serial_exc[-10:] if len(serial_exc) > 10 else serial_exc
+                serial: str = str(json_result.get(_JsonKey.SERIAL) if isinstance(json_result, dict) else json_result)
                 if len(serial) > 10:
                     serial = serial[-10:]
                 return serial

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.3"
+VERSION: Final = "2025.10.5"
 
 # Detect test speedup mode via environment
 _TEST_SPEEDUP: Final = (
@@ -29,6 +29,7 @@ _TEST_SPEEDUP: Final = (
 # default
 DEFAULT_STORAGE_FOLDER: 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
 DEFAULT_ENABLE_SYSVAR_SCAN: Final = True
@@ -124,8 +125,8 @@ UN_IGNORE_WILDCARD: Final = "all"
 WAIT_FOR_CALLBACK: Final[int | None] = None
 
 # Scheduler sleep durations (used by central scheduler loop)
-SCHEDULER_NOT_STARTED_SLEEP: Final = 0.05 if _TEST_SPEEDUP else 10
-SCHEDULER_LOOP_SLEEP: Final = 0.05 if _TEST_SPEEDUP else 5
+SCHEDULER_NOT_STARTED_SLEEP: Final = 0.2 if _TEST_SPEEDUP else 10
+SCHEDULER_LOOP_SLEEP: Final = 0.2 if _TEST_SPEEDUP else 5
 
 CALLBACK_WARN_INTERVAL: Final = CONNECTION_CHECKER_INTERVAL * 40
 
@@ -155,6 +156,7 @@ class BackendSystemEvent(StrEnum):
 
     DELETE_DEVICES = "deleteDevices"
     DEVICES_CREATED = "devicesCreated"
+    DEVICES_DELAYED = "devicesDelayed"
     ERROR = "error"
     HUB_REFRESHED = "hubDataPointRefreshed"
     LIST_DEVICES = "listDevices"
@@ -172,6 +174,16 @@ class CallSource(StrEnum):
     MANUAL_OR_SCHEDULED = "manual_or_scheduled"
 
 
+class CalulatedParameter(StrEnum):
+    """Enum with calculated Homematic parameters."""
+
+    APPARENT_TEMPERATURE = "APPARENT_TEMPERATURE"
+    DEW_POINT = "DEW_POINT"
+    FROST_POINT = "FROST_POINT"
+    OPERATING_VOLTAGE_LEVEL = "OPERATING_VOLTAGE_LEVEL"
+    VAPOR_CONCENTRATION = "VAPOR_CONCENTRATION"
+
+
 class CentralUnitState(StrEnum):
     """Enum with central unit states."""
 
@@ -183,6 +195,13 @@ class CentralUnitState(StrEnum):
     STOPPING = "stopping"
 
 
+class CommandRxMode(StrEnum):
+    """Enum for Homematic rx modes for commands."""
+
+    BURST = "BURST"
+    WAKEUP = "WAKEUP"
+
+
 class DataOperationResult(Enum):
     """Enum with data operation results."""
 
@@ -321,16 +340,6 @@ class Operations(IntEnum):
     EVENT = 4
 
 
-class CalulatedParameter(StrEnum):
-    """Enum with calculated Homematic parameters."""
-
-    APPARENT_TEMPERATURE = "APPARENT_TEMPERATURE"
-    DEW_POINT = "DEW_POINT"
-    FROST_POINT = "FROST_POINT"
-    OPERATING_VOLTAGE_LEVEL = "OPERATING_VOLTAGE_LEVEL"
-    VAPOR_CONCENTRATION = "VAPOR_CONCENTRATION"
-
-
 class Parameter(StrEnum):
     """Enum with Homematic parameters."""
 
@@ -530,11 +539,14 @@ class RxMode(IntEnum):
     LAZY_CONFIG = 16
 
 
-class CommandRxMode(StrEnum):
-    """Enum for Homematic rx modes for commands."""
+class SourceOfDeviceCreation(StrEnum):
+    """Enum with source of device creation."""
 
-    BURST = "BURST"
-    WAKEUP = "WAKEUP"
+    CACHE = "CACHE"
+    INIT = "INIT"
+    MANUAL = "MANUAL"
+    NEW = "NEW"
+    REFRESH = "REFRESH"
 
 
 class SysvarType(StrEnum):

aiohomematic/decorators.py

@@ -117,78 +117,84 @@ def inspector[**P, R](  # noqa: C901
 
         @wraps(func)
         def wrap_sync_function(*args: P.args, **kwargs: P.kwargs) -> R:
-            """Wrap sync functions."""
+            """Wrap sync functions with minimized per-call overhead."""
 
-            start = (
-                monotonic() if measure_performance and _LOGGER_PERFORMANCE.isEnabledFor(level=logging.DEBUG) else None
-            )
-            token = IN_SERVICE_VAR.set(True) if not IN_SERVICE_VAR.get() else None
+            # Fast-path: avoid logger check and time call unless explicitly enabled
+            start_needed = measure_performance and _LOGGER_PERFORMANCE.isEnabledFor(level=logging.DEBUG)
+            start = monotonic() if start_needed else None
+
+            # Avoid repeated ContextVar.get() calls; only set/reset when needed
+            was_in_service = IN_SERVICE_VAR.get()
+            token = IN_SERVICE_VAR.set(True) if not was_in_service else None
+            context_obj = args[0] if args else None
             try:
                 return_value: R = func(*args, **kwargs)
             except BaseHomematicException as bhexc:
-                if token:
+                if token is not None:
                     IN_SERVICE_VAR.reset(token)
                 return handle_exception(
                     exc=bhexc,
                     func=func,
-                    is_sub_service_call=IN_SERVICE_VAR.get(),
+                    is_sub_service_call=was_in_service,
                     is_homematic=True,
-                    context_obj=(args[0] if args else None),
+                    context_obj=context_obj,
                 )
             except Exception as exc:
-                if token:
+                if token is not None:
                     IN_SERVICE_VAR.reset(token)
                 return handle_exception(
                     exc=exc,
                     func=func,
-                    is_sub_service_call=IN_SERVICE_VAR.get(),
+                    is_sub_service_call=was_in_service,
                     is_homematic=False,
-                    context_obj=(args[0] if args else None),
+                    context_obj=context_obj,
                 )
             else:
-                if token:
+                if token is not None:
                     IN_SERVICE_VAR.reset(token)
                 return return_value
             finally:
-                if start:
+                if start is not None:
                     _log_performance_message(func, start, *args, **kwargs)
 
         @wraps(func)
         async def wrap_async_function(*args: P.args, **kwargs: P.kwargs) -> R:
-            """Wrap async functions."""
+            """Wrap async functions with minimized per-call overhead."""
+
+            start_needed = measure_performance and _LOGGER_PERFORMANCE.isEnabledFor(level=logging.DEBUG)
+            start = monotonic() if start_needed else None
 
-            start = (
-                monotonic() if measure_performance and _LOGGER_PERFORMANCE.isEnabledFor(level=logging.DEBUG) else None
-            )
-            token = IN_SERVICE_VAR.set(True) if not IN_SERVICE_VAR.get() else None
+            was_in_service = IN_SERVICE_VAR.get()
+            token = IN_SERVICE_VAR.set(True) if not was_in_service else None
+            context_obj = args[0] if args else None
             try:
-                return_value = await func(*args, **kwargs)  # type: ignore[misc]  # Await the async call
+                return_value = await func(*args, **kwargs)  # type: ignore[misc]
             except BaseHomematicException as bhexc:
-                if token:
+                if token is not None:
                     IN_SERVICE_VAR.reset(token)
                 return handle_exception(
                     exc=bhexc,
                     func=func,
-                    is_sub_service_call=IN_SERVICE_VAR.get(),
+                    is_sub_service_call=was_in_service,
                     is_homematic=True,
-                    context_obj=(args[0] if args else None),
+                    context_obj=context_obj,
                 )
             except Exception as exc:
-                if token:
+                if token is not None:
                     IN_SERVICE_VAR.reset(token)
                 return handle_exception(
                     exc=exc,
                     func=func,
-                    is_sub_service_call=IN_SERVICE_VAR.get(),
+                    is_sub_service_call=was_in_service,
                     is_homematic=False,
-                    context_obj=(args[0] if args else None),
+                    context_obj=context_obj,
                 )
             else:
-                if token:
+                if token is not None:
                     IN_SERVICE_VAR.reset(token)
                 return cast(R, return_value)
             finally:
-                if start:
+                if start is not None:
                     _log_performance_message(func, start, *args, **kwargs)
 
         # Check if the function is a coroutine or not and select the appropriate wrapper

aiohomematic/property_decorators.py

@@ -105,7 +105,7 @@ class _GenericProperty[GETTER, SETTER](property):
                 func_name = fdel.__name__
             else:
                 func_name = "prop"
-            self._cache_attr = f"_cached_{func_name}"  # Default name of the cache attribute
+            self._cache_attr = f"_cached_{func_name}"
 
     def getter(self, fget: Callable[[Any], GETTER], /) -> _GenericProperty:
         """Return generic getter."""
@@ -153,25 +153,45 @@ class _GenericProperty[GETTER, SETTER](property):
         if instance is None:
             # Accessed from class, return the descriptor itself
             return cast(GETTER, self)
-        if self.fget is None:
+
+        if (fget := self.fget) is None:
             raise AttributeError("unreadable attribute")  # pragma: no cover
 
         if not self._cached:
-            return self.fget(instance)
+            return fget(instance)
 
-        # If the cached value is not set yet, compute and store it
-        if not hasattr(instance, self._cache_attr):
-            value = self.fget(instance)
-            setattr(instance, self._cache_attr, value)
+        # Use direct __dict__ access when available for better performance
+        # Store cache_attr in local variable to avoid repeated attribute lookup
+        cache_attr = self._cache_attr
 
-        # Return the cached value
-        return cast(GETTER, getattr(instance, self._cache_attr))
+        try:
+            inst_dict = instance.__dict__
+            # Use 'in' check first to distinguish between missing and None
+            if cache_attr in inst_dict:
+                return cast(GETTER, inst_dict[cache_attr])
+
+            # Not cached yet, compute and store
+            value = fget(instance)
+            inst_dict[cache_attr] = value
+        except AttributeError:
+            # Object uses __slots__, fall back to getattr/setattr
+            try:
+                return cast(GETTER, getattr(instance, cache_attr))
+            except AttributeError:
+                value = fget(instance)
+                setattr(instance, cache_attr, value)
+        return value
 
     def __set__(self, instance: Any, value: Any, /) -> None:
         """Set the attribute value and invalidate cache if enabled."""
         # Delete the cached value so it can be recomputed on next access.
-        if self._cached and hasattr(instance, self._cache_attr):
-            delattr(instance, self._cache_attr)
+        if self._cached:
+            try:
+                instance.__dict__.pop(self._cache_attr, None)
+            except AttributeError:
+                # Object uses __slots__, fall back to delattr
+                if hasattr(instance, self._cache_attr):
+                    delattr(instance, self._cache_attr)
 
         if self.fset is None:
             raise AttributeError("can't set attribute")  # pragma: no cover
@@ -181,8 +201,13 @@ class _GenericProperty[GETTER, SETTER](property):
         """Delete the attribute and invalidate cache if enabled."""
 
         # Delete the cached value so it can be recomputed on next access.
-        if self._cached and hasattr(instance, self._cache_attr):
-            delattr(instance, self._cache_attr)
+        if self._cached:
+            try:
+                instance.__dict__.pop(self._cache_attr, None)
+            except AttributeError:
+                # Object uses __slots__, fall back to delattr
+                if hasattr(instance, self._cache_attr):
+                    delattr(instance, self._cache_attr)
 
         if self.fdel is None:
             raise AttributeError("can't delete attribute")  # pragma: no cover

aiohomematic/support.py

@@ -44,6 +44,7 @@ from aiohomematic.const import (
     PRIMARY_CLIENT_CANDIDATE_INTERFACES,
     TIMEOUT,
     CommandRxMode,
+    DeviceDescription,
     ParamsetKey,
     RxMode,
     SysvarType,
@@ -165,6 +166,19 @@ def check_or_create_directory(*, directory: str) -> bool:
     return True
 
 
+def extract_device_addresses_from_device_descriptions(
+    *, device_descriptions: tuple[DeviceDescription, ...]
+) -> tuple[str, ...]:
+    """Extract addresses from device descriptions."""
+    return tuple(
+        {
+            parent_address
+            for dev_desc in device_descriptions
+            if (parent_address := dev_desc.get("PARENT")) and (is_device_address(address=parent_address))
+        }
+    )
+
+
 def parse_sys_var(*, data_type: SysvarType | None, raw_value: Any) -> Any:
     """Parse system variables to fix type."""
     if not data_type:
@@ -352,6 +366,45 @@ def is_port(*, port: int) -> bool:
     return 0 <= port <= 65535
 
 
+@lru_cache(maxsize=2048)
+def _element_matches_key_cached(
+    *,
+    search_elements: tuple[str, ...] | str,
+    compare_with: str,
+    ignore_case: bool,
+    do_left_wildcard_search: bool,
+    do_right_wildcard_search: bool,
+) -> bool:
+    """Cache element matching for hashable inputs."""
+    compare_with_processed = compare_with.lower() if ignore_case else compare_with
+
+    if isinstance(search_elements, str):
+        element = search_elements.lower() if ignore_case else search_elements
+        if do_left_wildcard_search is True and do_right_wildcard_search is True:
+            return element in compare_with_processed
+        if do_left_wildcard_search:
+            return compare_with_processed.endswith(element)
+        if do_right_wildcard_search:
+            return compare_with_processed.startswith(element)
+        return compare_with_processed == element
+
+    # search_elements is a tuple
+    for item in search_elements:
+        element = item.lower() if ignore_case else item
+        if do_left_wildcard_search is True and do_right_wildcard_search is True:
+            if element in compare_with_processed:
+                return True
+        elif do_left_wildcard_search:
+            if compare_with_processed.endswith(element):
+                return True
+        elif do_right_wildcard_search:
+            if compare_with_processed.startswith(element):
+                return True
+        elif compare_with_processed == element:
+            return True
+    return False
+
+
 def element_matches_key(
     *,
     search_elements: str | Collection[str],
@@ -371,38 +424,48 @@ def element_matches_key(
     if compare_with is None or not search_elements:
         return False
 
-    compare_with = compare_with.lower() if ignore_case else compare_with
-
-    if isinstance(search_elements, str):
-        element = search_elements.lower() if ignore_case else search_elements
-        if do_left_wildcard_search is True and do_right_wildcard_search is True:
-            return element in compare_with
-        if do_left_wildcard_search:
-            return compare_with.endswith(element)
-        if do_right_wildcard_search:
-            return compare_with.startswith(element)
-        return compare_with == element
-    if isinstance(search_elements, Collection):
-        if isinstance(search_elements, dict) and (
-            match_key := _get_search_key(search_elements=search_elements, search_key=search_key) if search_key else None
-        ):
+    # Handle dict case with search_key
+    if isinstance(search_elements, dict) and search_key:
+        if match_key := _get_search_key(search_elements=search_elements, search_key=search_key):
             if (elements := search_elements.get(match_key)) is None:
                 return False
             search_elements = elements
+        else:
+            return False
+
+    search_elements_hashable: str | Collection[str]
+    # Convert to hashable types for caching
+    if isinstance(search_elements, str):
+        search_elements_hashable = search_elements
+    elif isinstance(search_elements, (list, set)):
+        search_elements_hashable = tuple(search_elements)
+    elif isinstance(search_elements, tuple):
+        search_elements_hashable = search_elements
+    else:
+        # Fall back to non-cached version for other collection types
+        compare_with_processed = compare_with.lower() if ignore_case else compare_with
         for item in search_elements:
             element = item.lower() if ignore_case else item
             if do_left_wildcard_search is True and do_right_wildcard_search is True:
-                if element in compare_with:
+                if element in compare_with_processed:
                     return True
             elif do_left_wildcard_search:
-                if compare_with.endswith(element):
+                if compare_with_processed.endswith(element):
                     return True
             elif do_right_wildcard_search:
-                if compare_with.startswith(element):
+                if compare_with_processed.startswith(element):
                     return True
-            elif compare_with == element:
+            elif compare_with_processed == element:
                 return True
-    return False
+        return False
+
+    return _element_matches_key_cached(
+        search_elements=search_elements_hashable,
+        compare_with=compare_with,
+        ignore_case=ignore_case,
+        do_left_wildcard_search=do_left_wildcard_search,
+        do_right_wildcard_search=do_right_wildcard_search,
+    )
 
 
 def _get_search_key(*, search_elements: Collection[str], search_key: str) -> str | None:

{aiohomematic-2025.10.3.dist-info → aiohomematic-2025.10.5.dist-info}/METADATA

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

@@ -1,25 +1,25 @@
 aiohomematic/__init__.py,sha256=ngULK_anZQwwUUCVcberBdVjguYfboiuG9VoueKy9fA,2283
-aiohomematic/async_support.py,sha256=EEzOwI3LAWjl16Q2QgtTLS7P9ktodBvs8Cw3ZKsjyxw,6153
-aiohomematic/const.py,sha256=mJmfDFhm3NFQP4qkRlb63d89qi-pDidoHUq0RYYOM6I,25565
+aiohomematic/async_support.py,sha256=BeNKaDrFsRA5-_uAFzmyyKPqlImfSs58C22Nqd5dZAg,7887
+aiohomematic/const.py,sha256=d_9gr5SrIwInmN0UTV3RJZ76z-HcxlVIZ1OuirBck4Y,25840
 aiohomematic/context.py,sha256=M7gkA7KFT0dp35gzGz2dzKVXu1PP0sAnepgLlmjyRS4,451
 aiohomematic/converter.py,sha256=gaNHe-WEiBStZMuuRz9iGn3Mo_CGz1bjgLtlYBJJAko,3624
-aiohomematic/decorators.py,sha256=oHEFSJoJVd-h9RYb6NLTJ60erkpRHPYv7EEipKn1a9Q,10636
+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=tAsmcSDnLsUiWlD1KUEe5fvYoIGpk5syYB0DrGuN4QU,16231
+aiohomematic/property_decorators.py,sha256=56lHGATgRtaFkIK_IXcR2tBW9mIVITcCwH5KOw575GA,17162
 aiohomematic/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-aiohomematic/support.py,sha256=w05YlO1IrelF2a1zKkUGWyr5E-nDJ-knh0LQqOHpR34,20514
+aiohomematic/support.py,sha256=PMiE_8MXDQBIqeJGw1GIS7O3jGY4sq3HT-u1MIyOG-M,22802
 aiohomematic/validator.py,sha256=HUikmo-SFksehFBAdZmBv4ajy0XkjgvXvcCfbexnzZo,3563
 aiohomematic/caches/__init__.py,sha256=_gI30tbsWgPRaHvP6cRxOQr6n9bYZzU-jp1WbHhWg-A,470
-aiohomematic/caches/dynamic.py,sha256=vyQsjBc2uGoNCCrWPMGmNBlUQ9GYvgVuupA9bhqH5hI,21466
-aiohomematic/caches/persistent.py,sha256=2bgASru4zbrFEd8rOn2YcReeHPiPJE8hMgMUPAbGh68,20117
+aiohomematic/caches/dynamic.py,sha256=0hOu-WoYUc9_3fofMeg_OjlYS-quD4uTyDI6zd5W4Do,22553
+aiohomematic/caches/persistent.py,sha256=xUMjvu5Vthz9W0LLllSbcqTADZvVV025b4VnPzrPnis,20604
 aiohomematic/caches/visibility.py,sha256=SThfEO3LKbIIERD4Novyj4ZZUkcYrBuvYdNQfPO29JQ,31676
-aiohomematic/central/__init__.py,sha256=nXbA9IYHSn-Gm59U_T9gqMeKwQxmliv3jdrkXnMtpXs,86940
+aiohomematic/central/__init__.py,sha256=Jh0CH_gj1zsBaYYBRm9Ue1-f8qf2TV62jcMWuYoX-xI,92241
 aiohomematic/central/decorators.py,sha256=v0gCa5QEQPNEvGy0O2YIOhoJy7OKiJZJWtK64OQm7y4,6918
 aiohomematic/central/xml_rpc_server.py,sha256=1Vr8BXakLSo-RC967IlRI9LPUCl4iXp2y-AXSZuDyPc,10777
-aiohomematic/client/__init__.py,sha256=XWHg8VTtiahu7jfHwq4yOVXOxUy8nw80JF9uyY7QNJI,70457
+aiohomematic/client/__init__.py,sha256=KcqPEsqYF6L5RoW3LoKd83GqyM2F8W6LkA_cBG_sLiw,71519
 aiohomematic/client/_rpc_errors.py,sha256=-NPtGvkQPJ4V2clDxv1tKy09M9JZm61pUCeki9DDh6s,2984
-aiohomematic/client/json_rpc.py,sha256=k5euUJkDzIQXdOX5JJxkua_7AUUTFspK8rTGnVKoCf8,49568
+aiohomematic/client/json_rpc.py,sha256=DSTmKB7YdxVmOH5b7HKoN_H-fI837n0CpyPdJyurans,50174
 aiohomematic/client/xml_rpc.py,sha256=9PEOWoTG0EMUAMyqiInF4iA_AduHv_hhjJW3YhYjYqU,9614
 aiohomematic/model/__init__.py,sha256=KO7gas_eEzm67tODKqWTs0617CSGeKKjOWOlDbhRo_Q,5458
 aiohomematic/model/data_point.py,sha256=Ml8AOQ1RcRezTYWiGBlIXwcTLolQMX5Cyb-O7GtNDm4,41586
@@ -69,10 +69,10 @@ aiohomematic/rega_scripts/get_serial.fn,sha256=t1oeo-sB_EuVeiY24PLcxFSkdQVgEWGXz
 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.3.dist-info/licenses/LICENSE,sha256=q-B0xpREuZuvKsmk3_iyVZqvZ-vJcWmzMZpeAd0RqtQ,1083
+aiohomematic-2025.10.5.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=CGZ6N_JCQ12_u2h56M_WCZ5SbcOK4xBsPYjLH2eyqlo,12820
-aiohomematic-2025.10.3.dist-info/METADATA,sha256=npEp8wqV-PrVJzhabx_yKlOicBz3Q7pnqrLf1nqqlLg,7603
-aiohomematic-2025.10.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiohomematic-2025.10.3.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
-aiohomematic-2025.10.3.dist-info/RECORD,,
+aiohomematic_support/client_local.py,sha256=nFeYkoX_EXXIwbrpL_5peYQG-934D0ASN6kflYp0_4I,12819
+aiohomematic-2025.10.5.dist-info/METADATA,sha256=8x8jCa_ZHMKfTyNBstzj2oqgTvdjgcS_v9E74Urd5aQ,7603
+aiohomematic-2025.10.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiohomematic-2025.10.5.dist-info/top_level.txt,sha256=5TDRlUWQPThIUwQjOj--aUo4UA-ow4m0sNhnoCBi5n8,34
+aiohomematic-2025.10.5.dist-info/RECORD,,

aiohomematic_support/client_local.py

@@ -35,7 +35,7 @@ from aiohomematic.decorators import inspector
 from aiohomematic.support import is_channel_address
 
 LOCAL_SERIAL: Final = "0815_4711"
-BACKEND_LOCAL: Final = "Local CCU"
+BACKEND_LOCAL: Final = "PyDevCCU"
 
 
 class ClientLocal(Client):  # pragma: no cover