conson-xp 1.36.0__py3-none-any.whl → 1.38.0__py3-none-any.whl

xp/cli/commands/conbus/conbus_output_commands.py

@@ -121,6 +121,7 @@ def xp_output_status(ctx: click.Context, serial_number: str) -> None:
             response: Datapoint response object.
         """
         click.echo(json.dumps(response.to_dict(), indent=2))
+        service.stop_reactor()
 
     with service:
         service.on_finish.connect(on_finish)
@@ -128,6 +129,7 @@ def xp_output_status(ctx: click.Context, serial_number: str) -> None:
             serial_number=serial_number,
             datapoint_type=DataPointType.MODULE_OUTPUT_STATE,
         )
+        service.start_reactor()
 
 
 @conbus_output.command("state")
@@ -156,6 +158,7 @@ def xp_module_state(ctx: click.Context, serial_number: str) -> None:
             response: Datapoint response object.
         """
         click.echo(json.dumps(response.to_dict(), indent=2))
+        service.stop_reactor()
 
     with service:
         service.on_finish.connect(on_finish)
@@ -163,3 +166,4 @@ def xp_module_state(ctx: click.Context, serial_number: str) -> None:
             serial_number=serial_number,
             datapoint_type=DataPointType.MODULE_STATE,
         )
+        service.start_reactor()

xp/models/actiontable/msactiontable.py

@@ -0,0 +1,9 @@
+"""Base class for MS Action Table models."""
+
+from pydantic import BaseModel
+
+
+class MsActionTable(BaseModel):
+    """Base class for all MS Action Table types (XP20, XP24, XP33)."""
+
+    pass

xp/models/actiontable/msactiontable_xp20.py

@@ -1,10 +1,11 @@
 """XP20 Action Table models for input actions and settings."""
 
-from dataclasses import dataclass, field
+from pydantic import BaseModel, Field
 
+from xp.models.actiontable.msactiontable import MsActionTable
 
-@dataclass
-class InputChannel:
+
+class InputChannel(BaseModel):
     """Configuration for a single input channel in XP20 action table.
 
     Attributes:
@@ -19,13 +20,12 @@ class InputChannel:
     invert: bool = False
     short_long: bool = False
     group_on_off: bool = False
-    and_functions: list[bool] = field(default_factory=lambda: [False] * 8)
+    and_functions: list[bool] = Field(default_factory=lambda: [False] * 8)
     sa_function: bool = False
     ta_function: bool = False
 
 
-@dataclass
-class Xp20MsActionTable:
+class Xp20MsActionTable(MsActionTable):
     """XP20 Action Table for managing 8 input channels.
 
     Contains configuration for 8 input channels (input1 through input8),
@@ -43,11 +43,11 @@ class Xp20MsActionTable:
         input8: Configuration for input channel 8.
     """
 
-    input1: InputChannel = field(default_factory=InputChannel)
-    input2: InputChannel = field(default_factory=InputChannel)
-    input3: InputChannel = field(default_factory=InputChannel)
-    input4: InputChannel = field(default_factory=InputChannel)
-    input5: InputChannel = field(default_factory=InputChannel)
-    input6: InputChannel = field(default_factory=InputChannel)
-    input7: InputChannel = field(default_factory=InputChannel)
-    input8: InputChannel = field(default_factory=InputChannel)
+    input1: InputChannel = Field(default_factory=InputChannel)
+    input2: InputChannel = Field(default_factory=InputChannel)
+    input3: InputChannel = Field(default_factory=InputChannel)
+    input4: InputChannel = Field(default_factory=InputChannel)
+    input5: InputChannel = Field(default_factory=InputChannel)
+    input6: InputChannel = Field(default_factory=InputChannel)
+    input7: InputChannel = Field(default_factory=InputChannel)
+    input8: InputChannel = Field(default_factory=InputChannel)

xp/models/actiontable/msactiontable_xp24.py

@@ -1,26 +1,88 @@
 """XP24 Action Table models for input actions and settings."""
 
-from dataclasses import dataclass, field
+from typing import Any, ClassVar, Union
 
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from xp.models.actiontable.msactiontable import MsActionTable
 from xp.models.telegram.input_action_type import InputActionType
 from xp.models.telegram.timeparam_type import TimeParam
 
 
-@dataclass
-class InputAction:
+class InputAction(BaseModel):
     """Represents an input action with type and parameter.
 
     Attributes:
