aiohomematic 2025.8.8__py3-none-any.whl → 2025.8.10__py3-none-any.whl

aiohomematic/central/__init__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 Central unit and core orchestration for HomeMatic CCU and compatible backends.
 
@@ -119,6 +121,7 @@ from aiohomematic.const import (
     TIMEOUT,
     UN_IGNORE_WILDCARD,
     BackendSystemEvent,
+    CentralUnitState,
     DataOperationResult,
     DataPointCategory,
     DataPointKey,
@@ -163,6 +166,7 @@ from aiohomematic.support import check_config, extract_exc_args, get_channel_no,
 __all__ = ["CentralConfig", "CentralUnit", "INTERFACE_EVENT_SCHEMA"]
 
 _LOGGER: Final = logging.getLogger(__name__)
+_LOGGER_EVENT: Final = logging.getLogger(f"{__name__}_event")
 
 # {central_name, central}
 CENTRAL_INSTANCES: Final[dict[str, CentralUnit]] = {}
@@ -184,7 +188,7 @@ class CentralUnit(PayloadMixin):
 
     def __init__(self, central_config: CentralConfig) -> None:
         """Init the central unit."""
-        self._started: bool = False
+        self._state: CentralUnitState = CentralUnitState.NEW
         self._clients_started: bool = False
         self._device_add_semaphore: Final = asyncio.Semaphore()
         self._connection_state: Final = CentralConnectionState()
@@ -298,14 +302,14 @@ class CentralUnit(PayloadMixin):
         )
 
     @property
-    def interface_ids(self) -> tuple[str, ...]:
+    def interface_ids(self) -> frozenset[str]:
         """Return all associated interface ids."""
-        return tuple(self._clients)
+        return frozenset(self._clients)
 
     @property
-    def interfaces(self) -> tuple[Interface, ...]:
+    def interfaces(self) -> frozenset[Interface]:
         """Return all associated interfaces."""
-        return tuple(client.interface for client in self._clients.values())
+        return frozenset(client.interface for client in self._clients.values())
 
     @property
     def is_alive(self) -> bool:
@@ -379,9 +383,9 @@ class CentralUnit(PayloadMixin):
         )
 
     @property
-    def started(self) -> bool:
-        """Return if the central is started."""
-        return self._started
+    def state(self) -> CentralUnitState:
+        """Return the central state."""
+        return self._state
 
     @property
     def supports_ping_pong(self) -> bool:
@@ -455,9 +459,17 @@ class CentralUnit(PayloadMixin):
     async def start(self) -> None:
         """Start processing of the central unit."""
 
-        if self._started:
+        _LOGGER.debug("START: Central %s is %s", self.name, self._state)
+        if self._state == CentralUnitState.INITIALIZING:
+            _LOGGER.debug("START: Central %s already starting", self.name)
+            return
+
+        if self._state == CentralUnitState.RUNNING:
             _LOGGER.debug("START: Central %s already started", self.name)
             return
+
+        self._state = CentralUnitState.INITIALIZING
+        _LOGGER.debug("START: Initializing Central %s", self.name)
         if self._config.enabled_interface_configs and (
             ip_addr := await self._identify_ip_addr(port=self._config.connection_check_port)
         ):
@@ -479,6 +491,7 @@ class CentralUnit(PayloadMixin):
                 self._listen_port = xml_rpc_server.listen_port
                 self._xml_rpc_server.add_central(self)
         except OSError as oserr:
+            self._state = CentralUnitState.STOPPED_BY_ERROR
             raise AioHomematicException(
                 f"START: Failed to start central unit {self.name}: {extract_exc_args(exc=oserr)}"
             ) from oserr
@@ -492,13 +505,24 @@ class CentralUnit(PayloadMixin):
             if self._config.enable_server:
                 self._start_scheduler()
 
-        self._started = True
+        self._state = CentralUnitState.RUNNING
+        _LOGGER.debug("START: Central %s is %s", self.name, self._state)
 
     async def stop(self) -> None:
         """Stop processing of the central unit."""
