pypck 0.9.2__py3-none-any.whl → 0.9.4__py3-none-any.whl

pypck/__init__.py

@@ -2,20 +2,22 @@
 
 from pypck import (
     connection,
+    device,
     helpers,
     inputs,
     lcn_addr,
     lcn_defs,
-    module,
     pck_commands,
+    status_requester,
 )
 
 __all__ = [
     "connection",
-    "inputs",
+    "device",
     "helpers",
+    "inputs",
     "lcn_addr",
     "lcn_defs",
-    "module",
     "pck_commands",
+    "status_requester",
 ]

pypck/connection.py

@@ -9,10 +9,10 @@ from types import TracebackType
 from typing import Any
 
 from pypck import inputs, lcn_defs
+from pypck.device import DeviceConnection
 from pypck.helpers import TaskRegistry
 from pypck.lcn_addr import LcnAddr
 from pypck.lcn_defs import LcnEvent
-from pypck.module import GroupConnection, ModuleConnection
 from pypck.pck_commands import PckGenerator
 
 _LOGGER = logging.getLogger(__name__)
@@ -131,7 +131,7 @@ class PchkConnectionManager:
         # stored in this dictionary.  Communication to groups is handled by
         # GroupConnection object that are created on the fly and not stored
         # permanently.
-        self.address_conns: dict[LcnAddr, ModuleConnection] = {}
+        self.device_connections: dict[LcnAddr, DeviceConnection] = {}
         self.segment_coupler_ids: list[int] = []
 
         self.input_callbacks: set[Callable[[inputs.Input], None]] = set()
@@ -360,15 +360,15 @@ class PchkConnectionManager:
         old_local_seg_id = self.local_seg_id
 
         self.local_seg_id = local_seg_id
-        # replace all address_conns with current local_seg_id with new
+        # replace all device_connections with current local_seg_id with new
         # local_seg_id
-        for addr in list(self.address_conns):
+        for addr in list(self.device_connections):
             if addr.seg_id == old_local_seg_id:
-                address_conn = self.address_conns.pop(addr)
+                address_conn = self.device_connections.pop(addr)
                 address_conn.addr = LcnAddr(
                     self.local_seg_id, addr.addr_id, addr.is_group
                 )
-                self.address_conns[address_conn.addr] = address_conn
+                self.device_connections[address_conn.addr] = address_conn
 
     def physical_to_logical(self, addr: LcnAddr) -> LcnAddr:
         """Convert the physical segment id of an address to the logical one."""
@@ -378,39 +378,28 @@ class PchkConnectionManager:
             addr.is_group,
         )
 
-    def get_module_conn(self, addr: LcnAddr) -> ModuleConnection:
-        """Create and/or return the given LCN module."""
-        assert not addr.is_group
+    def get_device_connection(self, addr: LcnAddr) -> DeviceConnection:
+        """Create and/or return a connection to the given module or group."""
         if addr.seg_id == 0 and self.local_seg_id != -1:
             addr = LcnAddr(self.local_seg_id, addr.addr_id, addr.is_group)
-        address_conn = self.address_conns.get(addr, None)
-        if address_conn is None:
-            address_conn = ModuleConnection(
-                self, addr, wants_ack=self.settings["ACKNOWLEDGE"]
-            )
-            self.address_conns[addr] = address_conn
 
-        return address_conn
-
-    def get_group_conn(self, addr: LcnAddr) -> GroupConnection:
-        """Create and return the GroupConnection for the given group."""
-        assert addr.is_group
-        if addr.seg_id == 0 and self.local_seg_id != -1:
-            addr = LcnAddr(self.local_seg_id, addr.addr_id, addr.is_group)
-        return GroupConnection(self, addr)
+        device_connection = self.device_connections.get(addr, None)
+        if device_connection is None:
+            device_connection = DeviceConnection(
+                self,
+                addr,
+                wants_ack=False if addr.is_group else self.settings["ACKNOWLEDGE"],
+            )
+            self.device_connections[addr] = device_connection
 
