pypck 0.8.9__tar.gz → 0.8.11__tar.gz

{pypck-0.8.9/pypck.egg-info → pypck-0.8.11}/PKG-INFO

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

pypck-0.8.11/VERSION

@@ -0,0 +1 @@
+0.8.11

{pypck-0.8.9 → pypck-0.8.11}/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.9 → pypck-0.8.11}/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.9 → pypck-0.8.11}/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.9 → pypck-0.8.11}/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.9 → pypck-0.8.11/pypck.egg-info}/PKG-INFO

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

{pypck-0.8.9 → pypck-0.8.11}/pypck.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ pypck/lcn_addr.py
 pypck/lcn_defs.py
 pypck/module.py
 pypck/pck_commands.py
+pypck/py.typed
 pypck/request_handlers.py
 pypck/timeout_retry.py
 pypck.egg-info/PKG-INFO
@@ -21,5 +22,6 @@ pypck.egg-info/top_level.txt
 tests/test_commands.py
 tests/test_connection.py
 tests/test_dyn_text.py
+tests/test_input.py
 tests/test_messages.py
 tests/test_vars.py

{pypck-0.8.9 → pypck-0.8.11}/pyproject.toml

@@ -38,6 +38,9 @@ version = {file = "VERSION"}
 [tool.setuptools.packages.find]
 include = ["pypck*"]
 
+[tool.setuptools.package-data]
+mypkg = ["py.typed"]
+
 [tool.black]
 target-version = ["py311", "py312", "py313"]
 

{pypck-0.8.9 → pypck-0.8.11}/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
     **{
@@ -305,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),
@@ -314,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),
@@ -326,7 +328,7 @@ COMMANDS = {
             -3000,
             0x170206,
         )
-        for var in Var.variables  # type: ignore
+        for var in Var.variables()
         if var != Var.TVAR
     },
     **{
@@ -337,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)
     },
@@ -349,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,
@@ -368,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,
@@ -380,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,
@@ -391,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,
@@ -562,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.11/tests/test_connection.py

