python-omnilogic-local 0.26.0__tar.gz → 0.27.1__tar.gz

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-omnilogic-local
-Version: 0.26.0
+Version: 0.27.1
 Summary: A library for local control of Hayward OmniHub/OmniLogic pool controllers using their local API
 Author: Chris Jowett, djtimca, garionphx
 Author-email: Chris Jowett <421501+cryptk@users.noreply.github.com>

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/api/api.py

@@ -8,11 +8,7 @@ from typing import TYPE_CHECKING, Literal, overload
 from pyomnilogic_local.models.filter_diagnostics import FilterDiagnostics
 from pyomnilogic_local.models.mspconfig import MSPConfig
 from pyomnilogic_local.models.telemetry import Telemetry
-from pyomnilogic_local.omnitypes import (
-    ColorLogicBrightness,
-    ColorLogicSpeed,
-    MessageType,
-)
+from pyomnilogic_local.omnitypes import ColorLogicBrightness, ColorLogicSpeed, MessageType
 
 from .constants import (
     DEFAULT_CONTROLLER_PORT,
@@ -117,10 +113,8 @@ class OmniLogicAPI:
 
     @overload
     async def async_send_message(self, message_type: MessageType, message: str | None, need_response: Literal[True]) -> str: ...
-
     @overload
     async def async_send_message(self, message_type: MessageType, message: str | None, need_response: Literal[False]) -> None: ...
-
     async def async_send_message(self, message_type: MessageType, message: str | None, need_response: bool = False) -> str | None:
         """Send a message via the Hayward Omni UDP protocol along with properly handling timeouts and responses.
 
@@ -138,7 +132,7 @@ class OmniLogicAPI:
         resp: str | None = None
         try:
             if need_response:
-                resp = await protocol.send_and_receive(message_type, message)
+                resp = await protocol.send_and_receive(message_type, message, response_timeout=self.response_timeout)
             else:
                 await protocol.send_message(message_type, message)
         finally:

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/api/constants.py

@@ -13,8 +13,8 @@ BLOCK_MESSAGE_HEADER_OFFSET = 8  # Offset to skip block message header and get t
 # Timing Constants (in seconds)
 OMNI_RETRANSMIT_TIME = 2.1  # Time Omni waits before retransmitting a packet
 OMNI_RETRANSMIT_COUNT = 5  # Number of retransmit attempts (6 total including initial)
-ACK_WAIT_TIMEOUT = 0.5  # Timeout waiting for ACK response
-DEFAULT_RESPONSE_TIMEOUT = 5.0  # Default timeout for receiving responses
+ACK_WAIT_TIMEOUT = 1  # Timeout waiting for ACK response, 0.5 showed to be just a tad too short in some cases.
+DEFAULT_RESPONSE_TIMEOUT = OMNI_RETRANSMIT_TIME * OMNI_RETRANSMIT_COUNT  # Default timeout for receiving responses
 
 # Network Constants
 DEFAULT_CONTROLLER_PORT = 10444  # Default UDP port for OmniLogic communication

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/api/mock_api.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 import logging
 from pathlib import Path
-from typing import Any, Literal, overload
+from typing import Any, Literal, TypedDict, overload
 
 from pyomnilogic_local.models.mspconfig import MSPConfig
 from pyomnilogic_local.models.telemetry import Telemetry
@@ -13,6 +13,12 @@ from pyomnilogic_local.models.telemetry import Telemetry
 _LOGGER = logging.getLogger(__name__)
 
 
+class SimData(TypedDict):
+    telemetry: str
+    msp_config: str
+    filepath: str
+
+
 class OmniLogicMockAPI:
     """Drop-in replacement for OmniLogicAPI that serves pre-recorded data from one or more JSON files.
 
@@ -43,7 +49,7 @@ class OmniLogicMockAPI:
         """
         paths = filepath.split(",")
 
-        self._sim_data: list[dict[str, Any]] = []
+        self._sim_data: list[SimData] = []
         for fp in paths:
             path = Path(fp)
             if not path.exists():

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/api/protocol.py

@@ -15,6 +15,7 @@ from pyomnilogic_local.omnitypes import ClientType, MessageType
 from .constants import (
     ACK_WAIT_TIMEOUT,
     BLOCK_MESSAGE_HEADER_OFFSET,
+    DEFAULT_RESPONSE_TIMEOUT,
     MAX_FRAGMENT_WAIT_TIME,
     MAX_QUEUE_SIZE,
     OMNI_RETRANSMIT_COUNT,
@@ -25,11 +26,7 @@ from .constants import (
     XML_ENCODING,
     XML_NAMESPACE,
 )
-from .exceptions import (
-    OmniFragmentationError,
-    OmniMessageFormatError,
-    OmniTimeoutError,
-)
+from .exceptions import OmniFragmentationError, OmniMessageFormatError, OmniTimeoutError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -225,21 +222,34 @@ class OmniLogicProtocol(asyncio.DatagramProtocol):
             Exception: If a protocol error occurs.
         """
         # Wait for either an ACK message or an error
-        while True:
+        # Race condition: datagram_received() calls put_nowait() synchronously, so data_task may
+        # already be done when wait_for fires its timeout CancelledError. In that case we catch
+        # the cancellation, skip re-looping, and fall through to check the result below. If the
+        # result is our ACK we return normally, suppressing the CancelledError so wait_for treats
+        # the call as successful. If it isn't, we re-raise after the loop.
+        cancelled: asyncio.CancelledError | None = None
+        retry = True
+        while retry:
             # Wait for either a message or an error
             data_task = asyncio.create_task(self.data_queue.get())
             error_task = asyncio.create_task(self.error_queue.get())
-            done, pending = await asyncio.wait([data_task, error_task], return_when=asyncio.FIRST_COMPLETED)
+            try:
+                done, pending = await asyncio.wait([data_task, error_task], return_when=asyncio.FIRST_COMPLETED)
+            except asyncio.CancelledError as exc:
+                retry = False
+                cancelled = exc
+                done = {t for t in (data_task, error_task) if t.done()}
+                pending = {t for t in (data_task, error_task) if not t.done()}
 
             # Cancel any pending tasks to avoid "Task was destroyed but it is pending" warnings
             for task in pending:
                 task.cancel()
 
             if error_task in done:
-                exc = error_task.result()
-                if isinstance(exc, Exception):
-                    raise exc
-                _LOGGER.error("Unknown error occurred during communication with OmniLogic: %s", exc)
+                err = error_task.result()
+                if isinstance(err, Exception):
+                    raise err
+                _LOGGER.error("Unknown error occurred during communication with OmniLogic: %s", err)
             if data_task in done:
                 message = data_task.result()
                 if message.id == ack_id:
@@ -251,6 +261,9 @@ class OmniLogicProtocol(asyncio.DatagramProtocol):
                     await self.data_queue.put(message)
                     return
 
+        if cancelled is not None:
+            raise cancelled
+
     async def _ensure_sent(
         self,
         message: OmniLogicMessage,
@@ -299,6 +312,7 @@ class OmniLogicProtocol(asyncio.DatagramProtocol):
         msg_type: MessageType,
         payload: str | None,
         msg_id: int | None = None,
+        response_timeout: float = DEFAULT_RESPONSE_TIMEOUT,
     ) -> str:
         """Send a message and wait for a response, returning the response payload as a string.
 
@@ -306,12 +320,13 @@ class OmniLogicProtocol(asyncio.DatagramProtocol):
             msg_type: Type of message to send.
             payload: Optional payload string.
             msg_id: Optional message ID.
+            response_timeout: Timeout in seconds to wait for the response.
 
         Returns:
             Response payload as a string.
         """
         await self.send_message(msg_type, payload, msg_id)
-        return await self._receive_file()
+        return await self._receive_file(response_timeout=response_timeout)
 
     # Send a message that you do NOT need a response to
     async def send_message(
@@ -346,11 +361,14 @@ class OmniLogicProtocol(asyncio.DatagramProtocol):
         req_body = ET.tostring(body_element, xml_declaration=True, encoding=XML_ENCODING)
         await self.send_message(MessageType.XML_ACK, req_body, msg_id)
 
-    async def _receive_file(self) -> str:
+    async def _receive_file(self, response_timeout: float = DEFAULT_RESPONSE_TIMEOUT) -> str:
         """Wait for and reassemble a full response from the controller.
 
         Handles single and multi-block (LeadMessage/BlockMessage) responses.
 
+        Args:
+            response_timeout: Timeout in seconds to wait for the initial response.
+
         Returns:
             Response payload as a string.
 
@@ -359,13 +377,21 @@ class OmniLogicProtocol(asyncio.DatagramProtocol):
             OmniFragmentationException: If fragment reassembly fails.
         """
         # wait for the initial packet.
-        message = await self.data_queue.get()
+        try:
+            message = await asyncio.wait_for(self.data_queue.get(), response_timeout)
+        except TimeoutError as exc:
+            msg = f"Timeout waiting for response from controller: {exc}"
+            raise OmniTimeoutError(msg) from exc
 
         # If messages have to be re-transmitted, we can sometimes receive multiple ACKs.  The first one would be handled by
         # self._ensure_sent, but if any subsequent ACKs are sent to us, we need to dump them and wait for a "real" message.
         while message.type in [MessageType.ACK, MessageType.XML_ACK]:
             _LOGGER.debug("Skipping duplicate ACK message")
-            message = await self.data_queue.get()
+            try:
+                message = await asyncio.wait_for(self.data_queue.get(), response_timeout)
+            except TimeoutError as exc:
+                msg = f"Timeout waiting for response from controller: {exc}"
+                raise OmniTimeoutError(msg) from exc
 
         await self._send_ack(message.id)
 
@@ -403,7 +429,7 @@ class OmniLogicProtocol(asyncio.DatagramProtocol):
 
                 # We need to wait long enough for the Omni to get through all of it's retries before we bail out.
                 try:
-                    resp = await asyncio.wait_for(self.data_queue.get(), self._omni_retransmit_time * self._omni_retransmit_count)
+                    resp = await asyncio.wait_for(self.data_queue.get(), response_timeout)
                 except TimeoutError as exc:
                     msg = f"Timeout receiving fragment: got {len(data_fragments)}/{leadmsg.msg_block_count} fragments: {exc}"
                     raise OmniFragmentationError(msg) from exc

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/models/filter_diagnostics.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, ValidationError
 from xmltodict import parse as xml_parse
 
+from pyomnilogic_local.models.exceptions import OmniParsingError
+
 # Example Filter Diagnostics XML:
 #
 # <?xml version="1.0" encoding="UTF-8" ?>
@@ -46,6 +48,7 @@ class FilterDiagnosticsParameters(BaseModel):
 
 class FilterDiagnostics(BaseModel):
     model_config = ConfigDict(from_attributes=True)
+    _raw: str = PrivateAttr(default="")
 
     name: str = Field(alias="Name")
     parameters: list[FilterDiagnosticsParameter] = Field(alias="Parameters")
@@ -64,4 +67,11 @@ class FilterDiagnostics(BaseModel):
         # The XML nests the Parameter entries under a Parameters entry, this is annoying to work with.  Here we are adjusting the data to
         # remove that extra level in the data
         data["Response"]["Parameters"] = data["Response"]["Parameters"]["Parameter"]
-        return FilterDiagnostics.model_validate(data["Response"])
+        try:
+            instance = FilterDiagnostics.model_validate(data["Response"])
+            instance._raw = xml
+        except ValidationError as exc:
+            msg = f"Failed to parse Filter Diagnostics: {exc}"
+            raise OmniParsingError(msg) from exc
+        else:
+            return instance

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/models/leadmessage.py

@@ -40,4 +40,4 @@ class LeadMessage(BaseModel):
                 if name := param.get("name"):
                     result[name] = int(param.text) if param.text else 0
             return result
-        return data
+        return data  # type: ignore[no-any-return]

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/models/mspconfig.py

@@ -9,6 +9,7 @@ from pydantic import (
     BaseModel,
     ConfigDict,
     Field,
+    PrivateAttr,
     ValidationError,
     computed_field,
     model_validator,
@@ -410,6 +411,7 @@ type MSPConfigType = MSPSystem | MSPEquipmentType
 
 class MSPConfig(BaseModel):
     model_config = ConfigDict(from_attributes=True)
+    _raw: str = PrivateAttr(default="")
 
     system: MSPSystem = Field(alias="System")
     backyard: MSPBackyard = Field(alias="Backyard")
@@ -459,7 +461,10 @@ class MSPConfig(BaseModel):
             ),
         )
         try:
-            return MSPConfig.model_validate(data["MSPConfig"], from_attributes=True)
+            instance = MSPConfig.model_validate(data["MSPConfig"], from_attributes=True)
+            instance._raw = xml
         except ValidationError as exc:
             msg = f"Failed to parse MSP Configuration: {exc}"
             raise OmniParsingError(msg) from exc
+        else:
+            return instance

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyomnilogic_local/models/telemetry.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from typing import Any, SupportsInt, cast, overload
 
-from pydantic import BaseModel, ConfigDict, Field, ValidationError, computed_field
+from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, ValidationError, computed_field
 from xmltodict import parse as xml_parse
 
 from pyomnilogic_local.omnitypes import (
@@ -492,6 +492,7 @@ class Telemetry(BaseModel):
     """
 
     model_config = ConfigDict(from_attributes=True)
+    _raw: str = PrivateAttr(default="")
 
     version: str = Field(alias="@version")
     backyard: TelemetryBackyard = Field(alias="Backyard")
@@ -525,7 +526,7 @@ class Telemetry(BaseModel):
 
             try:
                 newvalue = int(value)
-            except (ValueError, TypeError):
+            except ValueError, TypeError:
                 newvalue = value
 
             return key, newvalue
@@ -552,10 +553,13 @@ class Telemetry(BaseModel):
             ),
         )
         try:
-            return Telemetry.model_validate(data["STATUS"])
+            instance = Telemetry.model_validate(data["STATUS"])
+            instance._raw = xml
         except ValidationError as exc:
             msg = f"Failed to parse Telemetry: {exc}"
             raise OmniParsingError(msg) from exc
+        else:
+            return instance
 
     def get_telem_by_systemid(self, system_id: int) -> TelemetryType | None:
         for field_name, value in self:

{python_omnilogic_local-0.26.0 → python_omnilogic_local-0.27.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-omnilogic-local"
-version = "0.26.0"
+version = "0.27.1"
 description = "A library for local control of Hayward OmniHub/OmniLogic pool controllers using their local API"
 readme = "README.md"
 requires-python = ">=3.14.2"
@@ -43,14 +43,9 @@ dev = [
 
 [tool.mypy]
 python_version = "3.14"
-plugins = [
-    "pydantic.mypy"
-]
-# follow_imports = "silent"
+plugins = ["pydantic.mypy"]
+follow_imports = "normal"
 strict = true
-ignore_missing_imports = true
-disallow_subclassing_any = false
-warn_return_any = false
 
 [tool.ruff]
 line-length = 140