conson-xp 0.11.19__tar.gz → 0.11.21__tar.gz

{conson_xp-0.11.19 → conson_xp-0.11.21}/PKG-INFO

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

{conson_xp-0.11.19 → conson_xp-0.11.21}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "0.11.19"
+version = "0.11.21"
 
 [project.license]
 file = "LICENSE"

{conson_xp-0.11.19 → conson_xp-0.11.21}/src/xp/__init__.py

@@ -2,7 +2,7 @@
 
 """conson-xp"""
 
-__version__ = "0.11.19"
+__version__ = "0.11.21"
 __manufacturer__ = "salchichon"
 __model__ = "xp.cli"
 __serial__ = "2025.09.23.000"

{conson_xp-0.11.19 → conson_xp-0.11.21}/src/xp/cli/commands/__init__.py

@@ -38,7 +38,6 @@ from xp.cli.commands.conbus.conbus_datapoint_commands import (
 )
 from xp.cli.commands.conbus.conbus_discover_commands import send_discover_telegram
 from xp.cli.commands.conbus.conbus_lightlevel_commands import (
-    xp_lightlevel_get,
     xp_lightlevel_off,
     xp_lightlevel_on,
     xp_lightlevel_set,

{conson_xp-0.11.19 → conson_xp-0.11.21}/src/xp/cli/commands/conbus/conbus_lightlevel_commands.py

@@ -10,9 +10,10 @@ from xp.cli.utils.decorators import (
     handle_service_errors,
 )
 from xp.cli.utils.serial_number_type import SERIAL
-from xp.services.conbus.conbus_lightlevel_service import (
+from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
+from xp.services.conbus.conbus_lightlevel_set_service import (
     ConbusLightlevelError,
-    ConbusLightlevelService,
+    ConbusLightlevelSetService,
 )
 
 
@@ -34,12 +35,17 @@ def xp_lightlevel_set(
         xp conbus lightlevel set 0123450001 2 50   # Set output 2 to 50%
         xp conbus lightlevel set 0011223344 0 100  # Set output 0 to 100%
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.set_lightlevel(serial_number, output_number, level)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.set_lightlevel(serial_number, output_number, level, finish, 0.5)
+
 
 @conbus_lightlevel.command("off")
 @click.argument("serial_number", type=SERIAL)
@@ -58,12 +64,17 @@ def xp_lightlevel_off(
         xp conbus lightlevel off 0123450001 2   # Turn off output 2
         xp conbus lightlevel off 0011223344 0   # Turn off output 0
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.turn_off(serial_number, output_number)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.turn_off(serial_number, output_number, finish, 0.5)
+
 
 @conbus_lightlevel.command("on")
 @click.argument("serial_number", type=SERIAL)
@@ -82,12 +93,17 @@ def xp_lightlevel_on(
         xp conbus lightlevel on 0123450001 2   # Turn on output 2 (80%)
         xp conbus lightlevel on 0011223344 0   # Turn on output 0 (80%)
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.turn_on(serial_number, output_number)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.turn_on(serial_number, output_number, finish, 0.5)
+
 
 @conbus_lightlevel.command("get")
 @click.argument("serial_number", type=SERIAL)
@@ -99,15 +115,18 @@ def xp_lightlevel_get(
     ctx: click.Context, serial_number: str, output_number: int
 ) -> None:
     """Get current light level for output_number on XP module serial_number
-
     Examples:
-
     \b
         xp conbus lightlevel get 0123450001 2   # Get light level for output 2
         xp conbus lightlevel get 0011223344 0   # Get light level for output 0
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLightlevelService)
 
-    with service:
-        response = service.get_lightlevel(serial_number, output_number)
+    def finish(response: "ConbusLightlevelResponse") -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
+
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLightlevelSetService)
+    )
+
+    with service:
+        service.get_lightlevel(serial_number, output_number, finish, 0.5)

{conson_xp-0.11.19 → conson_xp-0.11.21}/src/xp/services/conbus/conbus_autoreport_get_service.py

@@ -79,22 +79,29 @@ class ConbusAutoreportGetService(ConbusProtocol):
             telegram_received.frame
         )
         if (
-            reply_telegram is not None
-            and reply_telegram.system_function == SystemFunction.READ_DATAPOINT
-            and reply_telegram.datapoint_type == DataPointType.AUTO_REPORT_STATUS
+            not reply_telegram
+            or reply_telegram.system_function != SystemFunction.READ_DATAPOINT
+            or reply_telegram.datapoint_type != DataPointType.AUTO_REPORT_STATUS
         ):
-            self.logger.debug("Received autoreport status telegram")
-            self.service_response.success = True
-            self.service_response.timestamp = datetime.now()
-            self.service_response.serial_number = self.serial_number
-            self.service_response.auto_report_status = reply_telegram.data_value
+            self.logger.debug("Not an autoreport reply")
+            return
+
+        autoreport_status = reply_telegram.data_value
+        self.succeed(autoreport_status)
 
-            if self.finish_callback:
-                self.finish_callback(self.service_response)
+    def succeed(self, autoreport_status: str) -> None:
+        self.logger.debug("Received autoreport status: {autoreport_status}")
+        self.service_response.success = True
+        self.service_response.serial_number = self.serial_number
+        self.service_response.timestamp = datetime.now()
+        self.service_response.auto_report_status = autoreport_status
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
 
     def failed(self, message: str) -> None:
         self.logger.debug(f"Failed with message: {message}")
         self.service_response.success = False
+        self.service_response.serial_number = self.serial_number
         self.service_response.timestamp = datetime.now()
         self.service_response.error = message
         if self.finish_callback:

conson_xp-0.11.21/src/xp/services/conbus/conbus_lightlevel_get_service.py

@@ -0,0 +1,149 @@
+"""Conbus Auto Report Service for getting and setting module auto report status.
+
+This service handles auto report status operations for modules through Conbus telegrams.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.reply_telegram import ReplyTelegram
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusLightlevelGetService(ConbusProtocol):
+    """
+    Service for receiving telegrams from Conbus servers.
+
+    Uses composition with ConbusService to provide receive-only functionality
+    for collecting waiting event telegrams from the server.
+    """
+
+    def __init__(
+        self,
+        telegram_service: TelegramService,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ) -> None:
+        """Initialize the Conbus client send service"""
+        super().__init__(cli_config, reactor)
+        self.telegram_service = telegram_service
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.finish_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+            None
+        )
+        self.service_response: ConbusLightlevelResponse = ConbusLightlevelResponse(
+            success=False,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            level=0,
+            timestamp=datetime.now(),
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        self.logger.debug("Connection established, retrieving lightlevel status...")
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.READ_DATAPOINT,
+            data_value=str(DataPointType.MODULE_LIGHT_LEVEL.value),
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.sent_telegram = telegram_sent
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+
+        self.logger.debug(f"Telegram received: {telegram_received}")
+        if not self.service_response.received_telegrams:
+            self.service_response.received_telegrams = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
+
+        if (
+            not telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply")
+            return
+
+        reply_telegram = self.telegram_service.parse_reply_telegram(
+            telegram_received.frame
+        )
+
+        if (
+            not reply_telegram
+            or reply_telegram.system_function != SystemFunction.READ_DATAPOINT
+            or reply_telegram.datapoint_type != DataPointType.MODULE_LIGHT_LEVEL
+        ):
+            self.logger.debug("Not a lightlevel telegram")
+            return
+
+        self.logger.debug("Received lightlevel status telegram")
+        lightlevel = self.extract_lightlevel(reply_telegram)
+        self.succeed(lightlevel)
+
+    def extract_lightlevel(self, reply_telegram: ReplyTelegram) -> int:
+        level = 0
+        for output_data in reply_telegram.data_value.split(","):
+            if ":" in output_data:
+                output_str, level_str = output_data.split(":")
+                if int(output_str) == self.output_number:
+                    level_str = level_str.replace("[%]", "")
+                    level = int(level_str)
+                    break
+        return level
+
+    def succeed(self, lightlevel: int) -> None:
+        self.service_response.success = True
+        self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
+        self.service_response.level = lightlevel
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        self.logger.debug(f"Failed with message: {message}")
+        self.service_response.success = False
+        self.service_response.timestamp = datetime.now()
+        self.service_response.error = message
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def get_light_level(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """
+        Get the current auto report status for a specific module.
+
+        Args:
+            :param  serial_number: 10-digit module serial number
+            :param  output_number: output module number
+            :param  finish_callback: callback function to call when the lightlevel status is
+            :param  timeout_seconds: timeout in seconds
+
+        """
+        self.logger.info("Starting get_lightlevel_status")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.start_reactor()

conson_xp-0.11.21/src/xp/services/conbus/conbus_lightlevel_set_service.py

@@ -0,0 +1,205 @@
+"""Conbus Lightlevel Service for controlling light levels on Conbus modules.
+
+This service implements lightlevel control operations for XP modules,
+including setting specific light levels, turning lights on/off, and
+querying current light levels.
+"""
+
+import logging
+from datetime import datetime
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
+from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.models.telegram.system_function import SystemFunction
+from xp.models.telegram.telegram_type import TelegramType
+from xp.services.protocol import ConbusProtocol
+
+
+class ConbusLightlevelError(Exception):
+    """Raised when Conbus lightlevel operations fail"""
+
+    pass
+
+
+class ConbusLightlevelSetService(ConbusProtocol):
+    """
+    Service for controlling light levels on Conbus modules.
+
+    Manages lightlevel operations including setting specific levels,
+    turning lights on/off, and querying current states.
+    """
+
+    def __init__(
+        self,
+        cli_config: ConbusClientConfig,
+        reactor: PosixReactorBase,
+    ):
+        """Initialize the Conbus lightlevel service"""
+        super().__init__(cli_config, reactor)
+        self.serial_number: str = ""
+        self.output_number: int = 0
+        self.level: int = 0
+        self.finish_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+            None
+        )
+        self.service_response: ConbusLightlevelResponse = ConbusLightlevelResponse(
+            success=False,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            level=None,
+            timestamp=datetime.now(),
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def connection_established(self) -> None:
+        self.logger.debug(
+            f"Connection established, setting light level for output {self.output_number} to {self.level}%..."
+        )
+
+        # Format data as output_number:level (e.g., ""15" + "02:050")
+        data_value = f"{DataPointType.MODULE_LIGHT_LEVEL.value}{self.output_number:02d}:{self.level:03d}"
+
+        # Send telegram using WRITE_CONFIG function with MODULE_LIGHT_LEVEL datapoint
+        self.send_telegram(
+            telegram_type=TelegramType.SYSTEM,
+            serial_number=self.serial_number,
+            system_function=SystemFunction.WRITE_CONFIG,  # "04"
+            data_value=data_value,
+        )
+
+    def telegram_sent(self, telegram_sent: str) -> None:
+        self.service_response.sent_telegram = telegram_sent
+
+    def telegram_received(self, telegram_received: TelegramReceivedEvent) -> None:
+        self.logger.debug(f"Telegram received: {telegram_received}")
+        if not self.service_response.received_telegrams:
+            self.service_response.received_telegrams = []
+        self.service_response.received_telegrams.append(telegram_received.frame)
+
+        if (
+            not telegram_received.checksum_valid
+            or telegram_received.telegram_type != TelegramType.REPLY
+            or telegram_received.serial_number != self.serial_number
+        ):
+            self.logger.debug("Not a reply for our serial number")
+            return
+
+        # Any valid reply means success (ACK or NAK)
+        if telegram_received.telegram_type == TelegramType.REPLY:
+            self.logger.debug("Received lightlevel response")
+            self.succeed()
+
+    def succeed(self) -> None:
+        self.logger.debug("Succeed")
+        self.service_response.success = True
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.level = self.level
+        self.service_response.timestamp = datetime.now()
+
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def failed(self, message: str) -> None:
+        self.logger.debug(f"Failed with message: {message}")
+        self.service_response.success = False
+        self.service_response.serial_number = self.serial_number
+        self.service_response.output_number = self.output_number
+        self.service_response.level = self.level
+        self.service_response.timestamp = datetime.now()
+        self.service_response.error = message
+
+        if self.finish_callback:
+            self.finish_callback(self.service_response)
+
+    def set_lightlevel(
+        self,
+        serial_number: str,
+        output_number: int,
+        level: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Set light level for a specific output on a module.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-based, 0-8)
+            level: Light level percentage (0-100)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+
+        Examples:
+            \b
+                xp conbus lightlevel set 0012345008 2 50
+                xp conbus lightlevel set 0012345008 0 100
+        """
+
+        self.logger.info(
+            f"Setting light level for {serial_number} output {output_number} to {level}%"
+        )
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.finish_callback = finish_callback
+        self.serial_number = serial_number
+        self.output_number = output_number
+        self.level = level
+
+        # Validate output_number range (0-8)
+        if not 0 <= self.output_number <= 8:
+            self.failed(
+                f"Output number must be between 0 and 8, got {self.output_number}"
+            )
+            return
+
+        # Validate level range
+        if not 0 <= self.level <= 100:
+            self.failed(f"Light level must be between 0 and 100, got {self.level}")
+            return
+
+        self.start_reactor()
+
+    def turn_off(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Turn off light (set level to 0) for a specific output.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-8)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.set_lightlevel(
+            serial_number, output_number, 0, finish_callback, timeout_seconds
+        )
+
+    def turn_on(
+        self,
+        serial_number: str,
+        output_number: int,
+        finish_callback: Callable[[ConbusLightlevelResponse], None],
+        timeout_seconds: Optional[float] = None,
+    ) -> None:
+        """Turn on light (set level to 80%) for a specific output.
+
+        Args:
+            serial_number: Module serial number
+            output_number: Output number (0-8)
+            finish_callback: Callback function to call when operation completes
+            timeout_seconds: Optional timeout in seconds
+        """
+        self.set_lightlevel(
+            serial_number, output_number, 80, finish_callback, timeout_seconds
+        )

{conson_xp-0.11.19 → conson_xp-0.11.21}/src/xp/utils/dependencies.py

@@ -37,7 +37,7 @@ from xp.services.conbus.conbus_datapoint_service import (
     ConbusDatapointService,
 )
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
-from xp.services.conbus.conbus_lightlevel_service import ConbusLightlevelService
+from xp.services.conbus.conbus_lightlevel_set_service import ConbusLightlevelSetService
 from xp.services.conbus.conbus_linknumber_service import ConbusLinknumberService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
@@ -224,11 +224,10 @@ class ServiceContainer:
         )
 
         self.container.register(
-            ConbusLightlevelService,
-            factory=lambda: ConbusLightlevelService(
-                telegram_service=self.container.resolve(TelegramService),
-                conbus_service=self.container.resolve(ConbusService),
-                datapoint_service=self.container.resolve(ConbusDatapointService),
+            ConbusLightlevelSetService,
+            factory=lambda: ConbusLightlevelSetService(
+                cli_config=self.container.resolve(ConbusClientConfig),
+                reactor=self.container.resolve(PosixReactorBase),
             ),
             scope=punq.Scope.singleton,
         )