conson-xp 1.39.0__tar.gz → 1.41.0__tar.gz

{conson_xp-1.39.0 → conson_xp-1.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.39.0
+Version: 1.41.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -376,6 +376,7 @@ xp conbus msactiontable
 xp conbus msactiontable download
 xp conbus msactiontable list
 xp conbus msactiontable show
+xp conbus msactiontable upload
 
 
 xp conbus output

{conson_xp-1.39.0 → conson_xp-1.41.0}/README.md

@@ -323,6 +323,7 @@ xp conbus msactiontable
 xp conbus msactiontable download
 xp conbus msactiontable list
 xp conbus msactiontable show
+xp conbus msactiontable upload
 
 
 xp conbus output

{conson_xp-1.39.0 → conson_xp-1.41.0}/pyproject.toml

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

{conson_xp-1.39.0 → conson_xp-1.41.0}/src/xp/__init__.py

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

{conson_xp-1.39.0 → conson_xp-1.41.0}/src/xp/cli/commands/conbus/conbus_msactiontable_commands.py

@@ -25,6 +25,9 @@ from xp.services.conbus.msactiontable.msactiontable_list_service import (
 from xp.services.conbus.msactiontable.msactiontable_show_service import (
     MsActionTableShowService,
 )
+from xp.services.conbus.msactiontable.msactiontable_upload_service import (
+    MsActionTableUploadService,
+)
 
 
 @conbus_msactiontable.command("download", short_help="Download MSActionTable")
@@ -55,29 +58,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 +97,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 +161,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 +207,88 @@ def conbus_show_msactiontable(ctx: Context, serial_number: str) -> None:
             finish_callback=on_finish,
             error_callback=error_callback,
         )
+
+
+@conbus_msactiontable.command("upload", short_help="Upload MSActionTable")
+@click.argument("serial_number", type=SERIAL)
+@click.argument("xpmoduletype", type=XP_MODULE_TYPE)
+@click.pass_context
+@connection_command()
+def conbus_upload_msactiontable(
+    ctx: Context, serial_number: str, xpmoduletype: str
+) -> None:
+    """Upload MS action table from conson.yml to XP module.
+
+    Args:
+        ctx: Click context object.
+        serial_number: 10-digit module serial number.
+        xpmoduletype: XP module type.
+    """
+    service: MsActionTableUploadService = (
+        ctx.obj.get("container").get_container().resolve(MsActionTableUploadService)
+    )
+
+    def on_progress(progress: str) -> None:
+        """Handle progress updates during MS action table upload.
+
+        Args:
+            progress: Progress message string.
+        """
+        click.echo(progress, nl=False)
+
+    def on_finish(success: bool) -> None:
+        """Handle successful completion of MS action table upload.
+
+        Args:
+            success: Whether upload was successful.
+        """
+        service.stop_reactor()
+        if success:
+            click.echo("\nMsactiontable uploaded successfully")
+
+    def on_error(error: str) -> None:
+        """Handle errors during MS action table upload.
+
+        Args:
+            error: Error message string.
+        """
+        service.stop_reactor()
+        click.echo(f"\nError: {error}")
+
+    click.echo(f"Uploading msactiontable to {serial_number}...")
+
+    with service:
+        service.on_progress.connect(on_progress)
+        service.on_error.connect(on_error)
+        service.on_finish.connect(on_finish)
+        service.start(
+            serial_number=serial_number,
+            xpmoduletype=xpmoduletype,
+        )
+        service.start_reactor()
+
+
+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.41.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.39.0 → conson_xp-1.41.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,7 +158,7 @@ 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) -> str:
+    def to_short_format(self) -> list[str]:
         """Convert action table to short format string.
 
         Returns:
@@ -179,7 +178,7 @@ class Xp24MsActionTable(MsActionTable):
             param_value = action.param.value
             action_parts.append(f"{short_code}:{param_value}")
 
-        result = f"XP24 {' '.join(action_parts)}"
+        result = " ".join(action_parts)
 
         # Add settings
         settings = (
@@ -191,10 +190,10 @@ class Xp24MsActionTable(MsActionTable):
         )
         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:
@@ -207,20 +206,20 @@ 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()
 
         # Parse action part
         tokens = action_part.split()
-        if len(tokens) != 5 or tokens[0] != "XP24":
+        if len(tokens) != 4:
             raise ValueError(
-                f"Invalid short format: expected 'XP24 <a1> <a2> <a3> <a4>', got '{action_part}'"
+                f"Invalid short format: expected '<a1> <a2> <a3> <a4>', got '{action_part}'"
             )
 
         # Parse input actions
         input_actions = []
-        for i, token in enumerate(tokens[1:5], 1):
+        for i, token in enumerate(tokens[0:4], 1):
             if ":" not in token:
                 raise ValueError(f"Invalid action format at position {i}: '{token}'")