+        model_config: Pydantic configuration to preserve enum objects.
         type: The input action type.
         param: Time parameter for the action.
     """
 
+    model_config = ConfigDict(use_enum_values=False)
+
     type: InputActionType = InputActionType.TOGGLE
     param: TimeParam = TimeParam.NONE
 
+    @field_validator("type", mode="before")
+    @classmethod
+    def validate_action_type(
+        cls, v: Union[str, int, InputActionType]
+    ) -> InputActionType:
+        """Convert string or int to InputActionType enum.
+
+        Args:
+            v: Input value (can be string name, int value, or enum).
+
+        Returns:
+            InputActionType enum value.
+
+        Raises:
+            ValueError: If the value cannot be converted to InputActionType.
+        """
+        if isinstance(v, InputActionType):
+            return v
+        if isinstance(v, str):
+            try:
+                return InputActionType[v]
+            except KeyError:
+                raise ValueError(f"Invalid InputActionType: {v}")
+        if isinstance(v, int):
+            try:
+                return InputActionType(v)
+            except ValueError:
+                raise ValueError(f"Invalid InputActionType value: {v}")
+        raise ValueError(f"Invalid type for InputActionType: {type(v)}")
+
+    @field_validator("param", mode="before")
+    @classmethod
+    def validate_time_param(cls, v: Union[str, int, TimeParam]) -> TimeParam:
+        """Convert string or int to TimeParam enum.
+
+        Args:
+            v: Input value (can be string name, int value, or enum).
+
+        Returns:
+            TimeParam enum value.
+
+        Raises:
+            ValueError: If the value cannot be converted to TimeParam.
+        """
+        if isinstance(v, TimeParam):
+            return v
+        if isinstance(v, str):
+            try:
+                return TimeParam[v]
+            except KeyError:
+                raise ValueError(f"Invalid TimeParam: {v}")
+        if isinstance(v, int):
+            try:
+                return TimeParam(v)
+            except ValueError:
+                raise ValueError(f"Invalid TimeParam value: {v}")
+        raise ValueError(f"Invalid type for TimeParam: {type(v)}")
 
-@dataclass
-class Xp24MsActionTable:
+
+class Xp24MsActionTable(MsActionTable):
     """XP24 Action Table for managing input actions and settings.
 
     Each input has an action type (TOGGLE, ON, LEVELSET, etc.)
@@ -29,6 +91,8 @@ class Xp24MsActionTable:
     Attributes:
         MS300: Timing constant for 300ms.
         MS500: Timing constant for 500ms.
+        ACTION_SHORT_CODES: Mapping from InputActionType to short code strings.
+        SHORT_CODE_TO_ACTION: Reverse mapping from short codes to InputActionType.
         input1_action: Action configuration for input 1.
         input2_action: Action configuration for input 2.
         input3_action: Action configuration for input 3.
