conson-xp 1.38.0__tar.gz → 1.40.0__tar.gz

{conson_xp-1.38.0 → conson_xp-1.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.38.0
+Version: 1.40.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License

{conson_xp-1.38.0 → conson_xp-1.40.0}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.38.0"
+version = "1.40.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.38.0 → conson_xp-1.40.0}/src/xp/__init__.py

@@ -3,7 +3,7 @@
 conson-xp package.
 """
 
-__version__ = "1.38.0"
+__version__ = "1.40.0"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-1.38.0 → conson_xp-1.40.0}/src/xp/cli/commands/conbus/conbus_msactiontable_commands.py

@@ -55,29 +55,30 @@ def conbus_download_msactiontable(
         click.echo(progress, nl=False)
 
     def on_finish(
-        msaction_table: Union[
-            Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable, None
-        ],
-        msaction_table_short: str,
+        msaction_table: Union[Xp20MsActionTable, Xp24MsActionTable, Xp33MsActionTable],
+        msaction_table_short: list[str],
     ) -> None:
-        """Handle successful completion of MS action table download.
+        """Handle successful completion of XP24 MS action table download.
 
         Args:
-            msaction_table: Downloaded MS action table object or None if failed.
-            msaction_table_short: Short version of MS action table object or None if failed.
-
-        Raises:
-            Abort: If action table download failed.
+            msaction_table: Downloaded XP MS action table object.
+            msaction_table_short: Short version of XP24 MS action table.
         """
         service.stop_reactor()
-        if msaction_table is None:
-            click.echo("Error: Failed to download MS action table")
-            raise click.Abort()
+
+        # Format short representation based on module type
+        short_field_name = f"{xpmoduletype}_msaction_table"
+        # XP24 returns single-element list, XP20/XP33 return multi-line lists
+        short_value: Union[str, list[str]]
+        if len(msaction_table_short) == 1:
+            short_value = msaction_table_short[0]
+        else:
+            short_value = msaction_table_short
 
         output = {
             "serial_number": serial_number,
             "xpmoduletype": xpmoduletype,
-            "msaction_table_short": msaction_table_short,
+            short_field_name: short_value,
             "msaction_table": msaction_table.model_dump(),
         }
         click.echo(json.dumps(output, indent=2, default=str))
@@ -93,6 +94,8 @@ def conbus_download_msactiontable(
     with service:
         service.on_progress.connect(on_progress)
         service.on_error.connect(on_error)
+
+        # Connect to the appropriate signal based on module type
         service.on_finish.connect(on_finish)
         service.start(
             serial_number=serial_number,
@@ -155,9 +158,37 @@ def conbus_show_msactiontable(ctx: Context, serial_number: str) -> None:
         Args:
             module: Dictionary containing module configuration.
         """
+        click.echo(f"\nModule: {module.name} ({module.serial_number})")
+
+        # Display short format if action table exists
+        if module.xp33_msaction_table:
+            click.echo("Short:")
+            for line in module.xp33_msaction_table:
+                click.echo(f"  - {line}")
+        elif module.xp24_msaction_table:
+            click.echo("Short:")
+            for line in module.xp24_msaction_table:
+                click.echo(f"  - {line}")
+        elif module.xp20_msaction_table:
+            click.echo("Short:")
+            for line in module.xp20_msaction_table:
+                click.echo(f"  - {line}")
+
+        # Display full YAML format
+        click.echo("Full:")
         module_data = module.model_dump()
         module_data.pop("action_table", None)
-        click.echo(json.dumps(module_data, indent=2, default=str))
+
+        # Show the action table in YAML format
+        if module.xp33_msaction_table:
+            yaml_dict = {"xp33_msaction_table": module_data}
+            click.echo(_format_yaml(yaml_dict, indent=2))
+        elif module.xp24_msaction_table:
+            yaml_dict = {"xp24_msaction_table": module_data}
+            click.echo(_format_yaml(yaml_dict, indent=2))
+        elif module.xp20_msaction_table:
+            yaml_dict = {"xp20_msaction_table": module_data}
+            click.echo(_format_yaml(yaml_dict, indent=2))
 
     def error_callback(error: str) -> None:
         """Handle errors during action table show.
@@ -173,3 +204,29 @@ def conbus_show_msactiontable(ctx: Context, serial_number: str) -> None:
             finish_callback=on_finish,
             error_callback=error_callback,
         )
+
+
+def _format_yaml(data: dict, indent: int = 0) -> str:
+    """Format a dictionary as YAML-like output.
+
+    Args:
+        data: Dictionary to format.
+        indent: Current indentation level.
+
+    Returns:
+        YAML-like formatted string.
+    """
+    lines: list[str] = []
+    for key, value in data.items():
+        if isinstance(value, dict):
+            lines.extend((f"{' ' * indent}{key}:", _format_yaml(value, indent + 2)))
+        elif isinstance(value, list):
+            lines.append(f"{' ' * indent}{key}:")
+            for item in value:
+                if isinstance(item, dict):
+                    lines.append(_format_yaml(item, indent + 2))
+                else:
+                    lines.append(f"{' ' * (indent + 2)}- {item}")
+        else:
+            lines.append(f"{' ' * indent}{key}: {value}")
+    return "\n".join(lines)

conson_xp-1.40.0/src/xp/models/actiontable/msactiontable_xp20.py

@@ -0,0 +1,143 @@
+"""XP20 Action Table models for input actions and settings."""
+
+from pydantic import BaseModel, Field
+
+
+class InputChannel(BaseModel):
+    """Configuration for a single input channel in XP20 action table.
+
+    Attributes:
+        invert: Input inversion flag
+        short_long: Short/long press detection flag
+        group_on_off: Group on/off function flag
+        and_functions: 8-bit AND function configuration array
+        sa_function: SA function flag
+        ta_function: TA function flag
+    """
+
+    invert: bool = False
+    short_long: bool = False
+    group_on_off: bool = False
+    and_functions: list[bool] = Field(default_factory=lambda: [False] * 8)
+    sa_function: bool = False
+    ta_function: bool = False
+
+
+class Xp20MsActionTable(BaseModel):
+    """XP20 Action Table for managing 8 input channels.
+
+    Contains configuration for 8 input channels (input1 through input8),
+    each with flags for inversion, short/long press detection, group functions,
+    AND functions, SA functions, and TA functions.
+
+    Attributes:
+        input1: Configuration for input channel 1.
+        input2: Configuration for input channel 2.
+        input3: Configuration for input channel 3.
+        input4: Configuration for input channel 4.
+        input5: Configuration for input channel 5.
+        input6: Configuration for input channel 6.
+        input7: Configuration for input channel 7.
+        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)
+
+    def to_short_format(self) -> list[str]:
+        """Convert action table to short format string.
+
+        Returns:
+            Short format string with each channel on a separate line.
+            Example:
+                CH1 I:0 S:0 G:0 AND:00000000 SA:0 TA:0
+                CH2 I:0 S:0 G:0 AND:00000000 SA:0 TA:0
+                ...
+        """
+        lines = []
+        for i in range(1, 9):
+            channel = getattr(self, f"input{i}")
+            # Convert and_functions list to binary string
+            and_bits = "".join("1" if bit else "0" for bit in channel.and_functions)
+            line = (
+                f"CH{i} "
+                f"I:{1 if channel.invert else 0} "
+                f"S:{1 if channel.short_long else 0} "
+                f"G:{1 if channel.group_on_off else 0} "
+                f"AND:{and_bits} "
+                f"SA:{1 if channel.sa_function else 0} "
+                f"TA:{1 if channel.ta_function else 0}"
+            )
+            lines.append(line)
+        return lines
+
+    @classmethod
+    def from_short_format(cls, short_str: list[str]) -> "Xp20MsActionTable":
+        """Parse short format string into action table.
+
+        Args:
+            short_str: Short format string with 8 channel lines.
+
+        Returns:
+            Xp20MsActionTable instance.
+
+        Raises:
+            ValueError: If format is invalid.
+        """
+        import re
+
+        if len(short_str) != 8:
+            raise ValueError(f"Expected 8 channel lines, got {len(short_str)}")
+
+        pattern = re.compile(
+            r"^CH([1-8]) I:([01]) S:([01]) G:([01]) AND:([01]{8}) SA:([01]) TA:([01])$"
+        )
+
+        channels = {}
+        for line in short_str:
+            line = line.strip()
+            match = pattern.match(line)
+            if not match:
+                raise ValueError(f"Invalid channel format: {line}")
+
+            ch_num = int(match.group(1))
+            invert = match.group(2) == "1"
+            short_long = match.group(3) == "1"
+            group_on_off = match.group(4) == "1"
+            and_bits = match.group(5)
+            sa_function = match.group(6) == "1"
+            ta_function = match.group(7) == "1"
+
+            # Convert binary string to list of bools
+            and_functions = [bit == "1" for bit in and_bits]
+
+            channels[ch_num] = InputChannel(
+                invert=invert,
+                short_long=short_long,
+                group_on_off=group_on_off,
+                and_functions=and_functions,
+                sa_function=sa_function,
+                ta_function=ta_function,
+            )
+
+        # Verify all channels are present
+        for i in range(1, 9):
+            if i not in channels:
+                raise ValueError(f"Missing channel {i}")
+
+        return cls(
+            input1=channels[1],
+            input2=channels[2],
+            input3=channels[3],
+            input4=channels[4],
+            input5=channels[5],
+            input6=channels[6],
+            input7=channels[7],
+            input8=channels[8],
+        )

{conson_xp-1.38.0 → conson_xp-1.40.0}/src/xp/models/actiontable/msactiontable_xp24.py

@@ -4,7 +4,6 @@ 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
 
@@ -82,7 +81,7 @@ class InputAction(BaseModel):
         raise ValueError(f"Invalid type for TimeParam: {type(v)}")
 
 
-class Xp24MsActionTable(MsActionTable):
+class Xp24MsActionTable(BaseModel):
     """XP24 Action Table for managing input actions and settings.
 
     Each input has an action type (TOGGLE, ON, LEVELSET, etc.)
@@ -159,14 +158,11 @@ class Xp24MsActionTable(MsActionTable):
     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:
+    def to_short_format(self) -> list[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").
+            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 = [
@@ -184,21 +180,20 @@ class Xp24MsActionTable(MsActionTable):
 
         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}"
+        # 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
+        return [result]
 
     @classmethod
-    def from_short_format(cls, short_str: str) -> "Xp24MsActionTable":
+    def from_short_format(cls, short_str: list[str]) -> "Xp24MsActionTable":
         """Parse short format string into action table.
 
         Args:
@@ -211,9 +206,9 @@ class Xp24MsActionTable(MsActionTable):
             ValueError: If format is invalid.
         """
         # Split by pipe to separate actions from settings
-        parts = short_str.split("|")
+        parts = short_str[0].split("|")
         action_part = parts[0].strip()
-        settings_part = parts[1].strip() if len(parts) > 1 else None
+        settings_part = parts[1].strip()
 
         # Parse action part
         tokens = action_part.split()
@@ -253,23 +248,22 @@ class Xp24MsActionTable(MsActionTable):
             "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)
+        # 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)