-    def get_address_conn(self, addr: LcnAddr) -> ModuleConnection | GroupConnection:
-        """Create and/or return a connection to the given module or group."""
-        if addr.is_group:
-            return self.get_group_conn(addr)
-        return self.get_module_conn(addr)
+        return device_connection
 
     # Other
 
     async def dump_modules(self) -> dict[str, dict[str, dict[str, Any]]]:
         """Dump all modules and information about them in a JSON serializable dict."""
         dump: dict[str, dict[str, dict[str, Any]]] = {}
-        for address_conn in self.address_conns.values():
+        for address_conn in self.device_connections.values():
             seg = f"{address_conn.addr.seg_id:d}"
             addr = f"{address_conn.addr.addr_id}"
             if seg not in dump:
@@ -484,7 +473,7 @@ class PchkConnectionManager:
             if isinstance(inp, inputs.ModInput):
                 logical_source_addr = self.physical_to_logical(inp.physical_source_addr)
                 if not logical_source_addr.is_group:
-                    module_conn = self.get_module_conn(logical_source_addr)
+                    module_conn = self.get_device_connection(logical_source_addr)
                     if isinstance(inp, inputs.ModSn):
                         # used to extend scan_modules() timeout
                         if self.module_serial_number_received.locked():

pypck/{module.py → device.py}

@@ -1,17 +1,18 @@
-"""Module and group classes."""
+"""LCN devices: Modules and groups."""
 
 from __future__ import annotations
 
 import asyncio
 import logging
 from collections.abc import Callable, Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, cast
 
 from pypck import inputs, lcn_defs
 from pypck.helpers import TaskRegistry
 from pypck.lcn_addr import LcnAddr
 from pypck.pck_commands import PckGenerator
+from pypck.status_requester import StatusRequester
 
 if TYPE_CHECKING:
     from pypck.connection import PchkConnectionManager
@@ -29,153 +30,8 @@ class Serials:
     hardware_type: lcn_defs.HardwareType
 
 
-@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: ModuleConnection,
-    ) -> 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
-
-
-class AbstractConnection:
-    """Organizes communication with a specific module.
+class DeviceConnection:
+    """Organizes communication with a specific module/group.
 
     Sends status requests to the connection and handles status responses.
     """
@@ -193,6 +49,22 @@ class AbstractConnection:
         self.serials = Serials(-1, -1, -1, lcn_defs.HardwareType.UNKNOWN)
         self._serials_known = asyncio.Event()
 
+        self.input_callbacks: set[Callable[[inputs.Input], None]] = set()
+
+        # List of queued acknowledge codes from the LCN modules.
+        self.acknowledges: asyncio.Queue[lcn_defs.AcknowledgeErrorCode] = (
+            asyncio.Queue()
+        )
+
+        # StatusRequester
+        self.status_requester = StatusRequester(self)
+
+        if self.addr.is_group:
+            self.wants_ack = False  # groups do not send acks
+            self._serials_known.set()
+        else:
+            self.task_registry.create_task(self._request_device_properties())
+
     @property
     def task_registry(self) -> TaskRegistry:
         """Get the task registry."""
@@ -216,6 +88,17 @@ class AbstractConnection:
     async def send_command(self, wants_ack: bool, pck: str | bytes) -> bool:
         """Send a command to the module represented by this class.
 
