pypck 0.9.6__tar.gz → 0.9.8__tar.gz

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

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

pypck-0.9.8/VERSION

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

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

@@ -58,6 +58,7 @@ class DeviceConnection:
 
         # StatusRequester
         self.status_requester = StatusRequester(self)
+        self.request_lock = asyncio.Lock()
 
         if self.addr.is_group:
             self.wants_ack = False  # groups do not send acks
@@ -794,11 +795,15 @@ class DeviceConnection:
             "groups": {
                 "static": sorted(
                     addr.addr_id
-                    for addr in await self.request_group_memberships(dynamic=False)
+                    for addr in (
+                        await self.request_group_memberships(dynamic=False) or set()
+                    )
                 ),
                 "dynamic": sorted(
                     addr.addr_id
-                    for addr in await self.request_group_memberships(dynamic=True)
+                    for addr in (
+                        await self.request_group_memberships(dynamic=True) or set()
+                    )
                 ),
             },
         }
@@ -829,7 +834,7 @@ class DeviceConnection:
             output_id=output_port.value,
         )
 
-        return cast(inputs.ModStatusOutput, result)
+        return cast(inputs.ModStatusOutput | None, result)
 
     async def request_status_relays(
         self, max_age: int = 0
@@ -845,7 +850,7 @@ class DeviceConnection:
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusRelays, result)
+        return cast(inputs.ModStatusRelays | None, result)
 
     async def request_status_motor_position(
         self,
@@ -879,7 +884,7 @@ class DeviceConnection:
             motor=motor.value,
         )
 
-        return cast(inputs.ModStatusMotorPositionBS4, result)
+        return cast(inputs.ModStatusMotorPositionBS4 | None, result)
 
     async def request_status_binary_sensors(
         self, max_age: int = 0
@@ -895,7 +900,7 @@ class DeviceConnection:
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusBinSensors, result)
+        return cast(inputs.ModStatusBinSensors | None, result)
 
     async def request_status_variable(
         self,
@@ -907,13 +912,17 @@ class DeviceConnection:
             _LOGGER.info("Status requests are not supported for groups.")
             return None
 
-        # do not use buffered response for old modules
-        # (variable response is typeless)
-        if self.serials.software_serial < 0x170206:
+        response_variable = variable
+
+        # for old modules the variable response is typeless
+        # - do not use concurrent requests
+        # - do not use buffered response
+        if has_typeless_response := not lcn_defs.Var.has_type_in_response(
+            variable, self.serials.software_serial
+        ):
+            await self.request_lock.acquire()
             max_age = 0
-            variable_response = lcn_defs.Var.UNKNOWN
-        else:
-            variable_response = variable
+            response_variable = lcn_defs.Var.UNKNOWN
 
         result = await self.status_requester.request(
             response_type=inputs.ModStatusVar,
@@ -921,14 +930,20 @@ class DeviceConnection:
                 variable, self.serials.software_serial
             ),
             max_age=max_age,
-            var=variable_response,
+            var=response_variable,
         )
 
-        result = cast(inputs.ModStatusVar, result)
-        if result:
-            if result.orig_var == lcn_defs.Var.UNKNOWN:
-                # Response without type (%Msssaaa.wwwww)
-                result.var = 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:
+            result.var = variable
+            for input_callback in self.input_callbacks:
+                input_callback(result)
+
+        if self.request_lock.locked():
+            self.request_lock.release()
         return result
 
     async def request_status_led_and_logic_ops(
@@ -945,7 +960,7 @@ class DeviceConnection:
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusLedsAndLogicOps, result)
+        return cast(inputs.ModStatusLedsAndLogicOps | None, result)
 
     async def request_status_locked_keys(
         self, max_age: int = 0
@@ -961,7 +976,7 @@ class DeviceConnection:
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusKeyLocks, result)
+        return cast(inputs.ModStatusKeyLocks | None, result)
 
     # Request module properties
 
@@ -1063,7 +1078,7 @@ class DeviceConnection:
 
     async def request_group_memberships(
         self, dynamic: bool = False, max_age: int = 0
-    ) -> set[LcnAddr]:
+    ) -> set[LcnAddr] | None:
         """Request module static/dynamic group memberships."""
         if self.addr.is_group:
             _LOGGER.info("Status requests are not supported for groups.")
@@ -1079,5 +1094,6 @@ class DeviceConnection:
             max_age=max_age,
             dynamic=dynamic,
         )
-
-        return set(cast(inputs.ModStatusGroups, result).groups)
+        if result is not None:
+            return set(cast(inputs.ModStatusGroups, result).groups)
+        return None

pypck-0.9.8/pypck/status_requester.py