@@ -41,14 +105,52 @@ class Xp24MsActionTable:
     """
 
     # MS timing constants
-    MS300 = 12
-    MS500 = 20
+    MS300: ClassVar[int] = 12
+    MS500: ClassVar[int] = 20
+
+    # Short format mapping for InputActionType
+    ACTION_SHORT_CODES: ClassVar[dict[InputActionType, str]] = {
+        InputActionType.VOID: "V",
+        InputActionType.ON: "ON",
+        InputActionType.OFF: "OF",
+        InputActionType.TOGGLE: "T",
+        InputActionType.BLOCK: "BL",
+        InputActionType.AUXRELAY: "AX",
+        InputActionType.MUTUALEX: "MX",
+        InputActionType.LEVELUP: "LU",
+        InputActionType.LEVELDOWN: "LD",
+        InputActionType.LEVELINC: "LI",
+        InputActionType.LEVELDEC: "LC",
+        InputActionType.LEVELSET: "LS",
+        InputActionType.FADETIME: "FT",
+        InputActionType.SCENESET: "SS",
+        InputActionType.SCENENEXT: "SN",
+        InputActionType.SCENEPREV: "SP",
+        InputActionType.CTRLMETHOD: "CM",
+        InputActionType.RETURNDATA: "RD",
+        InputActionType.DELAYEDON: "DO",
+        InputActionType.EVENTTIMER1: "E1",
+        InputActionType.EVENTTIMER2: "E2",
+        InputActionType.EVENTTIMER3: "E3",
+        InputActionType.EVENTTIMER4: "E4",
+        InputActionType.STEPCTRL: "SC",
+        InputActionType.STEPCTRLUP: "SU",
+        InputActionType.STEPCTRLDOWN: "SD",
+        InputActionType.LEVELSETINTERN: "LN",
+        InputActionType.FADE: "FD",
+        InputActionType.LEARN: "LR",
+    }
+
+    # Reverse mapping for parsing
+    SHORT_CODE_TO_ACTION: ClassVar[dict[str, InputActionType]] = {
+        v: k for k, v in ACTION_SHORT_CODES.items()
+    }
 
     # Input actions for each input (default to TOGGLE with None parameter)
-    input1_action: InputAction = field(default_factory=InputAction)
-    input2_action: InputAction = field(default_factory=InputAction)
-    input3_action: InputAction = field(default_factory=InputAction)
-    input4_action: InputAction = field(default_factory=InputAction)
+    input1_action: InputAction = Field(default_factory=InputAction)
+    input2_action: InputAction = Field(default_factory=InputAction)
+    input3_action: InputAction = Field(default_factory=InputAction)
+    input4_action: InputAction = Field(default_factory=InputAction)
 
     # Boolean settings
     mutex12: bool = False  # Mutual exclusion between inputs 1-2
@@ -56,3 +158,118 @@ class Xp24MsActionTable:
     curtain12: bool = False  # Curtain setting for inputs 1-2
     curtain34: bool = False  # Curtain setting for inputs 3-4
     mutual_deadtime: int = MS300  # Master timing (MS300=12 or MS500=20)
+
+    def to_short_format(self, include_settings: bool = False) -> str:
+        """Convert action table to short format string.
+
+        Args:
+            include_settings: Include settings after pipe separator.
+
+        Returns:
+            Short format string (e.g., "XP24 T:1 T:2 T:0 T:0").
+        """
+        # Format input actions
+        actions = [
+            self.input1_action,
+            self.input2_action,
+            self.input3_action,
+            self.input4_action,
+        ]
+
+        action_parts = []
+        for action in actions:
+            short_code = self.ACTION_SHORT_CODES.get(action.type, "??")
+            param_value = action.param.value
+            action_parts.append(f"{short_code}:{param_value}")
+
+        result = f"XP24 {' '.join(action_parts)}"
+
+        # Add settings if requested
+        if include_settings:
+            settings = (
+                f"M12:{1 if self.mutex12 else 0} "
+                f"M34:{1 if self.mutex34 else 0} "
+                f"C12:{1 if self.curtain12 else 0} "
+                f"C34:{1 if self.curtain34 else 0} "
+                f"DT:{self.mutual_deadtime}"
+            )
+            result = f"{result} | {settings}"
+
+        return result
+
+    @classmethod
+    def from_short_format(cls, short_str: str) -> "Xp24MsActionTable":
+        """Parse short format string into action table.
+
+        Args:
+            short_str: Short format string.
+
+        Returns:
+            Xp24MsActionTable instance.
+
+        Raises:
+            ValueError: If format is invalid.
+        """
+        # Split by pipe to separate actions from settings
+        parts = short_str.split("|")
+        action_part = parts[0].strip()
+        settings_part = parts[1].strip() if len(parts) > 1 else None
+
+        # Parse action part
+        tokens = action_part.split()
+        if len(tokens) != 5 or tokens[0] != "XP24":
+            raise ValueError(
+                f"Invalid short format: expected 'XP24 <a1> <a2> <a3> <a4>', got '{action_part}'"
+            )
+
+        # Parse input actions
+        input_actions = []
+        for i, token in enumerate(tokens[1:5], 1):
+            if ":" not in token:
+                raise ValueError(f"Invalid action format at position {i}: '{token}'")
+
+            code, param_str = token.split(":", 1)
+
+            # Look up action type
+            if code not in cls.SHORT_CODE_TO_ACTION:
+                raise ValueError(f"Unknown action code: '{code}'")
+
+            action_type = cls.SHORT_CODE_TO_ACTION[code]
+
+            # Parse param
+            try:
+                param_value = int(param_str)
+                param_type = TimeParam(param_value)
+            except (ValueError, KeyError):
+                raise ValueError(f"Invalid time param: '{param_str}'")
+
+            input_actions.append(InputAction(type=action_type, param=param_type))
+
+        # Parse settings if present
+        kwargs: dict[str, Any] = {
+            "input1_action": input_actions[0],
+            "input2_action": input_actions[1],
+            "input3_action": input_actions[2],
+            "input4_action": input_actions[3],
+        }
+
+        if settings_part:
+            # Parse settings: M12:0 M34:1 C12:0 C34:1 DT:12
+            for setting in settings_part.split():
+                if ":" not in setting:
+                    continue
+
+                key, value = setting.split(":", 1)
+
+                if key == "M12":
+                    kwargs["mutex12"] = value == "1"
+                elif key == "M34":
+                    kwargs["mutex34"] = value == "1"
+                elif key == "C12":
+                    kwargs["curtain12"] = value == "1"
+                elif key == "C34":
+                    kwargs["curtain34"] = value == "1"
+                elif key == "DT":
+                    kwargs["mutual_deadtime"] = int(value)
+
+        return cls(**kwargs)

xp/models/actiontable/msactiontable_xp33.py

@@ -1,12 +1,14 @@
 """XP33 Action Table models for output and scene configuration."""
 
-from dataclasses import dataclass, field
+from typing import Union
 
+from pydantic import BaseModel, Field, field_validator
+
+from xp.models.actiontable.msactiontable import MsActionTable
 from xp.models.telegram.timeparam_type import TimeParam
 
 
-@dataclass
-class Xp33Output:
+class Xp33Output(BaseModel):
     """Represents an XP33 output configuration.
 
     Attributes:
