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

aiohomematic/model/decorators.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Decorators for data points used within aiohomematic."""
 
 from __future__ import annotations
@@ -6,6 +8,7 @@ from collections.abc import Callable, Mapping
 from datetime import datetime
 from enum import Enum
 from typing import Any, ParamSpec, TypeVar, cast
+from weakref import WeakKeyDictionary
 
 __all__ = [
     "config_property",
@@ -18,7 +21,6 @@ __all__ = [
 
 P = ParamSpec("P")
 T = TypeVar("T")
-R = TypeVar("R")
 
 
 # pylint: disable=invalid-name
@@ -91,8 +93,9 @@ class state_property[GETTER, SETTER](generic_property[GETTER, SETTER]):
 
 
 # Cache for per-class attribute names by decorator to avoid repeated dir() scans
-# Keyed by (class, decorator class); value is a tuple of attribute names
-_PUBLIC_ATTR_CACHE: dict[tuple[type, type], tuple[str, ...]] = {}
+# Use WeakKeyDictionary to allow classes to be garbage-collected without leaking cache entries.
+# Structure: {cls: {decorator_class: (attr_name1, attr_name2, ...)}}
+_PUBLIC_ATTR_CACHE: WeakKeyDictionary[type, dict[type, tuple[str, ...]]] = WeakKeyDictionary()
 
 
 def _get_public_attributes_by_class_decorator(data_object: Any, class_decorator: type) -> Mapping[str, Any]:
@@ -102,15 +105,33 @@ def _get_public_attributes_by_class_decorator(data_object: Any, class_decorator:
     This caches the attribute names per (class, decorator) to reduce overhead
     from repeated dir()/getattr() scans. Values are not cached as they are
     instance-dependent and may change over time.
+
+    To minimize side effects, exceptions raised by property getters are caught
+    and the corresponding value is set to None. This ensures that payload
+    construction and attribute introspection do not fail due to individual
+    properties with transient errors or expensive side effects.
     """
     cls = data_object.__class__
-    cache_key = (cls, class_decorator)
 
-    if (names := _PUBLIC_ATTR_CACHE.get(cache_key)) is None:
-        names = tuple(y for y in dir(cls) if not y.startswith("_") and isinstance(getattr(cls, y), class_decorator))
-        _PUBLIC_ATTR_CACHE[cache_key] = names
+    # Get or create the per-class cache dict
+    if (decorator_cache := _PUBLIC_ATTR_CACHE.get(cls)) is None:
+        decorator_cache = {}
+        _PUBLIC_ATTR_CACHE[cls] = decorator_cache
 
-    return {name: _get_text_value(getattr(data_object, name)) for name in names}
+    # Get or compute the attribute names for this decorator
+    if (names := decorator_cache.get(class_decorator)) is None:
+        names = tuple(y for y in dir(cls) if not y.startswith("_") and isinstance(getattr(cls, y), class_decorator))
+        decorator_cache[class_decorator] = names
+
+    result: dict[str, Any] = {}
+    for name in names:
+        try:
+            value = getattr(data_object, name)
+        except Exception:
+            # Avoid propagating side effects/errors from getters
+            value = None
+        result[name] = _get_text_value(value)
+    return result
 
 
 def _get_text_value(value: Any) -> Any:

aiohomematic/model/device.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 Device and channel model for AioHomematic.
 
@@ -671,10 +673,11 @@ class Device(PayloadMixin):
         """Provide some useful information."""
         return (
             f"address: {self._address}, "
-            f"model: {len(self._model)}, "
+            f"model: {self._model}, "
             f"name: {self._name}, "
-            f"generic_data_points: {len(self.generic_data_points)}, "
-            f"custom_data_points: {len(self.custom_data_points)}, "
+            f"generic dps: {len(self.generic_data_points)}, "
+            f"calculated dps: {len(self.calculated_data_points)}, "
+            f"custom dps: {len(self.custom_data_points)}, "
             f"events: {len(self.generic_events)}"
         )
 
@@ -1077,8 +1080,9 @@ class Channel(PayloadMixin):
         return (
             f"address: {self._address}, "
             f"type: {self._type_name}, "
-            f"generic_data_points: {len(self._generic_data_points)}, "
-            f"custom_data_point: {self._custom_data_point is not None}, "
+            f"generic dps: {len(self._generic_data_points)}, "
+            f"calculated dps: {len(self._calculated_data_points)}, "
+            f"custom dp: {self._custom_data_point is not None}, "
             f"events: {len(self._generic_events)}"
         )
 