+        :param    bool    wants_ack:    Also send a request for acknowledge.
+        :param    str     pck:          PCK command (without header).
+        """
+        if not self.addr.is_group and wants_ack:
+            return await self.send_command_with_ack(pck)
+
+        return await self._send_command(wants_ack, pck)
+
+    async def _send_command(self, wants_ack: bool, pck: str | bytes) -> bool:
+        """Send a command to the module represented by this class.
+
         :param    bool    wants_ack:    Also send a request for acknowledge.
         :param    str     pck:          PCK command (without header).
         """
@@ -226,6 +109,50 @@ class AbstractConnection:
             return await self.conn.send_command(header + pck)
         return await self.conn.send_command(header.encode() + pck)
 
+    async def serials_known(self) -> None:
+        """Wait until the serials of this device are known."""
+        await self._serials_known.wait()
+
+    # ##
+    # ## Retry logic if an acknowledge is requested
+    # ##
+
+    async def send_command_with_ack(self, pck: str | bytes) -> bool:
+        """Send a PCK command and ensure receiving of an acknowledgement.
+
+        Resends the PCK command if no acknowledgement has been received
+        within timeout.
+
+        :param    str     pck:          PCK command (without header).
+        :returns:    True if acknowledge was received, False otherwise
+        :rtype:      bool
+        """
+        count = 0
+        while count < self.conn.settings["NUM_TRIES"]:
+            await self._send_command(True, pck)
+            try:
+                code = await asyncio.wait_for(
+                    self.acknowledges.get(),
+                    timeout=self.conn.settings["DEFAULT_TIMEOUT"],
+                )
+            except asyncio.TimeoutError:
+                count += 1
+                continue
+            if code == lcn_defs.AcknowledgeErrorCode.OK:
+                return True
+            break
+        return False
+
+    async def on_ack(
+        self, code: lcn_defs.AcknowledgeErrorCode = lcn_defs.AcknowledgeErrorCode.OK
+    ) -> None:
+        """Is called whenever an acknowledge is received from the LCN module.
+
+        :param     int    code:           The LCN internal code. -1 means
+                                          "positive" acknowledge
+        """
+        await self.acknowledges.put(code)
+
     # ##
     # ## Methods for sending PCK commands
     # ##
@@ -516,6 +443,22 @@ class AbstractConnection:
         :returns:    True if command was sent successfully, False otherwise
         :rtype:      bool
         """
+        if self.addr.is_group:
+            result = True
+            # for new modules (>=0x170206)
+            result &= await self.var_abs(var, value, unit, 0x170206)
+
+            # for old modules (<0x170206)
+            if var in [
+                lcn_defs.Var.TVAR,
+                lcn_defs.Var.R1VAR,
+                lcn_defs.Var.R2VAR,
+                lcn_defs.Var.R1VARSETPOINT,
+                lcn_defs.Var.R2VARSETPOINT,
+            ]:
+                result &= await self.var_abs(var, value, unit, 0x000000)
+            return result
+
         if not isinstance(value, lcn_defs.VarValue):
             value = lcn_defs.VarValue.from_var_unit(value, unit, True)
 
@@ -560,6 +503,19 @@ class AbstractConnection:
         :returns:    True if command was sent successfully, False otherwise
         :rtype:      bool
         """
+        if self.addr.is_group:
+            result = True
+            result &= await self.var_reset(var, 0x170206)
+            if var in [
+                lcn_defs.Var.TVAR,
+                lcn_defs.Var.R1VAR,
+                lcn_defs.Var.R2VAR,
+                lcn_defs.Var.R1VARSETPOINT,
+                lcn_defs.Var.R2VARSETPOINT,
+            ]:
+                result &= await self.var_reset(var, 0)
+            return result
+
         if software_serial == -1:
             await self._serials_known.wait()
             software_serial = self.serials.software_serial
@@ -586,6 +542,24 @@ class AbstractConnection:
         :returns:    True if command was sent successfully, False otherwise
         :rtype:      bool
         """
+        if self.addr.is_group:
+            result = True
+            result &= await self.var_rel(var, value, software_serial=0x170206)
+            if var in [
+                lcn_defs.Var.TVAR,
+                lcn_defs.Var.R1VAR,
+                lcn_defs.Var.R2VAR,
+                lcn_defs.Var.R1VARSETPOINT,
+                lcn_defs.Var.R2VARSETPOINT,
+                lcn_defs.Var.THRS1,
+                lcn_defs.Var.THRS2,
+                lcn_defs.Var.THRS3,
+                lcn_defs.Var.THRS4,
+                lcn_defs.Var.THRS5,
+            ]:
+                result &= await self.var_rel(var, value, software_serial=0)
+            return result
+
         if not isinstance(value, lcn_defs.VarValue):
             value = lcn_defs.VarValue.from_var_unit(value, unit, False)
 
