conson-xp 1.37.0__py3-none-any.whl → 1.39.0__py3-none-any.whl

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,113 @@ 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) -> str:
+        """Convert action table to short format string.
+
+        Returns:
+            Short format string with settings (e.g., "XP24 T:1 T:2 T:0 T:0 | M12:0 M34:0 C12:0 C34:0 DT:12").
+        """
+        # 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
+        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()
+
+        # 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],
+        }
+
+        # 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/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:

xp/services/conbus/actiontable/actiontable_list_service.py

@@ -59,7 +59,7 @@ class ActionTableListService:
 
         # Load configuration
         try:
-            from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+            from xp.models.config.conson_module_config import ConsonModuleListConfig
 
             config = ConsonModuleListConfig.from_yaml(str(config_path))
         except Exception as e:
@@ -72,6 +72,7 @@ class ActionTableListService:
             {
                 "serial_number": module.serial_number,
                 "module_type": module.module_type,
+                "action_table": len(module.action_table) if module.action_table else 0,
             }
             for module in config.root
         ]

xp/services/conbus/actiontable/actiontable_show_service.py

@@ -4,7 +4,7 @@ import logging
 from pathlib import Path
 from typing import Any, Callable, Optional
 
-from xp.models.homekit.homekit_conson_config import ConsonModuleConfig
+from xp.models.config.conson_module_config import ConsonModuleConfig
 
 
 class ActionTableShowService:
@@ -61,7 +61,7 @@ class ActionTableShowService:
 
         # Load configuration
         try:
-            from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+            from xp.models.config.conson_module_config import ConsonModuleListConfig
 
             config = ConsonModuleListConfig.from_yaml(str(config_path))
         except Exception as e:

xp/services/conbus/actiontable/actiontable_upload_service.py

@@ -5,7 +5,7 @@ from typing import Any, Optional
 
 from psygnal import Signal
 
-from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.models.config.conson_module_config import ConsonModuleListConfig
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
 from xp.models.telegram.system_function import SystemFunction
 from xp.models.telegram.telegram_type import TelegramType

xp/services/conbus/conbus_event_list_service.py

@@ -9,7 +9,7 @@ from collections import defaultdict
 from typing import Dict, List
 
 from xp.models import ConbusEventListResponse
-from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.models.config.conson_module_config import ConsonModuleListConfig
 from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
 
 

xp/services/conbus/conbus_export_service.py

@@ -9,7 +9,7 @@ import yaml
 from psygnal import Signal
 
 from xp.models.conbus.conbus_export import ConbusExportResponse
-from xp.models.homekit.homekit_conson_config import (
+from xp.models.config.conson_module_config import (
     ConsonModuleConfig,
     ConsonModuleListConfig,
 )

xp/services/conbus/msactiontable/__init__.py

@@ -0,0 +1 @@
+"""MsAction table services for Conbus."""

xp/services/conbus/{actiontable/msactiontable_service.py → msactiontable/msactiontable_download_service.py}

@@ -5,6 +5,7 @@ from typing import Any, Optional, Union
 
 from psygnal import Signal
 
+from xp.models.actiontable.msactiontable import MsActionTable
 from xp.models.actiontable.msactiontable_xp20 import Xp20MsActionTable
 from xp.models.actiontable.msactiontable_xp24 import Xp24MsActionTable
 from xp.models.actiontable.msactiontable_xp33 import Xp33MsActionTable
@@ -30,7 +31,7 @@ class MsActionTableError(Exception):
     pass
 
 
-class MsActionTableService:
+class MsActionTableDownloadService:
     """
     Service for downloading MS action tables via Conbus protocol.
 
@@ -46,7 +47,7 @@ class MsActionTableService:
 
     on_progress: Signal = Signal(str)
     on_error: Signal = Signal(str)
-    on_finish: Signal = Signal(object)  # Union type for Xp20/24/33 or None
+    on_finish: Signal = Signal(MsActionTable, str)  # Union type for Xp20/24/33 or None
 
     def __init__(
         self,
@@ -164,7 +165,8 @@ class MsActionTableService:
             all_data = "".join(self.msactiontable_data)
             # Deserialize from received data
             msactiontable = self.serializer.from_data(all_data)
-            self.succeed(msactiontable)
+            msactiontable_short = self.serializer.format_decoded_output(msactiontable)  # type: ignore[arg-type]
+            self.succeed(msactiontable, msactiontable_short)
             return
 
         self.logger.debug("Invalid msactiontable response")
@@ -186,13 +188,15 @@ class MsActionTableService:
     def succeed(
         self,
         msactiontable: Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable],
+        msactiontable_short: str,
     ) -> None:
         """Handle succeed connection event.
 
         Args:
             msactiontable: result.
+            msactiontable_short: result in short form.
         """
-        self.on_finish.emit(msactiontable)
+        self.on_finish.emit(msactiontable, msactiontable_short)
 
     def start(
         self,
@@ -241,7 +245,7 @@ class MsActionTableService:
         """Stop the reactor."""
         self.conbus_protocol.stop_reactor()
 
-    def __enter__(self) -> "MsActionTableService":
+    def __enter__(self) -> "MsActionTableDownloadService":
         """Enter context manager.
 
         Returns: