pypck 0.8.8__tar.gz → 0.8.10__tar.gz

{pypck-0.8.8/pypck.egg-info → pypck-0.8.10}/PKG-INFO

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

pypck-0.8.10/VERSION

@@ -0,0 +1 @@
+0.8.10

{pypck-0.8.8 → pypck-0.8.10}/pypck/connection.py

@@ -13,7 +13,7 @@ from pypck import inputs, lcn_defs
 from pypck.helpers import TaskRegistry
 from pypck.lcn_addr import LcnAddr
 from pypck.lcn_defs import LcnEvent
-from pypck.module import AbstractConnection, GroupConnection, ModuleConnection
+from pypck.module import GroupConnection, ModuleConnection
 from pypck.pck_commands import PckGenerator
 
 _LOGGER = logging.getLogger(__name__)
@@ -243,7 +243,7 @@ class PchkConnectionManager:
                     if isinstance(exc, (ConnectionRefusedError, OSError)):
                         raise PchkConnectionRefusedError()
                     else:
-                        raise awaitable.exception()  # type: ignore
+                        raise exc
 
         if pending:
             for awaitable in pending:
@@ -405,8 +405,8 @@ class PchkConnectionManager:
 
     def get_address_conn(
         self, addr: LcnAddr, request_serials: bool = True
-    ) -> AbstractConnection:
-        """Create and/or return an AbstractConnection to the given module or group."""
+    ) -> 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, request_serials)

{pypck-0.8.8 → pypck-0.8.10}/pypck/helpers.py

@@ -1,7 +1,7 @@
 """Helper functions for pypck."""
 
 import asyncio
-from collections.abc import Awaitable
+from collections.abc import Coroutine
 from typing import Any
 
 
@@ -30,9 +30,9 @@ class TaskRegistry:
         if task in self.tasks:
             self.tasks.remove(task)
 
-    def create_task(self, coro: Awaitable[Any]) -> "asyncio.Task[None]":
+    def create_task(self, coro: Coroutine[Any, Any, Any]) -> "asyncio.Task[None]":
         """Create a task and store a reference in the task registry."""
-        task = asyncio.create_task(coro)  # type: ignore
+        task: asyncio.Task[Any] = asyncio.create_task(coro)
         task.add_done_callback(self.remove_task)
         self.tasks.append(task)
         return task

{pypck-0.8.8 → pypck-0.8.10}/pypck/lcn_defs.py

@@ -360,6 +360,44 @@ class Var(Enum):
     S0INPUT3 = auto()
     S0INPUT4 = auto()  # LCN-BU4LJVarValue
 
+    @classmethod
+    def variables(cls) -> list[Var]:
+        """Return a list of all variable types."""
+        return [
+            cls.VAR1ORTVAR,
+            cls.VAR2ORR1VAR,
+            cls.VAR3ORR2VAR,
+            cls.VAR4,
+            cls.VAR5,
+            cls.VAR6,
+            cls.VAR7,
+            cls.VAR8,
+            cls.VAR9,
+            cls.VAR10,
+            cls.VAR11,
+            cls.VAR12,
+        ]
+
+    @classmethod
+    def set_points(cls) -> list[Var]:
+        """Return a list of all set-point variable types."""
+        return [cls.R1VARSETPOINT, cls.R2VARSETPOINT]
+
+    @classmethod
+    def thresholds(cls) -> list[list[Var]]:
+        """Return a list of all threshold variable types."""
+        return [
+            [cls.THRS1, cls.THRS2, cls.THRS3, cls.THRS4, cls.THRS5],
+            [cls.THRS2_1, cls.THRS2_2, cls.THRS2_3, cls.THRS2_4],
+            [cls.THRS3_1, cls.THRS3_2, cls.THRS3_3, cls.THRS3_4],
+            [cls.THRS4_1, cls.THRS4_2, cls.THRS4_3, cls.THRS4_4],
+        ]
+
+    @classmethod
+    def s0s(cls) -> list[Var]:
+        """Return a list of all S0-input variable types."""
+        return [cls.S0INPUT1, cls.S0INPUT2, cls.S0INPUT3, cls.S0INPUT4]
+
     @staticmethod
     def var_id_to_var(var_id: int) -> Var:
         """Translate a given id into a variable type.
@@ -369,9 +407,9 @@ class Var(Enum):
         :returns: The translated variable enum.
         :rtype: Var
         """