@@ -24,8 +26,7 @@ class Xp33Output:
     leading_edge: bool = False
 
 
-@dataclass
-class Xp33Scene:
+class Xp33Scene(BaseModel):
     """Represents a scene configuration.
 
     Attributes:
@@ -40,9 +41,36 @@ class Xp33Scene:
     output3_level: int = 0
     time: TimeParam = TimeParam.NONE
 
+    @field_validator("time", mode="before")
+    @classmethod
+    def validate_time_param(cls, v: Union[str, int, TimeParam]) -> TimeParam:
+        """Convert string or int to TimeParam enum.
+
+        Args:
+            v: Input value (can be string name, int value, or enum).
+
+        Returns:
+            TimeParam enum value.
+
+        Raises:
+            ValueError: If the value cannot be converted to TimeParam.
+        """
+        if isinstance(v, TimeParam):
+            return v
+        if isinstance(v, str):
+            try:
+                return TimeParam[v]
+            except KeyError:
+                raise ValueError(f"Invalid TimeParam: {v}")
+        if isinstance(v, int):
+            try:
+                return TimeParam(v)
+            except ValueError:
+                raise ValueError(f"Invalid TimeParam value: {v}")
+        raise ValueError(f"Invalid type for TimeParam: {type(v)}")
+
 
-@dataclass
-class Xp33MsActionTable:
+class Xp33MsActionTable(MsActionTable):
     """XP33 Action Table for managing outputs and scenes.
 
     Attributes:
@@ -55,11 +83,11 @@ class Xp33MsActionTable:
         scene4: Configuration for scene 4.
     """
 
-    output1: Xp33Output = field(default_factory=Xp33Output)
-    output2: Xp33Output = field(default_factory=Xp33Output)
-    output3: Xp33Output = field(default_factory=Xp33Output)
+    output1: Xp33Output = Field(default_factory=Xp33Output)
+    output2: Xp33Output = Field(default_factory=Xp33Output)
+    output3: Xp33Output = Field(default_factory=Xp33Output)
 
-    scene1: Xp33Scene = field(default_factory=Xp33Scene)
-    scene2: Xp33Scene = field(default_factory=Xp33Scene)
-    scene3: Xp33Scene = field(default_factory=Xp33Scene)
-    scene4: Xp33Scene = field(default_factory=Xp33Scene)
+    scene1: Xp33Scene = Field(default_factory=Xp33Scene)
+    scene2: Xp33Scene = Field(default_factory=Xp33Scene)
+    scene3: Xp33Scene = Field(default_factory=Xp33Scene)
+    scene4: Xp33Scene = Field(default_factory=Xp33Scene)

xp/models/conbus/conbus_export.py

@@ -3,7 +3,7 @@
 from dataclasses import dataclass, field
 from typing import Optional
 
-from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.models.config.conson_module_config import ConsonModuleListConfig
 
 
 @dataclass
@@ -14,8 +14,10 @@ class ConbusExportResponse:
         success: Whether the operation was successful.
         config: Exported module configuration list.
         device_count: Number of devices exported.
+        actiontable_count: Number of action tables downloaded.
+        actiontable_failed: Number of action table downloads that failed.
         output_file: Path to output file.
-        export_status: Export status (OK, FAILED_TIMEOUT, FAILED_NO_DEVICES, etc.).
+        export_status: Export status (OK, PARTIAL_ACTIONTABLE, FAILED_TIMEOUT, etc.).
         error: Error message if operation failed.
         sent_telegrams: List of telegrams sent during export.
         received_telegrams: List of telegrams received during export.
@@ -24,6 +26,8 @@ class ConbusExportResponse:
     success: bool
     config: Optional[ConsonModuleListConfig] = None
     device_count: int = 0
+    actiontable_count: int = 0
+    actiontable_failed: int = 0
     output_file: str = "export.yml"
     export_status: str = "OK"
     error: Optional[str] = None

xp/models/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration models package."""

