PyPlumIO 0.5.45__tar.gz → 0.5.47__tar.gz

{pyplumio-0.5.45 → pyplumio-0.5.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.45
+Version: 0.5.47
 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.7; extra == "test"
+Requires-Dist: ruff==0.11.8; 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.45 → pyplumio-0.5.47}/PyPlumIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.45
+Version: 0.5.47
 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.7; extra == "test"
+Requires-Dist: ruff==0.11.8; 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.45 → pyplumio-0.5.47}/PyPlumIO.egg-info/requires.txt

@@ -21,6 +21,6 @@ numpy<3.0.0,>=2.0.0
 pyserial-asyncio-fast==0.16
 pytest==8.3.5
 pytest-asyncio==0.26.0
-ruff==0.11.7
+ruff==0.11.8
 tox==4.25.0
 types-pyserial==3.5.0.20250326

{pyplumio-0.5.45 → pyplumio-0.5.47}/pyplumio/_version.py

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

{pyplumio-0.5.45 → pyplumio-0.5.47}/pyplumio/devices/__init__.py

@@ -39,7 +39,11 @@ def get_device_handler(device_type: int) -> str:
 
     type_name = to_camelcase(
         DeviceType(device_type).name,
-        overrides={"ecomax": "EcoMAX", "ecoster": "EcoSTER"},
+        overrides={
+            "ecomax": "EcoMAX",
+            "ecoster": "EcoSTER",
+            "econet": "EcoNET",
+        },
     )
     return f"devices.{type_name.lower()}.{type_name}"
 

{pyplumio-0.5.45 → pyplumio-0.5.47}/pyplumio/devices/ecomax.py

@@ -12,6 +12,7 @@ from pyplumio.const import (
     ATTR_FRAME_ERRORS,
     ATTR_PASSWORD,
     ATTR_SENSORS,
+    ATTR_SETUP,
     STATE_OFF,
     STATE_ON,
     DeviceState,
@@ -192,16 +193,8 @@ class EcoMAX(PhysicalDevice):
         self, frame_type: FrameType | int, version: int
     ) -> None:
         """Request frame version from the device."""
-        request_frame = False
-        if frame_type not in REQUIRED_TYPES:
-            # Frame not in required, so we'll request it right away.
-            request_frame = True
-
-        if frame_type in self._frame_versions:
-            # Frame in required and has been requested once by setup.
-            request_frame = True
-
-        if request_frame:
+        setup_done = self.get_nowait(ATTR_SETUP, False)
+        if setup_done or frame_type not in REQUIRED_TYPES:
             await super()._request_frame_version(frame_type, version)
 
     async def _set_ecomax_state(self, state: State) -> bool:

{pyplumio-0.5.45 → pyplumio-0.5.47}/pyplumio/helpers/factory.py

@@ -8,11 +8,14 @@ import logging
 from types import ModuleType
 from typing import Any, TypeVar
 
+from pyplumio.helpers.async_cache import acache
+
 _LOGGER = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
 
+@acache
 async def import_module(name: str) -> ModuleType:
     """Import module by name."""
     loop = asyncio.get_running_loop()

{pyplumio-0.5.45 → pyplumio-0.5.47}/pyplumio/helpers/schedule.py

@@ -15,13 +15,14 @@ from pyplumio.structures.schedules import collect_schedule_data
 
 TIME_FORMAT: Final = "%H:%M"
 
-MIDNIGHT: Final = "00:00"
+
+Time = Annotated[str, "Time string in %H:%M format"]
+
+MIDNIGHT: Final = Time("00:00")
 MIDNIGHT_DT = dt.datetime.strptime(MIDNIGHT, TIME_FORMAT)
 
 STEP = dt.timedelta(minutes=30)
 