-        if not self._started:
+        _LOGGER.debug("STOP: Central %s is %s", self.name, self._state)
+        if self._state == CentralUnitState.STOPPING:
+            _LOGGER.debug("STOP: Central %s is already stopping", self.name)
+            return
+        if self._state == CentralUnitState.STOPPED:
+            _LOGGER.debug("STOP: Central %s is already stopped", self.name)
+            return
+        if self._state != CentralUnitState.RUNNING:
             _LOGGER.debug("STOP: Central %s not started", self.name)
             return
+        self._state = CentralUnitState.STOPPING
+        _LOGGER.debug("STOP: Stopping Central %s", self.name)
+
         await self.save_caches(save_device_descriptions=True, save_paramset_descriptions=True)
         self._stop_scheduler()
         await self._stop_clients()
@@ -522,8 +546,8 @@ class CentralUnit(PayloadMixin):
 
         # cancel outstanding tasks to speed up teardown
         self.looper.cancel_tasks()
-        # wait until tasks are finished
-        await self.looper.block_till_done()
+        # wait until tasks are finished (with wait_time safeguard)
+        await self.looper.block_till_done(wait_time=5.0)
 
         # Wait briefly for any auxiliary threads to finish without blocking forever
         max_wait_seconds = 5.0
@@ -532,7 +556,8 @@ class CentralUnit(PayloadMixin):
         while self._has_active_threads and waited < max_wait_seconds:
             await asyncio.sleep(interval)
             waited += interval
-        self._started = False
+        self._state = CentralUnitState.STOPPED
+        _LOGGER.debug("STOP: Central %s is %s", self.name, self._state)
 
     async def restart_clients(self) -> None:
         """Restart clients."""
@@ -1009,19 +1034,19 @@ class CentralUnit(PayloadMixin):
             return
 
         async with self._device_add_semaphore:
-            # We need this to avoid adding duplicates.
-            known_addresses = tuple(
-                dev_desc["ADDRESS"]
-                for dev_desc in self._device_descriptions.get_raw_device_descriptions(interface_id=interface_id)
-            )
+            # 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)
             client = self._clients[interface_id]
             save_paramset_descriptions = False
             save_device_descriptions = False
             for dev_desc in 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 dev_desc["ADDRESS"] not in known_addresses:
+                    if is_new_address:
                         await client.fetch_paramset_descriptions(device_description=dev_desc)
                         save_paramset_descriptions = True
                 except Exception as exc:  # pragma: no cover
@@ -1043,7 +1068,7 @@ class CentralUnit(PayloadMixin):
                 await self._create_devices(new_device_addresses=new_device_addresses)
 
     def _check_for_new_device_addresses(self) -> Mapping[str, set[str]]:
-        """Check if there are new devices, that needs to be created."""
+        """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):
@@ -1053,21 +1078,16 @@ class CentralUnit(PayloadMixin):
                 )
                 continue
 
-            if interface_id not in new_device_addresses:
-                new_device_addresses[interface_id] = set()
-
+            # 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_device_addresses[interface_id].add(device_address)
-
-            if not new_device_addresses[interface_id]:
-                del new_device_addresses[interface_id]
+                    new_set.add(device_address)
+            if new_set:
+                new_device_addresses[interface_id] = new_set
 
         if _LOGGER.isEnabledFor(level=DEBUG):
-            count: int = 0
-            for item in new_device_addresses.values():
-                count += len(item)
-
+            count = sum(len(item) for item in new_device_addresses.values())
             _LOGGER.debug(
                 "CHECK_FOR_NEW_DEVICE_ADDRESSES: %s: %i.",
                 "Found new device addresses" if new_device_addresses else "Did not find any new device addresses",
@@ -1079,7 +1099,7 @@ class CentralUnit(PayloadMixin):
     @callback_event
     async def data_point_event(self, interface_id: str, channel_address: str, parameter: str, value: Any) -> None:
         """If a device emits some sort event, we will handle it here."""
-        _LOGGER.debug(
+        _LOGGER_EVENT.debug(
             "EVENT: interface_id = %s, channel_address = %s, parameter = %s, value = %s",
             interface_id,
             channel_address,
@@ -1117,7 +1137,7 @@ class CentralUnit(PayloadMixin):
                     if callable(callback_handler):
                         await callback_handler(value)
             except RuntimeError as rterr:  # pragma: no cover
-                _LOGGER.debug(
+                _LOGGER_EVENT.debug(
                     "EVENT: RuntimeError [%s]. Failed to call callback for: %s, %s, %s",
                     extract_exc_args(exc=rterr),
                     interface_id,
@@ -1125,7 +1145,7 @@ class CentralUnit(PayloadMixin):
                     parameter,
                 )
             except Exception as exc:  # pragma: no cover
-                _LOGGER.warning(
+                _LOGGER_EVENT.warning(
                     "EVENT failed: Unable to call callback for: %s, %s, %s, %s",
                     interface_id,
                     channel_address,
@@ -1135,7 +1155,7 @@ class CentralUnit(PayloadMixin):
 
     def data_point_path_event(self, state_path: str, value: str) -> None:
         """If a device emits some sort event, we will handle it here."""
-        _LOGGER.debug(
+        _LOGGER_EVENT.debug(
             "DATA_POINT_PATH_EVENT: topic = %s, payload = %s",
             state_path,
             value,
@@ -1154,7 +1174,7 @@ class CentralUnit(PayloadMixin):
 
     def sysvar_data_point_path_event(self, state_path: str, value: str) -> None:
         """If a device emits some sort event, we will handle it here."""
-        _LOGGER.debug(
+        _LOGGER_EVENT.debug(
             "SYSVAR_DATA_POINT_PATH_EVENT: topic = %s, payload = %s",
             state_path,
             value,
@@ -1166,13 +1186,13 @@ class CentralUnit(PayloadMixin):
                 if callable(callback_handler):
                     self._looper.create_task(callback_handler(value), name=f"sysvar-data-point-event-{state_path}")
             except RuntimeError as rterr:  # pragma: no cover
-                _LOGGER.debug(
+                _LOGGER_EVENT.debug(
                     "EVENT: RuntimeError [%s]. Failed to call callback for: %s",
                     extract_exc_args(exc=rterr),
                     state_path,
                 )
             except Exception as exc:  # pragma: no cover
-                _LOGGER.warning(
+                _LOGGER_EVENT.warning(
                     "EVENT failed: Unable to call callback for: %s, %s",
                     state_path,
                     extract_exc_args(exc=exc),
@@ -1298,7 +1318,7 @@ class CentralUnit(PayloadMixin):
         full_format: bool = False,
         un_ignore_candidates_only: bool = False,
         use_channel_wildcard: bool = False,
-    ) -> list[str]:
+    ) -> tuple[str, ...]:
         """
         Return all parameters from VALUES paramset.
 
@@ -1368,7 +1388,7 @@ class CentralUnit(PayloadMixin):
                     else:
                         parameters.add(f"{parameter}:{paramset_key}@{model}:{channel_repr}")
 
-        return list(parameters)
+        return tuple(parameters)
 
     def _get_virtual_remote(self, device_address: str) -> Device | None:
         """Get the virtual remote for the Client."""
@@ -1626,7 +1646,7 @@ class _Scheduler(threading.Thread):
     async def _run_scheduler_tasks(self) -> None:
         """Run all tasks."""
         while self._active:
-            if not self._central.started:
+            if self._central.state != CentralUnitState.RUNNING:
                 _LOGGER.debug("SCHEDULER: Waiting till central %s is started", self._central.name)
                 await asyncio.sleep(SCHEDULER_NOT_STARTED_SLEEP)
                 continue
@@ -1811,8 +1831,8 @@ class CentralConfig:
         enable_program_scan: bool = DEFAULT_ENABLE_PROGRAM_SCAN,
         enable_sysvar_scan: bool = DEFAULT_ENABLE_SYSVAR_SCAN,
         hm_master_poll_after_send_intervals: tuple[int, ...] = DEFAULT_HM_MASTER_POLL_AFTER_SEND_INTERVALS,
-        ignore_custom_device_definition_models: tuple[str, ...] = DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS,
-        interfaces_requiring_periodic_refresh: tuple[Interface, ...] = INTERFACES_REQUIRING_PERIODIC_REFRESH,
+        ignore_custom_device_definition_models: frozenset[str] = DEFAULT_IGNORE_CUSTOM_DEVICE_DEFINITION_MODELS,
+        interfaces_requiring_periodic_refresh: frozenset[Interface] = INTERFACES_REQUIRING_PERIODIC_REFRESH,
         json_port: int | None = None,
         listen_ip_addr: str | None = None,
         listen_port: int | None = None,
@@ -1823,7 +1843,7 @@ class CentralConfig:
         sys_scan_interval: int = DEFAULT_SYS_SCAN_INTERVAL,
         sysvar_markers: tuple[DescriptionMarker | str, ...] = DEFAULT_SYSVAR_MARKERS,
         tls: bool = DEFAULT_TLS,
-        un_ignore_list: tuple[str, ...] = DEFAULT_UN_IGNORES,
+        un_ignore_list: frozenset[str] = DEFAULT_UN_IGNORES,
         verify_tls: bool = DEFAULT_VERIFY_TLS,
     ) -> None:
         """Init the client config."""
@@ -1838,8 +1858,8 @@ class CentralConfig:
         self.enable_sysvar_scan: Final = enable_sysvar_scan
         self.hm_master_poll_after_send_intervals: Final = hm_master_poll_after_send_intervals
         self.host: Final = host
-        self.ignore_custom_device_definition_models: Final = ignore_custom_device_definition_models
-        self.interfaces_requiring_periodic_refresh: Final = interfaces_requiring_periodic_refresh
+        self.ignore_custom_device_definition_models: Final = frozenset(ignore_custom_device_definition_models or ())
+        self.interfaces_requiring_periodic_refresh: Final = frozenset(interfaces_requiring_periodic_refresh or ())
         self.json_port: Final = json_port
         self.listen_ip_addr: Final = listen_ip_addr
         self.listen_port: Final = listen_port
@@ -1877,9 +1897,9 @@ class CentralConfig:
         return 443 if self.tls else 80
 
     @property
-    def enabled_interface_configs(self) -> tuple[hmcl.InterfaceConfig, ...]:
+    def enabled_interface_configs(self) -> frozenset[hmcl.InterfaceConfig]:
         """Return the interface configs."""
-        return tuple(ic for ic in self._interface_configs if ic.enabled is True)
+        return frozenset(ic for ic in self._interface_configs if ic.enabled is True)
 
     @property
     def use_caches(self) -> bool:

aiohomematic/central/decorators.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Decorators for central used within aiohomematic."""
 
 from __future__ import annotations
@@ -17,6 +19,9 @@ from aiohomematic.support import extract_exc_args
 
 _LOGGER: Final = logging.getLogger(__name__)
 _INTERFACE_ID: Final = "interface_id"
+_CHANNEL_ADDRESS: Final = "channel_address"
+_PARAMETER: Final = "parameter"
+_VALUE: Final = "value"
 
 
 def callback_backend_system(system_event: BackendSystemEvent) -> Callable:
@@ -83,28 +88,68 @@ def callback_backend_system(system_event: BackendSystemEvent) -> Callable:
     return decorator_backend_system_callback
 
 
-def callback_event[**P, R](
-    func: Callable[P, R],
-) -> Callable:
+def callback_event[**P, R](func: Callable[P, R]) -> Callable:
     """Check if event_callback is set and call it AFTER original function."""
 
-    @wraps(func)
-    async def async_wrapper_event_callback(*args: P.args, **kwargs: P.kwargs) -> R:
-        """Wrap callback events."""
-        return_value = cast(R, await func(*args, **kwargs))  # type: ignore[misc]
-        _exec_event_callback(*args, **kwargs)
-        return return_value
-
     def _exec_event_callback(*args: Any, **kwargs: Any) -> None:
         """Execute the callback for a data_point event."""
         try:
-            args = args[1:]
-            interface_id: str = args[0] if len(args) > 1 else str(kwargs[_INTERFACE_ID])
+            # Expected signature: (self, interface_id, channel_address, parameter, value)
+            interface_id: str
+            if len(args) > 1:
+                interface_id = cast(str, args[1])
+                channel_address = cast(str, args[2])
+                parameter = cast(str, args[3])
+                value = args[4] if len(args) > 4 else kwargs.get(_VALUE)
+            else:
+                interface_id = cast(str, kwargs[_INTERFACE_ID])
+                channel_address = cast(str, kwargs[_CHANNEL_ADDRESS])
+                parameter = cast(str, kwargs[_PARAMETER])
+                value = kwargs[_VALUE]
+
             if client := hmcl.get_client(interface_id=interface_id):
                 client.modified_at = datetime.now()
-                client.central.fire_backend_parameter_callback(*args, **kwargs)
+                client.central.fire_backend_parameter_callback(
+                    interface_id=interface_id, channel_address=channel_address, parameter=parameter, value=value
+                )
         except Exception as exc:  # pragma: no cover
-            _LOGGER.warning("EXEC_DATA_POINT_EVENT_CALLBACK failed: Unable to reduce kwargs for event_callback")
+            _LOGGER.warning("EXEC_DATA_POINT_EVENT_CALLBACK failed: Unable to process args/kwargs for event_callback")
             raise AioHomematicException(f"args-exception event_callback [{extract_exc_args(exc=exc)}]") from exc
 
-    return async_wrapper_event_callback
+    def _schedule_or_exec(*args: Any, **kwargs: Any) -> None:
+        """Schedule event callback on central looper when possible, else execute inline."""
+        try:
+            # Prefer scheduling on the CentralUnit looper when available to avoid blocking hot path
+            unit = args[0]
+            if isinstance(unit, hmcu.CentralUnit):
+                unit.looper.create_task(
+                    _async_wrap_sync(_exec_event_callback, *args, **kwargs),
+                    name="wrapper_event_callback",
+                )
+                return
+        except Exception:
+            # Fall through to inline execution on any error
+            pass
+        _exec_event_callback(*args, **kwargs)
+
+    @wraps(func)
+    async def async_wrapper_event_callback(*args: P.args, **kwargs: P.kwargs) -> R:
+        """Wrap async callback events."""
+        return_value = cast(R, await func(*args, **kwargs))  # type: ignore[misc]
+        _schedule_or_exec(*args, **kwargs)
+        return return_value
+
+    @wraps(func)
+    def wrapper_event_callback(*args: P.args, **kwargs: P.kwargs) -> R:
+        """Wrap sync callback events."""
+        return_value = func(*args, **kwargs)
+        _schedule_or_exec(*args, **kwargs)
+        return return_value
+
+    # Helper to create a trivial coroutine from a sync callable
+    async def _async_wrap_sync(cb: Callable[..., None], *a: Any, **kw: Any) -> None:
+        cb(*a, **kw)
+
+    if inspect.iscoroutinefunction(func):
+        return async_wrapper_event_callback
+    return wrapper_event_callback

aiohomematic/central/xml_rpc_server.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 XML-RPC server module.
 
@@ -16,7 +18,7 @@ from xmlrpc.server import SimpleXMLRPCRequestHandler, SimpleXMLRPCServer
 from aiohomematic import central as hmcu
 from aiohomematic.central.decorators import callback_backend_system
 from aiohomematic.const import IP_ANY_V4, PORT_ANY, BackendSystemEvent
-from aiohomematic.support import find_free_port
+from aiohomematic.support import find_free_port, log_boundary_error
 
 _LOGGER: Final = logging.getLogger(__name__)
 
@@ -45,6 +47,18 @@ class RPCFunctions:
     @callback_backend_system(system_event=BackendSystemEvent.ERROR)
     def error(self, interface_id: str, error_code: str, msg: str) -> None:
         """When some error occurs the CCU / Homegear will send its error message here."""
+        # Structured boundary log (warning level). XML-RPC server received error notification.
+        try:
+            raise RuntimeError(str(msg))
+        except RuntimeError as err:
+            log_boundary_error(
+                logger=_LOGGER,
+                boundary="xml-rpc-server",
+                action="error",
+                err=err,
+                level=logging.WARNING,
+                context={"interface_id": interface_id, "error_code": int(error_code)},
+            )
         _LOGGER.warning(
             "ERROR failed: interface_id = %s, error_code = %i, message = %s",
             interface_id,

aiohomematic/client/__init__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 Client adapters for communicating with HomeMatic CCU and compatible backends.
 

aiohomematic/client/_rpc_errors.py

@@ -0,0 +1,81 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
+"""
+Error mapping helpers for RPC transports.
+
+This module centralizes small, transport-agnostic utilities to turn backend
+errors into domain-specific exceptions with useful context. It is used by both
+JSON-RPC and XML-RPC clients.
+
+Key types and functions
+- RpcContext: Lightweight context container that formats protocol/method/host
+  for readable error messages and logs.
+- map_jsonrpc_error: Maps a JSON-RPC error object to an appropriate exception
+  (AuthFailure, InternalBackendException, ClientException).
+- map_transport_error: Maps generic transport-level exceptions like OSError to
+  domain exceptions (NoConnectionException/ClientException).
+- map_xmlrpc_fault: Maps XML-RPC faults to domain exceptions with context.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from aiohomematic.exceptions import AuthFailure, ClientException, InternalBackendException, NoConnectionException
+
+
+@dataclass(slots=True)
+class RpcContext:
+    protocol: str
+    method: str
+    host: str | None = None
+    interface: str | None = None
+    params: Mapping[str, Any] | None = None
+
+    def fmt(self) -> str:
+        """Format context for error messages."""
+        parts: list[str] = [f"protocol={self.protocol}", f"method={self.method}"]
+        if self.interface:
+            parts.append(f"interface={self.interface}")
+        if self.host:
+            parts.append(f"host={self.host}")
+        return ", ".join(parts)
+
+
+def map_jsonrpc_error(error: Mapping[str, Any], ctx: RpcContext) -> Exception:
+    """Map JSON-RPC error to exception."""
+    # JSON-RPC 2.0 like error: {code, message, data?}
+    code = int(error.get("code", 0))
+    message = str(error.get("message", ""))
+    # Enrich message with context
+    base_msg = f"{message} ({ctx.fmt()})"
+
+    # Map common codes
+    if message.startswith("access denied") or code in (401, -32001):
+        return AuthFailure(base_msg)
+    if "internal error" in message.lower() or code in (-32603, 500):
+        return InternalBackendException(base_msg)
+    # Generic client exception for others
+    return ClientException(base_msg)
+
+
+def map_transport_error(exc: BaseException, ctx: RpcContext) -> Exception:
+    """Map transport error to exception."""
+    msg = f"{exc} ({ctx.fmt()})"
+    if isinstance(exc, OSError):
+        return NoConnectionException(msg)
+    return ClientException(msg)
+
+
+def map_xmlrpc_fault(code: int, fault_string: str, ctx: RpcContext) -> Exception:
+    """Map XML-RPC fault to exception."""
+    # Enrich message with context
+    fault_msg = f"XMLRPC Fault {code}: {fault_string} ({ctx.fmt()})"
+    # Simple mappings
+    if "unauthorized" in fault_string.lower():
+        return AuthFailure(fault_msg)
+    if "internal" in fault_string.lower():
+        return InternalBackendException(fault_msg)
+    return ClientException(fault_msg)