xp/models/{homekit/homekit_conson_config.py → config/conson_module_config.py}

@@ -23,6 +23,7 @@ class ConsonModuleConfig(BaseModel):
         sw_version: Optional software version.
         hw_version: Optional hardware version.
         action_table: Optional action table configuration.
+        msaction_table: Optional ms action table configuration.
         auto_report_status: Optional auto report status.
     """
 
@@ -37,8 +38,9 @@ class ConsonModuleConfig(BaseModel):
     conbus_port: Optional[int] = None
     sw_version: Optional[str] = None
     hw_version: Optional[str] = None
-    action_table: Optional[List[str]] = None
     auto_report_status: Optional[str] = None
+    action_table: Optional[List[str]] = None
+    msaction_table: Optional[str] = None
 
 
 class ConsonModuleListConfig(BaseModel):

xp/models/protocol/conbus_protocol.py

@@ -7,8 +7,8 @@ from typing import TYPE_CHECKING, Union
 from bubus import BaseEvent
 from pydantic import Field
 
+from xp.models.config.conson_module_config import ConsonModuleConfig
 from xp.models.homekit.homekit_config import HomekitAccessoryConfig
-from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
 from xp.models.telegram.datapoint_type import DataPointType
 
 if TYPE_CHECKING:

xp/models/telegram/datapoint_type.py

@@ -30,6 +30,36 @@ class DataPointType(str, Enum):
         SW_TOP_VERSION: Software top version.
         VOLTAGE: Voltage data point.
         AUTO_REPORT_STATUS: Auto report status.
+
+    Sample telegram datapoint request:
+       <S0020044966F02D30FL>
+
+    Sample telegram datapoint reply:
+       <R0020044966F02D00XP24FH>
+       <R0020044966F02D01XP24FG>
+       <R0020044966F02D02XP24_V0.34.03GI>
+       <R0020044966F02D030020044966FB>
+       <R0020044966F02D0406FL>
+       <R0020044966F02D050007FL>
+       <R0020044966F02D0601FO>
+       <R0020044966F02D0707FJ>
+       <R0020044966F02D08MIFF>
+       <R0020044966F02D09OFFBP>
+       <R0020044966F02D1000FI>
+       <R0020044966F02D11xxxx0000FJ>
+       <R0020044966F02D12xxxx0000FK>
+       <R0020044966F02D1500:000[%],01:000[%],02:000[%],03:000[%]HB>
+       <R0020044966F02D1600:000[H],01:000[H],02:000[H],03:000[H]HC>
+       <R0020044966F02D1700:00000[NA],01:00000[NA],02:00000[NA],03:00000[NA]HD>
+       <R0020044966F02D18+28,5§CIM>
+       <R0020044966F02D19??FB>
+       <R0020044966F02D20??FL>
+       <R0020044966F02D21PPFK>
+       <R0020044966F02D22PLLKMDINEM>
+       <R0020044966F02D23AAFI>
+       <R0020044966F02D24AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFP>
+       <R0020044966F02D25AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFO>
+       <R0020044966F02D26??FN>
     """
 
     MODULE_TYPE = "00"  # Module type (XP24, XP33, ..)

xp/services/actiontable/msactiontable_xp20_serializer.py

