conson-xp 0.11.19__py3-none-any.whl → 0.11.21__py3-none-any.whl

{conson_xp-0.11.19.dist-info → conson_xp-0.11.21.dist-info}/METADATA

@@ -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.dist-info → conson_xp-0.11.21.dist-info}/RECORD

@@ -1,8 +1,8 @@
-conson_xp-0.11.19.dist-info/METADATA,sha256=p1zZBcnLWzxqgjDpG5PV79RjfUlqHFro4Lg9UR7DCwM,9298
-conson_xp-0.11.19.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-conson_xp-0.11.19.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
-conson_xp-0.11.19.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
-xp/__init__.py,sha256=GI7bh7zmr-OWMd0qpVNaJWLLfl-rOYs03w6gLooWVqQ,177
+conson_xp-0.11.21.dist-info/METADATA,sha256=HwBfLHuKhBtOi-5wmg081HGTAng6BXa2E8W-hkfzkXU,9298
+conson_xp-0.11.21.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+conson_xp-0.11.21.dist-info/entry_points.txt,sha256=1OcdIcDM1hz3ljCXgybaPUh1IOFEwkaTgLIW9u9zGeg,50
+conson_xp-0.11.21.dist-info/licenses/LICENSE,sha256=rxj6woMM-r3YCyGq_UHFtbh7kHTAJgrccH6O-33IDE4,1419
+xp/__init__.py,sha256=Yo_o4SM3_458AZhuCwUhwwY3C5xsGcGv2-pF3Z-8Fhs,177
 xp/api/__init__.py,sha256=fCWjkuTzDlyJ8hIpU_QEBNcah3BB2bqVSfZwmP4ee5k,51
 xp/api/main.py,sha256=8OMXUYKnpsqjjnLChokC_M0DXZy-whrxY2dU4QTvr8A,3389
 xp/api/models/__init__.py,sha256=Xl8j2qiHc-Vb8b1ZmNZaMj7RtMvk0G_2SOvMgQumYzs,54
@@ -17,7 +17,7 @@ xp/api/routers/conbus_output.py,sha256=U-i7kjZv7H6aE0O_8AcZIKZDJuYwU8XostEWoNccn
 xp/api/routers/errors.py,sha256=5vzpeTt0cPQZDHL5YgrYJUxMh4uI7IgUNFAvL0NpLKM,1267
 xp/cli/__init__.py,sha256=KWYwhOU46dNEerlc2i4FHsVR4Fxmt90Pw5L5i2v1Jqc,80
 xp/cli/__main__.py,sha256=l2iKwMdat5rTGd3JWs-uGksnYYDDffp_Npz05QdKEeU,117
-xp/cli/commands/__init__.py,sha256=_Ia9P0gK7tCeiWbuU7p8RPgvBhQx1kFC6i3b1g1UuOo,4482
+xp/cli/commands/__init__.py,sha256=dJ_VaOojg14vdx4OwxbDH-egJd16h3uT7f5DSQX4ZB0,4459
 xp/cli/commands/api.py,sha256=d9uD5NnDV807suEK6eLzJSl62TGTtFSwIA_foPc6wtg,340
 xp/cli/commands/api_start_commands.py,sha256=q9yOkiIY-NmRD04pq3N6rRe-BjnrcMRZmai8Jg5TKhA,3116
 xp/cli/commands/conbus/__init__.py,sha256=gE3K5OEoXkkZX8UOc2v3nreQQzwkOQi7n0VZ-Z2juXA,495
@@ -29,7 +29,7 @@ xp/cli/commands/conbus/conbus_config_commands.py,sha256=MBLt7Z95-v2Drvr80r4HQxx8
 xp/cli/commands/conbus/conbus_custom_commands.py,sha256=NH8WDm31-7tb-KYH8nZprEXgo8a4asLWmNd0EgJVSHQ,1336
 xp/cli/commands/conbus/conbus_datapoint_commands.py,sha256=Ozc36DFKVfzDZyWU9xVdhebiYy8yodb_DgVKEpzK9Jg,2842
 xp/cli/commands/conbus/conbus_discover_commands.py,sha256=5HwuhlC3qyYJqLBuqQVyu5kr493BJOZ281V2pXtfoCY,961
