PyPlumIO 0.5.32__tar.gz → 0.5.34__tar.gz

{pyplumio-0.5.32 → pyplumio-0.5.34}/PKG-INFO

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

{pyplumio-0.5.32 → pyplumio-0.5.34}/PyPlumIO.egg-info/PKG-INFO

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

{pyplumio-0.5.32 → pyplumio-0.5.34}/pyplumio/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.5.32'
-__version_tuple__ = version_tuple = (0, 5, 32)
+__version__ = version = '0.5.34'
+__version_tuple__ = version_tuple = (0, 5, 34)

{pyplumio-0.5.32 → pyplumio-0.5.34}/pyplumio/devices/__init__.py

@@ -82,7 +82,7 @@ class Device(ABC, EventManager):
         """
         parameter = await self.get(name, timeout)
         if not isinstance(parameter, Parameter):
-            raise TypeError(f"{name} is not valid parameter")
+            raise TypeError(f"The parameter '{name}' is not valid or does not exist.")
 
         return await parameter.set(value, retries=retries)
 
@@ -143,7 +143,7 @@ class PhysicalDevice(Device, ABC):
                     and not self.has_frame_version(frame_type, version)
                 ):
                     _LOGGER.debug(
-                        "Updating frame %s to version %i", repr(frame_type), version
+                        "Updating frame %s to version %i", frame_type, version
                     )
                     request = await Request.create(frame_type, recipient=self.address)
                     self.queue.put_nowait(request)
@@ -151,15 +151,12 @@ class PhysicalDevice(Device, ABC):
 
         self.subscribe(ATTR_FRAME_VERSIONS, update_frame_versions)
 
-    def has_frame_version(self, frame_type: int, version: int | None = None) -> bool:
+    def has_frame_version(self, frame_type: FrameType | int, version: int) -> bool:
         """Return True if frame data is up to date, False otherwise."""
-        if frame_type not in self._frame_versions:
-            return False
-
-        if version is None or self._frame_versions[frame_type] == version:
-            return True
-
-        return False
+        return (
+            frame_type in self._frame_versions
+            and self._frame_versions[frame_type] == version
+        )
 
     def supports_frame_type(self, frame_type: int) -> bool:
         """Check if frame type is supported by the device."""
@@ -206,7 +203,10 @@ class PhysicalDevice(Device, ABC):
             except asyncio.TimeoutError:
                 retries -= 1
 
-        raise ValueError(f'could not request "{name}"', frame_type)
+        raise ValueError(
+            f"Failed to request parameter '{name}' with frame type '{frame_type}' "
+            f"after {retries} retries."
+        )
 
     @classmethod
     async def create(cls, device_type: int, **kwargs: Any) -> PhysicalDevice:

{pyplumio-0.5.32 → pyplumio-0.5.34}/pyplumio/devices/ecomax.py

@@ -98,6 +98,8 @@ SETUP_FRAME_TYPES: tuple[DataFrameDescription, ...] = (
 
 _LOGGER = logging.getLogger(__name__)
 
+ecomax_control_error = "ecoMAX control is not available. Please try again later."
+
 
 class EcoMAX(PhysicalDevice):
     """Represents an ecoMAX controller."""
@@ -192,6 +194,7 @@ class EcoMAX(PhysicalDevice):
                         values,
                         product.model,
                     )
+                    return
 
                 handler = (
                     EcomaxSwitch
@@ -393,7 +396,7 @@ class EcoMAX(PhysicalDevice):
             ecomax_control: EcomaxSwitch = self.data[ATTR_ECOMAX_CONTROL]
             return await ecomax_control.turn_on()
         except KeyError:
-            _LOGGER.error("ecoMAX control isn't available, please try later")
+            _LOGGER.error(ecomax_control_error)
             return False
 
     async def turn_off(self) -> bool:
@@ -402,7 +405,7 @@ class EcoMAX(PhysicalDevice):
             ecomax_control: EcomaxSwitch = self.data[ATTR_ECOMAX_CONTROL]
             return await ecomax_control.turn_off()
         except KeyError:
-            _LOGGER.error("ecoMAX control isn't available, please try later")
+            _LOGGER.error(ecomax_control_error)
             return False
 
     def turn_on_nowait(self) -> None:

{pyplumio-0.5.32 → pyplumio-0.5.34}/pyplumio/helpers/factory.py

@@ -26,9 +26,12 @@ async def create_instance(class_path: str, cls: type[T], **kwargs: Any) -> T:
         module = await _import_module(module_name)
         instance = getattr(module, class_name)(**kwargs)
         if not isinstance(instance, cls):
-            raise TypeError(f"class '{class_name}' should be derived from {cls}")
+            raise TypeError(
+                f"Expected instance of '{cls.__name__}', but got "
+                f"'{type(instance).__name__}' from '{class_name}'"
+            )
 
         return instance
     except Exception:
-        _LOGGER.error("Failed to load module (%s)", class_path)
+        _LOGGER.exception("Failed to create instance for class path '%s'", class_path)
         raise

{pyplumio-0.5.32 → pyplumio-0.5.34}/pyplumio/helpers/parameter.py

@@ -189,7 +189,8 @@ class Parameter(ABC):
         value = _normalize_parameter_value(value)
         if value < self.values.min_value or value > self.values.max_value:
             raise ValueError(
-                f"Value must be between '{self.min_value}' and '{self.max_value}'"
+                f"Invalid value: {value}. Must be between "
+                f"{self.min_value} and {self.max_value}."
             )
 
         return value
@@ -215,9 +216,10 @@ class Parameter(ABC):
         self._pending_update = True
         while self.pending_update:
             if retries <= 0:
-                _LOGGER.error(
-                    "Timed out while trying to set '%s' parameter",
+                _LOGGER.warning(
+                    "Failed to set parameter '%s' after %d retries",
                     self.description.name,
+                    retries,
                 )
                 return False
 

{pyplumio-0.5.32 → pyplumio-0.5.34}/pyplumio/helpers/schedule.py

@@ -50,8 +50,8 @@ def _get_time_range(
 
         if end_dt <= start_dt:
             raise ValueError(
-                f"Invalid interval ({start}, {end}). "
-                "Lower boundary must be less than upper."
+                f"Invalid time range: start time ({start}) must be earlier "
+                f"than end time ({end})."
             )
 
         def _dt_to_index(dt: dt.datetime) -> int:
@@ -107,7 +107,10 @@ class ScheduleDay(MutableMapping):
     ) -> None:
         """Set a schedule interval state."""
         if state not in get_args(ScheduleState):
-            raise ValueError(f'state "{state}" is not allowed')
+            raise ValueError(
+                f"Invalid state '{state}'. Allowed states are: "
+                f"{', '.join(get_args(ScheduleState))}"
+            )
 
         for index in _get_time_range(start, end):
             self._intervals[index] = True if state in ON_STATES else False

{pyplumio-0.5.32 → pyplumio-0.5.34}/pyplumio/stream.py

@@ -45,7 +45,7 @@ class FrameWriter:
         """Send the frame and wait until send buffer is empty."""
         self._writer.write(frame.bytes)
         await self._writer.drain()
-        _LOGGER.debug("Sent frame: %s", frame)
+        _LOGGER.debug("Sent frame: %s, bytes: %s", frame, frame.bytes)
 
     async def close(self) -> None:
         """Close the frame writer."""
@@ -53,7 +53,9 @@ class FrameWriter:
             self._writer.close()
             await self.wait_closed()
         except (OSError, asyncio.TimeoutError):
-            _LOGGER.exception("Unexpected error, while closing the writer")
+            _LOGGER.exception(
+                "Failed to close the frame writer due to an unexpected error"
+            )
 
     @timeout(WRITER_TIMEOUT)
     async def wait_closed(self) -> None:
@@ -96,7 +98,7 @@ class FrameReader:
                 buffer += await self._reader.readexactly(HEADER_SIZE - DELIMITER_SIZE)
             except IncompleteReadError as e:
                 raise ReadError(
-                    f"Got incomplete header, while trying to read {e.expected} bytes"
+                    f"Incomplete header, expected {e.expected} bytes"
                 ) from e
 
             return Header(*struct_header.unpack_from(buffer)[DELIMITER_SIZE:]), buffer
@@ -123,18 +125,21 @@ class FrameReader:
             raise UnknownDeviceError(f"Unknown sender type ({sender})")
 
         if frame_length > MAX_FRAME_LENGTH or frame_length < MIN_FRAME_LENGTH:
-            raise ReadError(f"Unexpected frame length ({frame_length})")
+            raise ReadError(
+                f"Unexpected frame length ({frame_length}), expected between "
+                f"{MIN_FRAME_LENGTH} and {MAX_FRAME_LENGTH}"
+            )
 
         try:
             buffer += await self._reader.readexactly(frame_length - HEADER_SIZE)
         except IncompleteReadError as e:
-            raise ReadError(
-                f"Got incomplete frame, while trying to read {e.expected} bytes"
-            ) from e
+            raise ReadError(f"Incomplete frame, expected {e.expected} bytes") from e
 
         if (checksum := bcc(buffer[:-2])) and checksum != buffer[-2]:
             raise ChecksumError(
-                f"Incorrect frame checksum ({checksum} != {buffer[-2]})"
+                f"Incorrect frame checksum: calculated {checksum}, "
+                f"expected {buffer[-2]}. "
+                f"Frame data: {buffer.hex()}"
             )
 
         frame = await Frame.create(
@@ -145,6 +150,6 @@ class FrameReader:
             econet_version=econet_version,
             message=buffer[HEADER_SIZE + 1 : -2],
         )
-        _LOGGER.debug("Received frame: %s", frame)
+        _LOGGER.debug("Received frame: %s, bytes: %s", frame, buffer.hex())
 
         return frame

{pyplumio-0.5.32 → pyplumio-0.5.34}/tests/helpers/test_factory.py

@@ -19,7 +19,7 @@ async def test_get_object_with_incorrect_base_class() -> None:
         await create_instance("frames.responses.UIDResponse", cls=Request)
 
     assert str(exc_info.value) == (
-        "class 'UIDResponse' should be derived from <class 'pyplumio.frames.Request'>"
+        "Expected instance of 'Request', but got 'UIDResponse' from 'UIDResponse'"
     )
 
 

{pyplumio-0.5.32 → pyplumio-0.5.34}/tests/helpers/test_parameter.py

@@ -268,7 +268,7 @@ async def test_number_request_with_unchanged_value(
     assert number.pending_update
     assert mock_put.await_count == 3  # type: ignore [unreachable]
     mock_put.reset_mock()
-    assert "Timed out while trying to set 'test_number' parameter" in caplog.text
+    assert "Failed to set parameter 'test_number' after 0 retries" in caplog.text
     await number.set(5)
     mock_put.assert_not_awaited()
 
@@ -283,7 +283,7 @@ async def test_switch_request_with_unchanged_value(
     assert switch.pending_update
     assert mock_put.await_count == 3  # type: ignore [unreachable]
     mock_put.reset_mock()
-    assert "Timed out while trying to set 'test_switch' parameter" in caplog.text
+    assert "Failed to set parameter 'test_switch' after 0 retries" in caplog.text
     await switch.set(True)
     mock_put.assert_not_awaited()
 

{pyplumio-0.5.32 → pyplumio-0.5.34}/tests/test_devices.py

@@ -165,15 +165,11 @@ async def test_async_setup_error() -> None:
 
 async def test_frame_versions_update(ecomax: EcoMAX) -> None:
     """Test requesting updated frames."""
-    assert not ecomax.has_frame_version(RegulatorDataSchemaRequest.frame_type)
     test_data = load_json_test_data("messages/sensor_data.json")[0]
     with patch("asyncio.Queue.put_nowait") as mock_put_nowait:
         ecomax.handle_frame(SensorDataMessage(message=test_data["message"]))
         await ecomax.wait_until_done()
 
-    assert not ecomax.has_frame_version(RegulatorDataSchemaRequest.frame_type, 0)
-    assert ecomax.has_frame_version(RegulatorDataSchemaRequest.frame_type, 45559)
-
     mock_put_nowait.assert_has_calls(
         [
             call(RegulatorDataSchemaRequest(recipient=DeviceType.ECOMAX)),
@@ -660,7 +656,7 @@ async def test_set(ecomax: EcoMAX) -> None:
 async def test_turn_on(ecomax: EcoMAX, caplog) -> None:
     """Test turning the controller on."""
     assert not await ecomax.turn_on()
-    assert "ecoMAX control isn't available" in caplog.text
+    assert "ecoMAX control is not available. Please try again later." in caplog.text
     ecomax.data[ATTR_ECOMAX_CONTROL] = AsyncMock()
     assert await ecomax.turn_on()
     ecomax.data[ATTR_ECOMAX_CONTROL].turn_on.assert_awaited_once()
@@ -669,7 +665,7 @@ async def test_turn_on(ecomax: EcoMAX, caplog) -> None:
 async def test_turn_off(ecomax: EcoMAX, caplog) -> None:
     """Test turning the controller off."""
     await ecomax.turn_off()
-    assert "ecoMAX control isn't available" in caplog.text
+    assert "ecoMAX control is not available. Please try again later." in caplog.text
     ecomax.data[ATTR_ECOMAX_CONTROL] = AsyncMock()
     await ecomax.turn_off()
     ecomax.data[ATTR_ECOMAX_CONTROL].turn_off.assert_awaited_once()

{pyplumio-0.5.32 → pyplumio-0.5.34}/tests/test_stream.py

@@ -53,7 +53,7 @@ async def test_frame_writer_with_close_error(
     writer = FrameWriter(mock_stream_writer)
     getattr(mock_stream_writer, method).side_effect = exception
     await writer.close()
-    assert "Unexpected error, while closing the writer" in caplog.text
+    assert "Failed to close the frame writer due to an unexpected error" in caplog.text
 
 
 @patch(
@@ -104,7 +104,7 @@ async def test_frame_reader_with_short_header(
     with pytest.raises(ReadError) as exc_info:
         await frame_reader.read()
 
-    assert "Got incomplete header, while trying to read 7 bytes" in str(exc_info.value)
+    assert "Incomplete header, expected 7 bytes" in str(exc_info.value)
 
 
 @patch(
@@ -137,7 +137,7 @@ async def test_frame_reader_with_incomplete_read(
     with pytest.raises(ReadError) as exc_info:
         await frame_reader.read()
 
-    assert "Got incomplete frame, while trying to read 10 bytes" in str(exc_info.value)
+    assert "Incomplete frame, expected 10 bytes" in str(exc_info.value)
 
 
 @patch(
@@ -152,7 +152,10 @@ async def test_frame_reader_with_incorrect_bcc(
     with pytest.raises(ChecksumError) as exc_info:
         await frame_reader.read()
 
-    assert "Incorrect frame checksum (200 != 201)" in str(exc_info.value)
+    assert (
+        "Incorrect frame checksum: calculated 200, expected 201. "
+        "Frame data: 680c000056300531fe00c916"
+    ) in str(exc_info.value)
 
 
 @patch(