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

pypck/device.py

@@ -50,8 +50,6 @@ class DeviceConnection:
         self._serials_known = asyncio.Event()
 
         self.input_callbacks: set[Callable[[inputs.Input], None]] = set()
-        self.last_requested_var_without_type_in_response = lcn_defs.Var.UNKNOWN
-        self.last_var_lock = asyncio.Lock()
 
         # List of queued acknowledge codes from the LCN modules.
         self.acknowledges: asyncio.Queue[lcn_defs.AcknowledgeErrorCode] = (
@@ -60,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
@@ -773,29 +772,9 @@ class DeviceConnection:
             await self.on_ack(inp.code)
             return None
 
-        # handle typeless variable responses
-        if isinstance(inp, inputs.ModStatusVar):
-            inp = self.preprocess_modstatusvar(inp)
-
         for input_callback in self.input_callbacks:
             input_callback(inp)
 
-    def preprocess_modstatusvar(self, inp: inputs.ModStatusVar) -> inputs.Input:
-        """Fill typeless response with last requested variable type."""
-        if inp.orig_var == lcn_defs.Var.UNKNOWN:
-            # Response without type (%Msssaaa.wwwww)
-            inp.var = self.last_requested_var_without_type_in_response
-
-            self.last_requested_var_without_type_in_response = lcn_defs.Var.UNKNOWN
-
-            if self.last_var_lock.locked():
-                self.last_var_lock.release()
-        else:
-            # Response with variable type (%Msssaaa.Avvvwww)
-            inp.var = inp.orig_var
-
-        return inp
-
     async def dump_details(self) -> dict[str, Any]:
         """Dump detailed information about this module."""
         is_local_segment = self.addr.seg_id in (0, self.conn.local_seg_id)
@@ -816,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()
+                    )
                 ),
             },
         }
@@ -851,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
@@ -867,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,
@@ -901,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
@@ -917,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,
@@ -929,17 +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:
-            if not lcn_defs.Var.has_type_in_response(
-                variable, self.serials.software_serial
-            ):
-                try:
-                    await asyncio.wait_for(self.last_var_lock.acquire(), timeout=3.0)
-                except asyncio.TimeoutError:
-                    pass
-                self.last_requested_var_without_type_in_response = variable
+        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
+            response_variable = lcn_defs.Var.UNKNOWN
 
         result = await self.status_requester.request(
             response_type=inputs.ModStatusVar,
@@ -947,10 +930,21 @@ class DeviceConnection:
                 variable, self.serials.software_serial
             ),
             max_age=max_age,
-            var=variable,
+            var=response_variable,
         )
 
-        return cast(inputs.ModStatusVar, result)
+        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(
         self, max_age: int = 0
@@ -966,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
@@ -982,7 +976,7 @@ class DeviceConnection:
             max_age=max_age,
         )
 
-        return cast(inputs.ModStatusKeyLocks, result)
+        return cast(inputs.ModStatusKeyLocks | None, result)
 
     # Request module properties
 
@@ -1084,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.")
@@ -1100,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/status_requester.py

@@ -32,6 +32,8 @@ class StatusRequest:
 class StatusRequester:
     """Handling of status requests."""
 
+    current_request: StatusRequest
+
     def __init__(
         self,
         device_connection: DeviceConnection,
@@ -39,69 +41,23 @@ class StatusRequester:
         """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
+        self.request_lock = asyncio.Lock()
 
     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)
+        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,
@@ -112,49 +68,40 @@ class StatusRequester:
         **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)
+        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
-            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
+
+            # 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.7.dist-info → pypck-0.9.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypck
-Version: 0.9.7
+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.7.dist-info → pypck-0.9.8.dist-info}/RECORD

@@ -1,15 +1,15 @@
 pypck/__init__.py,sha256=jVx-aBsV_LmBf6jiivMrMcBUofC_AOseywDafgOzAS4,323
 pypck/connection.py,sha256=n3itRe8oQtw64vyWGYhl6j4QJC6wgeeHitBSn-Cl2_4,23330
-pypck/device.py,sha256=Ek-Zy4Id63vl43oW1pSafbDqRAfidhgoJI0F4EMWCXY,40375
+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=10N5pbIBe_Ao-9ui_D7mCavk21BYZs9c-kxcTtmi-FI,5721
-pypck-0.9.7.dist-info/licenses/LICENSE,sha256=iYB6zyMJvShfAzQE7nhYFgLzzZuBmhasLw5fYP9KRz4,1023
-pypck-0.9.7.dist-info/METADATA,sha256=gooJ1CbK2mtAKuIEs8v3OKV_sDMHziMbmKHGPcEvsmE,2682
-pypck-0.9.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pypck-0.9.7.dist-info/top_level.txt,sha256=59ried49iFueDa5mQ_5BGVZcESjjzi4MZZKLcganvQA,6
-pypck-0.9.7.dist-info/RECORD,,
+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,,