-xp/cli/commands/conbus/conbus_lightlevel_commands.py,sha256=-0rkE6Y5XForr3WRYSuBT02JO2rXuXLYHkEwbMVNF14,3744
+xp/cli/commands/conbus/conbus_lightlevel_commands.py,sha256=hMzQewTgqGNB6s_Pag2HNfImhpgXnitwUVgMM6XXJv8,4161
 xp/cli/commands/conbus/conbus_linknumber_commands.py,sha256=Q8hh222Gq7xDD-dRvwS4tiLQj3l913n-Vk1J73QxGGc,1954
 xp/cli/commands/conbus/conbus_msactiontable_commands.py,sha256=n1g-ZKjjjbCQqTPGCrcCB595QoRClv0DGvGEx8y7BAY,1728
 xp/cli/commands/conbus/conbus_output_commands.py,sha256=B_N31H4uBjahBxr6VNsj_bnsJsqkQc4CTIofDBKY4v8,2885
@@ -118,7 +118,7 @@ xp/services/conbus/actiontable/msactiontable_service.py,sha256=89pxbUVlKd6mplpIe
 xp/services/conbus/actiontable/msactiontable_xp20_serializer.py,sha256=EYspooOdi0Z8oaXGxpazwnUoTmh-d7U9auhu11iBgmU,6527
 xp/services/conbus/actiontable/msactiontable_xp24_serializer.py,sha256=J_ve6uyMmsb_QT2Py1ciZngf4C0pfHpkbWFc8OL2QEk,3752
 xp/services/conbus/actiontable/msactiontable_xp33_serializer.py,sha256=AeGBbum5eIqlgVm9t4igfF6vyl-ACVpuzSUQm4TYfUQ,7962
-xp/services/conbus/conbus_autoreport_get_service.py,sha256=d97x_2AMq9BZsRS8ZvwN-LgdyNPzdDiyqjSqvWDqYjQ,4949
+xp/services/conbus/conbus_autoreport_get_service.py,sha256=mNWFOt0-Ahx5N_Ayyq4oa-rdf2Xcu4rwz7erIjfdNBg,5206
 xp/services/conbus/conbus_autoreport_set_service.py,sha256=0fa2xGVE1GSoBvEcOH8cnjAdhvEoamvHE27t40f7lUk,4937
 xp/services/conbus/conbus_blink_all_service.py,sha256=t_oaztEFRirjS3nL50AEBrKKpNXYssWwSBwWjWhhKqU,5959
 xp/services/conbus/conbus_blink_service.py,sha256=mHaD-84RCmEGqD2cD4Ve85A36D08tMBPwMgDEyAEMCc,5031
@@ -127,7 +127,8 @@ xp/services/conbus/conbus_custom_service.py,sha256=jM6B085GTT8epCE9EqVTT8mZLPMXM
 xp/services/conbus/conbus_datapoint_queryall_service.py,sha256=FBpFmwXVKoTiqMwQW-z2eYbamKL_ZGlTI86720ZcGt8,6095
 xp/services/conbus/conbus_datapoint_service.py,sha256=CspxjhEi8awX_dv6EpJpYjTtCsfLgjJ4ROl6jD1TOiY,5289
 xp/services/conbus/conbus_discover_service.py,sha256=kA_ewxXgbqXng0cXBjSgQSGYesyesbN2wK0tMp1fgfc,4281
-xp/services/conbus/conbus_lightlevel_service.py,sha256=Lfa1ruDDA4_M1103Ha-wSlGSjZmsGDpXuF22RfGBYDQ,7243
+xp/services/conbus/conbus_lightlevel_get_service.py,sha256=vrr5HhR5l58oOezTz2rorO-RHoyGbVuHrx2rGfKvH20,5739
+xp/services/conbus/conbus_lightlevel_set_service.py,sha256=6Mhq9xjWx-ixGVfcWBcJSnuYT256m8Lps1g8Tg-1nkM,7483
 xp/services/conbus/conbus_linknumber_service.py,sha256=r3Lyb7IV4i5kRY6zTnRK9jmC1vo8dpyHwh4WwdwrlL4,7703
 xp/services/conbus/conbus_output_service.py,sha256=_sHGF6AWadhT_CNSnRPaXwQLaNEwQHSVuyKtyZ9jgFc,5115
 xp/services/conbus/conbus_raw_service.py,sha256=riANTAiXTdSzOWbp_g-IQjdRhAf8CzZnNJtlT-aDvRs,3746
@@ -174,8 +175,8 @@ xp/services/telegram/telegram_service.py,sha256=Mp20QB50WDp43QBl8TzsR9BKV_hHP53R
 xp/services/telegram/telegram_version_service.py,sha256=21v256THg0lidTyUtp2i8r6TAl8J0CTaZo4bZw59nFk,10479
 xp/utils/__init__.py,sha256=clisBctja_VwtkAM9wnbOGDRPfbKHlCUqq4Sa4Z6zng,331
 xp/utils/checksum.py,sha256=HDpiQxmdIedbCbZ4o_Box0i_Zig417BtCV_46ZyhiTk,1711
-xp/utils/dependencies.py,sha256=ZG374ofjrWF7P4MqO3vpeuweD5M9d_RL0682ouJrQ3M,20566
+xp/utils/dependencies.py,sha256=VztcJM27MA6mykoVuX84zXMRsmKYuSGsVOKu5Gaw0b4,20490
 xp/utils/event_helper.py,sha256=W-A_xmoXlpWZBbJH6qdaN50o3-XrwFsDgvAGMJDiAgo,1001
 xp/utils/serialization.py,sha256=hZcrpzaBOe3a2wS_RFCIRs9PvnYsrbK7Ulq6s1rU0q4,4456
 xp/utils/time_utils.py,sha256=Yi3JxHrHsd9ZZxTBRIqlTOz1FYTCeE1IZbefDaXIop8,3800
-conson_xp-0.11.19.dist-info/RECORD,,
+conson_xp-0.11.21.dist-info/RECORD,,

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"

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,

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)

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:

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()

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
+        )

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,
         )

xp/services/conbus/conbus_lightlevel_service.py