-        if (var_id < 0) or (var_id >= len(Var.variables)):  # type: ignore
+        if (var_id < 0) or (var_id >= len(Var.variables())):
             raise ValueError("Bad var_id.")
-        return Var.variables[var_id]  # type: ignore
+        return Var.variables()[var_id]
 
     @staticmethod
     def set_point_id_to_var(set_point_id: int) -> Var:
@@ -382,9 +420,9 @@ class Var(Enum):
         :return: The translated var
         :rtype:  Var
         """
-        if (set_point_id < 0) or (set_point_id >= len(Var.set_points)):  # type: ignore
+        if (set_point_id < 0) or (set_point_id >= len(Var.set_points())):
             raise ValueError("Bad set_point_id.")
-        return Var.set_points[set_point_id]  # type: ignore
+        return Var.set_points()[set_point_id]
 
     @staticmethod
     def thrs_id_to_var(register_id: int, thrs_id: int) -> Var:
@@ -399,12 +437,12 @@ class Var(Enum):
         """
         if (
             (register_id < 0)
-            or (register_id >= len(Var.thresholds))  # type: ignore
+            or (register_id >= len(Var.thresholds()))
             or (thrs_id < 0)
             or (thrs_id >= (5 if (register_id == 0) else 4))
         ):
             raise ValueError("Bad register_id and/or thrs_id.")
-        return Var.thresholds[register_id][thrs_id]  # type: ignore
+        return Var.thresholds()[register_id][thrs_id]
 
     @staticmethod
     def s0_id_to_var(s0_id: int) -> Var:
@@ -415,9 +453,9 @@ class Var(Enum):
         :return:    The translated var
         :rtype:     Var
         """
-        if (s0_id < 0) or (s0_id >= len(Var.s0s)):  # type: ignore
+        if (s0_id < 0) or (s0_id >= len(Var.s0s())):
             raise ValueError("Bad s0_id.")
-        return Var.s0s[s0_id]  # type: ignore
+        return Var.s0s()[s0_id]
 
     @staticmethod
     def to_var_id(var: Var) -> int:
@@ -658,42 +696,6 @@ class Var(Enum):
         return (not lock_state) and (software_serial < 0x170206)
 
 
-# Helper list to get var by numeric id.
-Var.variables = [  # type: ignore
-    Var.VAR1ORTVAR,
-    Var.VAR2ORR1VAR,
-    Var.VAR3ORR2VAR,
-    Var.VAR4,
-    Var.VAR5,
-    Var.VAR6,
-    Var.VAR7,
-    Var.VAR8,
-    Var.VAR9,
-    Var.VAR10,
-    Var.VAR11,
-    Var.VAR12,
-]
-
-# Helper list to get set-point var by numeric id.
-Var.set_points = [Var.R1VARSETPOINT, Var.R2VARSETPOINT]  # type: ignore
-
-# Helper list to get threshold var by numeric id.
-Var.thresholds = [  # type: ignore
-    [Var.THRS1, Var.THRS2, Var.THRS3, Var.THRS4, Var.THRS5],
-    [Var.THRS2_1, Var.THRS2_2, Var.THRS2_3, Var.THRS2_4],
-    [Var.THRS3_1, Var.THRS3_2, Var.THRS3_3, Var.THRS3_4],
-    [Var.THRS4_1, Var.THRS4_2, Var.THRS4_3, Var.THRS4_4],
-]
-
-# Helper list to get S0-input var by numeric id.
-Var.s0s = [  # type: ignore
-    Var.S0INPUT1,
-    Var.S0INPUT2,
-    Var.S0INPUT3,
-    Var.S0INPUT4,
-]
-
-
 class VarUnit(Enum):
     """Measurement units used with LCN variables."""
 

{pypck-0.8.8 → pypck-0.8.10}/pypck/module.py

@@ -174,19 +174,22 @@ class AbstractConnection:
             self.wants_ack, PckGenerator.rel_output(output_id, percent)
         )
 
-    async def toggle_output(self, output_id: int, ramp: int) -> bool:
+    async def toggle_output(
+        self, output_id: int, ramp: int, to_memory: bool = False
+    ) -> bool:
         """Send a command that toggles a single output-port.
 
         Toggle mode: (on->off, off->on).
 
         :param    int    output_id:    Output id 0..3
         :param    int    ramp:         Ramp time in milliseconds