-Time = Annotated[str, "Time string in %H:%M format"]
-
 
 def get_time(
     index: int, start: dt.datetime = MIDNIGHT_DT, step: dt.timedelta = STEP

{pyplumio-0.5.45 → pyplumio-0.5.47}/pyplumio/helpers/timeout.py

@@ -23,6 +23,7 @@ def timeout(
         async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
             return await asyncio.wait_for(func(*args, **kwargs), timeout=seconds)
 
+        setattr(wrapper, "_has_timeout_seconds", seconds)
         return wrapper
 
     return decorator

{pyplumio-0.5.45 → pyplumio-0.5.47}/pyproject.toml

@@ -45,7 +45,7 @@ test = [
     "pyserial-asyncio-fast==0.16",
     "pytest==8.3.5",
     "pytest-asyncio==0.26.0",
-    "ruff==0.11.7",
+    "ruff==0.11.8",
     "tox==4.25.0",
     "types-pyserial==3.5.0.20250326"
 ]

{pyplumio-0.5.45 → pyplumio-0.5.47}/requirements_test.txt

@@ -7,7 +7,7 @@ pre-commit==4.2.0
 pyserial-asyncio-fast==0.16
 pytest-asyncio==0.26.0
 pytest==8.3.5
-ruff==0.11.7
+ruff==0.11.8
 tomli==2.2.1
 tox==4.25.0
 types-pyserial==3.5.0.20250326

pyplumio-0.5.47/tests/__init__.py

@@ -0,0 +1 @@
+"""Contains a test suite."""

pyplumio-0.5.47/tests/conftest.py

@@ -0,0 +1,153 @@
+"""Contains fixtures for the test suite."""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Sequence
+import functools
+import importlib
+import inspect
+import json
+import os
+import pathlib
+from typing import Any, Final, TypeVar
+from unittest.mock import patch
+
+from freezegun import freeze_time
+import pytest
+
+from pyplumio.const import ProductType
+from pyplumio.devices.ecomax import EcoMAX
+from pyplumio.structures.network_info import NetworkInfo
+from pyplumio.structures.product_info import ATTR_PRODUCT, ProductInfo
+
+TESTDATA_DIR: Final = "testdata"
+UNDEFINED: Final = "undefined"
+RAISES: Final = "raises"
+DEFAULT_TOLERANCE: Final = 1e-6
+
+T = TypeVar("T")
+
+
+def _create_class_instance(module_name: str, class_name: str, **kwargs):
+    """Create class instance and cache it."""
+    return getattr(importlib.import_module(module_name), class_name)(**kwargs)
+
+
+def try_int(key: Any) -> Any:
+    """Try to convert key to integer or return key unchanged on error."""
+    try:
+        return int(key)
+    except ValueError:
+        return key
+
+
+def _decode_hinted_objects(d: Any) -> Any:
+    """Decode a hinted JSON objects."""
+    if "__module__" in d and "__class__" in d:
+        module_name = d.pop("__module__")
+        class_name = d.pop("__class__")
+        return _create_class_instance(module_name, class_name, **d)
+
+    if "__bytearray__" in d:
+        return bytearray.fromhex("".join(d["items"]))
+
+    if "__tuple__" in d:
+        return tuple(d["items"])
+
+    return {try_int(k): v for k, v in d.items()}
+
+
+def load_json_test_data(path: str) -> Any:
+    """Load test data from JSON file."""
+    abs_path = "/".join([os.path.dirname(__file__), TESTDATA_DIR, path])
+    file = pathlib.Path(abs_path)
+    with open(file, encoding="utf-8") as fp:
+        return json.load(fp, object_hook=_decode_hinted_objects)
+
+
+def load_json_parameters(path: str):
+    """Prepare JSON test data for parametrization."""
+    test_data = load_json_test_data(path)
+    return [pytest.param(x["message"], x["data"], id=x["id"]) for x in test_data]
+
+
+def _bypass_pytest_argument_inspection(
+    wrapper: T, signature: inspect.Signature, argument: str
+) -> T:
+    """Remove argument from pytest's parameter inspection."""
+    replacement = signature.replace(
+        parameters=[p for p in signature.parameters.values() if p.name != argument]
+    )
+    setattr(wrapper, "__signature__", replacement)
+    return wrapper
+
+
+def json_test_data(json_path: str, selector: str | None = None, dataset: int = 0):
+    """Pytest decorator to inject JSON test data as a test argument."""
+    name = json_path.split("/")[-1].split("\\")[-1].rsplit(".", 1)[0]
+    if selector:
+        name += f"_{selector}"
+
+    def decorator(test_func):
+        @functools.wraps(test_func)
+        async def wrapper(*args, **kwargs):
+            json_test_data = load_json_test_data(json_path)[dataset]
+            kwargs[name] = json_test_data[selector] if selector else json_test_data
+            return await test_func(*args, **kwargs)
+
+        return _bypass_pytest_argument_inspection(
+            wrapper, inspect.signature(test_func), name
+        )
+
+    return decorator
+
+
+def class_from_json(
+    cls: type, json_path: str, /, dataset: int = 0, arguments: Sequence | None = None
+):
+    """Pytest decorator to inject JSON test data as a test argument."""
+    name = json_path.split("/")[-1].split("\\")[-1].rsplit(".", 1)[0]
+    init_args = arguments if arguments else ()
+
+    def decorator(test_func):
+        @functools.wraps(test_func)
+        async def wrapper(*args, **kwargs):
+            json_test_data = load_json_test_data(json_path)[dataset]
+            kwargs[name] = cls(**{k: json_test_data[k] for k in init_args})
+            return await test_func(*args, **kwargs)
+
+        return _bypass_pytest_argument_inspection(
+            wrapper, inspect.signature(test_func), name
+        )
+
+    return decorator
+
+
+@pytest.fixture(autouse=True)
+def bypass_asyncio_sleep():
+    """Bypass an asyncio sleep."""
+    with patch("asyncio.sleep"):
+        yield
+
+
+@pytest.fixture(name="ecomax")
+def fixture_ecomax() -> EcoMAX:
+    """Return an ecoMAX object."""
+    ecomax = EcoMAX(asyncio.Queue(), network=NetworkInfo())
+    ecomax.data[ATTR_PRODUCT] = ProductInfo(
+        type=ProductType.ECOMAX_P,
+        id=90,
+        uid="TEST",
+        logo=23040,
+        image=2816,
+        model="ecoMAX 350P2-ZF",
+    )
+    return ecomax
+
+
+@pytest.fixture(name="frozen_time")
+def fixture_frozen_time():
+    """Get frozen time."""
+    with freeze_time("2012-12-12 12:00:00") as frozen_time:
+        yield frozen_time

{pyplumio-0.5.45 → pyplumio-0.5.47}/tests/frames/test_init.py

@@ -2,9 +2,8 @@
 
 from __future__ import annotations
 
-from typing import ClassVar
-
 import pytest
+from tests.conftest import RAISES
 
 from pyplumio.const import DeviceType, FrameType
 from pyplumio.exceptions import UnknownFrameError
@@ -23,13 +22,13 @@ from pyplumio.structures.program_version import ATTR_VERSION, VersionInfo
 class RequestFrame(Request):
     """Representation of a request frame."""
 
-    frame_type: ClassVar[FrameType] = FrameType.REQUEST_PROGRAM_VERSION
+    frame_type = FrameType.REQUEST_PROGRAM_VERSION
 
 
 class ResponseFrame(Response):
     """Representation of a response frame."""
 
-    frame_type: ClassVar[FrameType] = FrameType.RESPONSE_PROGRAM_VERSION
+    frame_type = FrameType.RESPONSE_PROGRAM_VERSION
 
 
 @pytest.fixture(name="request_frame")
@@ -65,11 +64,22 @@ def test_decode_create_message(frames: tuple[Request, Response]) -> None:
         assert frame.decode_message(message=bytearray()) == {}
 
 
-def test_get_frame_handler() -> None:
+@pytest.mark.parametrize(
+    ("frame_type", "handler"),
+    [
+        (FrameType.REQUEST_STOP_MASTER, "frames.requests.StopMasterRequest"),
+        (FrameType.RESPONSE_ECOMAX_CONTROL, "frames.responses.EcomaxControlResponse"),
+        (FrameType.MESSAGE_REGULATOR_DATA, "frames.messages.RegulatorDataMessage"),
+        (99, RAISES),
+    ],
+)
+def test_get_frame_handler(frame_type: FrameType | int, handler: str) -> None:
     """Test getting a frame handler."""
-    assert get_frame_handler(0x18) == "frames.requests.StopMasterRequest"
-    with pytest.raises(UnknownFrameError):
-        get_frame_handler(0x0)
+    if handler == RAISES:
+        with pytest.raises(UnknownFrameError):
+            get_frame_handler(frame_type)
+    else:
+        assert get_frame_handler(frame_type) == handler
 
 
 def test_passing_frame_type(

{pyplumio-0.5.45 → pyplumio-0.5.47}/tests/frames/test_messages.py

@@ -3,23 +3,14 @@
 from typing import Final
 
 import pytest
-from tests import load_json_parameters, load_json_test_data
+from tests.conftest import json_test_data, load_json_parameters, load_json_test_data
 
-from pyplumio.const import ATTR_SENSORS, ATTR_STATE, DeviceType
+from pyplumio.const import ATTR_SENSORS, ATTR_STATE
 from pyplumio.devices.ecomax import EcoMAX
 from pyplumio.frames.messages import RegulatorDataMessage, SensorDataMessage
 from pyplumio.structures.frame_versions import ATTR_FRAME_VERSIONS
 from pyplumio.structures.regulator_data import ATTR_REGDATA
 
-INDEX_STATE: Final = 22
-
-
-def test_messages_type() -> None:
-    """Test if response is an instance of abstract frame class."""
-    for response in (RegulatorDataMessage, SensorDataMessage):
-        frame = response(recipient=DeviceType.ALL, sender=DeviceType.ECONET)
-        assert isinstance(frame, response)
-
 
 @pytest.mark.parametrize(
     ("schema", "regdata"),
@@ -57,9 +48,12 @@ def test_sensor_data_message(message, data) -> None:
     assert SensorDataMessage(message=message).data == data
 
 
-def test_sensor_data_message_with_unknown_state() -> None:
+INDEX_STATE: Final = 22
+
+
+@json_test_data("messages/sensor_data.json", selector="message")
+async def test_sensor_data_message_with_unknown_state(sensor_data_message) -> None:
     """Test a sensor data message with an unknown device state."""
-    test_data = load_json_test_data("messages/sensor_data.json")[0]
-    message = test_data["message"]
-    message[INDEX_STATE] = 99
-    assert SensorDataMessage(message=message).data[ATTR_SENSORS][ATTR_STATE] == 99
+    sensor_data_message[INDEX_STATE] = 99
+    sensor_data = SensorDataMessage(message=sensor_data_message)
+    assert sensor_data.data[ATTR_SENSORS][ATTR_STATE] == 99

{pyplumio-0.5.45 → pyplumio-0.5.47}/tests/frames/test_requests.py

@@ -1,7 +1,7 @@
 """Contains a tests for the request frame classes."""
 
 import pytest
-from tests import load_json_parameters
+from tests.conftest import load_json_parameters
 
 from pyplumio.const import DeviceType
 from pyplumio.exceptions import FrameDataError
@@ -12,17 +12,12 @@ from pyplumio.frames.requests import (
     EcomaxControlRequest,
     EcomaxParametersRequest,
     MixerParametersRequest,
-    PasswordRequest,
     ProgramVersionRequest,
-    RegulatorDataSchemaRequest,
     SetEcomaxParameterRequest,
     SetMixerParameterRequest,
     SetScheduleRequest,
     SetThermostatParameterRequest,
-    StartMasterRequest,
-    StopMasterRequest,
     ThermostatParametersRequest,
-    UIDRequest,
 )
 from pyplumio.frames.responses import DeviceAvailableResponse, ProgramVersionResponse
 
@@ -32,25 +27,6 @@ def test_request_class_response_property() -> None:
     assert Request().response() is None
 
 
-def test_request_type() -> None:
-    """Test if request is an instance of frame class."""
-    for request in (
-        ProgramVersionRequest,
-        CheckDeviceRequest,
-        UIDRequest,
-        PasswordRequest,
-        EcomaxParametersRequest,
-        MixerParametersRequest,
-        RegulatorDataSchemaRequest,
-        StartMasterRequest,
-        StopMasterRequest,
-        AlertsRequest,
-        ThermostatParametersRequest,
-    ):
-        frame = request(recipient=DeviceType.ALL, sender=DeviceType.ECONET)
-        assert isinstance(frame, request)
-
-
 def test_program_version_response_recipient_and_type() -> None:
     """Test if program version response recipient and type is set."""
     frame = ProgramVersionRequest(recipient=DeviceType.ALL, sender=DeviceType.ECONET)

{pyplumio-0.5.45 → pyplumio-0.5.47}/tests/frames/test_responses.py

@@ -1,9 +1,8 @@
 """Contains tests for the response frame classes."""
 
 import pytest
-from tests import load_json_parameters
+from tests.conftest import load_json_parameters
 
-from pyplumio.const import DeviceType
 from pyplumio.devices.ecomax import EcoMAX
 from pyplumio.frames.responses import (
     AlertsResponse,
@@ -20,22 +19,6 @@ from pyplumio.frames.responses import (
 from pyplumio.structures.thermostat_sensors import ATTR_THERMOSTATS_AVAILABLE
 
 
-def test_responses_type() -> None:
-    """Test if response is an instance of frame class."""
-    for response in (
-        ProgramVersionResponse,
-        DeviceAvailableResponse,
-        UIDResponse,
-        PasswordResponse,
-        EcomaxParametersResponse,
-        MixerParametersResponse,
-        RegulatorDataSchemaResponse,
-        AlertsResponse,
-    ):
-        frame = response(recipient=DeviceType.ALL, sender=DeviceType.ECONET)
-        assert isinstance(frame, response)
-
-
 @pytest.mark.parametrize(
     ("message", "data"),
     load_json_parameters("responses/alerts.json"),
@@ -126,7 +109,6 @@ async def test_thermostat_parameters_response(ecomax: EcoMAX, message, data) ->
     frame.assign_to(ecomax)
     ecomax.load_nowait({ATTR_THERMOSTATS_AVAILABLE: 3})
     await ecomax.wait_until_done()
-
     assert frame.data == data
 
 

{pyplumio-0.5.45 → pyplumio-0.5.47}/tests/helpers/test_event_manager.py

@@ -5,6 +5,7 @@ from unittest.mock import AsyncMock, Mock, call, patch
 
 import pytest
 
+from pyplumio.filters import Filter
 from pyplumio.helpers.event_manager import EventManager, event_listener
 
 
@@ -26,7 +27,7 @@ def test_register_event_listeners() -> None:
     # Create event listener with filter.
     mock_on_event_test2 = AsyncMock()
     setattr(mock_on_event_test2, "_on_event", "test2")
-    mock_filter = Mock()
+    mock_filter = Mock(spec=Filter)
     mock_wrapper = Mock(return_value=mock_filter)
     setattr(mock_on_event_test2, "_on_event_filter", mock_wrapper)
 

pyplumio-0.5.47/tests/helpers/test_factory.py

@@ -0,0 +1,41 @@
+"""Contains tests for the object factory."""
+
+from __future__ import annotations
+
+from typing import Literal
+
+import pytest
+
+from pyplumio.frames import Frame, Request, Response
+from pyplumio.frames.messages import RegulatorDataMessage
+from pyplumio.frames.requests import StopMasterRequest
+from pyplumio.frames.responses import UIDResponse
+from pyplumio.helpers.factory import create_instance
+from tests.conftest import RAISES
+
+
+@pytest.mark.parametrize(
+    ("path", "base", "expected", "error_pattern"),
+    [
+        ("frames.requests.StopMasterRequest", Request, StopMasterRequest, None),
+        ("frames.responses.UIDResponse", Response, UIDResponse, None),
+        ("frames.messages.RegulatorDataMessage", Frame, RegulatorDataMessage, None),
+        ("frames.responses.UIDResponse", Request, RAISES, "Expected instance"),
+        ("frames.requests.NonExistent", Request, RAISES, "no attribute"),
+        ("frames.request.StopMasterRequest", Request, RAISES, "No module"),
+    ],
+)
+async def test_create_instance(
+    path: str,
+    base: type,
+    expected: type | Literal["raises"],
+    error_pattern: str | None,
+) -> None:
+    """Test creating an instance of class."""
+    if expected == RAISES:
+        with pytest.raises(
+            (TypeError, AttributeError, ModuleNotFoundError), match=error_pattern
+        ):
+            await create_instance(path, cls=base)
+    else:
+        assert isinstance(await create_instance(path, cls=base), expected)