@@ -1,205 +0,0 @@
-"""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 Any, Optional
-
-from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
-from xp.models.telegram.datapoint_type import DataPointType
-from xp.models.telegram.system_function import SystemFunction
-from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
-from xp.services.conbus.conbus_service import ConbusService
-from xp.services.telegram.telegram_service import TelegramService
-
-
-class ConbusLightlevelError(Exception):
-    """Raised when Conbus lightlevel operations fail"""
-
-    pass
-
-
-class ConbusLightlevelService:
-    """
-    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,
-        telegram_service: TelegramService,
-        conbus_service: ConbusService,
-        datapoint_service: ConbusDatapointService,
-    ):
-        """Initialize the Conbus lightlevel service"""
-
-        # Service dependencies
-        self.telegram_service = telegram_service
-        self.conbus_service = conbus_service
-        self.datapoint_service = datapoint_service
-
-        # Set up logging
-        self.logger = logging.getLogger(__name__)
-
-    def __enter__(self) -> "ConbusLightlevelService":
-        return self
-
-    def __exit__(
-        self,
-        _exc_type: Optional[type],
-        _exc_val: Optional[Exception],
-        _exc_tb: Optional[Any],
-    ) -> None:
-        # Cleanup logic if needed
-        pass
-
-    def set_lightlevel(
-        self, serial_number: str, output_number: int, level: int
-    ) -> ConbusLightlevelResponse:
-        """Set light level for a specific output on a module.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-based)
-            level: Light level percentage (0-100)
-
-        Returns:
-            ConbusLightlevelResponse with operation result
-        """
-
-        # Validate output_number range (0-8)
-        if not 0 <= output_number <= 8:
-            return ConbusLightlevelResponse(
-                success=False,
-                serial_number=serial_number,
-                output_number=output_number,
-                level=level,
-                timestamp=datetime.now(),
-                error=f"Output number must be between 0 and 8, got {output_number}",
-            )
-
-        # Validate level range
-        if not 0 <= level <= 100:
-            return ConbusLightlevelResponse(
-                success=False,
-                serial_number=serial_number,
-                output_number=output_number,
-                level=level,
-                timestamp=datetime.now(),
-                error=f"Light level must be between 0 and 100, got {level}",
-            )
-
-        # Format data as output_number:level (e.g., "02:050")
-        data = f"{output_number:02d}:{level:03d}"
-
-        # Send telegram using WRITE_CONFIG function with MODULE_LIGHT_LEVEL datapoint
-        response = self.conbus_service.send_telegram(
-            serial_number,
-            SystemFunction.WRITE_CONFIG,  # "04"
-            f"{DataPointType.MODULE_LIGHT_LEVEL.value}{data}",  # "15" + "02:050"
-        )
-
-        return ConbusLightlevelResponse(
-            success=response.success,
-            serial_number=serial_number,
-            output_number=output_number,
-            level=level,
-            timestamp=response.timestamp or datetime.now(),
-            sent_telegram=response.sent_telegram,
-            received_telegrams=response.received_telegrams,
-            error=response.error,
-        )
-
-    def turn_off(
-        self, serial_number: str, output_number: int
-    ) -> ConbusLightlevelResponse:
-        """Turn off light (set level to 0) for a specific output.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-8)
-
-        Returns:
-            ConbusLightlevelResponse with operation result
-        """
-        return self.set_lightlevel(serial_number, output_number, 0)
-
-    def turn_on(
-        self, serial_number: str, output_number: int
-    ) -> ConbusLightlevelResponse:
-        """Turn on light (set level to 80%) for a specific output.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-8)
-
-        Returns:
-            ConbusLightlevelResponse with operation result
-        """
-        return self.set_lightlevel(serial_number, output_number, 80)
-
-    def get_lightlevel(
-        self, serial_number: str, output_number: int
-    ) -> ConbusLightlevelResponse:
-        """Query current light level for a specific output.
-
-        Args:
-            serial_number: Module serial number
-            output_number: Output number (0-8)
-
-        Returns:
-            ConbusLightlevelResponse with current light level
-        """
-
-        # TODO: Migrate to new ConbusDatapointService callback-based API
-        # Query MODULE_LIGHT_LEVEL datapoint
-        datapoint_response = self.datapoint_service.query_datapoint(  # type: ignore[call-arg,func-returns-value]
-            serial_number=serial_number,
-            datapoint_type=DataPointType.MODULE_LIGHT_LEVEL,
-        )
-
-        if not datapoint_response.success:
-            return ConbusLightlevelResponse(
-                success=False,
-                serial_number=serial_number,
-                output_number=output_number,
-                level=None,
-                timestamp=datetime.now(),
-                error=datapoint_response.error or "Failed to query light level",
-            )
-
-        # Parse the response to extract level for specific output
-        level = None
-        if (
-            datapoint_response.datapoint_telegram
-            and datapoint_response.datapoint_telegram.data_value
-        ):
-            try:
-                # Parse response format like "00:050,01:025,02:100"
-                data_value = str(datapoint_response.datapoint_telegram.data_value)
-                for output_data in data_value.split(","):
-                    if ":" in output_data:
-                        output_str, level_str = output_data.split(":")
-                        if int(output_str) == output_number:
-                            level_str = level_str.replace("[%]", "")
-                            level = int(level_str)
-                            break
-            except (ValueError, AttributeError) as e:
-                self.logger.debug(f"Failed to parse light level data: {e}")
-
-        return ConbusLightlevelResponse(
-            success=datapoint_response.success,
-            serial_number=serial_number,
-            output_number=output_number,
-            level=level,
-            timestamp=datetime.now(),
-            sent_telegram=datapoint_response.sent_telegram,
-            received_telegrams=datapoint_response.received_telegrams,
-            error=datapoint_response.error if level is None else None,
-        )