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

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

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

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

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

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

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

conson_xp-1.0.1/src/xp/cli/commands/conbus/conbus_config_commands.py

@@ -0,0 +1,24 @@
+import json
+
+import click
+from click import Context
+
+from xp.cli.commands.conbus.conbus import conbus
+from xp.cli.utils.decorators import handle_service_errors
+from xp.models import ConbusClientConfig
+
+
+@conbus.command("config")
+@click.pass_context
+@handle_service_errors(Exception)
+def show_config(ctx: Context) -> None:
+    """
+    Display current Conbus client configuration.
+
+    Examples:
+
+    \b
+        xp conbus config
+    """
+    config = ctx.obj.get("container").get_container().resolve(ConbusClientConfig)
+    click.echo(json.dumps(config.conbus.model_dump(mode="json"), indent=2))

{conson_xp-0.11.21 → conson_xp-1.0.1}/src/xp/cli/commands/conbus/conbus_linknumber_commands.py

@@ -7,11 +7,11 @@ import click
 from xp.cli.commands.conbus.conbus import conbus_linknumber
 from xp.cli.utils.decorators import (
     connection_command,
-    handle_service_errors,
 )
 from xp.cli.utils.serial_number_type import SERIAL
-from xp.services.conbus.conbus_linknumber_service import ConbusLinknumberService
-from xp.services.telegram.telegram_link_number_service import LinkNumberError
+from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
+from xp.services.conbus.conbus_linknumber_get_service import ConbusLinknumberGetService
+from xp.services.conbus.conbus_linknumber_set_service import ConbusLinknumberSetService
 
 
 @conbus_linknumber.command("set", short_help="Set link number for a module")
@@ -19,7 +19,6 @@ from xp.services.telegram.telegram_link_number_service import LinkNumberError
 @click.argument("link_number", type=click.IntRange(0, 99))
 @click.pass_context
 @connection_command()
-@handle_service_errors(LinkNumberError)
 def set_linknumber_command(
     ctx: click.Context, serial_number: str, link_number: int
 ) -> None:
@@ -34,18 +33,25 @@ def set_linknumber_command(
     \b
         xp conbus linknumber set 0123450001 25
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLinknumberService)
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLinknumberSetService)
+    )
 
-    with service:
-        response = service.set_linknumber(serial_number, link_number)
+    def on_finish(response: ConbusLinknumberResponse) -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    with service:
+        service.set_linknumber(
+            serial_number=serial_number,
+            link_number=link_number,
+            finish_callback=on_finish,
+        )
+
 
 @conbus_linknumber.command("get", short_help="Get link number for a module")
 @click.argument("serial_number", type=SERIAL)
 @click.pass_context
 @connection_command()
-@handle_service_errors(LinkNumberError)
 def get_linknumber_command(ctx: click.Context, serial_number: str) -> None:
     """
     Get the current link number for a specific module.
@@ -57,8 +63,15 @@ def get_linknumber_command(ctx: click.Context, serial_number: str) -> None:
     \b
         xp conbus linknumber get 0123450001
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusLinknumberService)
+    service = (
+        ctx.obj.get("container").get_container().resolve(ConbusLinknumberGetService)
+    )
 
-    with service:
-        response = service.get_linknumber(serial_number)
+    def on_finish(response: ConbusLinknumberResponse) -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
+
+    with service:
+        service.get_linknumber(
+            serial_number=serial_number,
+            finish_callback=on_finish,
+        )

{conson_xp-0.11.21 → conson_xp-1.0.1}/src/xp/cli/commands/conbus/conbus_output_commands.py

@@ -9,7 +9,11 @@ from xp.cli.utils.decorators import (
     connection_command,
 )
 from xp.cli.utils.serial_number_type import SERIAL
+from xp.models import ConbusDatapointResponse
+from xp.models.conbus.conbus_output import ConbusOutputResponse
 from xp.models.telegram.action_type import ActionType
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 
 
@@ -24,16 +28,20 @@ def xp_output_on(ctx: click.Context, serial_number: str, output_number: int) ->
     Examples:
 
     \b
-        xp conbus input on 0011223344 0  # Toggle input 0
+        xp conbus output on 0011223344 0  # Turn on output 0
     """
     service = ctx.obj.get("container").get_container().resolve(ConbusOutputService)
 
-    with service:
+    def on_finish(response: ConbusOutputResponse) -> None:
+        click.echo(json.dumps(response.to_dict(), indent=2))
 