@@ -0,0 +1,107 @@
+"""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

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

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

{pypck-0.9.6 → pypck-0.9.8}/tests/test_module.py

@@ -140,17 +140,17 @@ async def test_request_status_binary_sensors(module10: MockDeviceConnection) ->
 
 
 @pytest.mark.parametrize(
-    "variable, response_variable, software_serial",
+    "variable, software_serial",
     [
         *[
-            (variable, variable, 0x170206)
+            (variable, 0x170206)
             for variable in lcn_defs.Var.variables_new()
             + lcn_defs.Var.set_points()
             + list(chain(*lcn_defs.Var.thresholds_new()))
             + lcn_defs.Var.s0s()
         ],
         *[
-            (variable, lcn_defs.Var.UNKNOWN, 0x170000)
+            (variable, 0x170000)
             for variable in lcn_defs.Var.variables_old()
             + lcn_defs.Var.set_points()
             + list(chain(*lcn_defs.Var.thresholds_old()))
@@ -158,16 +158,18 @@ async def test_request_status_binary_sensors(module10: MockDeviceConnection) ->
     ],
 )
 async def test_request_status_variable(
-    module10: MockDeviceConnection,
-    variable: lcn_defs.Var,
-    response_variable: lcn_defs.Var,
-    software_serial: int,
+    module10: MockDeviceConnection, variable: lcn_defs.Var, software_serial: int
 ) -> None:
     """Test requesting the variable status of a module."""
     module10.serials.software_serial = software_serial
     request_task = asyncio.create_task(module10.request_status_variable(variable))
 
     await wait_until_called(module10.send_command)
+    response_variable = (
+        variable
+        if lcn_defs.Var.has_type_in_response(variable, software_serial)
+        else lcn_defs.Var.UNKNOWN
+    )
     await module10.async_process_input(
         inputs.ModStatusVar(
             module10.addr, response_variable, lcn_defs.VarValue.from_native(50)

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

@@ -1,7 +1,6 @@
 """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
@@ -39,32 +38,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.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_expired(module10: MockDeviceConnection) -> None:

pypck-0.9.6/VERSION

@@ -1 +0,0 @@
-0.9.6

pypck-0.9.6/pypck/status_requester.py

@@ -1,160 +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."""
-
-    def __init__(
-        self,
-        device_connection: DeviceConnection,
-    ) -> None:
-        """Initialize the context."""
-        self.device_connection = device_connection
-        self.last_requests: set[StatusRequest] = set()
-        self.unregister_inputs = self.device_connection.register_for_inputs(
-            self.input_callback
-        )
-        self.max_response_age = self.device_connection.conn.settings["MAX_RESPONSE_AGE"]
-        # asyncio.get_running_loop().create_task(self.prune_loop())
-
-    async def prune_loop(self) -> None:
-        """Periodically prune old status requests."""
-        while True:
-            await asyncio.sleep(self.max_response_age)
-            self.prune_status_requests()
-
-    def prune_status_requests(self) -> None:
-        """Prune old status requests."""
-        entries_to_remove = {
-            request
-            for request in self.last_requests
-            if asyncio.get_running_loop().time() - request.timestamp
-            > self.max_response_age
-        }
-        for entry in entries_to_remove:
-            entry.response.cancel()
-        self.last_requests.difference_update(entries_to_remove)
-
-    def get_status_requests(
-        self,
-        request_type: type[inputs.Input],
-        parameters: frozenset[tuple[str, Any]] | None = None,
-        max_age: int = 0,
-    ) -> list[StatusRequest]:
-        """Get the status requests for the given type and parameters."""
-        if parameters is None:
-            parameters = frozenset()
-        loop = asyncio.get_running_loop()
-        results = [
-            request
-            for request in self.last_requests
-            if request.type == request_type
-            and parameters.issubset(request.parameters)
-            and (
-                (request.timestamp == -1)
-                or (max_age == -1)
-                or (loop.time() - request.timestamp < max_age)
-            )
-        ]
-        results.sort(key=lambda request: request.timestamp, reverse=True)
-        return results
-
-    def input_callback(self, inp: inputs.Input) -> None:
-        """Handle incoming inputs and set the result for the corresponding requests."""
-        requests = [
-            request
-            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
-            )
-        ]
-        for request in requests:
-            if request.response.done() or request.response.cancelled():
-                continue
-            request.timestamp = asyncio.get_running_loop().time()
-            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."""
-        parameters = frozenset(request_kwargs.items())
-
-        # check if we already have a received response for the current request
-        if requests := self.get_status_requests(response_type, parameters, max_age):
-            try:
-                async with asyncio.timeout(
-                    self.device_connection.conn.settings["DEFAULT_TIMEOUT"]
-                ):
-                    return await requests[0].response
-            except asyncio.TimeoutError:
-                return None
-            except asyncio.CancelledError:
-                return None
-
-        # no stored request or forced request: set up a new request
-        request = StatusRequest(
-            response_type,
-            frozenset(request_kwargs.items()),
-            -1,
-            asyncio.get_running_loop().create_future(),
-        )
-
-        self.last_requests.discard(request)
-        self.last_requests.add(request)
-        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(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:
-            request.response.cancel()
-            self.last_requests.discard(request)
-        return result