@@ -773,199 +747,6 @@ class AbstractConnection:
         """
         return await self.send_command(self.wants_ack, pck)
 
-
-class GroupConnection(AbstractConnection):
-    """Organizes communication with a specific group.
-
-    It is assumed that all modules within this group are newer than FW170206
-    """
-
-    def __init__(
-        self,
-        conn: PchkConnectionManager,
-        addr: LcnAddr,
-    ):
-        """Construct GroupConnection instance."""
-        assert addr.is_group
-        super().__init__(conn, addr, wants_ack=False)
-        self._serials_known.set()
-
-    async def var_abs(
-        self,
-        var: lcn_defs.Var,
-        value: float | lcn_defs.VarValue,
-        unit: lcn_defs.VarUnit = lcn_defs.VarUnit.NATIVE,
-        software_serial: int = -1,
-    ) -> bool:
-        """Send a command to set the absolute value to a variable.
-
-        :param     Var        var:      Variable
-        :param     float      value:    Absolute value to set
-        :param     VarUnit    unit:     Unit of variable
-        """
-        result = True
-        # for new modules (>=0x170206)
-        result &= await super().var_abs(var, value, unit, 0x170206)
-
-        # for old modules (<0x170206)
-        if var in [
-            lcn_defs.Var.TVAR,
-            lcn_defs.Var.R1VAR,
-            lcn_defs.Var.R2VAR,
-            lcn_defs.Var.R1VARSETPOINT,
-            lcn_defs.Var.R2VARSETPOINT,
-        ]:
-            result &= await super().var_abs(var, value, unit, 0x000000)
-        return result
-
-    async def var_reset(
-        self, var: lcn_defs.Var, software_serial: int | None = None
-    ) -> bool:
-        """Send a command to reset the variable value.
-
-        :param    Var    var:    Variable
-        """
-        result = True
-        result &= await super().var_reset(var, 0x170206)
-        if var in [
-            lcn_defs.Var.TVAR,
-            lcn_defs.Var.R1VAR,
-            lcn_defs.Var.R2VAR,
-            lcn_defs.Var.R1VARSETPOINT,
-            lcn_defs.Var.R2VARSETPOINT,
-        ]:
-            result &= await super().var_reset(var, 0)
-        return result
-
-    async def var_rel(
-        self,
-        var: lcn_defs.Var,
-        value: float | lcn_defs.VarValue,
-        unit: lcn_defs.VarUnit = lcn_defs.VarUnit.NATIVE,
-        value_ref: lcn_defs.RelVarRef = lcn_defs.RelVarRef.CURRENT,
-        software_serial: int = -1,
-    ) -> bool:
-        """Send a command to change the value of a variable.
-
-        :param     Var        var:      Variable
-        :param     float      value:    Relative value to add (may also be
-                                        negative)
-        :param     VarUnit    unit:     Unit of variable
-        """
-        result = True
-        result &= await super().var_rel(var, value, software_serial=0x170206)
-        if var in [
-            lcn_defs.Var.TVAR,
-            lcn_defs.Var.R1VAR,
-            lcn_defs.Var.R2VAR,
-            lcn_defs.Var.R1VARSETPOINT,
-            lcn_defs.Var.R2VARSETPOINT,
-            lcn_defs.Var.THRS1,
-            lcn_defs.Var.THRS2,
-            lcn_defs.Var.THRS3,
-            lcn_defs.Var.THRS4,
-            lcn_defs.Var.THRS5,
-        ]:
-            result &= await super().var_rel(var, value, software_serial=0)
-        return result
-
-
-class ModuleConnection(AbstractConnection):
-    """Organizes communication with a specific module or group."""
-
-    def __init__(
-        self,
-        conn: PchkConnectionManager,
-        addr: LcnAddr,
-        has_s0_enabled: bool = False,
-        wants_ack: bool = True,
-    ):
-        """Construct ModuleConnection instance."""
-        assert not addr.is_group
-        super().__init__(conn, addr, wants_ack=wants_ack)
-        self.has_s0_enabled = has_s0_enabled
-
-        self.input_callbacks: set[Callable[[inputs.Input], None]] = set()
-
-        # List of queued acknowledge codes from the LCN modules.
-        self.acknowledges: asyncio.Queue[int] = asyncio.Queue()
-
-        # StatusRequester
-        self.status_requester = StatusRequester(self)
-
-        self.task_registry.create_task(self.request_module_properties())
-
-    async def request_module_properties(self) -> None:
-        """Request module properties (serials)."""
-        self.serials = await self.request_serials()
-        self._serials_known.set()
-
-    async def send_command(self, wants_ack: bool, pck: str | bytes) -> bool:
-        """Send a command to the module represented by this class.
-
-        :param    bool    wants_ack:    Also send a request for acknowledge.
-        :param    str     pck:          PCK command (without header).
-        """
-        if wants_ack:
-            return await self.send_command_with_ack(pck)
-
-        return await super().send_command(False, pck)
-
-    async def serials_known(self) -> None:
-        """Wait until the serials of this module are known."""
-        await self._serials_known.wait()
-
-    # ##
-    # ## Retry logic if an acknowledge is requested
-    # ##
-
-    async def send_command_with_ack(self, pck: str | bytes) -> bool:
-        """Send a PCK command and ensure receiving of an acknowledgement.
-
-        Resends the PCK command if no acknowledgement has been received
-        within timeout.
-
-        :param    str     pck:          PCK command (without header).
-        :returns:    True if acknowledge was received, False otherwise
-        :rtype:      bool
-        """
-        count = 0
-        while count < self.conn.settings["NUM_TRIES"]:
-            await super().send_command(True, pck)
-            try:
-                code = await asyncio.wait_for(
-                    self.acknowledges.get(),
-                    timeout=self.conn.settings["DEFAULT_TIMEOUT"],
-                )
-            except asyncio.TimeoutError:
-                count += 1
-                continue
-            if code == -1:
-                return True
-            break
-        return False
-
-    async def on_ack(self, code: int = -1) -> None:
-        """Is called whenever an acknowledge is received from the LCN module.
-
-        :param     int    code:           The LCN internal code. -1 means
-                                          "positive" acknowledge
-        """
-        await self.acknowledges.put(code)
-
-    def set_s0_enabled(self, s0_enabled: bool) -> None:
-        """Set the activation status for S0 variables.
-
-        :param     bool    s0_enabled:   If True, a BU4L has to be connected
-                                         to the hardware module and S0 mode
-                                         has to be activated in LCN-PRO.
-        """
-        self.has_s0_enabled = s0_enabled
-
-    def get_s0_enabled(self) -> bool:
-        """Get the activation status for S0 variables."""
-        return self.has_s0_enabled
-
     # ##
     # ## Methods for handling input objects
     # ##
@@ -1022,12 +803,25 @@ class ModuleConnection(AbstractConnection):
             },
         }
 
+    # ##
+    # ## Methods for requesting module properties and status
+    # ##
+
+    async def _request_device_properties(self) -> None:
+        """Request module properties (serials)."""
+        self.serials = await self.request_serials()
+        self._serials_known.set()
+
     # Request status methods
 
     async def request_status_output(
         self, output_port: lcn_defs.OutputPort, max_age: int = 0
     ) -> inputs.ModStatusOutput | None:
         """Request the status of an output port from a module."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         result = await self.status_requester.request(
             response_type=inputs.ModStatusOutput,
             request_pck=PckGenerator.request_output_status(output_id=output_port.value),