-        response = service.send_action(
-            serial_number, output_number, ActionType.ON_RELEASE
+    with service:
+        service.send_action(
+            serial_number=serial_number,
+            output_number=output_number,
+            action_type=ActionType.ON_RELEASE,
+            finish_callback=on_finish,
         )
-        click.echo(json.dumps(response.to_dict(), indent=2))
 
 
 @conbus_output.command("off")
@@ -47,16 +55,20 @@ def xp_output_off(ctx: click.Context, serial_number: str, output_number: int) ->
     Examples:
 
     \b
-        xp conbus input off 0011223344 1    # Toggle input 1
+        xp conbus output off 0011223344 1    # Turn off output 1
     """
     service = ctx.obj.get("container").get_container().resolve(ConbusOutputService)
 
-    with service:
+    def on_finish(response: ConbusOutputResponse) -> None:
+        click.echo(json.dumps(response.to_dict(), indent=2))
 
-        response = service.send_action(
-            serial_number, output_number, ActionType.OFF_PRESS
+    with service:
+        service.send_action(
+            serial_number=serial_number,
+            output_number=output_number,
+            action_type=ActionType.OFF_PRESS,
+            finish_callback=on_finish,
         )
-        click.echo(json.dumps(response.to_dict(), indent=2))
 
 
 @conbus_output.command("status")
@@ -71,13 +83,20 @@ def xp_output_status(ctx: click.Context, serial_number: str) -> None:
     \b
         xp conbus output status 0011223344    # Query output status
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusOutputService)
-
-    with service:
+    service: ConbusDatapointService = (
+        ctx.obj.get("container").get_container().resolve(ConbusDatapointService)
+    )
 
-        response = service.get_output_state(serial_number)
+    def on_finish(response: ConbusDatapointResponse) -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
 
+    with service:
+        service.query_datapoint(
+            serial_number=serial_number,
+            datapoint_type=DataPointType.MODULE_OUTPUT_STATE,
+            finish_callback=on_finish,
+        )
+
 
 @conbus_output.command("state")
 @click.argument("serial_number", type=SERIAL)
@@ -91,9 +110,16 @@ def xp_module_state(ctx: click.Context, serial_number: str) -> None:
     \b
         xp conbus output state 0011223344    # Query module state
     """
-    service = ctx.obj.get("container").get_container().resolve(ConbusOutputService)
+    service: ConbusDatapointService = (
+        ctx.obj.get("container").get_container().resolve(ConbusDatapointService)
+    )
 
-    with service:
-
-        response = service.get_module_state(serial_number)
+    def on_finish(response: ConbusDatapointResponse) -> None:
         click.echo(json.dumps(response.to_dict(), indent=2))
+
+    with service:
+        service.query_datapoint(
+            serial_number=serial_number,
+            datapoint_type=DataPointType.MODULE_STATE,
+            finish_callback=on_finish,
+        )

{conson_xp-0.11.21 → conson_xp-1.0.1}/src/xp/models/conbus/conbus.py

@@ -32,24 +32,25 @@ class ConbusResponse:
     """Represents a response from Conbus send operation"""
 
     success: bool
-    request: ConbusRequest
-    sent_telegram: Optional[str] = None
-    received_telegrams: Optional[list[str]] = None
-    error: Optional[str] = None
-    timestamp: Optional[datetime] = None
+    sent_telegrams: list[str]
+    received_telegrams: list[str]
+    timestamp: datetime
+    error: str = ""
+    serial_number: str = ""
+    function_code: str = ""
 
     def __post_init__(self) -> None:
-        if self.timestamp is None:
-            self.timestamp = datetime.now()
-        if self.received_telegrams is None:
-            self.received_telegrams = []
+        self.timestamp = datetime.now()
+        self.sent_telegrams = []
+        self.received_telegrams = []
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert to dictionary for JSON serialization"""
         return {
             "success": self.success,
-            "request": self.request.to_dict(),
-            "sent_telegram": self.sent_telegram,
+            "serial_number": self.serial_number,
+            "function_code": self.function_code,
+            "sent_telegrams": self.sent_telegrams,
             "received_telegrams": self.received_telegrams,
             "error": self.error,
             "timestamp": self.timestamp.isoformat() if self.timestamp else None,

conson_xp-1.0.1/src/xp/services/conbus/conbus_autoreport_get_service.py

@@ -0,0 +1,85 @@
+"""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 typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
+from xp.models.conbus.conbus_autoreport import ConbusAutoreportResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusAutoreportGetService(ConbusDatapointService):
+    """
+    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__(telegram_service, cli_config, reactor)
+        self.service_callback: Optional[Callable[[ConbusAutoreportResponse], None]] = (
+            None
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
+
+        self.logger.debug("Parsing datapoint response")
+        autoreport_status = ""
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            autoreport_status = datapoint_response.datapoint_telegram.data_value
+
+        service_response = ConbusAutoreportResponse(
+            success=datapoint_response.success,
+            serial_number=self.serial_number,
+            auto_report_status=autoreport_status,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datapoint_response.timestamp,
+        )
+
+        if self.service_callback:
+            self.service_callback(service_response)
+
+    def get_autoreport_status(
+        self,
+        serial_number: str,
+        finish_callback: Callable[[ConbusAutoreportResponse], 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  finish_callback: callback function to call when the linknumber status is
+            :param  timeout_seconds: timeout in seconds
+
+        """
+        self.logger.info("Starting get_autoreport_status")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.datapoint_type = DataPointType.AUTO_REPORT_STATUS
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
+        self.start_reactor()

{conson_xp-0.11.21 → conson_xp-1.0.1}/src/xp/services/conbus/conbus_datapoint_service.py

@@ -12,6 +12,7 @@ from twisted.internet.posixbase import PosixReactorBase
 from xp.models import ConbusClientConfig, ConbusDatapointResponse
 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
@@ -93,13 +94,16 @@ class ConbusDatapointService(ConbusProtocol):
             return
 
         self.logger.debug("Received datapoint telegram")
+        self.succeed(datapoint_telegram)
+
+    def succeed(self, datapoint_telegram: ReplyTelegram) -> None:
+        self.logger.debug("Succeed querying datapoint")
         self.service_response.success = True
         self.service_response.timestamp = datetime.now()
         self.service_response.serial_number = self.serial_number
         self.service_response.system_function = SystemFunction.READ_DATAPOINT
         self.service_response.datapoint_type = self.datapoint_type
         self.service_response.datapoint_telegram = datapoint_telegram
-
         if self.finish_callback:
             self.finish_callback(self.service_response)
 
@@ -107,6 +111,7 @@ class ConbusDatapointService(ConbusProtocol):
         self.logger.debug(f"Failed with message: {message}")
         self.service_response.success = False
         self.service_response.timestamp = datetime.now()
+        self.service_response.serial_number = self.serial_number
         self.service_response.error = message
         if self.finish_callback:
             self.finish_callback(self.service_response)

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

@@ -0,0 +1,101 @@
+"""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, ConbusDatapointResponse
+from xp.models.conbus.conbus_lightlevel import ConbusLightlevelResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusLightlevelGetService(ConbusDatapointService):
+    """
+    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__(telegram_service, cli_config, reactor)
+        self.output_number: int = 0
+        self.service_callback: Optional[Callable[[ConbusLightlevelResponse], None]] = (
+            None
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
+
+        self.logger.debug("Parsing datapoint response")
+
+        level = 0
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            for output_data in datapoint_response.datapoint_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
+
+        service_response = ConbusLightlevelResponse(
+            success=datapoint_response.success,
+            serial_number=self.serial_number,
+            output_number=self.output_number,
+            level=level,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datetime.now(),
+        )
+
+        if self.service_callback:
+            self.service_callback(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.serial_number = serial_number
+        self.output_number = output_number
+        self.datapoint_type = DataPointType.MODULE_LIGHT_LEVEL
+
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
+        self.start_reactor()

conson_xp-1.0.1/src/xp/services/conbus/conbus_linknumber_get_service.py

@@ -0,0 +1,86 @@
+"""Conbus Link Number Service for setting module link numbers.
+
+This service handles setting link numbers for modules through Conbus telegrams.
+"""
+
+import logging
+from typing import Callable, Optional
+
+from twisted.internet.posixbase import PosixReactorBase
+
+from xp.models import ConbusClientConfig, ConbusDatapointResponse
+from xp.models.conbus.conbus_linknumber import ConbusLinknumberResponse
+from xp.models.telegram.datapoint_type import DataPointType
+from xp.services.conbus.conbus_datapoint_service import ConbusDatapointService
+from xp.services.telegram.telegram_service import TelegramService
+
+
+class ConbusLinknumberGetService(ConbusDatapointService):
+    """
+    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__(telegram_service, cli_config, reactor)
+        self.service_callback: Optional[Callable[[ConbusLinknumberResponse], None]] = (
+            None
+        )
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+
+    def finish_service_callback(
+        self, datapoint_response: ConbusDatapointResponse
+    ) -> None:
+
+        self.logger.debug("Parsing datapoint response")
+        link_number_value = 0
+        if datapoint_response.success and datapoint_response.datapoint_telegram:
+            link_number_value = int(datapoint_response.datapoint_telegram.data_value)
+
+        linknumber_response = ConbusLinknumberResponse(
+            success=datapoint_response.success,
+            result="SUCCESS" if datapoint_response.success else "FAILURE",
+            link_number=link_number_value,
+            serial_number=self.serial_number,
+            error=datapoint_response.error,
+            sent_telegram=datapoint_response.sent_telegram,
+            received_telegrams=datapoint_response.received_telegrams,
+            timestamp=datapoint_response.timestamp,
+        )
+
+        if self.service_callback:
+            self.service_callback(linknumber_response)
+
+    def get_linknumber(
+        self,
+        serial_number: str,
+        finish_callback: Callable[[ConbusLinknumberResponse], 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  finish_callback: callback function to call when the linknumber status is
+            :param  timeout_seconds: timeout in seconds
+
+        """
+        self.logger.info("Starting get_linknumber")
+        if timeout_seconds:
+            self.timeout_seconds = timeout_seconds
+        self.serial_number = serial_number
+        self.datapoint_type = DataPointType.LINK_NUMBER
+        self.finish_callback = self.finish_service_callback
+        self.service_callback = finish_callback
+        self.start_reactor()