conson-xp 1.17.0__tar.gz → 1.18.0__tar.gz

{conson_xp-1.17.0 → conson_xp-1.18.0}/PKG-INFO

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

{conson_xp-1.17.0 → conson_xp-1.18.0}/pyproject.toml

@@ -21,7 +21,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.17.0"
+version = "1.18.0"
 
 [project.license]
 file = "LICENSE"

{conson_xp-1.17.0 → conson_xp-1.18.0}/src/xp/__init__.py

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

{conson_xp-1.17.0 → conson_xp-1.18.0}/src/xp/cli/commands/conbus/conbus_event_commands.py

@@ -6,8 +6,8 @@ import click
 
 from xp.cli.commands.conbus.conbus import conbus
 from xp.cli.utils.decorators import connection_command
+from xp.cli.utils.module_type_choice import MODULE_TYPE
 from xp.models import ConbusEventRawResponse
-from xp.models.telegram.module_type_code import ModuleTypeCode
 from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
 
 
@@ -18,15 +18,15 @@ def conbus_event() -> None:
 
 
 @conbus_event.command("raw")
-@click.argument("module_type", type=str)
-@click.argument("link_number", type=int)
-@click.argument("input_number", type=int)
-@click.argument("time_ms", type=int, default=1000)
+@click.argument("module_type", type=MODULE_TYPE)
+@click.argument("link_number", type=click.IntRange(0, 99))
+@click.argument("input_number", type=click.IntRange(0, 9))
+@click.argument("time_ms", type=click.IntRange(min=1), default=1000)
 @click.pass_context
 @connection_command()
 def send_event_raw(
     ctx: click.Context,
-    module_type: str,
+    module_type: int,
     link_number: int,
     input_number: int,
     time_ms: int,
@@ -45,40 +45,6 @@ def send_event_raw(
         xp conbus event raw CP20 00 00
         xp conbus event raw XP33 00 00 500
     """
-    # Validate parameters
-    if link_number < 0 or link_number > 99:
-        click.echo(
-            json.dumps({"error": "Link number must be between 0 and 99"}, indent=2)
-        )
-        return
-
-    if input_number < 0 or input_number > 9:
-        click.echo(
-            json.dumps({"error": "Input number must be between 0 and 9"}, indent=2)
-        )
-        return
-
-    if time_ms <= 0:
-        click.echo(json.dumps({"error": "Time must be greater than 0"}, indent=2))
-        return
-
-    # Resolve module type to numeric code
-    module_type_code: int = 0
-    try:
-        # Try to get the enum value by name
-        module_type_enum = ModuleTypeCode[module_type.upper()]
-        module_type_code = module_type_enum.value
-    except KeyError:
-        # Module type not found
-        click.echo(
-            json.dumps(
-                {
-                    "error": f"Unknown module type: {module_type}. Use module types like CP20, XP33, XP24, etc."
-                },
-                indent=2,
-            )
-        )
-        return
 
     def on_finish(response: ConbusEventRawResponse) -> None:
         """Handle successful completion of event raw operation.
@@ -100,7 +66,7 @@ def send_event_raw(
         ctx.obj.get("container").get_container().resolve(ConbusEventRawService)
     )
     service.run(
-        module_type_code=module_type_code,
+        module_type_code=module_type,
         link_number=link_number,
         input_number=input_number,
         time_ms=time_ms,

conson_xp-1.18.0/src/xp/cli/utils/module_type_choice.py

@@ -0,0 +1,56 @@
+"""Click parameter type for ModuleTypeCode enum validation."""
+
+from typing import Any, Optional
+
+import click
+
+from xp.models.telegram.module_type_code import ModuleTypeCode
+
+
+class ModuleTypeChoice(click.ParamType):
+    """Click parameter type for validating ModuleTypeCode enum values.
+
+    Attributes:
+        name: The parameter type name.
+        choices: List of valid choice strings.
+    """
+
+    name = "module_type"
+
+    def __init__(self) -> None:
+        """Initialize the ModuleTypeChoice parameter type."""
+        self.choices = [key for key in ModuleTypeCode.__members__.keys()]
+
+    def convert(
+        self, value: Any, param: Optional[click.Parameter], ctx: Optional[click.Context]
+    ) -> int:
+        """Convert and validate input to ModuleTypeCode value.
+
+        Args:
+            value: The input value to convert.
+            param: The Click parameter.
+            ctx: The Click context.
+
+        Returns:
+            Module type code integer value if valid.
+        """
+        if value is None:
+            self.fail("Module type is required", param, ctx)
+
+        # Convert to upper for comparison
+        normalized_value = value.upper()
+
+        if normalized_value in self.choices:
+            # Return the actual enum value (integer)
+            return ModuleTypeCode[normalized_value].value
+
+        # If not found, show error with available choices
+        choices_list = "\n".join(f" - {choice}" for choice in sorted(self.choices))
+        self.fail(
+            f"{value!r} is not a valid module type. " f"Choose from:\n{choices_list}",
+            param,
+            ctx,
+        )
+
+
+MODULE_TYPE = ModuleTypeChoice()

{conson_xp-1.17.0 → conson_xp-1.18.0}/src/xp/services/conbus/conbus_event_raw_service.py

@@ -63,13 +63,11 @@ class ConbusEventRawService:
         payload = f"E{self.module_type_code:02d}L{self.link_number:02d}I{self.input_number:02d}M"
         self.logger.debug(f"Sending MAKE event: {payload}")
         self.conbus_protocol.telegram_queue.put_nowait(payload.encode())
-        self.conbus_protocol._reactor.callLater(
-            0.0, self.conbus_protocol.start_queue_manager
-        )
+        self.conbus_protocol.call_later(0.0, self.conbus_protocol.start_queue_manager)
 
         # Schedule BREAK event after delay
         delay_seconds = self.time_ms / 1000.0
-        self.break_event_call = self.conbus_protocol._reactor.callLater(
+        self.break_event_call = self.conbus_protocol.call_later(
             delay_seconds, self._send_break_event
         )
 
@@ -78,9 +76,7 @@ class ConbusEventRawService:
         payload = f"E{self.module_type_code:02d}L{self.link_number:02d}I{self.input_number:02d}B"
         self.logger.debug(f"Sending BREAK event: {payload}")
         self.conbus_protocol.telegram_queue.put_nowait(payload.encode())
-        self.conbus_protocol._reactor.callLater(
-            0.0, self.conbus_protocol.start_queue_manager
-        )
+        self.conbus_protocol.call_later(0.0, self.conbus_protocol.start_queue_manager)
 
     def telegram_sent(self, telegram_sent: str) -> None:
         """Handle telegram sent event.

{conson_xp-1.17.0 → conson_xp-1.18.0}/src/xp/services/protocol/conbus_event_protocol.py

@@ -7,7 +7,7 @@ import logging
 from queue import SimpleQueue
 from random import randint
 from threading import Lock
-from typing import Any, Optional
+from typing import Any, Callable, Optional
 
 from psygnal import Signal
 from twisted.internet import protocol
@@ -209,7 +209,27 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             f"D{data_value}"
         )
         self.telegram_queue.put_nowait(payload.encode())
-        self._reactor.callLater(0.0, self.start_queue_manager)
+        self.call_later(0.0, self.start_queue_manager)
+
+    def call_later(
+        self,
+        delay: float,
+        callable_action: Callable[..., Any],
+        *args: object,
+        **kw: object,
+    ) -> DelayedCall:
+        """Schedule a callable to be called later.
+
+        Args:
+            delay: Delay in seconds before calling.
+            callable_action: The callable to execute.
+            args: Positional arguments to pass to callable.
+            kw: Keyword arguments to pass to callable.
+
+        Returns:
+            DelayedCall object that can be cancelled.
+        """
+        return self._reactor.callLater(delay, callable_action, *args, **kw)
 
     def buildProtocol(self, addr: IAddress) -> protocol.Protocol:
         """Build protocol instance for connection.
@@ -264,9 +284,7 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
     def _reset_timeout(self) -> None:
         """Reset the inactivity timeout."""
         self._cancel_timeout()
-        self.timeout_call = self._reactor.callLater(
-            self.timeout_seconds, self._on_timeout
-        )
+        self.timeout_call = self.call_later(self.timeout_seconds, self._on_timeout)
 
     def _cancel_timeout(self) -> None:
         """Cancel the inactivity timeout."""
@@ -320,7 +338,7 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         telegram = self.telegram_queue.get_nowait()
         self.sendFrame(telegram)
         later = randint(10, 80) / 100
-        self._reactor.callLater(later, self.process_telegram_queue)
+        self.call_later(later, self.process_telegram_queue)
 
     def __enter__(self) -> "ConbusEventProtocol":
         """Enter context manager.

{conson_xp-1.17.0 → conson_xp-1.18.0}/tests/unit/test_services/test_conbus_event_raw_service.py

@@ -28,7 +28,9 @@ class TestConbusEventRawService:
         protocol.on_failed.connect = Mock()
         protocol._reactor = Mock()
         protocol.telegram_queue = Mock()
+        protocol.call_later = Mock()
         protocol.timeout_seconds = 5
+        protocol.stop_reactor = Mock()
         return protocol
 
     @pytest.fixture
@@ -61,7 +63,7 @@ class TestConbusEventRawService:
         assert call_args == b"E02L10I05M"
 
         # Verify BREAK event was scheduled
-        mock_protocol._reactor.callLater.assert_called()
+        mock_protocol.call_later.assert_called()
 
     def test_telegram_sent(self, service):
         """Test telegram_sent callback updates service response."""