PyPlumIO 0.5.32__py3-none-any.whl → 0.5.34__py3-none-any.whl

{PyPlumIO-0.5.32.dist-info → PyPlumIO-0.5.34.dist-info}/METADATA

@@ -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.dist-info → PyPlumIO-0.5.34.dist-info}/RECORD

@@ -1,16 +1,16 @@
 pyplumio/__init__.py,sha256=ditJTIOFGJDg60atHzOpiggdUrZHpSynno7MtpZUGVk,3299
 pyplumio/__main__.py,sha256=3IwHHSq-iay5FaeMc95klobe-xv82yydSKcBE7BFZ6M,500
-pyplumio/_version.py,sha256=G1xfKG6efA0TsiygMdo8hJeE0DmA_V8-y12DGNZw7do,413
+pyplumio/_version.py,sha256=NdVLEG4QoQ2gCknxsIGvrBsx6YVY3lCufzs3YmFEJws,413
 pyplumio/connection.py,sha256=6mUbcjGxxEhMVIbzZgCqH-Ez-fcYoRj7ZbVSzpikpNA,5949
 pyplumio/const.py,sha256=LyXa5aVy2KxnZq7H7F8s5SYsAgEC2UzZYMMRauliB2E,5502
 pyplumio/exceptions.py,sha256=Wn-y5AJ5xfaBlHhTUVKB27_0Us8_OVHqh-sicnr9sYA,700
 pyplumio/filters.py,sha256=AMW1zHQ1YjJfHX7e87Dhv7AGixJ3y9Vn-_JAQn7vIsg,12526
 pyplumio/protocol.py,sha256=VRxrj8vZ1FMawqblKkyxg_V61TBSvVynd9u0JXYnMUU,8090
 pyplumio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyplumio/stream.py,sha256=mtMpnUR3TfEmL5JUGXr6GnpPGBwzCokqIKDWp4vYiVg,4654
+pyplumio/stream.py,sha256=Ne-mWkO6FpILAjGdagbAh_VL3QEla-eDiT2N-kOc5o4,4883
 pyplumio/utils.py,sha256=TnBzRopinyp92wruguijxcIYmaeyNVTFX0dygI5FCMU,823
-pyplumio/devices/__init__.py,sha256=BEUpL2XxEk4YDfp4w0VX_LI4JQwK27eGWoJ6al_e1nE,8038
-pyplumio/devices/ecomax.py,sha256=ybFLJN7O3unBcyzuVmYTssBv86bPiiTGvFpFJezwUE4,15478
+pyplumio/devices/__init__.py,sha256=aOn9G7uo-CXM8BPqfm1GjmBLmWuekw-qyiEXjYG30Ps,8083
+pyplumio/devices/ecomax.py,sha256=LWDIlnC2lIOF2L5obLwpHKY0KTxp81TbrMGAzk7GlSw,15528
 pyplumio/devices/ecoster.py,sha256=jNWli7ye9T6yfkcFJZhhUHH7KOv-L6AgYFp_dKyv3OM,263
 pyplumio/devices/mixer.py,sha256=CnHWrJELtFgs2YTHGpQwKr2UTRdetX76OvLBA2PH-fs,3207
 pyplumio/devices/thermostat.py,sha256=-CZNRyywoDU6csFu85KSmQ5woVXY0x6peXkeOsi_fqg,2617
@@ -21,9 +21,9 @@ pyplumio/frames/responses.py,sha256=Ch1AVBmD6Ek7BazoEMDDEa6ad_fUdUXf4bNssQOu0sI,
 pyplumio/helpers/__init__.py,sha256=H2xxdkF-9uADLwEbfBUoxNTdwru3L5Z2cfJjgsuRsn0,31
 pyplumio/helpers/data_types.py,sha256=nB3afOLmppgSCWkZoX1-1yWPNMMNSem77x7XQ1Mi8H8,9103
 pyplumio/helpers/event_manager.py,sha256=xQOfiP_nP1Pz5zhB6HU5gXyyJXjhisYshL8_HRxDgt8,6412
-pyplumio/helpers/factory.py,sha256=6ArzJDq3MiiMaRpMEP0kC6wJWsoqOqe32V1RCxg1478,1005
-pyplumio/helpers/parameter.py,sha256=I0LJ4d29kLRt83ukfumWP6NJXfEuPS7vRlS_1HeZHT4,12306
-pyplumio/helpers/schedule.py,sha256=PnVEkgthg6tHpHvZK9fXJz9VKNDyQ_7BFT4TTVEwNhI,5310
+pyplumio/helpers/factory.py,sha256=v07s9DyihfkNUzt7ndyJbNd_DLS8UpRkut_xkGrbi6c,1123
+pyplumio/helpers/parameter.py,sha256=UWv4cQ-Mk2hBD3F2amS-6OIL0ulcMmEZcnogOXcXhng,12373
+pyplumio/helpers/schedule.py,sha256=rlq3O2Xflqks6V1rMoHKy_lww8zJJpuHFFouM2pikJw,5417
 pyplumio/helpers/task_manager.py,sha256=HAd69yGTRL0zQsu-ywnbLu1UXiJzgHWuhYWA--vs4lQ,1181
 pyplumio/helpers/timeout.py,sha256=JAhWNtIpcXyVILIwHWVy5mYofqbbRDGKLdTUKkQuajs,772
 pyplumio/helpers/uid.py,sha256=J7gN8i8LE0g6tfL66BJbwsQQqzBBxWx7giyvqaJh4BM,976
@@ -53,8 +53,8 @@ pyplumio/structures/statuses.py,sha256=wkoynyMRr1VREwfBC6vU48kPA8ZQ83pcXuciy2xHJ
 pyplumio/structures/temperatures.py,sha256=1CDzehNmbALz1Jyt_9gZNIk52q6Wv-xQXjijVDCVYec,2337
 pyplumio/structures/thermostat_parameters.py,sha256=QA-ZyulBG3P10sqgdI7rmpQYlKm9SJIXxBxAXs8Bwow,8295
 pyplumio/structures/thermostat_sensors.py,sha256=8e1TxYIJTQKT0kIGO9gG4hGdLOBUpIhiPToQyOMyeNE,3237
-PyPlumIO-0.5.32.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
-PyPlumIO-0.5.32.dist-info/METADATA,sha256=9VeND8m5qvmZeIwWG3ne9GcBET6IAr5aDdzNtMNbHT8,5510
-PyPlumIO-0.5.32.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-PyPlumIO-0.5.32.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
-PyPlumIO-0.5.32.dist-info/RECORD,,
+PyPlumIO-0.5.34.dist-info/LICENSE,sha256=m-UuZFjXJ22uPTGm9kSHS8bqjsf5T8k2wL9bJn1Y04o,1088
+PyPlumIO-0.5.34.dist-info/METADATA,sha256=fKpSdOn-36ISpqOsoM7wiwnbJn0jHfvdHnwyIge5KQM,5510
+PyPlumIO-0.5.34.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyPlumIO-0.5.34.dist-info/top_level.txt,sha256=kNBz9UPPkPD9teDn3U_sEy5LjzwLm9KfADCXtBlbw8A,9
+PyPlumIO-0.5.34.dist-info/RECORD,,

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/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/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/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/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/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/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