pypck 0.9.8__tar.gz → 0.9.9__tar.gz

{pypck-0.9.8/pypck.egg-info → pypck-0.9.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypck
-Version: 0.9.8
+Version: 0.9.9
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>

pypck-0.9.9/VERSION

@@ -0,0 +1 @@
+0.9.9

{pypck-0.9.8 → pypck-0.9.9}/pypck/device.py

@@ -827,15 +827,13 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusOutput,
             request_pck=PckGenerator.request_output_status(output_id=output_port.value),
             max_age=max_age,
             output_id=output_port.value,
         )
 
-        return cast(inputs.ModStatusOutput | None, result)
-
     async def request_status_relays(
         self, max_age: int = 0
     ) -> inputs.ModStatusRelays | None:
@@ -844,14 +842,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusRelays,
             request_pck=PckGenerator.request_relays_status(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusRelays | None, result)
-
     async def request_status_motor_position(
         self,
         motor: lcn_defs.MotorPort,
@@ -877,15 +873,13 @@ class DeviceConnection:
             _LOGGER.debug("Only BS4 mode is supported for motor position requests.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusMotorPositionBS4,
             request_pck=PckGenerator.request_motor_position_status(motor.value // 2),
             max_age=max_age,
             motor=motor.value,
         )
 
-        return cast(inputs.ModStatusMotorPositionBS4 | None, result)
-
     async def request_status_binary_sensors(
         self, max_age: int = 0
     ) -> inputs.ModStatusBinSensors | None:
@@ -894,14 +888,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusBinSensors,
             request_pck=PckGenerator.request_bin_sensors_status(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusBinSensors | None, result)
-
     async def request_status_variable(
         self,
         variable: lcn_defs.Var,
@@ -933,8 +925,6 @@ class DeviceConnection:
             var=response_variable,
         )
 
-        result = cast(inputs.ModStatusVar | None, result)
-
         # for old modules (typeless response) we need to set the original variable
         # - call input_callbacks with the original variable type
         if result is not None and has_typeless_response:
@@ -954,14 +944,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusLedsAndLogicOps,
             request_pck=PckGenerator.request_leds_and_logic_ops(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusLedsAndLogicOps | None, result)
-
     async def request_status_locked_keys(
         self, max_age: int = 0
     ) -> inputs.ModStatusKeyLocks | None:
@@ -970,14 +958,12 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        result = await self.status_requester.request(
+        return await self.status_requester.request(
             response_type=inputs.ModStatusKeyLocks,
             request_pck=PckGenerator.request_key_lock_status(),
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusKeyLocks | None, result)
-
     # Request module properties
 
     async def request_serials(self, max_age: int = 0) -> Serials:
@@ -986,23 +972,20 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return Serials(-1, -1, -1, lcn_defs.HardwareType.UNKNOWN)
 
-        result = cast(
-            inputs.ModSn | None,
-            await self.status_requester.request(
-                response_type=inputs.ModSn,
-                request_pck=PckGenerator.request_serial(),
-                max_age=max_age,
-            ),
+        result = await self.status_requester.request(
+            response_type=inputs.ModSn,
+            request_pck=PckGenerator.request_serial(),
+            max_age=max_age,
         )
 
-        if result is None:
-            return Serials(-1, -1, -1, lcn_defs.HardwareType.UNKNOWN)
-        return Serials(
-            result.hardware_serial,
-            result.manu,
-            result.software_serial,
-            result.hardware_type,
-        )
+        if isinstance(result, inputs.ModSn):
+            return Serials(
+                result.hardware_serial,
+                result.manu,
+                result.software_serial,
+                result.hardware_type,
+            )
+        return Serials(-1, -1, -1, lcn_defs.HardwareType.UNKNOWN)
 
     async def request_name(self, max_age: int = 0) -> str | None:
         """Request module name."""
@@ -1010,7 +993,7 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        coros = [
+        coros = (
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
                 request_pck=PckGenerator.request_name(block_id),
@@ -1018,8 +1001,8 @@ class DeviceConnection:
                 command="N",
                 block_id=block_id,
             )
-            for block_id in [0, 1]
-        ]
+            for block_id in (0, 1)
+        )
 
         coro_results = [await coro for coro in coros]
         if not all(coro_results):
@@ -1034,7 +1017,7 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        coros = [
+        coros = (
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
                 request_pck=PckGenerator.request_comment(block_id),
@@ -1042,15 +1025,15 @@ class DeviceConnection:
                 command="K",
                 block_id=block_id,
             )
-            for block_id in [0, 1, 2]
-        ]
+            for block_id in (0, 1, 2)
+        )
 
         coro_results = [await coro for coro in coros]
         if not all(coro_results):
             return None
         results = cast(list[inputs.ModNameComment], coro_results)
-        name = "".join([result.text for result in results if result])
-        return name
+        comment = "".join([result.text for result in results if result])
+        return comment
 
     async def request_oem_text(self, max_age: int = 0) -> str | None:
         """Request module name."""
@@ -1058,7 +1041,7 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        coros = [
+        coros = (
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
                 request_pck=PckGenerator.request_oem_text(block_id),
@@ -1066,15 +1049,15 @@ class DeviceConnection:
                 command="O",
                 block_id=block_id,
             )
-            for block_id in [0, 1, 2, 3]
-        ]
+            for block_id in (0, 1, 2, 3)
+        )
 
         coro_results = [await coro for coro in coros]
         if not all(coro_results):
             return None
         results = cast(list[inputs.ModNameComment], coro_results)
-        name = "".join([result.text for result in results if result])
-        return name
+        oem_text = "".join([result.text for result in results if result])
+        return oem_text
 
     async def request_group_memberships(
         self, dynamic: bool = False, max_age: int = 0
@@ -1095,5 +1078,5 @@ class DeviceConnection:
             dynamic=dynamic,
         )
         if result is not None:
-            return set(cast(inputs.ModStatusGroups, result).groups)
+            return set(result.groups)
         return None

{pypck-0.9.8 → pypck-0.9.9}/pypck/inputs.py

@@ -26,6 +26,7 @@ class Input:
 
     def __init__(self) -> None:
         """Construct Input object."""
+        self.pck = ""
 
     @staticmethod
     def try_parse(data: str) -> list[Input] | None:
@@ -1368,9 +1369,11 @@ class InputParser:
         :rtype:     List with instances of :class:`~pypck.input.Input`
         """
         for parser in InputParser.parsers:
-            ret: list[Input] | None = parser.try_parse(data)
-            if ret is not None:
-                return ret
+            returns: list[Input] | None = parser.try_parse(data)
+            if returns is not None:
+                for ret in returns:
+                    ret.pck = data
+                return returns
 
         # We must never get to this point since the Unknown parser matches
         # everything.

{pypck-0.9.8 → pypck-0.9.9}/pypck/pck_commands.py

@@ -880,20 +880,20 @@ class PckGenerator:
         if software_serial >= 0x170206:
             var_id = lcn_defs.Var.to_var_id(var)
             if var_id != -1:
-                return f"MWT{var_id + 1:03d}"
+                return f"MWT{var_id + 1}"
 
             set_point_id = lcn_defs.Var.to_set_point_id(var)
             if set_point_id != -1:
-                return f"MWS{set_point_id + 1:03d}"
+                return f"MWS{set_point_id + 1}"
 
             thrs_register_id = lcn_defs.Var.to_thrs_register_id(var)
             if thrs_register_id != -1:
                 # Whole register
-                return f"SE{thrs_register_id + 1:03d}"
+                return f"SE{thrs_register_id + 1}"
 
             s0_id = lcn_defs.Var.to_s0_id(var)
             if s0_id != -1:
-                return f"MWC{s0_id + 1:03d}"
+                return f"MWC{s0_id + 1}"
         else:
             if var == lcn_defs.Var.VAR1ORTVAR:
                 pck = "MWV"

pypck-0.9.9/pypck/status_requester.py

@@ -0,0 +1,155 @@
+"""Status requester."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
+
+from pypck import inputs
+
+if TYPE_CHECKING:
+    from pypck.device import DeviceConnection
+
+_LOGGER = logging.getLogger(__name__)
+
+ResponseT = TypeVar("ResponseT", bound=inputs.Input)
+
+
+@dataclass(unsafe_hash=True)
+class StatusRequest(Generic[ResponseT]):
+    """Data class for status requests."""
+
+    type: type[ResponseT]  # Type of the input expected as response
+    parameters: frozenset[tuple[str, Any]]  # {(parameter_name, parameter_value)}
+    timestamp: float = field(
+        compare=False
+    )  # timestamp the response was received; -1=no timestamp
+    response: asyncio.Future[ResponseT] = field(
+        compare=False
+    )  # the response input object
+
+
+class StatusRequester:
+    """Handling of status requests."""
+
+    current_request: StatusRequest[inputs.Input] | None
+
+    def __init__(
+        self,
+        device_connection: DeviceConnection,
+    ) -> None:
+        """Initialize the context."""
+        self.device_connection = device_connection
+        self.current_request = None
+        self.request_cache: set[StatusRequest[inputs.Input]] = set()
+        self.max_response_age = self.device_connection.conn.settings["MAX_RESPONSE_AGE"]
+        self.request_lock = asyncio.Lock()
+
+        self.unregister_inputs = self.device_connection.register_for_inputs(
+            self.input_callback
+        )
+
+    def get_status_requests(
+        self,
+        request_type: type[ResponseT],
+        parameters: frozenset[tuple[str, Any]] | None = None,
+        max_age: int = 0,
+    ) -> list[StatusRequest[ResponseT]]:
+        """Get the status requests for the given type and parameters."""
+        if parameters is None:
+            parameters = frozenset()
+        results = [
+            request
+            for request in self.request_cache
+            if request.type == request_type
+            and parameters.issubset(request.parameters)
+            and (
+                (request.timestamp == -1)
+                or (max_age == -1)
+                or (asyncio.get_running_loop().time() - request.timestamp < max_age)
+            )
+        ]
+        results.sort(key=lambda request: request.timestamp, reverse=True)
+        return cast(list[StatusRequest[ResponseT]], results)
+
+    def input_callback(self, inp: inputs.Input) -> None:
+        """Handle incoming inputs and set the result for the corresponding requests."""
+        # Update current request (if it exists)
+        if (
+            self.current_request is not None
+            and not self.current_request.response.done()
+        ):
+            if isinstance(inp, self.current_request.type) and all(
+                getattr(inp, parameter_name) == parameter_value
+                for parameter_name, parameter_value in self.current_request.parameters
+            ):
+                self.current_request.timestamp = asyncio.get_running_loop().time()
+                self.current_request.response.set_result(inp)
+
+        # Update cached requests
+        for request in self.get_status_requests(type(inp)):
+            if all(
+                getattr(inp, parameter_name) == parameter_value
+                for parameter_name, parameter_value in request.parameters
+            ):
+                request.timestamp = asyncio.get_running_loop().time()
+                request.response = asyncio.get_running_loop().create_future()
+                request.response.set_result(inp)
+
+    async def request(
+        self,
+        response_type: type[ResponseT],
+        request_pck: str,
+        request_acknowledge: bool = False,
+        max_age: int = 0,  # -1: no age limit / infinite age
+        **request_kwargs: Any,
+    ) -> ResponseT | None:
+        """Execute a status request and wait for the response."""
+        async with self.request_lock:
+            # check for matching request in cache
+            if requests := self.get_status_requests(
+                response_type,
+                frozenset(request_kwargs.items()),
+                max_age,
+            ):
+                _LOGGER.debug(
+                    "from %s: %s (cached)",
+                    self.device_connection.conn.connection_id,
+                    requests[0].response.result().pck,
+                )
+                return requests[0].response.result()
+
+            # no matching request in cache
+            self.current_request = StatusRequest(
+                response_type,
+                frozenset(request_kwargs.items()),
+                -1,
+                asyncio.get_running_loop().create_future(),
+            )
+
+            result = None
+            # send the request up to NUM_TRIES and wait for response future completion
+            for _ in range(self.device_connection.conn.settings["NUM_TRIES"]):
+                await self.device_connection.send_command(
+                    request_acknowledge, request_pck
+                )
+
+                try:
+                    async with asyncio.timeout(
+                        self.device_connection.conn.settings["DEFAULT_TIMEOUT"]
+                    ):
+                        # Need to shield the future. Otherwise it would get cancelled.
+                        result = await asyncio.shield(self.current_request.response)
+                        break
+                except asyncio.TimeoutError:
+                    continue
+                except asyncio.CancelledError:
+                    break
+
+            if result is not None:  # add request to cache
+                self.request_cache.discard(self.current_request)
+                self.request_cache.add(self.current_request)
+
+            return cast(ResponseT | None, result)

{pypck-0.9.8 → pypck-0.9.9/pypck.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypck
-Version: 0.9.8
+Version: 0.9.9
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>

{pypck-0.9.8 → pypck-0.9.9}/tests/test_commands.py

@@ -89,7 +89,7 @@ COMMANDS: dict[str | bytes, Any] = {
     "STX": (PckGenerator.request_key_lock_status,),
     # Variable status (new commands)
     **{
-        f"MWT{Var.to_var_id(var) + 1:03d}": (
+        f"MWT{Var.to_var_id(var) + 1}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,
@@ -97,7 +97,7 @@ COMMANDS: dict[str | bytes, Any] = {
         for var in Var.variables()
     },
     **{
-        f"MWS{Var.to_set_point_id(var) + 1:03d}": (
+        f"MWS{Var.to_set_point_id(var) + 1}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,
@@ -105,7 +105,7 @@ COMMANDS: dict[str | bytes, Any] = {
         for var in Var.set_points()
     },
     **{
-        f"MWC{Var.to_s0_id(var) + 1:03d}": (
+        f"MWC{Var.to_s0_id(var) + 1}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,
@@ -113,7 +113,7 @@ COMMANDS: dict[str | bytes, Any] = {
         for var in Var.s0s()
     },
     **{
-        f"SE{Var.to_thrs_register_id(var) + 1:03d}": (
+        f"SE{Var.to_thrs_register_id(var) + 1}": (
             PckGenerator.request_var_status,
             var,
             NEW_VAR_SW_AGE,

{pypck-0.9.8 → pypck-0.9.9}/tests/test_messages.py

@@ -361,4 +361,4 @@ def test_message_parsing_mod_inputs(
     for idx, inp in enumerate(inputs):
         exp = (expected[idx][0])(LcnAddr(0, 10, False), *expected[idx][1:])
         assert type(inp) is type(exp)  # pylint: disable=unidiomatic-typecheck
-        assert vars(inp) == vars(exp)
+        assert vars(inp) == vars(exp) | {"pck": message}

{pypck-0.9.8 → pypck-0.9.9}/tests/test_status_requester.py

@@ -1,6 +1,7 @@
 """Test the status requester of a module connection."""
 
 import asyncio
+from unittest.mock import call
 
 from pypck.pck_commands import PckGenerator
 from pypck.status_requester import StatusRequest
@@ -38,32 +39,32 @@ async def test_request_status(module10: MockDeviceConnection) -> None:
     assert result.states == RELAY_STATES
 
 
-# async def test_request_status_stored(module10: MockDeviceConnection) -> None:
-#     """Test requesting the status of a module with stored status request."""
-#     status_request = StatusRequest(
-#         type=inputs.ModStatusRelays,
-#         parameters=frozenset(),
-#         timestamp=asyncio.get_running_loop().time(),
-#         response=asyncio.get_running_loop().create_future(),
-#     )
-#     status_request.response.set_result(
-#         inputs.ModStatusRelays(module10.addr, RELAY_STATES)
-#     )
-#     module10.status_requester.last_requests.add(status_request)
-
-#     result = await module10.status_requester.request(
-#         response_type=inputs.ModStatusRelays,
-#         request_pck=PckGenerator.request_relays_status(),
-#         max_age=10,
-#     )
-
-#     assert isinstance(result, inputs.ModStatusRelays)
-#     assert result.physical_source_addr == module10.addr
-#     assert result.states == RELAY_STATES
-#     assert (
-#         call(False, PckGenerator.request_relays_status())
-#         not in module10.send_command.await_args_list
-#     )
+async def test_request_status_stored(module10: MockDeviceConnection) -> None:
+    """Test requesting the status of a module with stored status request."""
+    status_request = StatusRequest(
+        type=inputs.ModStatusRelays,
+        parameters=frozenset(),
+        timestamp=asyncio.get_running_loop().time(),
+        response=asyncio.get_running_loop().create_future(),
+    )
+    status_request.response.set_result(
+        inputs.ModStatusRelays(module10.addr, RELAY_STATES)
+    )
+    module10.status_requester.request_cache.add(status_request)
+
+    result = await module10.status_requester.request(
+        response_type=inputs.ModStatusRelays,
+        request_pck=PckGenerator.request_relays_status(),
+        max_age=10,
+    )
+
+    assert isinstance(result, inputs.ModStatusRelays)
+    assert result.physical_source_addr == module10.addr
+    assert result.states == RELAY_STATES
+    assert (
+        call(False, PckGenerator.request_relays_status())
+        not in module10.send_command.await_args_list
+    )
 
 
 async def test_request_status_expired(module10: MockDeviceConnection) -> None:
@@ -76,7 +77,7 @@ async def test_request_status_expired(module10: MockDeviceConnection) -> None:
         response=asyncio.get_running_loop().create_future(),
     )
     status_request.response.set_result(inputs.ModStatusRelays(module10.addr, states))
-    module10.status_requester.last_requests.add(status_request)
+    module10.status_requester.request_cache.add(status_request)
 
     request_task = asyncio.create_task(
         module10.status_requester.request(

pypck-0.9.8/VERSION

@@ -1 +0,0 @@
-0.9.8

pypck-0.9.8/pypck/status_requester.py

@@ -1,107 +0,0 @@
-"""Status requester."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-from pypck import inputs
-
-if TYPE_CHECKING:
-    from pypck.device import DeviceConnection
-
-_LOGGER = logging.getLogger(__name__)
-
-
-@dataclass(unsafe_hash=True)
-class StatusRequest:
-    """Data class for status requests."""
-
-    type: type[inputs.Input]  # Type of the input expected as response
-    parameters: frozenset[tuple[str, Any]]  # {(parameter_name, parameter_value)}
-    timestamp: float = field(
-        compare=False
-    )  # timestamp the response was received; -1=no timestamp
-    response: asyncio.Future[inputs.Input] = field(
-        compare=False
-    )  # Future to hold the response input object
-
-
-class StatusRequester:
-    """Handling of status requests."""
-
-    current_request: StatusRequest
-
-    def __init__(
-        self,
-        device_connection: DeviceConnection,
-    ) -> None:
-        """Initialize the context."""
-        self.device_connection = device_connection
-        self.last_requests: set[StatusRequest] = set()
-        self.max_response_age = self.device_connection.conn.settings["MAX_RESPONSE_AGE"]
-        self.request_lock = asyncio.Lock()
-
-    def input_callback(self, inp: inputs.Input) -> None:
-        """Handle incoming inputs and set the result for the corresponding requests."""
-        if (
-            self.current_request.response.done()
-            or self.current_request.response.cancelled()
-        ):
-            return
-
-        if isinstance(inp, self.current_request.type) and all(
-            getattr(inp, parameter_name) == parameter_value
-            for parameter_name, parameter_value in self.current_request.parameters
-        ):
-            self.current_request.timestamp = asyncio.get_running_loop().time()
-            self.current_request.response.set_result(inp)
-
-    async def request(
-        self,
-        response_type: type[inputs.Input],
-        request_pck: str,
-        request_acknowledge: bool = False,
-        max_age: int = 0,  # -1: no age limit / infinite age
-        **request_kwargs: Any,
-    ) -> inputs.Input | None:
-        """Execute a status request and wait for the response."""
-        async with self.request_lock:
-            self.current_request = StatusRequest(
-                response_type,
-                frozenset(request_kwargs.items()),
-                -1,
-                asyncio.get_running_loop().create_future(),
-            )
-
-            unregister_inputs = self.device_connection.register_for_inputs(
-                self.input_callback
-            )
-
-            result = None
-            # send the request up to NUM_TRIES and wait for response future completion
-            for _ in range(self.device_connection.conn.settings["NUM_TRIES"]):
-                await self.device_connection.send_command(
-                    request_acknowledge, request_pck
-                )
-
-                try:
-                    async with asyncio.timeout(
-                        self.device_connection.conn.settings["DEFAULT_TIMEOUT"]
-                    ):
-                        # Need to shield the future. Otherwise it would get cancelled.
-                        result = await asyncio.shield(self.current_request.response)
-                        break
-                except asyncio.TimeoutError:
-                    continue
-                except asyncio.CancelledError:
-                    break
-
-            # if we got no results, remove the request from the set
-            if result is None:
-                self.current_request.response.cancel()
-
-            unregister_inputs()
-            return result