@@ -1041,6 +835,10 @@ class ModuleConnection(AbstractConnection):
         self, max_age: int = 0
     ) -> inputs.ModStatusRelays | None:
         """Request the status of relays from a module."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         result = await self.status_requester.request(
             response_type=inputs.ModStatusRelays,
             request_pck=PckGenerator.request_relays_status(),
@@ -1056,6 +854,10 @@ class ModuleConnection(AbstractConnection):
         max_age: int = 0,
     ) -> inputs.ModStatusMotorPositionBS4 | None:
         """Request the status of motor positions from a module."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         if motor not in (
             lcn_defs.MotorPort.MOTOR1,
             lcn_defs.MotorPort.MOTOR2,
@@ -1083,6 +885,10 @@ class ModuleConnection(AbstractConnection):
         self, max_age: int = 0
     ) -> inputs.ModStatusBinSensors | None:
         """Request the status of binary sensors from a module."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         result = await self.status_requester.request(
             response_type=inputs.ModStatusBinSensors,
             request_pck=PckGenerator.request_bin_sensors_status(),
@@ -1097,6 +903,10 @@ class ModuleConnection(AbstractConnection):
         max_age: int = 0,
     ) -> inputs.ModStatusVar | None:
         """Request the status of a variable from a module."""
+        if self.addr.is_group:
+            _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:
@@ -1122,6 +932,10 @@ class ModuleConnection(AbstractConnection):
         self, max_age: int = 0
     ) -> inputs.ModStatusLedsAndLogicOps | None:
         """Request the status of LEDs and logic operations from a module."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         result = await self.status_requester.request(
             response_type=inputs.ModStatusLedsAndLogicOps,
             request_pck=PckGenerator.request_leds_and_logic_ops(),
@@ -1134,6 +948,10 @@ class ModuleConnection(AbstractConnection):
         self, max_age: int = 0
     ) -> inputs.ModStatusKeyLocks | None:
         """Request the status of locked keys from a module."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         result = await self.status_requester.request(
             response_type=inputs.ModStatusKeyLocks,
             request_pck=PckGenerator.request_key_lock_status(),
@@ -1146,6 +964,10 @@ class ModuleConnection(AbstractConnection):
 
     async def request_serials(self, max_age: int = 0) -> Serials:
         """Request module serials."""
+        if self.addr.is_group:
+            _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(
@@ -1166,6 +988,10 @@ class ModuleConnection(AbstractConnection):
 
     async def request_name(self, max_age: int = 0) -> str | None:
         """Request module name."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         coros = [
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
@@ -1186,6 +1012,10 @@ class ModuleConnection(AbstractConnection):
 
     async def request_comment(self, max_age: int = 0) -> str | None:
         """Request module name."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         coros = [
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
@@ -1206,6 +1036,10 @@ class ModuleConnection(AbstractConnection):
 
     async def request_oem_text(self, max_age: int = 0) -> str | None:
         """Request module name."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return None
+
         coros = [
             self.status_requester.request(
                 response_type=inputs.ModNameComment,
@@ -1228,6 +1062,10 @@ class ModuleConnection(AbstractConnection):
         self, dynamic: bool = False, max_age: int = 0
     ) -> set[LcnAddr]:
         """Request module static/dynamic group memberships."""
+        if self.addr.is_group:
+            _LOGGER.info("Status requests are not supported for groups.")
+            return set()
+
         result = await self.status_requester.request(
             response_type=inputs.ModStatusGroups,
             request_pck=(

pypck/inputs.py

@@ -280,17 +280,15 @@ class Ping(Input):
 class ModAck(ModInput):
     """Acknowledge message received from module."""
 
-    def __init__(self, physical_source_addr: LcnAddr, code: int):
+    def __init__(
+        self, physical_source_addr: LcnAddr, code: lcn_defs.AcknowledgeErrorCode
+    ):
         """Construct ModInput object."""
         super().__init__(physical_source_addr)
         self.code = code
 
-    def get_code(self) -> int:
-        """Return the acknowledge code.
-
-        :return:    Acknowledge code.
-        :rtype:     int
-        """
+    def get_code(self) -> lcn_defs.AcknowledgeErrorCode:
+        """Return the acknowledge code."""
         return self.code
 
     @staticmethod
@@ -310,14 +308,18 @@ class ModAck(ModInput):
             addr = LcnAddr(
                 int(matcher_pos.group("seg_id")), int(matcher_pos.group("mod_id"))
             )
-            return [ModAck(addr, -1)]
+            return [ModAck(addr, lcn_defs.AcknowledgeErrorCode.OK)]
 
         matcher_neg = PckParser.PATTERN_ACK_NEG.match(data)
         if matcher_neg:
             addr = LcnAddr(
                 int(matcher_neg.group("seg_id")), int(matcher_neg.group("mod_id"))
             )
-            return [ModAck(addr, int(matcher_neg.group("code")))]
+            return [
+                ModAck(
+                    addr, lcn_defs.AcknowledgeErrorCode(int(matcher_neg.group("code")))
+                )
+            ]
 
         return None
 

pypck/lcn_defs.py

@@ -1444,6 +1444,27 @@ class AccessControlPeriphery(Enum):
     CODELOCK = "codelock"
 
 
+class AcknowledgeErrorCode(Enum):
+    """Acknowledge error codes."""
+
+    UNKNOWN = -1
+    OK = 0
+    UNKNOWN_COMMAND = 5
+    WRONG_PARAMETER_COUNT = 6
+    INVALID_PARAMETER_VALUE = 7
+    CURRENTLY_NOT_ALLOWED = 8
+    NOT_ALLOWED_BY_PROGRAMMING = 9
+    INAPPROPRIATE_MODULE = 10
+    MISSING_PERIPHERY = 11
+    PROGRAMMING_MODE_REQUIRED = 12
+    FUSE_DEFECT = 14
+
+    @classmethod
+    def _missing_(cls, value: Any) -> AcknowledgeErrorCode:
+        """Handle missing values."""
+        return cls.UNKNOWN
+
+
 class LcnEvent(Enum):
     """LCN events."""
 

pypck/status_requester.py

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

{pypck-0.9.2.dist-info → pypck-0.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pypck
-Version: 0.9.2
+Version: 0.9.4
 Summary: LCN-PCK library
 Home-page: https://github.com/alengwenus/pypck
 Author-email: Andre Lengwenus <alengwenus@gmail.com>
@@ -55,7 +55,7 @@ async def main():
         password="lcn",
         settings={"SK_NUM_TRIES": 0},
     ) as pck_client:
-        module = pck_client.get_address_conn(LcnAddr(0, 10, False))
+        module = pck_client.get_device_connection(LcnAddr(0, 10, False))
 
         await module.dim_output(0, 100, 0)
         await asyncio.sleep(1)

pypck-0.9.4.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=sR9FtHQ84uUjxiWBEt8qqGWoEMn9HWwuTlBLzEwUVtw,39313
+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.4.dist-info/licenses/LICENSE,sha256=iYB6zyMJvShfAzQE7nhYFgLzzZuBmhasLw5fYP9KRz4,1023
+pypck-0.9.4.dist-info/METADATA,sha256=9fz5eH50liD4D9pv54ye7XcWc1KDJvi1i46gF3cic_A,2682
+pypck-0.9.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pypck-0.9.4.dist-info/top_level.txt,sha256=59ried49iFueDa5mQ_5BGVZcESjjzi4MZZKLcganvQA,6
+pypck-0.9.4.dist-info/RECORD,,

pypck-0.9.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-pypck/__init__.py,sha256=_40HMoShQbAlJT0ZdOjQagqn2NRTrvUGOmoS3cYBuIA,277
-pypck/connection.py,sha256=CrcvSnTn3Pbd9rwP_CBDagocJVG2DEE9KKN95ljdOVY,23839
-pypck/helpers.py,sha256=_5doqIsSRpqdQNPIUsjFh813xKGuMuEFY6sNGobJGIk,1280
-pypck/inputs.py,sha256=cjhvYKPr5QHw7Rjfkkg8LPbP8ohq_-z_Tvk51Rkx0aY,45828
-pypck/lcn_addr.py,sha256=N2Od8KuANOglqKjf596hJVH1SRcG7MhESKA5YYlDnbw,1946
-pypck/lcn_defs.py,sha256=hB4fxcjz7zkO3qkgBpWmdg8z17ZLAkZmRCyaucp70eM,42850
-pypck/module.py,sha256=5ytzV81BlFpXg6-lhPkbShIlq_UDb737rt5HbgjfSr8,45141
-pypck/pck_commands.py,sha256=eJxmh2e8EbKGpek97L2961Kr_nVfT8rKgJCN3YgjIQM,50458
-pypck-0.9.2.dist-info/licenses/LICENSE,sha256=iYB6zyMJvShfAzQE7nhYFgLzzZuBmhasLw5fYP9KRz4,1023
-pypck-0.9.2.dist-info/METADATA,sha256=r0YVKu3bk_tczrldgEEHu5vrXwJC7aOjAJMY9fA_ueg,2677
-pypck-0.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pypck-0.9.2.dist-info/top_level.txt,sha256=59ried49iFueDa5mQ_5BGVZcESjjzi4MZZKLcganvQA,6
-pypck-0.9.2.dist-info/RECORD,,