@@ -0,0 +1,155 @@
+"""Connection tests."""
+
+import asyncio
+from unittest.mock import AsyncMock, Mock, call, patch
+
+import pytest
+
+from pypck import inputs
+from pypck.connection import (
+    PchkAuthenticationError,
+    PchkConnectionFailedError,
+    PchkConnectionManager,
+    PchkConnectionRefusedError,
+    PchkLicenseError,
+)
+from pypck.lcn_defs import LcnEvent
+from pypck.pck_commands import PckGenerator
+
+from .conftest import HOST, PASSWORD, PORT, USERNAME, MockPchkConnectionManager
+
+
+async def test_close_without_connect(pypck_client: MockPchkConnectionManager) -> None:
+    """Test closing of PchkConnectionManager without connecting."""
+    await pypck_client.async_close()
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+@patch.object(PchkConnectionManager, "scan_segment_couplers")
+async def test_async_connect(
+    mock_scan_segment_couplers: AsyncMock,
+    mock_open_connection: AsyncMock,
+) -> None:
+    """Test successful connection."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+
+    pypck_client.license_error_future.set_result(True)
+    pypck_client.authentication_completed_future.set_result(True)
+    pypck_client.segment_scan_completed_event.set()
+
+    await connect_task
+
+    mock_scan_segment_couplers.assert_awaited()
+    mock_open_connection.assert_awaited()
+    assert pypck_client.is_ready()
+
+
+@patch.object(PchkConnectionManager, "ping")
+@patch.object(PchkConnectionManager, "open_connection")
+@patch.object(PchkConnectionManager, "scan_segment_couplers")
+@patch.object(PchkConnectionManager, "send_command")
+async def test_successful_connection_procedure(
+    mock_send_command: AsyncMock,
+    mock_scan_segment_couplers: AsyncMock,
+    mock_open_connection: AsyncMock,
+    mock_ping: AsyncMock,
+) -> None:
+    """Test successful connection procedure."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+
+    await pypck_client.async_process_input(inputs.AuthUsername())
+    mock_send_command.assert_awaited_with(USERNAME, to_host=True)
+
+    await pypck_client.async_process_input(inputs.AuthPassword())
+    mock_send_command.assert_awaited_with(PASSWORD, to_host=True)
+
+    await pypck_client.async_process_input(inputs.AuthOk())
+    mock_send_command.assert_awaited_with(PckGenerator.set_dec_mode(), to_host=True)
+    assert pypck_client.authentication_completed_future.result()
+
+    await pypck_client.async_process_input(inputs.DecModeSet())
+    mock_send_command.assert_awaited_with(
+        PckGenerator.set_operation_mode(
+            pypck_client.dim_mode, pypck_client.status_mode
+        ),
+        to_host=True,
+    )
+    assert pypck_client.license_error_future.result()
+
+    await connect_task
+
+    mock_open_connection.assert_awaited()
+    mock_scan_segment_couplers.assert_awaited()
+    mock_ping.assert_awaited()
+
+
+@pytest.mark.parametrize("side_effect", [ConnectionRefusedError, OSError])
+async def test_connection_error(side_effect: ConnectionRefusedError | OSError) -> None:
+    """Test connection error."""
+    with (
+        patch.object(PchkConnectionManager, "open_connection", side_effect=side_effect),
+        pytest.raises(PchkConnectionRefusedError),
+    ):
+        pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+        await pypck_client.async_connect()
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+async def test_authentication_error(mock_open_connection: AsyncMock) -> None:
+    """Test wrong login credentials."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+    await pypck_client.async_process_input(inputs.AuthFailed())
+
+    with (
+        pytest.raises(PchkAuthenticationError),
+    ):
+        await connect_task
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+async def test_license_error(mock_open_connection: AsyncMock) -> None:
+    """Test wrong login credentials."""
+    pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+    connect_task = asyncio.create_task(pypck_client.async_connect())
+    await asyncio.sleep(0)
+    await pypck_client.async_process_input(inputs.LicenseError())
+
+    with (
+        pytest.raises(PchkLicenseError),
+    ):
+        await connect_task
+
+
+@patch.object(PchkConnectionManager, "open_connection")
+async def test_timeout_error(mock_open_connection: AsyncMock) -> None:
+    """Test timeout when connecting."""
+    with pytest.raises(PchkConnectionFailedError):
+        pypck_client = PchkConnectionManager(HOST, PORT, USERNAME, PASSWORD)
+        await pypck_client.async_connect(timeout=0)
+
+
+async def test_lcn_connected(pypck_client: MockPchkConnectionManager) -> None:
+    """Test lcn connected events."""
+    event_callback = Mock()
+    pypck_client.register_for_events(event_callback)
+    await pypck_client.async_connect()
+
+    # bus disconnected
+    await pypck_client.async_process_input(inputs.LcnConnState(is_lcn_connected=False))
+    assert not pypck_client.is_lcn_connected
+    event_callback.assert_has_calls(
+        (call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED), call(LcnEvent.BUS_DISCONNECTED))
+    )
+
+    # bus connected
+    await pypck_client.async_process_input(inputs.LcnConnState(is_lcn_connected=True))
+    assert pypck_client.is_lcn_connected
+    event_callback.assert_has_calls(
+        (call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED), call(LcnEvent.BUS_CONNECTED))
+    )

{pypck-0.8.9 → pypck-0.8.11}/tests/test_dyn_text.py

@@ -1,10 +1,10 @@
 """Module connection tests."""
 
-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
@@ -55,19 +55,20 @@ TEST_VECTORS = {
 }
 
 
-@pytest.mark.asyncio
 @pytest.mark.parametrize("text, parts", TEST_VECTORS.items())
-async def test_dyn_text(pypck_client, text, parts):
-    """dyn_text."""
-    # await pypck_client.async_connect()
+async def test_dyn_text(
+    pypck_client: MockPchkConnectionManager,
+    text: str,
+    parts: tuple[bytes, bytes, bytes, bytes, bytes],
+) -> None:
+    """Tests for dynamic text."""
     module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
 
-    with patch.object(ModuleConnection, "send_command") as send_command:
-        await module.dyn_text(3, text)
+    await module.dyn_text(3, text)
 
-    send_command.assert_awaited()
-    await_args = (call.args for call in send_command.await_args_list)
+    module.send_command.assert_awaited()  # type: ignore[attr-defined]
+    await_args = (call.args for call in module.send_command.await_args_list)  # type: ignore[attr-defined]
     _, 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.11/tests/test_input.py

@@ -0,0 +1,46 @@
+"""Test the data flow for Input objects."""
+
+from unittest.mock import patch
+
+from pypck.inputs import Input, ModInput
+from pypck.lcn_addr import LcnAddr
+from pypck.module import ModuleConnection
+
+from .conftest import MockPchkConnectionManager
+
+
+async def test_message_to_input(pypck_client: MockPchkConnectionManager) -> None:
+    """Test data flow from message to input."""
+    inp = Input()
+    message = "dummy_message"
+    with patch.object(
+        pypck_client, "async_process_input"
+    ) as pypck_client_process_input:
+        with patch("pypck.inputs.InputParser.parse", return_value=[inp]) as inp_parse:
+            await pypck_client.process_message(message)
+
+        inp_parse.assert_called_with(message)
+        pypck_client_process_input.assert_awaited_with(inp)
+
+
+async def test_physical_to_logical_segment_id(
+    pypck_client: MockPchkConnectionManager,
+) -> None:
+    """Test conversion from logical to physical segment id."""
+    pypck_client.local_seg_id = 20
+    module = pypck_client.get_address_conn(LcnAddr(20, 7, False))
+    assert isinstance(module, ModuleConnection)
+    with (
+        patch("tests.conftest.MockPchkConnectionManager.is_ready", return_value=True),
+        patch.object(module, "async_process_input") as module_process_input,
+    ):
+        inp = ModInput(LcnAddr(20, 7, False))
+        await pypck_client.async_process_input(inp)
+
+        inp = ModInput(LcnAddr(0, 7, False))
+        await pypck_client.async_process_input(inp)
+
+        inp = ModInput(LcnAddr(4, 7, False))
+        await pypck_client.async_process_input(inp)
+
+        assert module_process_input.await_count == 3

{pypck-0.8.9 → pypck-0.8.11}/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.9 → pypck-0.8.11}/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.9/VERSION

@@ -1 +0,0 @@
-0.8.9

pypck-0.8.9/tests/test_connection.py

@@ -1,420 +0,0 @@
-"""Connection tests."""
-
-import asyncio
-import json
-from unittest.mock import Mock, call
-
-import pytest
-
-from pypck.connection import (
-    PchkAuthenticationError,
-    PchkConnectionFailedError,
-    PchkConnectionRefusedError,
-    PchkLicenseError,
-)
-from pypck.lcn_addr import LcnAddr
-from pypck.lcn_defs import LcnEvent
-from pypck.module import ModuleConnection
-
-
-@pytest.mark.asyncio
-async def test_close_without_connect(pypck_client):
-    """Test closing of PchkConnectionManager without connecting."""
-    await pypck_client.async_close()
-
-
-@pytest.mark.asyncio
-async def test_authenticate(pchk_server, pypck_client):
-    """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):
-    """Test wrong port."""
-    pypck_client.port = 55555
-    with pytest.raises(PchkConnectionRefusedError):
-        await pypck_client.async_connect()
-
-
-@pytest.mark.asyncio
-async def test_authentication_error(pchk_server, pypck_client):
-    """Test wrong login credentials."""
-    pypck_client.password = "wrong_password"
-    with pytest.raises(PchkAuthenticationError):
-        await pypck_client.async_connect()
-
-
-@pytest.mark.asyncio
-async def test_license_error(pchk_server, pypck_client):
-    """Test license error."""
-    pchk_server.set_license_error(True)
-
-    with pytest.raises(PchkLicenseError):
-        await pypck_client.async_connect()
-
-
-@pytest.mark.asyncio
-async def test_timeout_error(pchk_server, pypck_client):
-    """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):
-    """Test lcn disconnected event."""
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-    await pchk_server.send_message("$io:#LCN:connected")
-    await pypck_client.received("$io:#LCN:connected")
-
-    event_callback.assert_has_calls(
-        [
-            call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED),
-            call(LcnEvent.BUS_CONNECTED),
-        ]
-    )
-
-
-@pytest.mark.asyncio
-async def test_lcn_disconnected(pchk_server, pypck_client):
-    """Test lcn disconnected event."""
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-    await pchk_server.send_message("$io:#LCN:disconnected")
-    await pypck_client.received("$io:#LCN:disconnected")
-
-    event_callback.assert_has_calls(
-        [call(LcnEvent.BUS_CONNECTION_STATUS_CHANGED), call(LcnEvent.BUS_DISCONNECTED)]
-    )
-
-
-@pytest.mark.asyncio
-async def test_connection_lost(pchk_server, pypck_client):
-    """Test pchk server connection close."""
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-
-    await pchk_server.stop()
-    # ensure that pypck_client is about to be closed
-    await pypck_client.wait_closed()
-
-    event_callback.assert_has_calls([call(LcnEvent.CONNECTION_LOST)])
-
-
-@pytest.mark.asyncio
-async def test_multiple_connections(
-    pchk_server, pypck_client, pchk_server_2, pypck_client_2
-):
-    """Test that two independent connections can coexists."""
-    await pypck_client_2.async_connect()
-
-    event_callback = Mock()
-    pypck_client.register_for_events(event_callback)
-    await pypck_client.async_connect()
-
-    await pchk_server.stop()
-    await pypck_client.wait_closed()
-
-    event_callback.assert_has_calls([call(LcnEvent.CONNECTION_LOST)])
-
-    assert len(pypck_client.task_registry.tasks) == 0
-    assert len(pypck_client_2.task_registry.tasks) > 0
-
-
-@pytest.mark.asyncio
-async def test_segment_coupler_search(pchk_server, pypck_client):
-    """Test segment coupler search."""
-    await pypck_client.async_connect()
-    await pypck_client.scan_segment_couplers(3, 0)
-
-    assert await pchk_server.received(">G003003.SK")
-    assert await pchk_server.received(">G003003.SK")
-    assert await pchk_server.received(">G003003.SK")
-
-    assert pypck_client.is_ready()
-
-
-@pytest.mark.asyncio
-async def test_segment_coupler_response(pchk_server, pypck_client):
-    """Test segment coupler response."""
-    await pypck_client.async_connect()
-
-    assert pypck_client.local_seg_id == 0
-
-    await pchk_server.send_message("=M000005.SK020")
-    await pchk_server.send_message("=M021021.SK021")
-    await pchk_server.send_message("=M022010.SK022")
-    assert await pypck_client.received("=M000005.SK020")
-    assert await pypck_client.received("=M021021.SK021")
-    assert await pypck_client.received("=M022010.SK022")
-
-    assert pypck_client.local_seg_id == 20
-    assert set(pypck_client.segment_coupler_ids) == {20, 21, 22}
-
-
-@pytest.mark.asyncio
-async def test_module_scan(pchk_server, pypck_client):
-    """Test module scan."""
-    await pypck_client.async_connect()
-    await pypck_client.scan_modules(3, 0)
-
-    assert await pchk_server.received(">G000003!LEER")
-    assert await pchk_server.received(">G000003!LEER")
-    assert await pchk_server.received(">G000003!LEER")
-
-
-@pytest.mark.asyncio
-async def test_module_sn_response(pchk_server, pypck_client):
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 7, False))
-
-    message = "=M000007.SN1AB20A123401FW190B11HW015"
-    await pchk_server.send_message(message)
-    assert await pypck_client.received(message)
-
-    assert await module.serial_known
-    assert module.hardware_serial == 0x1AB20A1234
-    assert module.manu == 1
-    assert module.software_serial == 0x190B11
-    assert module.hardware_type.value == 15
-
-
-@pytest.mark.asyncio
-async def test_send_command_to_server(pchk_server, pypck_client):
-    """Test sending a command to the PCHK server."""
-    await pypck_client.async_connect()
-    message = ">M000007.PIN003"
-    await pypck_client.send_command(message)
-    assert await pchk_server.received(message)
-
-
-@pytest.mark.asyncio
-async def test_ping(pchk_server, pypck_client):
-    """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):
-    """Test if new address connections are added on request."""
-    lcn_addr = LcnAddr(0, 10, False)
-    assert lcn_addr not in pypck_client.address_conns
-
-    addr_conn = pypck_client.get_address_conn(lcn_addr)
-    assert isinstance(addr_conn, ModuleConnection)
-
-    assert lcn_addr in pypck_client.address_conns
-
-
-@pytest.mark.asyncio
-async def test_add_address_connections_by_message(pchk_server, pypck_client):
-    """Test if new address connections are added by received message."""
-    await pypck_client.async_connect()
-    lcn_addr = LcnAddr(0, 10, False)
-    assert lcn_addr not in pypck_client.address_conns
-
-    message = ":M000010A1050"
-    await pchk_server.send_message(message)
-    assert await pypck_client.received(message)
-
-    assert lcn_addr in pypck_client.address_conns
-
-
-@pytest.mark.asyncio
-async def test_groups_static_membership_discovery(pchk_server, pypck_client):
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
-
-    task = asyncio.create_task(module.request_static_groups())
-    assert await pchk_server.received(">M000010.GP")
-    await pchk_server.send_message("=M000010.GP012011200051")
-    assert await task == {
-        LcnAddr(0, 11, True),
-        LcnAddr(0, 200, True),
-        LcnAddr(0, 51, True),
-    }
-
-
-@pytest.mark.asyncio
-async def test_groups_dynamic_membership_discovery(pchk_server, pypck_client):
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
-
-    task = asyncio.create_task(module.request_dynamic_groups())
-    assert await pchk_server.received(">M000010.GD")
-    await pchk_server.send_message("=M000010.GD008011200051")
-    assert await task == {
-        LcnAddr(0, 11, True),
-        LcnAddr(0, 200, True),
-        LcnAddr(0, 51, True),
-    }
-
-
-@pytest.mark.asyncio
-async def test_groups_membership_discovery(pchk_server, pypck_client):
-    """Test module scan."""
-    await pypck_client.async_connect()
-    module = pypck_client.get_address_conn(LcnAddr(0, 10, False))
-
-    task = asyncio.create_task(module.request_groups())
-    assert await pchk_server.received(">M000010.GP")
-    await pchk_server.send_message("=M000010.GP012011200051")
-    assert await pchk_server.received(">M000010.GD")
-    await pchk_server.send_message("=M000010.GD008015100052")
-    assert await task == {
-        LcnAddr(0, 11, True),
-        LcnAddr(0, 200, True),
-        LcnAddr(0, 51, True),
-        LcnAddr(0, 15, True),
-        LcnAddr(0, 100, True),
-        LcnAddr(0, 52, True),
-    }
-
-
-@pytest.mark.asyncio
-async def test_multiple_serial_requests(pchk_server, pypck_client):
-    """Test module scan."""
-    await pypck_client.async_connect()
-
-    pypck_client.get_address_conn(LcnAddr(0, 10, False))
-    pypck_client.get_address_conn(LcnAddr(0, 11, False))
-    pypck_client.get_address_conn(LcnAddr(0, 12, False))
-
-    assert await pchk_server.received(">M000010.SN")
-    assert await pchk_server.received(">M000011.SN")
-    assert await pchk_server.received(">M000012.SN")
-
-    message = "=M000010.SN1AB20A123401FW190B11HW015"
-    await pchk_server.send_message(message)
-    assert await pypck_client.received(message)
-
-    await pypck_client.async_close()
-
-
-@pytest.mark.asyncio
-async def test_dump_modules_no_segement_couplers(pchk_server, pypck_client):
-    """Test module information dumping."""
-    await pypck_client.async_connect()
-
-    for msg in (
-        "=M000007.SN1AB20A123401FW190B11HW015",
-        "=M000008.SN1BB20A123401FW1A0B11HW015",
-        "=M000007.GP012011200051",
-        "=M000008.GP012011220051",
-        "=M000007.GD008015100052",
-        "=M000008.GD008015120052",
-    ):
-        await pchk_server.send_message(msg)
-        assert await pypck_client.received(msg)
-
-    dump = pypck_client.dump_modules()
-    json.dumps(dump)
-
-    assert dump == {
-        "0": {
-            "7": {
-                "segment": 0,
-                "address": 7,
-                "is_local_segment": True,
-                "serials": {
-                    "hardware_serial": "1AB20A1234",
-                    "manu": "01",
-                    "software_serial": "190B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 200], "dynamic": [15, 52, 100]},
-            },
-            "8": {
-                "segment": 0,
-                "address": 8,
-                "is_local_segment": True,
-                "serials": {
-                    "hardware_serial": "1BB20A1234",
-                    "manu": "01",
-                    "software_serial": "1A0B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 220], "dynamic": [15, 52, 120]},
-            },
-        }
-    }
-
-
-@pytest.mark.asyncio
-async def test_dump_modules_multi_segment(pchk_server, pypck_client):
-    """Test module information dumping."""
-    await pypck_client.async_connect()
-
-    # Populate the bus topology information
-    for msg in (
-        "=M000007.SK020",
-        "=M022008.SK022",
-        "=M000007.SN1AB20A123401FW190B11HW015",
-        "=M022008.SN1BB20A123401FW1A0B11HW015",
-        "=M000007.GP012011200051",
-        "=M022008.GP012011220051",
-        "=M000007.GD008015100052",
-        "=M022008.GD008015120052",
-    ):
-        await pchk_server.send_message(msg)
-        assert await pypck_client.received(msg)
-
-    dump = pypck_client.dump_modules()
-    json.dumps(dump)
-
-    assert dump == {
-        "20": {
-            "7": {
-                "segment": 20,
-                "address": 7,
-                "is_local_segment": True,
-                "serials": {
-                    "hardware_serial": "1AB20A1234",
-                    "manu": "01",
-                    "software_serial": "190B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 200], "dynamic": [15, 52, 100]},
-            },
-        },
-        "22": {
-            "8": {
-                "segment": 22,
-                "address": 8,
-                "is_local_segment": False,
-                "serials": {
-                    "hardware_serial": "1BB20A1234",
-                    "manu": "01",
-                    "software_serial": "1A0B11",
-                    "hardware_type": "15",
-                    "hardware_name": "LCN-SH-Plus",
-                },
-                "name": "",
-                "comment": "",
-                "oem_text": ["", "", "", ""],
-                "groups": {"static": [11, 51, 220], "dynamic": [15, 52, 120]},
-            },
-        },
-    }