@@ -15,6 +15,18 @@ TA_FUNCTION_INDEX: int = 12
 class Xp20MsActionTableSerializer:
     """Handles serialization/deserialization of XP20 action tables to/from telegrams."""
 
+    @staticmethod
+    def format_decoded_output(action_table: Xp20MsActionTable) -> str:
+        """Serialize XP20 action table to humane compact readable format.
+
+        Args:
+            action_table: XP20 action table to serialize
+
+        Returns:
+            Human-readable string describing XP20 action table
+        """
+        return ""
+
     @staticmethod
     def to_data(action_table: Xp20MsActionTable) -> str:
         """Serialize XP20 action table to telegram hex string format.

xp/services/actiontable/msactiontable_xp24_serializer.py

@@ -9,6 +9,18 @@ from xp.utils.serialization import de_nibbles, nibbles
 class Xp24MsActionTableSerializer:
     """Handles serialization/deserialization of XP24 action tables to/from telegrams."""
 
+    @staticmethod
+    def format_decoded_output(action_table: Xp24MsActionTable) -> str:
+        """Serialize XP24 action table to humane compact readable format.
+
+        Args:
+            action_table: XP24 action table to serialize
+
+        Returns:
+            Human-readable string describing XP24 action table
+        """
+        return action_table.to_short_format()
+
     @staticmethod
     def to_data(action_table: Xp24MsActionTable) -> str:
         """Serialize action table to telegram format.
@@ -117,4 +129,4 @@ class Xp24MsActionTableSerializer:
         action_type = InputActionType(function_id)
         param_type = TimeParam(param_id)
 
-        return InputAction(action_type, param_type)
+        return InputAction(type=action_type, param=param_type)

xp/services/actiontable/msactiontable_xp33_serializer.py

@@ -12,6 +12,18 @@ from xp.utils.serialization import bits_to_byte, byte_to_bits, de_nibbles, nibbl
 class Xp33MsActionTableSerializer:
     """Handles serialization/deserialization of XP33 action tables to/from telegrams."""
 
+    @staticmethod
+    def format_decoded_output(action_table: Xp33MsActionTable) -> str:
+        """Serialize XP33 action table to humane compact readable format.
+
+        Args:
+            action_table: XP33 action table to serialize
+
+        Returns:
+            Human-readable string describing XP33 action table
+        """
+        return ""
+
     @staticmethod
     def _percentage_to_byte(percentage: int) -> int:
         """Convert percentage (0-100) to byte value for telegram encoding."""

xp/services/conbus/actiontable/actiontable_download_service.py

@@ -2,10 +2,11 @@
 
 import logging
 from dataclasses import asdict
-from typing import Any, Optional
+from typing import Any, Dict, Optional
 
 from psygnal import Signal
 
+from xp.models.actiontable.actiontable import ActionTable
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType
@@ -14,7 +15,7 @@ from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 from xp.services.telegram.telegram_service import TelegramService
 
 
-class ActionTableService:
+class ActionTableDownloadService:
     """TCP client service for downloading action tables from Conbus modules.
 
     Manages TCP socket connections, handles telegram generation and transmission,
@@ -28,7 +29,9 @@ class ActionTableService:
 
     on_progress: Signal = Signal(str)
     on_error: Signal = Signal(str)
-    on_finish: Signal = Signal(object)  # (ActionTable, Dict[str, Any], list[str])
+    on_finish: Signal = Signal(
+        ActionTable, Dict[str, Any], list[str]
+    )  # (ActionTable, Dict[str, Any], list[str])
 
     def __init__(
         self,
@@ -123,7 +126,7 @@ class ActionTableService:
             actiontable = self.serializer.from_encoded_string(all_data)
             actiontable_dict = asdict(actiontable)
             actiontable_short = self.serializer.format_decoded_output(actiontable)
-            self.on_finish.emit((actiontable, actiontable_dict, actiontable_short))
+            self.on_finish.emit(actiontable, actiontable_dict, actiontable_short)
 
     def timeout(self) -> None:
         """Handle timeout event."""
@@ -172,7 +175,7 @@ class ActionTableService:
         """Stop the reactor."""
         self.conbus_protocol.stop_reactor()
 
-    def __enter__(self) -> "ActionTableService":
+    def __enter__(self) -> "ActionTableDownloadService":
         """Enter context manager - reset state for singleton reuse.
 
         Returns: