PyPlumIO 0.5.47__py3-none-any.whl → 0.5.49__py3-none-any.whl

pyplumio/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.47'
-__version_tuple__ = version_tuple = (0, 5, 47)
+__version__ = version = '0.5.49'
+__version_tuple__ = version_tuple = (0, 5, 49)

pyplumio/devices/__init__.py

@@ -72,7 +72,7 @@ class Device(ABC, EventManager):
         :param name: Name of the parameter
         :type name: str
         :param value: New value for the parameter
-        :type value: int | float | bool | Literal["off", "on"]
+        :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
             times, defaults to 5
         :type retries: int, optional
@@ -104,7 +104,7 @@ class Device(ABC, EventManager):
         :param name: Name of the parameter
         :type name: str
         :param value: New value for the parameter
-        :type value: int | float | bool | Literal["off", "on"]
+        :type value: int | float | bool | Literal["on", "off"]
         :param retries: Try setting parameter for this amount of
             times, defaults to 5
         :type retries: int, optional

pyplumio/devices/ecomax.py

@@ -260,10 +260,10 @@ class EcoMAX(PhysicalDevice):
         """Update ecoMAX parameters and dispatch the events."""
         _LOGGER.info("Received device parameters")
         product_info: ProductInfo = await self.get(ATTR_PRODUCT)
+        parameter_types = await get_ecomax_parameter_types(product_info)
 
-        def _ecomax_parameter_events() -> Generator[Coroutine, Any, None]:
+        def _ecomax_parameter_events() -> Generator[Coroutine]:
             """Get dispatch calls for ecoMAX parameter events."""
-            parameter_types = get_ecomax_parameter_types(product_info)
             for index, values in parameters:
                 try:
                     description = parameter_types[index]

pyplumio/devices/mixer.py

@@ -42,10 +42,10 @@ class Mixer(VirtualDevice):
         """Update mixer parameters and dispatch the events."""
         _LOGGER.info("Received mixer %i parameters", self.index)
         product_info: ProductInfo = await self.parent.get(ATTR_PRODUCT)
+        parameter_types = get_mixer_parameter_types(product_info)
 
-        def _mixer_parameter_events() -> Generator[Coroutine, Any, None]:
+        def _mixer_parameter_events() -> Generator[Coroutine]:
             """Get dispatch calls for mixer parameter events."""
-            parameter_types = get_mixer_parameter_types(product_info)
             for index, values in parameters:
                 try:
                     description = parameter_types[index]

pyplumio/devices/thermostat.py

@@ -40,10 +40,10 @@ class Thermostat(VirtualDevice):
     ) -> bool:
         """Update thermostat parameters and dispatch the events."""
         _LOGGER.info("Received thermostat %i parameters", self.index)
+        parameter_types = get_thermostat_parameter_types()
 
-        def _thermostat_parameter_events() -> Generator[Coroutine, Any, None]:
+        def _thermostat_parameter_events() -> Generator[Coroutine]:
             """Get dispatch calls for thermostat parameter events."""
-            parameter_types = get_thermostat_parameter_types()
             for index, values in parameters:
                 description = parameter_types[index]
                 handler = (

pyplumio/filters.py

@@ -36,7 +36,6 @@ with suppress(ImportError):
 
 
 UNDEFINED: Final = "undefined"
-TOLERANCE: Final = 0.1
 
 
 @runtime_checkable
@@ -63,26 +62,34 @@ class SupportsComparison(Protocol):
 
 Comparable = TypeVar("Comparable", Parameter, SupportsFloat, SupportsComparison)
 
+DEFAULT_TOLERANCE: Final = 1e-6
+
 
 @overload
-def is_close(old: Parameter, new: Parameter) -> bool: ...
+def is_close(old: Parameter, new: Parameter, tolerance: None = None) -> bool: ...
 
 
 @overload
-def is_close(old: SupportsFloat, new: SupportsFloat) -> bool: ...
+def is_close(
+    old: SupportsFloat, new: SupportsFloat, tolerance: float = DEFAULT_TOLERANCE
+) -> bool: ...
 
 
 @overload
-def is_close(old: SupportsComparison, new: SupportsComparison) -> bool: ...
+def is_close(
+    old: SupportsComparison, new: SupportsComparison, tolerance: None = None
+) -> bool: ...
 
 
-def is_close(old: Comparable, new: Comparable) -> bool:
+def is_close(
+    old: Comparable, new: Comparable, tolerance: float | None = DEFAULT_TOLERANCE
+) -> bool:
     """Check if value is significantly changed."""
     if isinstance(old, Parameter) and isinstance(new, Parameter):
         return new.pending_update or old.values.__ne__(new.values)
 
-    if isinstance(old, SupportsFloat) and isinstance(new, SupportsFloat):
-        return not math.isclose(old, new, abs_tol=TOLERANCE)
+    if tolerance and isinstance(old, SupportsFloat) and isinstance(new, SupportsFloat):
+        return not math.isclose(old, new, abs_tol=tolerance)
 
     return old.__ne__(new)
 
@@ -293,6 +300,53 @@ def custom(callback: Callback, filter_fn: _FilterT) -> _Custom:
     return _Custom(callback, filter_fn)
 
 
+class _Deadband(Filter):
+    """Represents a deadband filter.
+
+    Calls a callback only when value is significantly changed from the
+    previous callback call.
+    """
+
+    __slots__ = ("_tolerance",)
+
+    _tolerance: float
+
+    def __init__(self, callback: Callback, tolerance: float) -> None:
+        """Initialize a new value changed filter."""
+        self._tolerance = tolerance
+        super().__init__(callback)
+
+    async def __call__(self, new_value: Any) -> Any:
+        """Set a new value for the callback."""
+        if not isinstance(new_value, (float, int, Decimal)):
+            raise TypeError(
+                "Deadband filter can only be used with numeric values, got "
+                f"{type(new_value).__name__}: {new_value}"
+            )
+
+        if self._value == UNDEFINED or is_close(
+            self._value, new_value, tolerance=self._tolerance
+        ):
+            self._value = new_value
+            return await self._callback(new_value)
+
+
+def deadband(callback: Callback, tolerance: float) -> _Deadband:
+    """Create a new deadband filter.
+
+    A callback function will only be called when the value is significantly changed
+    from the previous callback call.
+
+    :param callback: A callback function to be awaited on significant value change
+    :type callback: Callback
+    :param tolerance: The minimum difference required to trigger the callback
+    :type tolerance: float
+    :return: An instance of callable filter
+    :rtype: _Deadband
+    """
+    return _Deadband(callback, tolerance)
+
+
 class _Debounce(Filter):
     """Represents a debounce filter.
 
@@ -468,6 +522,7 @@ __all__ = [
     "aggregate",
     "clamp",
     "custom",
+    "deadband",
     "debounce",
     "delta",
     "on_change",

pyplumio/helpers/async_cache.py

@@ -4,10 +4,11 @@ from collections.abc import Awaitable
 from functools import wraps
 from typing import Any, Callable, TypeVar, cast
 
-from typing_extensions import ParamSpec
+from typing_extensions import ParamSpec, TypeAlias
 
 T = TypeVar("T")
 P = ParamSpec("P")
+_CallableT: TypeAlias = Callable[..., Awaitable[Any]]
 
 
 class AsyncCache:
@@ -21,7 +22,7 @@ class AsyncCache:
         """Initialize the cache."""
         self.cache = {}
 
-    async def get(self, key: str, coro: Callable[..., Awaitable[Any]]) -> Any:
+    async def get(self, key: str, coro: _CallableT) -> Any:
         """Get a value from the cache or compute and store it."""
         if key not in self.cache:
             self.cache[key] = await coro()

pyplumio/helpers/factory.py

@@ -25,19 +25,15 @@ async def import_module(name: str) -> ModuleType:
 async def create_instance(class_path: str, /, cls: type[T], **kwargs: Any) -> T:
     """Return a class instance from the class path."""
     module_name, class_name = class_path.rsplit(".", 1)
-    try:
-        module = await import_module(module_name)
-        instance = getattr(module, class_name)(**kwargs)
-        if not isinstance(instance, cls):
-            raise TypeError(
-                f"Expected instance of '{cls.__name__}', but got "
-                f"'{type(instance).__name__}' from '{class_name}'"
-            )
-
-        return instance
-    except Exception:
-        _LOGGER.exception("Failed to create instance for class path '%s'", class_path)
-        raise
+    module = await import_module(module_name)
+    instance = getattr(module, class_name)(**kwargs)
+    if not isinstance(instance, cls):
+        raise TypeError(
+            f"Expected instance of '{cls.__name__}', but got "
+            f"'{type(instance).__name__}' from '{class_name}'"
+        )
+
+    return instance
 
 
 __all__ = ["create_instance"]

pyplumio/parameters/__init__.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 import asyncio
-from collections.abc import Sequence
 from dataclasses import dataclass
 import logging
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, get_args
@@ -12,16 +11,8 @@ from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, get_args
 from dataslots import dataslots
 from typing_extensions import TypeAlias
 
-from pyplumio.const import (
-    BYTE_UNDEFINED,
-    STATE_OFF,
-    STATE_ON,
-    ProductModel,
-    State,
-    UnitOfMeasurement,
-)
+from pyplumio.const import BYTE_UNDEFINED, STATE_OFF, STATE_ON, State, UnitOfMeasurement
 from pyplumio.frames import Request
-from pyplumio.structures.product_info import ProductInfo
 from pyplumio.utils import is_divisible
 
 if TYPE_CHECKING:
@@ -120,8 +111,8 @@ class Parameter(ABC):
             other = other.values
 
         if isinstance(other, ParameterValues):
-            handler = getattr(self.values, method_to_call)
-            return handler(other)
+            handler = getattr(self.values.value, method_to_call)
+            return handler(other.value)
 
         if isinstance(other, (int, float, bool)) or other in get_args(State):
             handler = getattr(self.values.value, method_to_call)
@@ -486,53 +477,6 @@ class Switch(Parameter):
         return STATE_ON
 
 
-@dataclass
-class ParameterOverride:
-    """Represents a parameter override."""
-
-    __slot__ = ("original", "replacement", "product_model", "product_id")
-
-    original: str
-    replacement: ParameterDescription
-    product_model: ProductModel
-    product_id: int
-
-
-_DescriptorT = TypeVar("_DescriptorT", bound=ParameterDescription)
-
-
-def patch_parameter_types(
-    product_info: ProductInfo,
-    parameter_types: list[_DescriptorT],
-    parameter_overrides: Sequence[ParameterOverride],
-) -> list[_DescriptorT]:
-    """Patch the parameter types based on the provided overrides.
-
-    Note:
-        The `# type: ignore[assignment]` comment is used to suppress a
-        type-checking error caused by mypy bug. For more details, see:
-        https://github.com/python/mypy/issues/13596
-
-    """
-    replacements = {
-        override.original: override.replacement
-        for override in parameter_overrides
-        if override.product_model.value == product_info.model
-        and override.product_id == product_info.id
-    }
-    for index, description in enumerate(parameter_types):
-        if description.name in replacements:
-            _LOGGER.info(
-                "Replacing parameter description for '%s' with '%s' (%s)",
-                description.name,
-                replacements[description.name],
-                product_info.model,
-            )
-            parameter_types[index] = replacements[description.name]  # type: ignore[assignment]
-
-    return parameter_types
-
-
 __all__ = [
     "Number",
     "NumberDescription",
@@ -542,7 +486,6 @@ __all__ = [
     "Parameter",
     "ParameterDescription",
     "ParameterValues",
-    "patch_parameter_types",
     "State",
     "Switch",
     "SwitchDescription",

pyplumio/parameters/custom/__init__.py

@@ -0,0 +1,111 @@
+"""Custom parameters for products."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import dataclass
+import logging
+from typing import ClassVar, TypeVar, cast
+
+from pyplumio.helpers.factory import create_instance
+from pyplumio.parameters import ParameterDescription
+from pyplumio.structures.product_info import ProductInfo
+from pyplumio.utils import to_camelcase
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class Signature:
+    """Represents a product signature."""
+
+    __slots__ = ("id", "model")
+
+    id: int
+    model: str
+
+
+@dataclass
+class CustomParameter:
+    """Represents a custom parameter."""
+
+    __slot__ = ("original", "replacement")
+
+    original: str
+    replacement: ParameterDescription
+
+
+class CustomParameters:
+    """Represents a custom parameters."""
+
+    __slots__ = ("signature", "replacements")
+
+    signature: ClassVar[Signature]
+    replacements: ClassVar[Sequence[CustomParameter]]
+
+    def validate(self, product_info: ProductInfo) -> bool:
+        """Validate the product info."""
+        return (
+            self.signature.id == product_info.id
+            and self.signature.model == product_info.model
+        )
+
+
+async def _load_custom_parameters(
+    product_info: ProductInfo,
+) -> dict[str, ParameterDescription] | None:
+    """Load custom parameters."""
+    module_name = product_info.model.replace("-", "_").replace(" ", "_").lower()
+    module_path = f"parameters.custom.{module_name}"
+    class_name = to_camelcase(module_name).upper().replace("ECOMAX", "EcoMAX")
+    class_path = f"{module_path}.{class_name}"
+    try:
+        _LOGGER.debug(
+            "Trying to load custom parameters for %s from %s",
+            product_info.model,
+            class_path,
+        )
+        custom_parameters = await create_instance(class_path, cls=CustomParameters)
+        if not custom_parameters.validate(product_info):
+            raise ValueError
+    except (ImportError, TypeError, ValueError):
+        _LOGGER.debug("No custom parameters found for %s", product_info.model)
+        return None
+
+    return {
+        custom_parameter.original: custom_parameter.replacement
+        for custom_parameter in custom_parameters.replacements
+    }
+
+
+_DescriptionT = TypeVar("_DescriptionT", bound=ParameterDescription)
+
+
+async def inject_custom_parameters(
+    product_info: ProductInfo, parameter_types: list[_DescriptionT]
+) -> list[_DescriptionT]:
+    """Patch the parameter types based on the provided overrides."""
+    if custom_parameters := await _load_custom_parameters(product_info):
+        _LOGGER.debug("Custom parameters found for %s", product_info.model)
+        return cast(
+            list[_DescriptionT],
+            [
+                replacement
+                if original.name in custom_parameters
+                and (replacement := custom_parameters[original.name])
+                and (base_class := original.__class__.__bases__[0])
+                and isinstance(replacement, base_class)
+                else original
+                for original in parameter_types
+            ],
+        )
+
+    return parameter_types
+
+
+__all__ = (
+    "inject_custom_parameters",
+    "CustomParameters",
+    "CustomParameter",
+    "Signature",
+)

pyplumio/parameters/custom/ecomax_860d3_hb.py

@@ -0,0 +1,80 @@
+"""Contains patch for ecoMAX 860D3-HB."""
+
+from pyplumio.const import UnitOfMeasurement
+from pyplumio.parameters.custom import CustomParameter, CustomParameters, Signature
+from pyplumio.parameters.ecomax import EcomaxNumberDescription, EcomaxSwitchDescription
+
+
+class EcoMAX860D3HB(CustomParameters):
+    """Replacements for ecoMAX 860D3-HB."""
+
+    __slots__ = ()
+
+    signature = Signature(model="ecoMAX 860D3-HB", id=48)
+
+    replacements = (
+        # Summer mode
+        CustomParameter(
+            original="summer_mode_disable_temp",
+            replacement=EcomaxNumberDescription(name="__unknown_parameter_1"),
+        ),
+        CustomParameter(
+            original="water_heater_target_temp",
+            replacement=EcomaxNumberDescription(name="summer_mode"),
+        ),
+        CustomParameter(
+            original="min_water_heater_target_temp",
+            replacement=EcomaxNumberDescription(
+                name="summer_mode_enable_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="max_water_heater_target_temp",
+            replacement=EcomaxNumberDescription(
+                name="summer_mode_disable_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        # Water heater
+        CustomParameter(
+            original="disable_pump_on_thermostat",
+            replacement=EcomaxNumberDescription(
+                name="water_heater_target_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="boiler_alert_temp",
+            replacement=EcomaxNumberDescription(
+                name="min_water_heater_target_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="max_feeder_temp",
+            replacement=EcomaxNumberDescription(
+                name="max_water_heater_target_temp",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="water_heater_work_mode",
+            replacement=EcomaxNumberDescription(name="water_heater_feeding_extension"),
+        ),
+        CustomParameter(
+            original="external_boiler_temp",
+            replacement=EcomaxNumberDescription(name="water_heater_work_mode"),
+        ),
+        CustomParameter(
+            original="alert_notify",
+            replacement=EcomaxNumberDescription(
+                name="water_heater_hysteresis",
+                unit_of_measurement=UnitOfMeasurement.CELSIUS,
+            ),
+        ),
+        CustomParameter(
+            original="pump_hysteresis",
+            replacement=EcomaxSwitchDescription(name="water_heater_disinfection"),
+        ),
+    )

pyplumio/parameters/ecomax.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from functools import cache, partial
+from functools import partial
 from typing import TYPE_CHECKING
 
 from dataslots import dataslots
@@ -15,21 +15,20 @@ from pyplumio.const import (
     ATTR_VALUE,
     PERCENTAGE,
     FrameType,
-    ProductModel,
     ProductType,
     UnitOfMeasurement,
 )
 from pyplumio.frames import Request
+from pyplumio.helpers.async_cache import acache
 from pyplumio.parameters import (
     OffsetNumber,
     OffsetNumberDescription,
     Parameter,
     ParameterDescription,
-    ParameterOverride,
     Switch,
     SwitchDescription,
-    patch_parameter_types,
 )
+from pyplumio.parameters.custom import inject_custom_parameters
 from pyplumio.structures.ecomax_parameters import ATTR_ECOMAX_CONTROL
 from pyplumio.structures.product_info import ProductInfo
 from pyplumio.structures.thermostat_parameters import ATTR_THERMOSTAT_PROFILE
@@ -798,58 +797,13 @@ ECOMAX_CONTROL_PARAMETER = EcomaxSwitchDescription(
 THERMOSTAT_PROFILE_PARAMETER = EcomaxNumberDescription(name=ATTR_THERMOSTAT_PROFILE)
 
 
-@dataclass
-class EcomaxParameterOverride(ParameterOverride):
-    """Represents an ecoMAX parameter override."""
-
-    __slots__ = ()
-
-    replacement: EcomaxParameterDescription
-
-
-PARAMETER_OVERRIDES: tuple[EcomaxParameterOverride, ...] = (
-    EcomaxParameterOverride(
-        original="summer_mode_disable_temp",
-        replacement=EcomaxNumberDescription(name="__unknown_parameter_1"),
-        product_model=ProductModel.ECOMAX_860D3_HB,
-        product_id=48,
-    ),
-    EcomaxParameterOverride(
-        original="water_heater_target_temp",
-        replacement=EcomaxNumberDescription(name="summer_mode"),
-        product_model=ProductModel.ECOMAX_860D3_HB,
-        product_id=48,
-    ),
-    EcomaxParameterOverride(
-        original="min_water_heater_target_temp",
-        replacement=EcomaxNumberDescription(
-            name="summer_mode_enable_temp",
-            unit_of_measurement=UnitOfMeasurement.CELSIUS,
-        ),
-        product_model=ProductModel.ECOMAX_860D3_HB,
-        product_id=48,
-    ),
-    EcomaxParameterOverride(
-        original="max_water_heater_target_temp",
-        replacement=EcomaxNumberDescription(
-            name="summer_mode_disable_temp",
-            unit_of_measurement=UnitOfMeasurement.CELSIUS,
-        ),
-        product_model=ProductModel.ECOMAX_860D3_HB,
-        product_id=48,
-    ),
-)
-
-
-@cache
-def get_ecomax_parameter_types(
+@acache
+async def get_ecomax_parameter_types(
     product_info: ProductInfo,
 ) -> list[EcomaxParameterDescription]:
     """Return ecoMAX parameter types for specific product."""
-    return patch_parameter_types(
-        product_info,
-        parameter_types=PARAMETER_TYPES[product_info.type],
-        parameter_overrides=PARAMETER_OVERRIDES,
+    return await inject_custom_parameters(
+        product_info, parameter_types=PARAMETER_TYPES[product_info.type]
     )
 
 
@@ -862,7 +816,6 @@ __all__ = [
     "EcomaxSwitch",
     "EcomaxSwitchDescription",
     "get_ecomax_parameter_types",
-    "PARAMETER_OVERRIDES",
     "PARAMETER_TYPES",
     "THERMOSTAT_PROFILE_PARAMETER",
 ]

{pyplumio-0.5.47.dist-info → pyplumio-0.5.49.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.47
+Version: 0.5.49
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -35,7 +35,7 @@ Requires-Dist: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
 Requires-Dist: pytest==8.3.5; extra == "test"
 Requires-Dist: pytest-asyncio==0.26.0; extra == "test"
-Requires-Dist: ruff==0.11.8; extra == "test"
+Requires-Dist: ruff==0.11.9; extra == "test"
 Requires-Dist: tox==4.25.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20250326; extra == "test"
 Provides-Extra: docs

{pyplumio-0.5.47.dist-info → pyplumio-0.5.49.dist-info}/RECORD

@@ -1,36 +1,38 @@
 pyplumio/__init__.py,sha256=3H5SO4WFw5mBTFeEyD4w0H8-MsNo93NyOH3RyMN7IS0,3337
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=tpJ3MabeNP2gyG46GJo9SxcUsTxxCYTWOLGwuYR8gLk,513
+pyplumio/_version.py,sha256=u94vlma_2aQlFbifB92wUyxJiUQkXGcFrFlXXxDUYBA,513
 pyplumio/connection.py,sha256=9MCPb8W62uqCrzd1YCROcn9cCjRY8E65934FnJDF5Js,5902
 pyplumio/const.py,sha256=FxF97bl_GunYuB8Wo72zCzHtznRCM64ygC2qfaR3UyA,5684
 pyplumio/data_types.py,sha256=r-QOIZiIpBFo4kRongyu8n0BHTaEU6wWMTmNkWBNjq8,9223
 pyplumio/exceptions.py,sha256=_B_0EgxDxd2XyYv3WpZM733q0cML5m6J-f55QOvYRpI,996
-pyplumio/filters.py,sha256=1AIEesbIBOceLdz--7SwDb8IPn8aLNk4gd1F6EJCZ-s,13667
+pyplumio/filters.py,sha256=s35hmm8HxqktMOtNZMdXbqMeywBNKoIsAc5hWd0AEpk,15391
 pyplumio/protocol.py,sha256=UnrXDouo4dDi7hqwJYHoEAvCoYJs3PgP1DFBBwRqBrw,8427
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyplumio/stream.py,sha256=iCB-XlNXRRE0p7nstb1AkXwVDwcCsgym_ggB_IDiJc8,4926
 pyplumio/utils.py,sha256=D6_SJzYkFjXoUrlNPt_mIQAP8hjMU05RsTqlAFphj3Y,1205
-pyplumio/devices/__init__.py,sha256=bYewj3QFU6SV1eOMtgTy9f9a20Tr4kp6bTerE_URB84,7999
-pyplumio/devices/ecomax.py,sha256=Qm2oIXVfWW1Mry3qGhrnAA150Z_jHMJrLbdgfqs9A3A,16200
+pyplumio/devices/__init__.py,sha256=frEoioDkJJuSGoBDlW42qxsRN_8lpzOvNJH56YQpd9E,7999
+pyplumio/devices/ecomax.py,sha256=-4rVUEg5MbzzoNXOFjp4cShsf4cqFh0mlIqlloZyWz4,16191
 pyplumio/devices/ecoster.py,sha256=X46ky5XT8jHMFq9sBW0ve8ZI_tjItQDMt4moXsW-ogY,307
-pyplumio/devices/mixer.py,sha256=cuqhWcIeGgHNIVqmRm-NyvaRb-ltGY5YZXrQN81xKP0,2744
-pyplumio/devices/thermostat.py,sha256=Wylm0xgheS6E_y-w0E8JEKax6Gckfw7qZu9fgv8iSMc,2266
+pyplumio/devices/mixer.py,sha256=q2UXMCQl6gueigHt-1Y1_P1sTEbBisZeQC75u2zAKmc,2729
+pyplumio/devices/thermostat.py,sha256=LBHJHfbkJgrwAifILk_IW_rRuDzSX1CDnA2xcLh4-NI,2251
 pyplumio/frames/__init__.py,sha256=5lw19oFlN89ZvO8KGwnkwERULQNYiP-hhZKk65LsjYY,7862
 pyplumio/frames/messages.py,sha256=ImQGWFFTa2eaXfytQmFZKC-IxyPRkxD8qp0bEm16-ws,3628
 pyplumio/frames/requests.py,sha256=jr-_XSSCCDDTbAmrw95CKyWa5nb7JNeGzZ2jDXIxlAo,7348
 pyplumio/frames/responses.py,sha256=M6Ky4gg2AoShmRXX0x6nftajxrvmQLKPVRWbwyhvI0E,6663
 pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
-pyplumio/helpers/async_cache.py,sha256=TlxpL4P3IZEobS4KyP86cEtqZghKtPWmVj57n5FpvTQ,1259
+pyplumio/helpers/async_cache.py,sha256=EGQcU8LWJpVx3Hk6iaI-3mqAhnR5ACfBOGb9tWw-VSY,1305
 pyplumio/helpers/event_manager.py,sha256=aKNlhsPNTy3eOSfWVb9TJxtIsN9GAQv9XxhOi_BOhlM,8097
-pyplumio/helpers/factory.py,sha256=XMfSfz4LzdUKHq80e2bH9oGgE9aT01643yt3r7Fjd4U,1213
+pyplumio/helpers/factory.py,sha256=c3sitnkUjJWz7fPpTE9uRIpa8h46Qim3xsAblMw3eDo,1049
 pyplumio/helpers/schedule.py,sha256=ODNfMuqRZuFnnFxzFFvbE0sSQ6sxp4EUyxPMDBym-L0,5308
 pyplumio/helpers/task_manager.py,sha256=N71F6Ag1HHxdf5zJeCMcEziFdH9lmJKtMPoRGjJ-E40,1209
 pyplumio/helpers/timeout.py,sha256=2wAcOug-2TgdCchKbfv0VhAfNzP-MPM0TEFtRNFJ_m8,803
 pyplumio/helpers/uid.py,sha256=HeM5Zmd0qfNmVya6RKE-bBYzdxG-pAiViOZRHqw33VU,1011
-pyplumio/parameters/__init__.py,sha256=kEDaPqJLRemc6puIGThmjfAbdt86oZnXIUE34scXG5Q,16603
-pyplumio/parameters/ecomax.py,sha256=MfjiXYW_MoEPMPdmeeZi2Wb8tNhZKTHXYxSBCQNYf9g,27606
+pyplumio/parameters/__init__.py,sha256=g9AWuCgEByGpLaiXRqE8f9xZ208ut2DNhEiDUJ0SJhs,14963
+pyplumio/parameters/ecomax.py,sha256=4UqI7cokCt7qS9Du4-7JgLhM7mhHCHt8SWPl_qncmXQ,26239
 pyplumio/parameters/mixer.py,sha256=RjhfUU_62STyNV0Ud9A4G4FEvVwo02qGVl8h1QvqQXI,6646
 pyplumio/parameters/thermostat.py,sha256=-DK2Mb78CGrKmdhwAD0M3GiGJatczPnl1e2gVeT19tI,5070
+pyplumio/parameters/custom/__init__.py,sha256=tI_MXv0ExI8do7nPjA3oWiu0m0alGLlctggNNrgq09c,3240
+pyplumio/parameters/custom/ecomax_860d3_hb.py,sha256=DgPm-o2iOxveLR-2KTrf5xC9KRVJxBHK_3cQV4UNsEs,2860
 pyplumio/structures/__init__.py,sha256=emZVH5OFgdTUPbEJoznMKitmK0nlPm0I4SmF86It1Do,1345
 pyplumio/structures/alerts.py,sha256=fglFcxHoZ3hZJscPHmbJJqTr2mH8YXRW0T18L4Dirds,3692
 pyplumio/structures/boiler_load.py,sha256=e-6itp9L6iJeeOyhSTiOclHLuYmqG7KkcepsHwJSQSI,894
@@ -57,8 +59,8 @@ pyplumio/structures/statuses.py,sha256=1h-EUw1UtuS44E19cNOSavUgZeAxsLgX3iS0eVC8p
 pyplumio/structures/temperatures.py,sha256=2VD3P_vwp9PEBkOn2-WhifOR8w-UYNq35aAxle0z2Vg,2831
 pyplumio/structures/thermostat_parameters.py,sha256=st3x3HkjQm3hqBrn_fpvPDQu8fuc-Sx33ONB19ViQak,3007
 pyplumio/structures/thermostat_sensors.py,sha256=rO9jTZWGQpThtJqVdbbv8sYMYHxJi4MfwZQza69L2zw,3399
-pyplumio-0.5.47.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-pyplumio-0.5.47.dist-info/METADATA,sha256=JlJrg9WaZZR--e6JbaTZpbfOnkqx_IC_HtwRmeGRzs0,5611
-pyplumio-0.5.47.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-pyplumio-0.5.47.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-pyplumio-0.5.47.dist-info/RECORD,,
+pyplumio-0.5.49.dist-info/licenses/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+pyplumio-0.5.49.dist-info/METADATA,sha256=dmnFwYN07jJBW5VBjNpme32Y7DbbAp1M9FPDn4AuRJA,5611
+pyplumio-0.5.49.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+pyplumio-0.5.49.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+pyplumio-0.5.49.dist-info/RECORD,,

{pyplumio-0.5.47.dist-info → pyplumio-0.5.49.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any