PyPlumIO 0.5.49__tar.gz → 0.5.50__tar.gz

{pyplumio-0.5.49 → pyplumio-0.5.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.49
+Version: 0.5.50
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License

{pyplumio-0.5.49 → pyplumio-0.5.50}/PyPlumIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.5.49
+Version: 0.5.50
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License

{pyplumio-0.5.49 → pyplumio-0.5.50}/pyplumio/_version.py

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

{pyplumio-0.5.49 → pyplumio-0.5.50}/pyplumio/const.py

@@ -184,6 +184,7 @@ class FrameType(IntEnum):
     REQUEST_SET_MIXER_PARAMETER = 52
     REQUEST_SCHEDULES = 54
     REQUEST_SET_SCHEDULE = 55
+    REQUEST_ECOMAX_PARAMETER_CHANGES = 56
     REQUEST_UID = 57
     REQUEST_PASSWORD = 58
     REQUEST_ECOMAX_CONTROL = 59
@@ -203,6 +204,7 @@ class FrameType(IntEnum):
     RESPONSE_ECOMAX_CONTROL = 187
     RESPONSE_ALERTS = 189
     RESPONSE_PROGRAM_VERSION = 192
+    RESPONSE_ECOMAX_PARAMETER_CHANGES = 212
     RESPONSE_REGULATOR_DATA_SCHEMA = 213
     RESPONSE_THERMOSTAT_PARAMETERS = 220
     RESPONSE_SET_THERMOSTAT_PARAMETER = 221

{pyplumio-0.5.49 → pyplumio-0.5.50}/pyplumio/devices/__init__.py

@@ -145,21 +145,26 @@ class PhysicalDevice(Device, ABC):
     @event_listener(filter=on_change)
     async def on_event_frame_versions(self, versions: dict[int, int]) -> None:
         """Check frame versions and update outdated frames."""
-        _LOGGER.info("Received frame version table")
+        _LOGGER.debug("Received frame version table")
         for frame_type, version in versions.items():
             if (
                 is_known_frame_type(frame_type)
                 and self.supports_frame_type(frame_type)
                 and not self.has_frame_version(frame_type, version)
             ):
-                await self._request_frame_version(frame_type, version)
+                request_frame_type = (
+                    FrameType.REQUEST_ECOMAX_PARAMETERS
+                    if frame_type == FrameType.REQUEST_ECOMAX_PARAMETER_CHANGES
+                    else frame_type
+                )
+                await self._request_frame_version(request_frame_type, version)
                 self._frame_versions[frame_type] = version
 
     async def _request_frame_version(
         self, frame_type: FrameType | int, version: int
     ) -> None:
         """Request frame version from the device."""
-        _LOGGER.info("Updating frame %s to version %i", repr(frame_type), version)
+        _LOGGER.debug("Updating frame %s to version %i", repr(frame_type), version)
         request = await Request.create(frame_type, recipient=self.address)
         self.queue.put_nowait(request)
 

{pyplumio-0.5.49 → pyplumio-0.5.50}/pyplumio/devices/ecomax.py

@@ -234,7 +234,7 @@ class EcoMAX(PhysicalDevice):
     @event_listener
     async def on_event_setup(self, setup: bool) -> None:
         """Request frames required to set up an ecoMAX entry."""
-        _LOGGER.info("Setting up device entry")
+        _LOGGER.debug("Setting up device entry")
         await self.wait_for(ATTR_SENSORS)
         results = await asyncio.gather(
             *(
@@ -251,14 +251,14 @@ class EcoMAX(PhysicalDevice):
         if errors:
             self.dispatch_nowait(ATTR_FRAME_ERRORS, errors)
 
-        _LOGGER.info("Device entry setup done")
+        _LOGGER.debug("Device entry setup done")
 
     @event_listener
     async def on_event_ecomax_parameters(
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update ecoMAX parameters and dispatch the events."""
-        _LOGGER.info("Received device parameters")
+        _LOGGER.debug("Received device parameters")
         product_info: ProductInfo = await self.get(ATTR_PRODUCT)
         parameter_types = await get_ecomax_parameter_types(product_info)
 
@@ -307,7 +307,7 @@ class EcoMAX(PhysicalDevice):
         parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
     ) -> bool:
         """Handle mixer parameters and dispatch the events."""
-        _LOGGER.info("Received mixer parameters")
+        _LOGGER.debug("Received mixer parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -324,7 +324,7 @@ class EcoMAX(PhysicalDevice):
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
         """Update mixer sensors and dispatch the events."""
-        _LOGGER.info("Received mixer sensors")
+        _LOGGER.debug("Received mixer sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -364,7 +364,7 @@ class EcoMAX(PhysicalDevice):
     @event_listener
     async def on_event_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update ecoMAX sensors and dispatch the events."""
-        _LOGGER.info("Received device sensors")
+        _LOGGER.debug("Received device sensors")
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -376,7 +376,7 @@ class EcoMAX(PhysicalDevice):
         parameters: dict[int, list[tuple[int, ParameterValues]]] | None,
     ) -> bool:
         """Handle thermostat parameters and dispatch the events."""
-        _LOGGER.info("Received thermostat parameters")
+        _LOGGER.debug("Received thermostat parameters")
         if parameters:
             await asyncio.gather(
                 *(
@@ -407,7 +407,7 @@ class EcoMAX(PhysicalDevice):
         self, sensors: dict[int, dict[str, Any]] | None
     ) -> bool:
         """Update thermostat sensors and dispatch the events."""
-        _LOGGER.info("Received thermostat sensors")
+        _LOGGER.debug("Received thermostat sensors")
         if sensors:
             await asyncio.gather(
                 *(
@@ -427,7 +427,7 @@ class EcoMAX(PhysicalDevice):
         self, schedules: list[tuple[int, list[list[bool]]]]
     ) -> dict[str, Schedule]:
         """Update schedules."""
-        _LOGGER.info("Received device schedules")
+        _LOGGER.debug("Received device schedules")
         return {
             SCHEDULES[index]: Schedule(
                 name=SCHEDULES[index],

{pyplumio-0.5.49 → pyplumio-0.5.50}/pyplumio/devices/mixer.py

@@ -29,7 +29,7 @@ class Mixer(VirtualDevice):
     @event_listener
     async def on_event_mixer_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update mixer sensors and dispatch the events."""
-        _LOGGER.info("Received mixer %i sensors", self.index)
+        _LOGGER.debug("Received mixer %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -40,7 +40,7 @@ class Mixer(VirtualDevice):
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update mixer parameters and dispatch the events."""
-        _LOGGER.info("Received mixer %i parameters", self.index)
+        _LOGGER.debug("Received mixer %i parameters", self.index)
         product_info: ProductInfo = await self.parent.get(ATTR_PRODUCT)
         parameter_types = get_mixer_parameter_types(product_info)
 

{pyplumio-0.5.49 → pyplumio-0.5.50}/pyplumio/devices/thermostat.py

@@ -28,7 +28,7 @@ class Thermostat(VirtualDevice):
     @event_listener
     async def on_event_thermostat_sensors(self, sensors: dict[str, Any]) -> bool:
         """Update thermostat sensors and dispatch the events."""
-        _LOGGER.info("Received thermostat %i sensors", self.index)
+        _LOGGER.debug("Received thermostat %i sensors", self.index)
         await asyncio.gather(
             *(self.dispatch(name, value) for name, value in sensors.items())
         )
@@ -39,7 +39,7 @@ class Thermostat(VirtualDevice):
         self, parameters: list[tuple[int, ParameterValues]]
     ) -> bool:
         """Update thermostat parameters and dispatch the events."""
-        _LOGGER.info("Received thermostat %i parameters", self.index)
+        _LOGGER.debug("Received thermostat %i parameters", self.index)
         parameter_types = get_thermostat_parameter_types()
 
         def _thermostat_parameter_events() -> Generator[Coroutine]:

{pyplumio-0.5.49 → pyplumio-0.5.50}/pyplumio/protocol.py

@@ -230,20 +230,17 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     @acache
     async def get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
         """Return the device entry."""
-
-        @acache
-        async def _setup_device_entry(device_type: DeviceType) -> PhysicalDevice:
-            """Set up the device entry."""
-            device = await PhysicalDevice.create(
-                device_type, queue=self._queues.write, network=self._network
-            )
-            device.dispatch_nowait(ATTR_CONNECTED, True)
-            device.dispatch_nowait(ATTR_SETUP, True)
-            self.dispatch_nowait(device_type.name.lower(), device)
-            return device
-
         async with self._entry_lock:
-            return await _setup_device_entry(device_type)
+            name = device_type.name.lower()
+            if name not in self.data:
+                device = await PhysicalDevice.create(
+                    device_type, queue=self._queues.write, network=self._network
+                )
+                device.dispatch_nowait(ATTR_CONNECTED, True)
+                device.dispatch_nowait(ATTR_SETUP, True)
+                await self.dispatch(device_type.name.lower(), device)
+
+        return self.data[name]
 
 
 __all__ = ["Protocol", "DummyProtocol", "AsyncProtocol"]

{pyplumio-0.5.49 → pyplumio-0.5.50}/tests/devices/test_ecomax.py

@@ -43,6 +43,7 @@ from pyplumio.frames.messages import SensorDataMessage
 from pyplumio.frames.requests import (
     AlertsRequest,
     EcomaxControlRequest,
+    EcomaxParametersRequest,
     SetEcomaxParameterRequest,
     SetScheduleRequest,
     SetThermostatParameterRequest,
@@ -104,10 +105,24 @@ async def test_ecomax_handle_frame(
     mock_handle_frame.assert_called_once_with(request)
 
 
+@pytest.mark.parametrize(
+    ("frame_type", "frame_request"),
+    [
+        (FrameType.REQUEST_ALERTS, AlertsRequest(recipient=DeviceType.ECOMAX)),
+        (
+            FrameType.REQUEST_ECOMAX_PARAMETER_CHANGES,
+            EcomaxParametersRequest(recipient=DeviceType.ECOMAX),
+        ),
+    ],
+)
 @patch("asyncio.Queue.put_nowait")
 @class_from_json(SensorDataMessage, "messages/sensor_data.json", arguments=("message",))
 async def test_frame_versions_tracker(
-    mock_put_nowait, ecomax: EcoMAX, sensor_data: SensorDataMessage
+    mock_put_nowait,
+    ecomax: EcoMAX,
+    sensor_data: SensorDataMessage,
+    frame_type: FrameType,
+    frame_request: Request,
 ) -> None:
     """Test frame version tracker."""
 
@@ -116,7 +131,7 @@ async def test_frame_versions_tracker(
         return {ATTR_SENSORS: {ATTR_FRAME_VERSIONS: {frame: version}}}
 
     # Test with frame type that are handled during setup.
-    sensor_data.data = _frame_version_data(FrameType.REQUEST_ALERTS, 1)
+    sensor_data.data = _frame_version_data(frame_type, 1)
     ecomax.data.clear()
     ecomax.handle_frame(sensor_data)
     await ecomax.wait_until_done()
@@ -124,12 +139,12 @@ async def test_frame_versions_tracker(
 
     # Test with same frame type after setup done.
     mock_put_nowait.reset_mock()
-    sensor_data.data = _frame_version_data(FrameType.REQUEST_ALERTS, 2)
+    sensor_data.data = _frame_version_data(frame_type, 2)
     ecomax.data.clear()
     ecomax.data[ATTR_SETUP] = True
     ecomax.handle_frame(sensor_data)
     await ecomax.wait_until_done()
-    mock_put_nowait.assert_called_once_with(AlertsRequest(recipient=DeviceType.ECOMAX))
+    mock_put_nowait.assert_called_once_with(frame_request)
 
 
 @pytest.mark.parametrize("state", [STATE_ON, STATE_OFF])

{pyplumio-0.5.49 → pyplumio-0.5.50}/tests/devices/test_init.py

@@ -102,19 +102,34 @@ def fixture_physical_device() -> PhysicalDevice:
 class TestPhysicalDevice:
     """Contains tests for PhysicalDevice class."""
 
+    @pytest.mark.parametrize(
+        ("frame_type", "requested_frame_type"),
+        [
+            (FrameType.REQUEST_ALERTS, FrameType.REQUEST_ALERTS),
+            (
+                FrameType.REQUEST_ECOMAX_PARAMETER_CHANGES,
+                FrameType.REQUEST_ECOMAX_PARAMETERS,
+            ),
+        ],
+    )
     @patch("pyplumio.frames.Request.create", autospec=True)
     @patch("asyncio.Queue.put_nowait")
     async def test_frame_versions_event_listener(
-        self, mock_put_nowait, mock_request_create, physical_device: PhysicalDevice
+        self,
+        mock_put_nowait,
+        mock_request_create,
+        physical_device: PhysicalDevice,
+        frame_type: FrameType,
+        requested_frame_type: FrameType,
     ) -> None:
         """Test event listener for frame versions."""
-        assert physical_device.has_frame_version(FrameType.REQUEST_ALERTS, 1) is False
-        await physical_device.on_event_frame_versions({FrameType.REQUEST_ALERTS: 1})
+        assert physical_device.has_frame_version(frame_type, 1) is False
+        await physical_device.on_event_frame_versions({frame_type: 1})
         mock_request_create.assert_awaited_once_with(
-            FrameType.REQUEST_ALERTS, recipient=DummyPhysicalDevice.address
+            requested_frame_type, recipient=DummyPhysicalDevice.address
         )
         mock_put_nowait.assert_called_once_with(mock_request_create.return_value)
-        assert physical_device.has_frame_version(FrameType.REQUEST_ALERTS, 1) is True
+        assert physical_device.has_frame_version(frame_type, 1) is True
 
     def test_frame_versions_event_listener_decorator(self) -> None:
         """Test decorator for the frame version event listener."""