+        :param    bool   to_memory:    If True, the dimming status is stored
 
         :returns:    True if command was sent successfully, False otherwise
         :rtype:      bool
         """
         return await self.send_command(
-            self.wants_ack, PckGenerator.toggle_output(output_id, ramp)
+            self.wants_ack, PckGenerator.toggle_output(output_id, ramp, to_memory)
         )
 
     async def toggle_all_outputs(self, ramp: int) -> bool:

{pypck-0.8.8 → pypck-0.8.10}/pypck/pck_commands.py

@@ -471,19 +471,21 @@ class PckGenerator:
         return pck
 
     @staticmethod
-    def toggle_output(output_id: int, ramp: int) -> str:
+    def toggle_output(output_id: int, ramp: int, to_memory: bool = False) -> str:
         """Generate a command that toggles a single output-port.
 
         Toggle mode: (on->off, off->on).
 
         :param    int    output_id:    Output id 0..3
         :param    int    ramp:         Ramp value
+        :param    bool   to_memory:    If True, the dimming status is stored
+
         :return:    The PCK command (without address header) as text
         :rtype:    str
         """
         if (output_id < 0) or (output_id > 3):
             raise ValueError("Invalid output_id.")
-        return f"A{output_id + 1}TA{ramp:03d}"
+        return f"A{output_id + 1}{'MT' if to_memory else 'TA'}{ramp:03d}"
 
     @staticmethod
     def toggle_all_outputs(ramp: int) -> str:

{pypck-0.8.8 → pypck-0.8.10}/pypck/request_handlers.py

@@ -660,6 +660,7 @@ class StatusRequestsHandler:
     async def activate_all(self, activate_s0: bool = False) -> None:
         """Activate all status requests."""
         await self.addr_conn.conn.segment_scan_completed_event.wait()
+        var_s0s = lcn_defs.Var.s0s()
         for item in (
             list(lcn_defs.OutputPort)
             + list(lcn_defs.RelayPort)
@@ -673,7 +674,7 @@ class StatusRequestsHandler:
             if (
                 (not activate_s0)
                 and isinstance(item, lcn_defs.Var)
-                and (item in lcn_defs.Var.s0s)  # type: ignore
+                and (item in var_s0s)
             ):
                 continue
             await self.activate(item)

{pypck-0.8.8 → pypck-0.8.10/pypck.egg-info}/PKG-INFO

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

{pypck-0.8.8 → pypck-0.8.10}/tests/test_commands.py

@@ -1,5 +1,7 @@
 """Tests for command generation directed at bus modules and groups."""
 
+from typing import Any
+
 import pytest
 
 from pypck.lcn_addr import LcnAddr
@@ -24,7 +26,7 @@ from pypck.pck_commands import PckGenerator
 
 NEW_VAR_SW_AGE = 0x170206
 
-COMMANDS = {
+COMMANDS: dict[str | bytes, Any] = {
     # Host commands
     **{
         f"^ping{counter:d}": (PckGenerator.ping, counter)
@@ -93,7 +95,7 @@ COMMANDS = {
             var,
             NEW_VAR_SW_AGE,
         )
-        for var in Var.variables  # type: ignore
+        for var in Var.variables()
     },
     **{
         f"MWS{Var.to_set_point_id(var) + 1:03d}": (
@@ -101,7 +103,7 @@ COMMANDS = {
             var,
             NEW_VAR_SW_AGE,
         )
-        for var in Var.set_points  # type: ignore
+        for var in Var.set_points()
     },
     **{
         f"MWC{Var.to_s0_id(var) + 1:03d}": (
@@ -109,7 +111,7 @@ COMMANDS = {
             var,
             NEW_VAR_SW_AGE,
         )
-        for var in Var.s0s  # type: ignore
+        for var in Var.s0s()
     },
     **{
         f"SE{Var.to_thrs_register_id(var) + 1:03d}": (
@@ -117,7 +119,7 @@ COMMANDS = {
             var,
             NEW_VAR_SW_AGE,
         )
-        for reg in Var.thresholds  # type: ignore
+        for reg in Var.thresholds()
         for var in reg
     },
     # Variable status (legacy commands)
@@ -128,7 +130,7 @@ COMMANDS = {
     "MWSB": (PckGenerator.request_var_status, Var.R2VARSETPOINT, NEW_VAR_SW_AGE - 1),
     **{
         "SL1": (PckGenerator.request_var_status, var, NEW_VAR_SW_AGE - 1)
-        for var in Var.thresholds[0]  # type: ignore
+        for var in Var.thresholds()[0]
     },
     # Output manipulation
     **{
@@ -165,6 +167,10 @@ COMMANDS = {
         f"A{output + 1:d}TA123": (PckGenerator.toggle_output, output, 123)
         for output in range(4)
     },
+    **{
+        f"A{output + 1:d}MT123": (PckGenerator.toggle_output, output, 123, True)
+        for output in range(4)
+    },
     "AU123": (PckGenerator.toggle_all_outputs, 123),
     # Relay state manipulation
     "R80-1U1-U0": (
@@ -301,7 +307,7 @@ COMMANDS = {
     # Variable manipulation
     **{
         f"X2{var.value | 0x40:03d}016225": (PckGenerator.update_status_var, var, 4321)
-        for var in Var.variables  # type: ignore
+        for var in Var.variables()
     },
     "X2030044129": (PckGenerator.var_abs, Var.R1VARSETPOINT, 4201),
     "X2030108129": (PckGenerator.var_abs, Var.R2VARSETPOINT, 4201),
@@ -310,7 +316,7 @@ COMMANDS = {
     "ZS30000": (PckGenerator.var_reset, Var.TVAR, 0x170205),
     **{
         f"Z-{var.value + 1:03d}4090": (PckGenerator.var_reset, var, 0x170206)
-        for var in Var.variables  # type: ignore
+        for var in Var.variables()
     },
     "ZA23423": (PckGenerator.var_rel, Var.TVAR, RelVarRef.CURRENT, 23423, 0x170205),
     "ZS23423": (PckGenerator.var_rel, Var.TVAR, RelVarRef.CURRENT, -23423, 0x170205),
@@ -322,7 +328,7 @@ COMMANDS = {
             -3000,
             0x170206,
         )
-        for var in Var.variables  # type: ignore
+        for var in Var.variables()
         if var != Var.TVAR
     },
     **{
@@ -333,7 +339,7 @@ COMMANDS = {
             -500,
             sw_age,
         )
-        for nvar, var in enumerate(Var.set_points)  # type: ignore
+        for nvar, var in enumerate(Var.set_points())
         for nref, ref in enumerate(RelVarRef)
         for sw_age in (0x170206, 0x170205)
     },
@@ -345,14 +351,14 @@ COMMANDS = {
             500,
             sw_age,
         )
-        for nvar, var in enumerate(Var.set_points)  # type: ignore
+        for nvar, var in enumerate(Var.set_points())
         for nref, ref in enumerate(RelVarRef)
         for sw_age in (0x170206, 0x170205)
     },
     **{
         f"SS{('R', 'E')[nref]}0500SR{r + 1}{i + 1}": (
             PckGenerator.var_rel,
-            Var.thresholds[r][i],  # type: ignore
+            Var.thresholds()[r][i],
             ref,
             -500,
             0x170206,
@@ -364,7 +370,7 @@ COMMANDS = {
     **{
         f"SS{('R', 'E')[nref]}0500AR{r + 1}{i + 1}": (
             PckGenerator.var_rel,
-            Var.thresholds[r][i],  # type: ignore
+            Var.thresholds()[r][i],
             ref,
             500,
             0x170206,
@@ -376,7 +382,7 @@ COMMANDS = {
     **{
         f"SS{('R', 'E')[nref]}0500S{1 << (4 - i):05b}": (
             PckGenerator.var_rel,
-            Var.thresholds[0][i],  # type: ignore
+            Var.thresholds()[0][i],
             ref,
             -500,
             0x170205,
@@ -387,7 +393,7 @@ COMMANDS = {
     **{
         f"SS{('R', 'E')[nref]}0500A{1 << (4 - i):05b}": (
             PckGenerator.var_rel,
-            Var.thresholds[0][i],  # type: ignore
+            Var.thresholds()[0][i],
             ref,
             500,
             0x170205,
@@ -558,6 +564,8 @@ COMMANDS = {
 
 
 @pytest.mark.parametrize("expected, command", COMMANDS.items())
-def test_command_generation_single_mod_noack(expected, command):
+def test_command_generation_single_mod_noack(
+    expected: str, command: tuple[Any, ...]
+) -> None:
     """Test if InputMod parses message correctly."""
     assert expected == command[0](*command[1:])

{pypck-0.8.8 → pypck-0.8.10}/tests/test_connection.py

@@ -16,22 +16,29 @@ from pypck.lcn_addr import LcnAddr
 from pypck.lcn_defs import LcnEvent
 from pypck.module import ModuleConnection
 
+from .conftest import MockPchkConnectionManager
+from .mock_pchk import MockPchkServer
+
 
 @pytest.mark.asyncio
-async def test_close_without_connect(pypck_client):
+async def test_close_without_connect(pypck_client: MockPchkConnectionManager) -> None:
     """Test closing of PchkConnectionManager without connecting."""
     await pypck_client.async_close()
 
 
 @pytest.mark.asyncio
-async def test_authenticate(pchk_server, pypck_client):
+async def test_authenticate(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test authentication procedure."""
     await pypck_client.async_connect()
     assert pypck_client.is_ready()
 
 
 @pytest.mark.asyncio
