pypck 0.9.8__py3-none-any.whl → 0.9.9__py3-none-any.whl

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/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/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/status_requester.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, cast
 
 from pypck import inputs
 
@@ -14,25 +14,27 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+ResponseT = TypeVar("ResponseT", bound=inputs.Input)
+
 
 @dataclass(unsafe_hash=True)
-class StatusRequest:
+class StatusRequest(Generic[ResponseT]):
     """Data class for status requests."""
 
-    type: type[inputs.Input]  # Type of the input expected as response
+    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[inputs.Input] = field(
+    response: asyncio.Future[ResponseT] = field(
         compare=False
-    )  # Future to hold the response input object
+    )  # the response input object
 
 
 class StatusRequester:
     """Handling of status requests."""
 
-    current_request: StatusRequest
+    current_request: StatusRequest[inputs.Input] | None
 
     def __init__(
         self,
@@ -40,35 +42,86 @@ class StatusRequester:
     ) -> None:
         """Initialize the context."""
         self.device_connection = device_connection
-        self.last_requests: set[StatusRequest] = set()
+        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.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 is not None
+            and not self.current_request.response.done()
         ):
-            self.current_request.timestamp = asyncio.get_running_loop().time()
-            self.current_request.response.set_result(inp)
+            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[inputs.Input],
+        response_type: type[ResponseT],
         request_pck: str,
         request_acknowledge: bool = False,
         max_age: int = 0,  # -1: no age limit / infinite age
         **request_kwargs: Any,
-    ) -> inputs.Input | None:
+    ) -> 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()),
@@ -76,10 +129,6 @@ class StatusRequester:
                 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"]):
@@ -99,9 +148,8 @@ class StatusRequester:
                 except asyncio.CancelledError:
                     break
 
-            # if we got no results, remove the request from the set
-            if result is None:
-                self.current_request.response.cancel()
+            if result is not None:  # add request to cache
+                self.request_cache.discard(self.current_request)
+                self.request_cache.add(self.current_request)
 
-            unregister_inputs()
-            return result
+            return cast(ResponseT | None, result)

{pypck-0.9.8.dist-info → pypck-0.9.9.dist-info}/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,15 @@
+pypck/__init__.py,sha256=jVx-aBsV_LmBf6jiivMrMcBUofC_AOseywDafgOzAS4,323
+pypck/connection.py,sha256=n3itRe8oQtw64vyWGYhl6j4QJC6wgeeHitBSn-Cl2_4,23330
+pypck/device.py,sha256=1R9C4Wra8llzJph4eher-KPF2iF7uGOspq3eWcqTLyM,39591
+pypck/helpers.py,sha256=_5doqIsSRpqdQNPIUsjFh813xKGuMuEFY6sNGobJGIk,1280
+pypck/inputs.py,sha256=dw9ebhP9RBM9d-lPSFqRrFH1TOETNsT4RNschNjAnA8,46056
+pypck/lcn_addr.py,sha256=N2Od8KuANOglqKjf596hJVH1SRcG7MhESKA5YYlDnbw,1946
+pypck/lcn_defs.py,sha256=wSceYBwM46NqPwvff1hi8RluqUECmNY1gNcm1kDKTaI,43356
+pypck/pck_commands.py,sha256=SL9zpsswRGCHjAWm4uKWFTqtSBx2jURFHzq86QrtwuU,50442
+pypck/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypck/status_requester.py,sha256=Ea9c9moA1Kxoh3U9tPVqHKAmnRwq-1vraP_cwqxGZt8,5774
+pypck-0.9.9.dist-info/licenses/LICENSE,sha256=iYB6zyMJvShfAzQE7nhYFgLzzZuBmhasLw5fYP9KRz4,1023
+pypck-0.9.9.dist-info/METADATA,sha256=HER_BuajbZll66fngbD2rQVTR6bcice7kOMW8bOLggk,2682
+pypck-0.9.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pypck-0.9.9.dist-info/top_level.txt,sha256=59ried49iFueDa5mQ_5BGVZcESjjzi4MZZKLcganvQA,6
+pypck-0.9.9.dist-info/RECORD,,

pypck-0.9.8.dist-info/RECORD

@@ -1,15 +0,0 @@
-pypck/__init__.py,sha256=jVx-aBsV_LmBf6jiivMrMcBUofC_AOseywDafgOzAS4,323
-pypck/connection.py,sha256=n3itRe8oQtw64vyWGYhl6j4QJC6wgeeHitBSn-Cl2_4,23330
-pypck/device.py,sha256=m-JUdea-yzsGMqGZEKvTQkxUpjlaUwR3KKMCFi35RYs,40103
-pypck/helpers.py,sha256=_5doqIsSRpqdQNPIUsjFh813xKGuMuEFY6sNGobJGIk,1280
-pypck/inputs.py,sha256=F7E8rprIhYzZnHARozt_hguYNgJaiNP3htrZ2E3Qa5I,45951
-pypck/lcn_addr.py,sha256=N2Od8KuANOglqKjf596hJVH1SRcG7MhESKA5YYlDnbw,1946
-pypck/lcn_defs.py,sha256=wSceYBwM46NqPwvff1hi8RluqUECmNY1gNcm1kDKTaI,43356
-pypck/pck_commands.py,sha256=eJxmh2e8EbKGpek97L2961Kr_nVfT8rKgJCN3YgjIQM,50458
-pypck/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypck/status_requester.py,sha256=70RETS9tetq7eMRainQ1xws7ziK5rWnhkc3BtUUcqEw,3693
-pypck-0.9.8.dist-info/licenses/LICENSE,sha256=iYB6zyMJvShfAzQE7nhYFgLzzZuBmhasLw5fYP9KRz4,1023
-pypck-0.9.8.dist-info/METADATA,sha256=S3pUkmBRAvz0Qbw9-brGEvV96g9JgRJFmXqJaSqNwM0,2682
-pypck-0.9.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pypck-0.9.8.dist-info/top_level.txt,sha256=59ried49iFueDa5mQ_5BGVZcESjjzi4MZZKLcganvQA,6
-pypck-0.9.8.dist-info/RECORD,,