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

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

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

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

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

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

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

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

@@ -159,14 +159,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) -> 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,16 +181,15 @@ 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
 
@@ -213,7 +209,7 @@ class Xp24MsActionTable(MsActionTable):
         # 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
+        settings_part = parts[1].strip()
 
         # Parse action part
         tokens = action_part.split()
@@ -253,23 +249,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)

{conson_xp-1.38.0 → conson_xp-1.39.0}/tests/unit/test_models/test_xp24_action_table_short_format.py

@@ -27,7 +27,10 @@ class TestXp24ShortFormat:
             ),
         )
 
-        assert action_table.to_short_format() == "XP24 T:1 T:2 T:0 T:0"
+        assert (
+            action_table.to_short_format()
+            == "XP24 T:1 T:2 T:0 T:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
+        )
 
     def test_to_short_format_with_settings(self):
         """Test conversion to short format with settings."""
@@ -49,7 +52,7 @@ class TestXp24ShortFormat:
             curtain12=False,
             curtain34=False,
             mutual_deadtime=20,
-        ).to_short_format(include_settings=True)
+        ).to_short_format()
         assert short == "XP24 T:0 T:0 T:0 T:0 | M12:1 M34:1 C12:0 C34:0 DT:20"
 
     def test_to_short_format_mixed_actions(self):
@@ -64,7 +67,7 @@ class TestXp24ShortFormat:
                 type=InputActionType.SCENESET, param=TimeParam.T2MIN
             ),
         ).to_short_format()
-        assert short == "XP24 ON:4 OF:0 LS:12 SS:11"
+        assert short == "XP24 ON:4 OF:0 LS:12 SS:11 | M12:0 M34:0 C12:0 C34:0 DT:12"
 
     def test_to_short_format_all_void(self):
         """Test conversion with all VOID actions."""
@@ -74,11 +77,11 @@ class TestXp24ShortFormat:
             input3_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
             input4_action=InputAction(type=InputActionType.VOID, param=TimeParam.NONE),
         ).to_short_format()
-        assert short == "XP24 V:0 V:0 V:0 V:0"
+        assert short == "XP24 V:0 V:0 V:0 V:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
 
     def test_from_short_format_basic(self):
         """Test parsing basic short format."""
-        short = "XP24 T:1 T:2 T:0 T:0"
+        short = "XP24 T:1 T:2 T:0 T:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
         action_table = Xp24MsActionTable.from_short_format(short)
 
         assert action_table.input1_action.type == InputActionType.TOGGLE
@@ -103,7 +106,7 @@ class TestXp24ShortFormat:
 
     def test_from_short_format_mixed_actions(self):
         """Test parsing mixed action types."""
-        short = "XP24 ON:4 OF:0 LS:12 SS:11"
+        short = "XP24 ON:4 OF:0 LS:12 SS:11 | M12:0 M34:0 C12:0 C34:0 DT:12"
         action_table = Xp24MsActionTable.from_short_format(short)
 
         assert action_table.input1_action.type == InputActionType.ON
@@ -135,7 +138,7 @@ class TestXp24ShortFormat:
             mutual_deadtime=20,
         )
 
-        short = original.to_short_format(include_settings=True)
+        short = original.to_short_format()
         restored = Xp24MsActionTable.from_short_format(short)
 
         assert restored == original
@@ -143,22 +146,30 @@ class TestXp24ShortFormat:
     def test_from_short_format_invalid_format(self):
         """Test that invalid format raises ValueError."""
         with pytest.raises(ValueError, match="Invalid short format"):
-            Xp24MsActionTable.from_short_format("INVALID")
+            Xp24MsActionTable.from_short_format(
+                "INVALID | M12:0 M34:0 C12:0 C34:0 DT:12"
+            )
 
     def test_from_short_format_invalid_action_code(self):
         """Test that invalid action code raises ValueError."""
         with pytest.raises(ValueError, match="Unknown action code"):
-            Xp24MsActionTable.from_short_format("XP24 XX:0 T:0 T:0 T:0")
+            Xp24MsActionTable.from_short_format(
+                "XP24 XX:0 T:0 T:0 T:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
+            )
 
     def test_from_short_format_invalid_param(self):
         """Test that invalid param raises ValueError."""
         with pytest.raises(ValueError, match="Invalid time param"):
-            Xp24MsActionTable.from_short_format("XP24 T:999 T:0 T:0 T:0")
+            Xp24MsActionTable.from_short_format(
+                "XP24 T:999 T:0 T:0 T:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
+            )
 
     def test_from_short_format_missing_colon(self):
         """Test that missing colon raises ValueError."""
         with pytest.raises(ValueError, match="Invalid action format"):
-            Xp24MsActionTable.from_short_format("XP24 T1 T:0 T:0 T:0")
+            Xp24MsActionTable.from_short_format(
+                "XP24 T1 T:0 T:0 T:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
+            )
 
     def test_all_action_types(self):
         """Test that all action types can be converted."""
@@ -199,7 +210,7 @@ class TestXp24ShortFormat:
                 input1_action=InputAction(type=action_type, param=TimeParam.NONE),
             )
             short = action_table.to_short_format()
-            assert short.startswith(f"XP24 {expected_code}:0")
+            assert short.startswith(f"XP24 {expected_code}:0 ")
 
             # Test round-trip
             restored = Xp24MsActionTable.from_short_format(short)
@@ -237,7 +248,10 @@ class TestXp24ShortFormat:
                 ),
             )
             short = action_table.to_short_format()