-async def test_port_error(pchk_server, pypck_client):
+async def test_port_error(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test wrong port."""
     pypck_client.port = 55555
     with pytest.raises(PchkConnectionRefusedError):
@@ -39,7 +46,9 @@ async def test_port_error(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_authentication_error(pchk_server, pypck_client):
+async def test_authentication_error(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test wrong login credentials."""
     pypck_client.password = "wrong_password"
     with pytest.raises(PchkAuthenticationError):
@@ -47,7 +56,9 @@ async def test_authentication_error(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_license_error(pchk_server, pypck_client):
+async def test_license_error(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test license error."""
     pchk_server.set_license_error(True)
 
@@ -56,14 +67,18 @@ async def test_license_error(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_timeout_error(pchk_server, pypck_client):
+async def test_timeout_error(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test timeout when connecting."""
     with pytest.raises(PchkConnectionFailedError):
         await pypck_client.async_connect(timeout=0)
 
 
 @pytest.mark.asyncio
-async def test_lcn_connected(pchk_server, pypck_client):
+async def test_lcn_connected(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test lcn disconnected event."""
     event_callback = Mock()
     pypck_client.register_for_events(event_callback)
@@ -80,7 +95,9 @@ async def test_lcn_connected(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_lcn_disconnected(pchk_server, pypck_client):
+async def test_lcn_disconnected(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test lcn disconnected event."""
     event_callback = Mock()
     pypck_client.register_for_events(event_callback)
@@ -94,7 +111,9 @@ async def test_lcn_disconnected(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_connection_lost(pchk_server, pypck_client):
+async def test_connection_lost(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test pchk server connection close."""
     event_callback = Mock()
     pypck_client.register_for_events(event_callback)
@@ -109,8 +128,11 @@ async def test_connection_lost(pchk_server, pypck_client):
 
 @pytest.mark.asyncio
 async def test_multiple_connections(
-    pchk_server, pypck_client, pchk_server_2, pypck_client_2
-):
+    pchk_server: MockPchkServer,
+    pypck_client: MockPchkConnectionManager,
+    pchk_server_2: MockPchkServer,
+    pypck_client_2: MockPchkConnectionManager,
+) -> None:
     """Test that two independent connections can coexists."""
     await pypck_client_2.async_connect()
 
@@ -128,7 +150,9 @@ async def test_multiple_connections(
 
 
 @pytest.mark.asyncio
-async def test_segment_coupler_search(pchk_server, pypck_client):
+async def test_segment_coupler_search(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test segment coupler search."""
     await pypck_client.async_connect()
     await pypck_client.scan_segment_couplers(3, 0)
@@ -141,7 +165,9 @@ async def test_segment_coupler_search(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_segment_coupler_response(pchk_server, pypck_client):
+async def test_segment_coupler_response(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test segment coupler response."""
     await pypck_client.async_connect()
 
@@ -159,7 +185,9 @@ async def test_segment_coupler_response(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_module_scan(pchk_server, pypck_client):
+async def test_module_scan(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module scan."""
     await pypck_client.async_connect()
     await pypck_client.scan_modules(3, 0)
@@ -170,7 +198,9 @@ async def test_module_scan(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_module_sn_response(pchk_server, pypck_client):
+async def test_module_sn_response(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module scan."""
     await pypck_client.async_connect()
     module = pypck_client.get_address_conn(LcnAddr(0, 7, False))
@@ -187,7 +217,9 @@ async def test_module_sn_response(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_send_command_to_server(pchk_server, pypck_client):
+async def test_send_command_to_server(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test sending a command to the PCHK server."""
     await pypck_client.async_connect()
     message = ">M000007.PIN003"
@@ -196,14 +228,16 @@ async def test_send_command_to_server(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_ping(pchk_server, pypck_client):
+async def test_ping(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test if pings are send."""
     await pypck_client.async_connect()
     assert await pchk_server.received("^ping0")
 
 
 @pytest.mark.asyncio
-async def test_add_address_connections(pypck_client):
+async def test_add_address_connections(pypck_client: MockPchkConnectionManager) -> None:
     """Test if new address connections are added on request."""
     lcn_addr = LcnAddr(0, 10, False)
     assert lcn_addr not in pypck_client.address_conns
@@ -215,7 +249,9 @@ async def test_add_address_connections(pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_add_address_connections_by_message(pchk_server, pypck_client):
+async def test_add_address_connections_by_message(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test if new address connections are added by received message."""
     await pypck_client.async_connect()
     lcn_addr = LcnAddr(0, 10, False)
@@ -229,10 +265,13 @@ async def test_add_address_connections_by_message(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_groups_static_membership_discovery(pchk_server, pypck_client):
+async def test_groups_static_membership_discovery(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module scan."""
     await pypck_client.async_connect()
     module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
+    assert isinstance(module, ModuleConnection)
 
     task = asyncio.create_task(module.request_static_groups())
     assert await pchk_server.received(">M000010.GP")
@@ -245,10 +284,13 @@ async def test_groups_static_membership_discovery(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_groups_dynamic_membership_discovery(pchk_server, pypck_client):
+async def test_groups_dynamic_membership_discovery(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module scan."""
     await pypck_client.async_connect()
     module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
+    assert isinstance(module, ModuleConnection)
 
     task = asyncio.create_task(module.request_dynamic_groups())
     assert await pchk_server.received(">M000010.GD")
@@ -261,10 +303,13 @@ async def test_groups_dynamic_membership_discovery(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_groups_membership_discovery(pchk_server, pypck_client):
+async def test_groups_membership_discovery(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module scan."""
     await pypck_client.async_connect()
     module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
+    assert isinstance(module, ModuleConnection)
 
     task = asyncio.create_task(module.request_groups())
     assert await pchk_server.received(">M000010.GP")
@@ -282,7 +327,9 @@ async def test_groups_membership_discovery(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_multiple_serial_requests(pchk_server, pypck_client):
+async def test_multiple_serial_requests(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module scan."""
     await pypck_client.async_connect()
 
@@ -302,7 +349,9 @@ async def test_multiple_serial_requests(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_dump_modules_no_segement_couplers(pchk_server, pypck_client):
+async def test_dump_modules_no_segement_couplers(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module information dumping."""
     await pypck_client.async_connect()
 
@@ -359,7 +408,9 @@ async def test_dump_modules_no_segement_couplers(pchk_server, pypck_client):
 
 
 @pytest.mark.asyncio
-async def test_dump_modules_multi_segment(pchk_server, pypck_client):
+async def test_dump_modules_multi_segment(
+    pchk_server: MockPchkServer, pypck_client: MockPchkConnectionManager
+) -> None:
     """Test module information dumping."""
     await pypck_client.async_connect()
 

{pypck-0.8.8 → pypck-0.8.10}/tests/test_dyn_text.py

@@ -3,9 +3,12 @@
 from unittest.mock import patch
 
 import pytest
+
 from pypck.lcn_addr import LcnAddr
 from pypck.module import ModuleConnection
 
+from .conftest import MockPchkConnectionManager
+
 TEST_VECTORS = {
     # empty
     "": (b"", b"", b"", b"", b""),
@@ -57,8 +60,12 @@ TEST_VECTORS = {
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize("text, parts", TEST_VECTORS.items())
-async def test_dyn_text(pypck_client, text, parts):
-    """dyn_text."""
+async def test_dyn_text(
+    pypck_client: MockPchkConnectionManager,
+    text: str,
+    parts: tuple[bytes, bytes, bytes, bytes, bytes],
+) -> None:
+    """Tests for dynamic text."""
     # await pypck_client.async_connect()
     module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
 
@@ -70,4 +77,4 @@ async def test_dyn_text(pypck_client, text, parts):
     _, commands = zip(*await_args)
 
     for i, part in enumerate(parts):
-        assert f"GTDT4{i+1:d}".encode() + part in commands
+        assert f"GTDT4{i + 1:d}".encode() + part in commands

{pypck-0.8.8 → pypck-0.8.10}/tests/test_messages.py

@@ -1,5 +1,7 @@
 """Tests for input message parsing for bus messages."""
 
+from typing import Any
+
 import pytest
 
 from pypck.inputs import (
@@ -348,7 +350,10 @@ MESSAGES = {
 
 
 @pytest.mark.parametrize("message, expected", MESSAGES.items())
-def test_message_parsing_mod_inputs(message, expected):
+def test_message_parsing_mod_inputs(
+    message: str,
+    expected: list[tuple[Any, ...]],
+) -> None:
     """Test if InputMod parses message correctly."""
     inputs = InputParser.parse(message)
     assert len(inputs) == len(expected)

{pypck-0.8.8 → pypck-0.8.10}/tests/test_vars.py

@@ -1,7 +1,9 @@
 """Tests for variable value and unit handling."""
 
 import math
+
 import pytest
+
 from pypck.lcn_defs import VarUnit, VarValue
 
 VARIABLE_TEST_VALUES = (
@@ -108,7 +110,7 @@ CALIBRATION_TEST_VECTORS = (
 
 
 @pytest.mark.parametrize("unit, native, expected", ROUNDTRIP_TEST_VECTORS)
-def test_roundtrip(unit, native, expected):
+def test_roundtrip(unit: VarUnit, native: int, expected: VarValue) -> None:
     """Test that variable conversion roundtrips."""
     assert (
         expected
@@ -119,6 +121,6 @@ def test_roundtrip(unit, native, expected):
 
 
 @pytest.mark.parametrize("unit, native, value", CALIBRATION_TEST_VECTORS)
-def test_calibration(unit, native, value):
+def test_calibration(unit: VarUnit, native: int, value: int | float) -> None:
     """Test proper calibration of variable conversion."""
     assert value == VarValue.to_var_unit(VarValue.from_native(native), unit)

pypck-0.8.8/VERSION

@@ -1 +0,0 @@
-0.8.8