aiohomematic/model/event.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 Event model for AioHomematic.
 

aiohomematic/model/generic/__init__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 Generic data points for AioHomematic.
 

aiohomematic/model/generic/action.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 Module for action data points.
 

aiohomematic/model/generic/binary_sensor.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the binary_sensor category."""
 
 from __future__ import annotations

aiohomematic/model/generic/button.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the button category."""
 
 from __future__ import annotations

aiohomematic/model/generic/data_point.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Generic python representation of a CCU parameter."""
 
 from __future__ import annotations
@@ -16,6 +18,7 @@ from aiohomematic.const import (
     ParamsetKey,
 )
 from aiohomematic.decorators import inspector
+from aiohomematic.exceptions import ValidationException
 from aiohomematic.model import data_point as hme, device as hmd
 from aiohomematic.model.decorators import cached_slot_property
 from aiohomematic.model.support import DataPointNameData, GenericParameterType, get_data_point_name_data
@@ -101,7 +104,7 @@ class GenericDataPoint[ParameterT: GenericParameterType, InputParameterT: Generi
             return set()
         try:
             prepared_value = self._prepare_value_for_sending(value=value, do_validate=do_validate)
-        except ValueError as verr:
+        except (ValueError, ValidationException) as verr:
             _LOGGER.warning(verr)
             return set()
 

aiohomematic/model/generic/number.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the number category."""
 
 from __future__ import annotations
@@ -5,6 +7,7 @@ from __future__ import annotations
 from typing import cast
 
 from aiohomematic.const import DataPointCategory
+from aiohomematic.exceptions import ValidationException
 from aiohomematic.model.decorators import state_property
 from aiohomematic.model.generic.data_point import GenericDataPoint
 
@@ -30,7 +33,7 @@ class BaseDpNumber[NumberParameterT: int | float | None](GenericDataPoint[Number
             return cast(NumberParameterT, type_converter(value))
         if self._special and isinstance(value, str) and value in self._special:
             return cast(NumberParameterT, type_converter(self._special[value]))
-        raise ValueError(
+        raise ValidationException(
             f"NUMBER failed: Invalid value: {value} (min: {self._min}, max: {self._max}, special:{self._special})"
         )
 

aiohomematic/model/generic/select.py

@@ -1,8 +1,11 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the select category."""
 
 from __future__ import annotations
 
 from aiohomematic.const import DataPointCategory
+from aiohomematic.exceptions import ValidationException
 from aiohomematic.model.decorators import state_property
 from aiohomematic.model.generic.data_point import GenericDataPoint
 from aiohomematic.model.support import get_value_from_value_list
@@ -33,4 +36,4 @@ class DpSelect(GenericDataPoint[int | str, int | float | str]):
             return int(value)
         if self._values and value in self._values:
             return self._values.index(value)
-        raise ValueError(f"Value not in value_list for {self.name}/{self.unique_id}")
+        raise ValidationException(f"Value not in value_list for {self.name}/{self.unique_id}")

aiohomematic/model/generic/sensor.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the sensor category."""
 
 from __future__ import annotations

aiohomematic/model/generic/switch.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the switch category."""
 
 from __future__ import annotations

aiohomematic/model/generic/text.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the text category."""
 
 from __future__ import annotations

aiohomematic/model/hub/__init__.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """
 Hub (backend) data points for AioHomematic.
 

aiohomematic/model/hub/binary_sensor.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for hub data points implemented using the binary_sensor category."""
 
 from __future__ import annotations

aiohomematic/model/hub/button.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for hub data points implemented using the button category."""
 
 from __future__ import annotations

aiohomematic/model/hub/data_point.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for AioHomematic hub data points."""
 
 from __future__ import annotations
@@ -107,6 +109,10 @@ class GenericHubDataPoint(CallbackDataPoint, PayloadMixin):
         """Return, if the state is uncertain."""
         return self._state_uncertain
 
+    def _get_signature(self) -> str:
+        """Return the signature of the data_point."""
+        return f"{self._category}/{self.name}"
+
 
 class GenericSysvarDataPoint(GenericHubDataPoint):
     """Class for a HomeMatic system variable."""

aiohomematic/model/hub/number.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the number category."""
 
 from __future__ import annotations

aiohomematic/model/hub/select.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for hub data points implemented using the select category."""
 
 from __future__ import annotations

aiohomematic/model/hub/sensor.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for hub data points implemented using the sensor category."""
 
 from __future__ import annotations

aiohomematic/model/hub/switch.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for hub data points implemented using the switch category."""
 
 from __future__ import annotations

aiohomematic/model/hub/text.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for hub data points implemented using the text category."""
 
 from __future__ import annotations

aiohomematic/model/support.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Support for data points used within aiohomematic."""
 
 from __future__ import annotations
@@ -5,6 +7,7 @@ from __future__ import annotations
 from abc import abstractmethod
 from collections.abc import Mapping
 from enum import StrEnum
+from functools import lru_cache
 import logging
 from typing import Any, Final
 
@@ -533,7 +536,29 @@ def _check_channel_name_with_channel_no(name: str) -> bool:
 
 
 def convert_value(value: Any, target_type: ParameterType, value_list: tuple[str, ...] | None) -> Any:
-    """Convert a value to target_type."""
+    """
+    Convert a value to target_type with safe memoization.
+
+    To avoid redundant conversions across layers, we use an internal
+    LRU-cached helper for hashable inputs. For unhashable inputs, we
+    fall back to a direct conversion path.
+    """
+    # Normalize value_list to tuple to ensure hashability where possible
+    norm_value_list: tuple[str, ...] | None = tuple(value_list) if isinstance(value_list, list) else value_list
+    try:
+        # This will be cached if all arguments are hashable
+        return _convert_value_cached(value, target_type, norm_value_list)
+    except TypeError:
+        # Fallback non-cached path if any argument is unhashable
+        return _convert_value_noncached(value, target_type, norm_value_list)
+
+
+@lru_cache(maxsize=2048)
+def _convert_value_cached(value: Any, target_type: ParameterType, value_list: tuple[str, ...] | None) -> Any:
+    return _convert_value_noncached(value, target_type, value_list)
+
+
+def _convert_value_noncached(value: Any, target_type: ParameterType, value_list: tuple[str, ...] | None) -> Any:
     if value is None:
         return None
     if target_type == ParameterType.BOOL:

aiohomematic/model/update.py

@@ -1,3 +1,5 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
 """Module for data points implemented using the update category."""
 
 from __future__ import annotations
@@ -96,6 +98,10 @@ class DpUpdate(CallbackDataPoint, PayloadMixin):
             return self._device.available_firmware
         return self._device.firmware
 
+    def _get_signature(self) -> str:
+        """Return the signature of the data_point."""
+        return f"{self._category}/{self._device.model}"
+
     def _get_path_data(self) -> DataPointPathData:
         """Return the path data of the data_point."""
         return DataPointPathData(

aiohomematic/support.py

@@ -1,14 +1,22 @@
-"""Helper functions used within aiohomematic."""
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
+"""
+Helper functions used within aiohomematic.
+
+Public API of this module is defined by __all__.
+"""
 
 from __future__ import annotations
 
 import base64
 from collections import defaultdict
-from collections.abc import Callable, Collection, Set as AbstractSet
+from collections.abc import Callable, Collection, Mapping, Set as AbstractSet
 import contextlib
 from dataclasses import dataclass
 from datetime import datetime
+from functools import lru_cache
 import hashlib
+import inspect
 from ipaddress import IPv4Address
 import logging
 import os
@@ -18,6 +26,8 @@ import ssl
 import sys
 from typing import Any, Final, cast
 
+import orjson
+
 from aiohomematic import client as hmcl
 from aiohomematic.const import (
     ADDRESS_SEPARATOR,
@@ -254,8 +264,14 @@ def is_paramset_key(paramset_key: ParamsetKey | str) -> bool:
     return isinstance(paramset_key, ParamsetKey) or (isinstance(paramset_key, str) and paramset_key in ParamsetKey)
 
 
+@lru_cache(maxsize=4096)
 def get_split_channel_address(channel_address: str) -> tuple[str, int | None]:
-    """Return the device part of an address."""
+    """
+    Return the device part of an address.
+
+    Cached to avoid redundant parsing across layers when repeatedly handling
+    the same channel addresses.
+    """
     if ADDRESS_SEPARATOR in channel_address:
         device_address, channel_no = channel_address.split(ADDRESS_SEPARATOR)
         if channel_no in (None, "None"):
@@ -430,9 +446,20 @@ def debug_enabled() -> bool:
 
 
 def hash_sha256(value: Any) -> str:
-    """Hash a value with sha256."""
+    """
+    Hash a value with sha256.
+
+    Uses orjson to serialize the value with sorted keys for a fast and stable
+    representation. Falls back to the repr-based approach if
+    serialization fails (e.g., unsupported types).
+    """
     hasher = hashlib.sha256()
-    hasher.update(repr(_make_value_hashable(value)).encode())
+    try:
+        data = orjson.dumps(value, option=orjson.OPT_SORT_KEYS | orjson.OPT_NON_STR_KEYS)
+    except Exception:
+        # Fallback: convert to a hashable representation and use repr()
+        data = repr(_make_value_hashable(value)).encode()
+    hasher.update(data)
     return base64.b64encode(hasher.digest()).decode()
 
 
@@ -480,3 +507,146 @@ def supports_rx_mode(command_rx_mode: CommandRxMode, rx_modes: tuple[RxMode, ...
 def cleanup_text_from_html_tags(text: str) -> str:
     """Cleanup text from html tags."""
     return re.sub(HTMLTAG_PATTERN, "", text)
+
+
+# --- Structured error boundary logging helpers ---
+
+_BOUNDARY_MSG = "error_boundary"
+
+
+def _safe_context(context: Mapping[str, Any] | None) -> dict[str, Any]:
+    """Extract safe context from a mapping."""
+    ctx: dict[str, Any] = {}
+    if not context:
+        return ctx
+    # Avoid logging potentially sensitive values by redacting common keys
+    redact_keys = {"password", "passwd", "pwd", "token", "authorization", "auth"}
+    for k, v in context.items():
+        if k.lower() in redact_keys:
+            ctx[k] = "***"
+        else:
+            # Ensure value is serializable / printable
+            try:
+                str(v)
+                ctx[k] = v
+            except Exception:
+                ctx[k] = repr(v)
+    return ctx
+
+
+def build_log_context_from_obj(obj: Any | None) -> dict[str, Any]:
+    """
+    Extract structured context like device_id/channel/parameter from common objects.
+
+    Tries best-effort extraction without raising. Returns a dict suitable for logger.extra.
+    """
+    ctx: dict[str, Any] = {}
+    if obj is None:
+        return ctx
+    try:
+        # DataPoint-like: has channel and parameter
+        if hasattr(obj, "channel"):
+            ch = getattr(obj, "channel")
+            try:
+                # channel address/id
+                channel_address = ch.address if not callable(ch.address) else ch.address()
+                ctx["channel"] = channel_address
+            except Exception:
+                # Fallback to str
+                ctx["channel"] = str(ch)
+            try:
+                if (dev := ch.device if hasattr(ch, "device") else None) is not None:
+                    device_id = dev.id if not callable(dev.id) else dev.id()
+                    ctx["device_id"] = device_id
+            except Exception:
+                pass
+        # Parameter on DataPoint-like
+        if hasattr(obj, "parameter"):
+            with contextlib.suppress(Exception):
+                ctx["parameter"] = getattr(obj, "parameter")
+
+        # Also support objects exposing address directly
+        if "device_id" not in ctx and hasattr(obj, "device"):
+            dev = getattr(obj, "device")
+            try:
+                device_id = dev.id if not callable(dev.id) else dev.id()
+                ctx["device_id"] = device_id
+            except Exception:
+                pass
+        if "channel" not in ctx and hasattr(obj, "address"):
+            try:
+                addr = obj.address if not callable(obj.address) else obj.address()
+                ctx["channel"] = addr
+            except Exception:
+                pass
+    except Exception:
+        # Never allow context building to break the application
+        return {}
+    return ctx
+
+
+def log_boundary_error(
+    logger: logging.Logger,
+    *,
+    boundary: str,
+    action: str,
+    err: Exception,
+    level: int | None = None,
+    context: Mapping[str, Any] | None = None,
+) -> None:
+    """
+    Log a boundary error with the provided logger.
+
+    This function differentiates
+    between recoverable and non-recoverable domain errors to select an appropriate
+    logging level if not explicitly provided. Additionally, it enriches the log
+    record with extra context about the error and action boundaries.
+
+    :param logger: The logger instance used to log the error.
+    :type logger: logging.Logger
+    :param boundary: The name of the boundary at which the error occurred.
+    :type boundary: str
+    :param action: The action being performed when the error occurred.
+    :type action: str
+    :param err: The exception instance representing the error to log.
+    :type err: Exception
+    :param level: The optional logging level. Defaults to WARNING for recoverable
+        domain errors and ERROR for non-recoverable errors if not provided.
+    :type level: int | None
+    :param context: Optional mapping of additional information or context to
+        include in the log record.
+    :type context: Mapping[str, Any] | None
+    :return: None. This function logs the provided information but does not
+        return a value.
+    :rtype: None
+    """
+    extra = {
+        "boundary": boundary,
+        "action": action,
+        "err_type": err.__class__.__name__,
+        "err": extract_exc_args(exc=err),
+        **_safe_context(context),
+    }
+
+    # Choose level if not provided:
+    chosen_level = level
+    if chosen_level is None:
+        # Use WARNING for expected/recoverable domain errors, ERROR otherwise.
+        chosen_level = logging.WARNING if isinstance(err, BaseHomematicException) else logging.ERROR
+
+    if chosen_level >= logging.ERROR:
+        logger.exception(_BOUNDARY_MSG, extra=extra)
+    else:
+        logger.log(chosen_level, _BOUNDARY_MSG, extra=extra)
+
+
+# Define public API for this module
+__all__ = tuple(
+    sorted(
+        name
+        for name, obj in globals().items()
+        if not name.startswith("_")
+        and (inspect.isfunction(obj) or inspect.isclass(obj))
+        and getattr(obj, "__module__", __name__) == __name__
+    )
+)

aiohomematic/validator.py

@@ -1,10 +1,19 @@
-"""Validator functions used within aiohomematic."""
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2021-2025 Daniel Perna, SukramJ
+"""
+Validator functions used within aiohomematic.
+
+Public API of this module is defined by __all__.
+"""
 
 from __future__ import annotations
 
+import inspect
+
 import voluptuous as vol
 
-from aiohomematic.const import MAX_WAIT_FOR_CALLBACK
+from aiohomematic.const import BLOCKED_CATEGORIES, CATEGORIES, HUB_CATEGORIES, MAX_WAIT_FOR_CALLBACK, DataPointCategory
+from aiohomematic.model.custom import definition as hmed
 from aiohomematic.support import (
     check_password,
     is_channel_address,
@@ -63,3 +72,41 @@ def paramset_key(value: str) -> str:
 
 address = vol.All(vol.Coerce(str), vol.Any(device_address, channel_address))
 host = vol.All(vol.Coerce(str), vol.Any(hostname, ipv4_address))
+
+
+def validate_startup() -> None:
+    """
+    Validate enum and mapping exhaustiveness at startup.
+
+    - Ensure DataPointCategory coverage: all categories except UNDEFINED must be present
+      in either HUB_CATEGORIES or CATEGORIES. UNDEFINED must not appear in those lists.
+    """
+    categories_in_lists = set(BLOCKED_CATEGORIES) | set(CATEGORIES) | set(HUB_CATEGORIES)
+    all_categories = set(DataPointCategory)
+    if DataPointCategory.UNDEFINED in categories_in_lists:
+        raise vol.Invalid(
+            "DataPointCategory.UNDEFINED must not be present in BLOCKED_CATEGORIES/CATEGORIES/HUB_CATEGORIES"
+        )
+
+    if missing := all_categories - {DataPointCategory.UNDEFINED} - categories_in_lists:
+        missing_str = ", ".join(sorted(c.value for c in missing))
+        raise vol.Invalid(
+            f"BLOCKED_CATEGORIES/CATEGORIES/HUB_CATEGORIES are not exhaustive. Missing categories: {missing_str}"
+        )
+
+    # Validate custom definition mapping schema (Field <-> Parameter mappings)
+    # This ensures Field mappings are valid and consistent at startup.
+    if hmed.validate_custom_data_point_definition() is None:
+        raise vol.Invalid("Custom data point definition schema is invalid")
+
+
+# Define public API for this module
+__all__ = tuple(
+    sorted(
+        name
+        for name, obj in globals().items()
+        if not name.startswith("_")
+        and (inspect.isfunction(obj) or inspect.isclass(obj))
+        and getattr(obj, "__module__", __name__) == __name__
+    )
+)