-            assert short == f"XP24 T:{time_param.value} T:0 T:0 T:0"
+            assert (
+                short
+                == f"XP24 T:{time_param.value} T:0 T:0 T:0 | M12:0 M34:0 C12:0 C34:0 DT:12"
+            )
 
             # Test round-trip
             restored = Xp24MsActionTable.from_short_format(short)

conson_xp-1.38.0/src/xp/connection/__init__.py

@@ -1,13 +0,0 @@
-"""Connection layer for XP CLI tool."""
-
-from xp.connection.exceptions import (
-    ProtocolError,
-    ValidationError,
-    XPError,
-)
-
-__all__ = [
-    "XPError",
-    "ProtocolError",
-    "ValidationError",
-]

conson_xp-1.38.0/src/xp/connection/exceptions.py

@@ -1,22 +0,0 @@
-"""Connection-related exceptions for XP CLI tool.
-
-Following the architecture requirement for structured error handling.
-"""
-
-
-class XPError(Exception):
-    """Base exception for XP CLI tool."""
-
-    pass
-
-
-class ProtocolError(XPError):
-    """Console bus protocol errors."""
-
-    pass
-
-
-class ValidationError(XPError):
-    """Input validation errors."""
-
-    pass

conson_xp-1.38.0/tests/unit/test_connection/__init__.py

@@ -1 +0,0 @@
-"""Unit tests for connection handling."""

conson_xp-1.38.0/tests/unit/test_connection/test_connection_init.py

@@ -1,33 +0,0 @@
-"""Tests for connection module initialization."""
-
-import xp.connection as connection_module
-from xp.connection import ProtocolError, ValidationError, XPError
-
-
-class TestConnectionInit:
-    """Test connection module initialization."""
-
-    def test_xp_error_imported(self):
-        """Test XPError is importable from connection module."""
-        assert hasattr(connection_module, "XPError")
-        assert connection_module.XPError is XPError
-
-    def test_protocol_error_imported(self):
-        """Test ProtocolError is importable from connection module."""
-        assert hasattr(connection_module, "ProtocolError")
-        assert connection_module.ProtocolError is ProtocolError
-
-    def test_validation_error_imported(self):
-        """Test ValidationError is importable from connection module."""
-        assert hasattr(connection_module, "ValidationError")
-        assert connection_module.ValidationError is ValidationError
-
-    def test_all_exports(self):
-        """Test __all__ contains expected exports."""
-        expected = ["XPError", "ProtocolError", "ValidationError"]
-        assert connection_module.__all__ == expected
-
-    def test_all_members_accessible(self):
-        """Test all members in __all__ are accessible."""
-        for member in connection_module.__all__:
-            assert hasattr(connection_module, member)

conson_xp-1.38.0/tests/unit/test_connection/test_exceptions.py

@@ -1,88 +0,0 @@
-"""Tests for connection exceptions."""
-
-import pytest
-
-from xp.connection.exceptions import ProtocolError, ValidationError, XPError
-
-
-class TestXPError:
-    """Test XPError base exception."""
-
-    def test_xp_error_is_exception(self):
-        """Test XPError inherits from Exception."""
-        assert issubclass(XPError, Exception)
-
-    def test_xp_error_can_be_raised(self):
-        """Test XPError can be raised."""
-        with pytest.raises(XPError):
-            raise XPError("Test error")
-
-    def test_xp_error_with_message(self):
-        """Test XPError with custom message."""
-        msg = "Custom error message"
-        with pytest.raises(XPError) as exc_info:
-            raise XPError(msg)
-        assert str(exc_info.value) == msg
-
-    def test_xp_error_without_message(self):
-        """Test XPError without message."""
-        with pytest.raises(XPError):
-            raise XPError()
-
-
-class TestProtocolError:
-    """Test ProtocolError exception."""
-
-    def test_protocol_error_inherits_from_xp_error(self):
-        """Test ProtocolError inherits from XPError."""
-        assert issubclass(ProtocolError, XPError)
-
-    def test_protocol_error_is_exception(self):
-        """Test ProtocolError is also an Exception."""
-        assert issubclass(ProtocolError, Exception)
-
-    def test_protocol_error_can_be_raised(self):
-        """Test ProtocolError can be raised."""
-        with pytest.raises(ProtocolError):
-            raise ProtocolError("Protocol error")
-
-    def test_protocol_error_with_message(self):
-        """Test ProtocolError with custom message."""
-        msg = "Invalid protocol format"
-        with pytest.raises(ProtocolError) as exc_info:
-            raise ProtocolError(msg)
-        assert str(exc_info.value) == msg
-
-    def test_protocol_error_caught_as_xp_error(self):
-        """Test ProtocolError can be caught as XPError."""
-        with pytest.raises(XPError):
-            raise ProtocolError("Protocol error")
-
-
-class TestValidationError:
-    """Test ValidationError exception."""
-
-    def test_validation_error_inherits_from_xp_error(self):
-        """Test ValidationError inherits from XPError."""
-        assert issubclass(ValidationError, XPError)
-
-    def test_validation_error_is_exception(self):
-        """Test ValidationError is also an Exception."""
-        assert issubclass(ValidationError, Exception)
-
-    def test_validation_error_can_be_raised(self):
-        """Test ValidationError can be raised."""
-        with pytest.raises(ValidationError):
-            raise ValidationError("Validation failed")
-
-    def test_validation_error_with_message(self):
-        """Test ValidationError with custom message."""
-        msg = "Invalid input data"
-        with pytest.raises(ValidationError) as exc_info:
-            raise ValidationError(msg)
-        assert str(exc_info.value) == msg
-
-    def test_validation_error_caught_as_xp_error(self):
-        """Test ValidationError can be caught as XPError."""
-        with pytest.raises(XPError):
-            raise ValidationError("Validation error")