conson-xp 1.19.0__tar.gz → 1.21.0__tar.gz

{conson_xp-1.19.0 → conson_xp-1.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.19.0
+Version: 1.21.0
 Summary: XP Protocol Communication Tools
 Author-Email: ldvchosal <ldvchosal@github.com>
 License: MIT License
@@ -48,6 +48,7 @@ Requires-Dist: punq>=0.7.0
 Requires-Dist: twisted>=25.5.0
 Requires-Dist: bubus>=1.5.6
 Requires-Dist: psygnal>=0.15.0
+Requires-Dist: textual>=1.0.0
 Description-Content-Type: text/markdown
 
 # 🔌 XP Protocol Communication Tool
@@ -398,6 +399,10 @@ xp telegram parse
 xp telegram validate
 xp telegram version
 
+
+xp term
+xp term protocol
+
 <!-- END CLI HELP -->
 ```
 </details>

{conson_xp-1.19.0 → conson_xp-1.21.0}/README.md

@@ -346,6 +346,10 @@ xp telegram parse
 xp telegram validate
 xp telegram version
 
+
+xp term
+xp term protocol
+
 <!-- END CLI HELP -->
 ```
 </details>

{conson_xp-1.19.0 → conson_xp-1.21.0}/pyproject.toml

@@ -18,10 +18,11 @@ dependencies = [
     "twisted>=25.5.0",
     "bubus>=1.5.6",
     "psygnal>=0.15.0",
+    "textual>=1.0.0",
 ]
 requires-python = ">=3.11"
 readme = "README.md"
-version = "1.19.0"
+version = "1.21.0"
 
 [project.license]
 file = "LICENSE"
@@ -56,6 +57,7 @@ dev = [
     "isort>=6.0.1",
     "absolufy-imports>=0.3.1",
     "pytest-asyncio>=1.2.0",
+    "types-docutils>=0.22.2.20251006",
 ]
 
 [tool.pytest.ini_options]

{conson_xp-1.19.0 → conson_xp-1.21.0}/src/xp/__init__.py

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

{conson_xp-1.19.0 → conson_xp-1.21.0}/src/xp/cli/commands/__init__.py

@@ -86,6 +86,8 @@ from xp.cli.commands.telegram.telegram_parse_commands import (
     validate_telegram,
 )
 from xp.cli.commands.telegram.telegram_version_commands import generate_version_request
+from xp.cli.commands.term.term import term
+from xp.cli.commands.term.term_commands import protocol_monitor
 
 __all__ = [
     # Main command groups (conbus excluded to avoid module shadowing)
@@ -109,7 +111,9 @@ __all__ = [
     "checksum",
     "homekit",
     "homekit_start",
+    "term",
     # Individual command functions
+    "protocol_monitor",
     "conbus_download_msactiontable",
     "conbus_download_actiontable",
     "send_blink_on_telegram",

{conson_xp-1.19.0 → conson_xp-1.21.0}/src/xp/cli/commands/conbus/conbus_receive_commands.py

@@ -56,4 +56,5 @@ def receive_telegrams(ctx: Context, timeout: float) -> None:
         ctx.obj.get("container").get_container().resolve(ConbusReceiveService)
     )
     with service:
-        service.start(progress, on_finish, timeout)
+        service.init(progress, on_finish, timeout)
+        service.start_reactor()

conson_xp-1.21.0/src/xp/cli/commands/term/__init__.py

@@ -0,0 +1,5 @@
+"""Term CLI commands package for TUI interfaces."""
+
+from xp.cli.commands.term.term import term
+
+__all__ = ["term"]

conson_xp-1.21.0/src/xp/cli/commands/term/term.py

@@ -0,0 +1,12 @@
+"""Term CLI group definition for TUI commands."""
+
+import click
+from click_help_colors import HelpColorsGroup
+
+
+@click.group(
+    cls=HelpColorsGroup, help_headers_color="yellow", help_options_color="green"
+)
+def term() -> None:
+    """Terminal UI commands for interactive monitoring and control."""
+    pass

conson_xp-1.21.0/src/xp/cli/commands/term/term_commands.py

@@ -0,0 +1,31 @@
+"""Term protocol CLI command for TUI monitoring."""
+
+import click
+from click import Context
+
+from xp.cli.commands.term.term import term
+
+
+@term.command("protocol")
+@click.pass_context
+def protocol_monitor(ctx: Context) -> None:
+    r"""Start TUI for real-time protocol monitoring.
+
+    Displays live RX/TX telegram stream from Conbus server
+    in an interactive terminal interface.
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp term protocol
+    """
+    from xp.term.app import ProtocolMonitorApp
+
+    # Resolve ServiceContainer from context
+    container = ctx.obj.get("container").get_container()
+
+    # Initialize and run Textual app
+    app = ProtocolMonitorApp(container=container)
+    app.run()

{conson_xp-1.19.0 → conson_xp-1.21.0}/src/xp/cli/main.py

@@ -1,7 +1,5 @@
 """XP CLI tool entry point with modular command structure."""
 
-import logging
-
 import click
 from click_help_colors import HelpColorsGroup
 
@@ -16,8 +14,10 @@ from xp.cli.commands.server.server_commands import server
 
 # Import command groups from modular structure
 from xp.cli.commands.telegram.telegram_parse_commands import telegram
+from xp.cli.commands.term.term import term
 from xp.cli.utils.click_tree import add_tree_command
 from xp.utils.dependencies import ServiceContainer
+from xp.utils.logging import LoggerService
 
 
 @click.group(
@@ -31,44 +31,15 @@ def cli(ctx: click.Context) -> None:
     Args:
         ctx: Click context object for passing state between commands.
     """
-    # Configure logging with thread information
-    log_format = "%(asctime)s - [%(threadName)s-%(thread)d] - %(levelname)s - %(name)s - %(message)s"
-    date_format = "%H:%M:%S"
-
-    # Force format on root logger and all handlers
-    formatter = logging.Formatter(log_format, datefmt=date_format)
-    root_logger = logging.getLogger()
-    root_logger.setLevel(logging.DEBUG)
-
-    # Update all existing handlers or create new one
-    if root_logger.handlers:
-        for handler in root_logger.handlers:
-            handler.setFormatter(formatter)
-    else:
-        handler = logging.StreamHandler()
-        handler.setFormatter(formatter)
-        root_logger.addHandler(handler)
-
-    # Suppress pyhap.hap_protocol logs
-
-    # bubus
-    logging.getLogger("bubus").setLevel(logging.WARNING)
-
-    # xp
-    logging.getLogger("xp").setLevel(logging.DEBUG)
-    logging.getLogger("xp.services.homekit").setLevel(logging.DEBUG)
-
-    # pyhap
-    logging.getLogger("pyhap").setLevel(logging.WARNING)
-    logging.getLogger("pyhap.hap_handler").setLevel(logging.WARNING)
-    logging.getLogger("pyhap.hap_protocol").setLevel(logging.WARNING)
-    # logging.getLogger('pyhap.accessory_driver').setLevel(logging.WARNING)
+    container = ServiceContainer()
+    logger_config = container.get_container().resolve(LoggerService)
+    logger_config.setup()
 
     # Initialize the service container and store it in the context
     ctx.ensure_object(dict)
     # Only create a new container if one wasn't provided (e.g., for testing)
     if "container" not in ctx.obj:
-        ctx.obj["container"] = ServiceContainer()
+        ctx.obj["container"] = container
 
 
 # Register all command groups
@@ -79,6 +50,7 @@ cli.add_command(module)
 cli.add_command(file)
 cli.add_command(server)
 cli.add_command(reverse_proxy)
+cli.add_command(term)
 
 # Add the tree command
 add_tree_command(cli)

{conson_xp-1.19.0 → conson_xp-1.21.0}/src/xp/models/conbus/conbus_client_config.py

@@ -49,6 +49,7 @@ class ConbusClientConfig(BaseModel):
         except FileNotFoundError:
             logger.error(f"File {file_path} does not exist, loading default")
             return cls()
+
         except yaml.YAMLError:
             logger.error(f"File {file_path} is not valid")
             # Return default config if YAML parsing fails

conson_xp-1.21.0/src/xp/models/conbus/conbus_logger_config.py

@@ -0,0 +1,107 @@
+"""Logger configuration models for XP application."""
+
+import logging
+from pathlib import Path
+from typing import Dict, Union
+
+import yaml
+from pydantic import BaseModel, Field, field_validator
+
+
+class LoggingConfig(BaseModel):
+    """Logging configuration.
+
+    Attributes:
+        path: log folder.
+        default_level: DEBUG, WARNING, INFO, ERROR, CRITICAL.
+        levels: Per-module log level overrides.
+        max_bytes: Maximum size in bytes before rotating (default: 1MB).
+        backup_count: Number of backup files to keep (default: 365).
+        log_format: Log message format string.
+        date_format: Date format string for timestamps.
+    """
+
+    path: str = "log"
+    default_level: str = "DEBUG"
+    levels: Dict[str, int] = {
+        "xp": logging.DEBUG,
+        "xp.services.homekit": logging.WARNING,
+        "xp.services.server": logging.WARNING,
+    }
+    max_bytes: int = 1024 * 1024  # 1MB
+    backup_count: int = 365
+    log_format: str = (
+        "%(asctime)s - [%(threadName)s-%(thread)d] - %(levelname)s - %(name)s - %(message)s"
+    )
+    date_format: str = "%H:%M:%S"
+
+    @field_validator("levels", mode="before")
+    @classmethod
+    def convert_level_names(cls, v: Dict[str, Union[str, int]]) -> Dict[str, int]:
+        """Convert string level names to numeric values.
+
+        Args:
+            v: Dictionary with string or int log levels.
+
+        Returns:
+            Dictionary with numeric log levels.
+
+        Raises:
+            ValueError: If an invalid log level name is provided.
+        """
+        level_map = {
+            "DEBUG": logging.DEBUG,
+            "INFO": logging.INFO,
+            "WARNING": logging.WARNING,
+            "ERROR": logging.ERROR,
+            "CRITICAL": logging.CRITICAL,
+        }
+
+        result = {}
+        for module, level in v.items():
+            if isinstance(level, str):
+                level_upper = level.upper()
+                if level_upper not in level_map:
+                    raise ValueError(
+                        f"Invalid log level '{level}' for module '{module}'. "
+                        f"Must be one of: {', '.join(level_map.keys())}"
+                    )
+                result[module] = level_map[level_upper]
+            else:
+                result[module] = level
+        return result
+
+
+class ConbusLoggerConfig(BaseModel):
+    """Logging configuration.
+
+    Attributes:
+        log: LoggingConfig instance for logging settings.
+    """
+
+    log: LoggingConfig = Field(default_factory=LoggingConfig)
+
+    @classmethod
+    def from_yaml(cls, file_path: str) -> "ConbusLoggerConfig":
+        """Load configuration from YAML file.
+
+        Args:
+            file_path: Path to the YAML configuration file.
+
+        Returns:
+            ConbusClientConfig instance loaded from file or default config.
+        """
+        logger = logging.getLogger(__name__)
+        try:
+            with Path(file_path).open("r") as file:
+                data = yaml.safe_load(file)
+                return cls(**data)
+
+        except FileNotFoundError:
+            logger.error(f"File {file_path} does not exist, loading default")
+            return cls()
+
+        except yaml.YAMLError:
+            logger.error(f"File {file_path} is not valid")
+            # Return default config if YAML parsing fails
+            return cls()

conson_xp-1.21.0/src/xp/models/term/__init__.py

@@ -0,0 +1,11 @@
+"""Terminal UI models."""
+
+from xp.models.term.protocol_keys_config import (
+    ProtocolKeyConfig,
+    ProtocolKeysConfig,
+)
+
+__all__ = [
+    "ProtocolKeyConfig",
+    "ProtocolKeysConfig",
+]

conson_xp-1.21.0/src/xp/models/term/protocol_keys_config.py

@@ -0,0 +1,45 @@
+"""Protocol keys configuration model."""
+
+from pathlib import Path
+from typing import Dict
+
+import yaml
+from pydantic import BaseModel, Field
+
+
+class ProtocolKeyConfig(BaseModel):
+    """Configuration for a single protocol key.
+
+    Attributes:
+        name: Human-readable command name.
+        telegrams: List of raw telegram strings to send (without angle brackets).
+    """
+
+    name: str = Field(..., description="Human-readable command name")
+    telegrams: list[str] = Field(..., description="List of raw telegram strings")
+
+
+class ProtocolKeysConfig(BaseModel):
+    """Protocol keys configuration.
+
+    Attributes:
+        protocol: Dictionary mapping key to protocol configuration.
+    """
+
+    protocol: Dict[str, ProtocolKeyConfig] = Field(
+        default_factory=dict, description="Protocol key mappings"
+    )
+
+    @classmethod
+    def from_yaml(cls, config_path: Path) -> "ProtocolKeysConfig":
+        """Load protocol keys from YAML file.
+
+        Args:
+            config_path: Path to YAML configuration file.
+
+        Returns:
+            ProtocolKeysConfig instance.
+        """
+        with config_path.open("r") as f:
+            data = yaml.safe_load(f)
+        return cls(**data)

{conson_xp-1.19.0 → conson_xp-1.21.0}/src/xp/services/conbus/conbus_receive_service.py

@@ -1,51 +1,55 @@
 """Conbus Receive Service for receiving telegrams from Conbus servers.
 
-This service uses ConbusProtocol to provide receive-only functionality,
+This service uses ConbusEventProtocol to provide receive-only functionality,
 allowing clients to receive waiting event telegrams using empty telegram sends.
 """
 
+import asyncio
 import logging
-from typing import Callable, Optional
+from typing import Any, Callable, Optional
 
-from twisted.internet.posixbase import PosixReactorBase
-
-from xp.models import ConbusClientConfig
 from xp.models.conbus.conbus_receive import ConbusReceiveResponse
 from xp.models.protocol.conbus_protocol import TelegramReceivedEvent
-from xp.services.protocol import ConbusProtocol
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
 
 
-class ConbusReceiveService(ConbusProtocol):
+class ConbusReceiveService:
     """
     Service for receiving telegrams from Conbus servers.
 
-    Uses ConbusProtocol to provide receive-only functionality
+    Uses ConbusEventProtocol to provide receive-only functionality
     for collecting waiting event telegrams from the server.
+
+    Attributes:
+        conbus_protocol: Protocol instance for Conbus communication.
     """
 
-    def __init__(
-        self,
-        cli_config: ConbusClientConfig,
-        reactor: PosixReactorBase,
-    ) -> None:
+    conbus_protocol: ConbusEventProtocol
+
+    def __init__(self, conbus_protocol: ConbusEventProtocol) -> None:
         """Initialize the Conbus receive service.
 
         Args:
-            cli_config: Conbus client configuration.
-            reactor: Twisted reactor instance.
+            conbus_protocol: ConbusEventProtocol instance.
         """
-        super().__init__(cli_config, reactor)
         self.progress_callback: Optional[Callable[[str], None]] = None
         self.finish_callback: Optional[Callable[[ConbusReceiveResponse], None]] = None
         self.receive_response: ConbusReceiveResponse = ConbusReceiveResponse(
             success=True
         )
 
+        self.conbus_protocol: ConbusEventProtocol = conbus_protocol
+        self.conbus_protocol.on_connection_made.connect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.connect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.connect(self.telegram_received)
+        self.conbus_protocol.on_timeout.connect(self.timeout)
+        self.conbus_protocol.on_failed.connect(self.failed)
+
         # Set up logging
         self.logger = logging.getLogger(__name__)
 
-    def connection_established(self) -> None:
-        """Handle connection established event."""
+    def connection_made(self) -> None:
+        """Handle connection made event."""
         self.logger.debug("Connection established, waiting for telegrams.")
 
     def telegram_sent(self, telegram_sent: str) -> None:
@@ -70,17 +74,13 @@ class ConbusReceiveService(ConbusProtocol):
             self.receive_response.received_telegrams = []
         self.receive_response.received_telegrams.append(telegram_received.frame)
 
-    def timeout(self) -> bool:
-        """Handle timeout event to stop receiving.
-
-        Returns:
-            False to stop the reactor.
-        """
-        self.logger.info("Receive stopped after: %ss", self.timeout_seconds)
+    def timeout(self) -> None:
+        """Handle timeout event to stop receiving."""
+        timeout = self.conbus_protocol.timeout_seconds
+        self.logger.info("Receive stopped after: %ss", timeout)
         self.receive_response.success = True
         if self.finish_callback:
             self.finish_callback(self.receive_response)
-        return False
 
     def failed(self, message: str) -> None:
         """Handle failed connection event.
@@ -94,22 +94,50 @@ class ConbusReceiveService(ConbusProtocol):
         if self.finish_callback:
             self.finish_callback(self.receive_response)
 
-    def start(
+    def init(
         self,
         progress_callback: Callable[[str], None],
         finish_callback: Callable[[ConbusReceiveResponse], None],
         timeout_seconds: Optional[float] = None,
+        event_loop: Optional[asyncio.AbstractEventLoop] = None,
     ) -> None:
-        """Run reactor in dedicated thread with its own event loop.
+        """Setup callbacks and timeout for receiving telegrams.
 
         Args:
             progress_callback: Callback for each received telegram.
             finish_callback: Callback when receiving completes.
             timeout_seconds: Optional timeout in seconds.
+            event_loop: Optional event loop to use for async operations.
         """
         self.logger.info("Starting receive")
         if timeout_seconds:
-            self.timeout_seconds = timeout_seconds
+            self.conbus_protocol.timeout_seconds = timeout_seconds
         self.progress_callback = progress_callback
         self.finish_callback = finish_callback
-        self.start_reactor()
+
+        if event_loop:
+            self.conbus_protocol.set_event_loop(event_loop)
+
+    def start_reactor(self) -> None:
+        """Start the reactor."""
+        self.conbus_protocol.start_reactor()
+
+    def __enter__(self) -> "ConbusReceiveService":
+        """Enter context manager.
+
+        Returns:
+            Self for context manager protocol.
+        """
+        # Reset state for singleton reuse
+        self.receive_response = ConbusReceiveResponse(success=True)
+        return self
+
+    def __exit__(
+        self, _exc_type: Optional[type], _exc_val: Optional[Exception], _exc_tb: Any
+    ) -> None:
+        """Exit context manager and disconnect signals."""
+        self.conbus_protocol.on_connection_made.disconnect(self.connection_made)
+        self.conbus_protocol.on_telegram_sent.disconnect(self.telegram_sent)
+        self.conbus_protocol.on_telegram_received.disconnect(self.telegram_received)
+        self.conbus_protocol.on_timeout.disconnect(self.timeout)
+        self.conbus_protocol.on_failed.disconnect(self.failed)

{conson_xp-1.19.0 → conson_xp-1.21.0}/src/xp/services/protocol/conbus_event_protocol.py

@@ -3,6 +3,7 @@
 This module implements the Twisted protocol for Conbus communication.
 """
 
+import asyncio
 import logging
 from queue import SimpleQueue
 from random import randint
@@ -208,6 +209,14 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             f"F{system_function.value}"
             f"D{data_value}"
         )
+        self.send_raw_telegram(payload)
+
+    def send_raw_telegram(self, payload: str) -> None:
+        """Send telegram with specified parameters.
+
+        Args:
+            payload: Telegram to send.
+        """
         self.telegram_queue.put_nowait(payload.encode())
         self.call_later(0.0, self.start_queue_manager)
 
@@ -302,14 +311,21 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
             self.logger.info("Stopping reactor")
             self._reactor.stop()
 
-    def start_reactor(self) -> None:
-        """Start the reactor if it's running."""
-        # Connect to TCP server
+    def connect(self) -> None:
+        """Connect to TCP server."""
         self.logger.info(
             f"Connecting to TCP server {self.cli_config.ip}:{self.cli_config.port}"
         )
         self._reactor.connectTCP(self.cli_config.ip, self.cli_config.port, self)
 
+    def disconnect(self) -> None:
+        """Disconnect from TCP server."""
+        self.logger.info("Disconnecting TCP server")
+        self._reactor.disconnectAll()
+
+    def start_reactor(self) -> None:
+        """Start the reactor if it's running."""
+        self.connect()
         # Run the reactor (which now uses asyncio underneath)
         self.logger.info("Starting reactor event loop.")
         self._reactor.run()
@@ -340,6 +356,23 @@ class ConbusEventProtocol(protocol.Protocol, protocol.ClientFactory):
         later = randint(10, 80) / 100
         self.call_later(later, self.process_telegram_queue)
 
+    def set_event_loop(self, event_loop: asyncio.AbstractEventLoop) -> None:
+        """Change the event loop.
+
+        Args:
+            event_loop: the event loop instance.
+        """
+        reactor = self._reactor
+        if hasattr(reactor, "_asyncioEventloop"):
+            reactor._asyncioEventloop = event_loop
+
+        # Set reactor to running state
+        if not reactor.running:
+            reactor.running = True
+            if hasattr(reactor, "startRunning"):
+                reactor.startRunning()
+            self.logger.info("Set reactor to running state")
+
     def __enter__(self) -> "ConbusEventProtocol":
         """Enter context manager.
 

conson_xp-1.21.0/src/xp/term/__init__.py

@@ -0,0 +1 @@
+"""TUI (Terminal User Interface) module for XP."""