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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conson-xp
-Version: 1.18.0
+Version: 1.20.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
@@ -306,6 +307,7 @@ xp conbus datapoint query
 xp conbus discover
 
 xp conbus event
+xp conbus event list
 xp conbus event raw
 
 
@@ -397,6 +399,10 @@ xp telegram parse
 xp telegram validate
 xp telegram version
 
+
+xp term
+xp term protocol
+
 <!-- END CLI HELP -->
 ```
 </details>

{conson_xp-1.18.0 → conson_xp-1.20.0}/README.md

@@ -254,6 +254,7 @@ xp conbus datapoint query
 xp conbus discover
 
 xp conbus event
+xp conbus event list
 xp conbus event raw
 
 
@@ -345,6 +346,10 @@ xp telegram parse
 xp telegram validate
 xp telegram version
 
+
+xp term
+xp term protocol
+
 <!-- END CLI HELP -->
 ```
 </details>

{conson_xp-1.18.0 → conson_xp-1.20.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.18.0"
+version = "1.20.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.18.0 → conson_xp-1.20.0}/src/xp/__init__.py

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

{conson_xp-1.18.0 → conson_xp-1.20.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.18.0 → conson_xp-1.20.0}/src/xp/cli/commands/conbus/conbus_event_commands.py

@@ -8,6 +8,7 @@ from xp.cli.commands.conbus.conbus import conbus
 from xp.cli.utils.decorators import connection_command
 from xp.cli.utils.module_type_choice import MODULE_TYPE
 from xp.models import ConbusEventRawResponse
+from xp.services.conbus.conbus_event_list_service import ConbusEventListService
 from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
 
 
@@ -17,6 +18,30 @@ def conbus_event() -> None:
     pass
 
 
+@conbus_event.command("list")
+@click.pass_context
+def list_events(ctx: click.Context) -> None:
+    r"""List configured event telegrams from module action tables.
+
+    Reads conson.yml configuration, parses action tables, and groups
+    modules by their event keys to show which modules are assigned to
+    each event (button configuration).
+
+    Output is sorted by module count (most frequently used events first).
+
+    Args:
+        ctx: Click context object.
+
+    Examples:
+        \b
+        xp conbus event list
+    """
+    service: ConbusEventListService = (
+        ctx.obj.get("container").get_container().resolve(ConbusEventListService)
+    )
+    click.echo(json.dumps(service.list_events().to_dict(), indent=2))
+
+
 @conbus_event.command("raw")
 @click.argument("module_type", type=MODULE_TYPE)
 @click.argument("link_number", type=click.IntRange(0, 99))

{conson_xp-1.18.0 → conson_xp-1.20.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.20.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.20.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.20.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.tui.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.18.0 → conson_xp-1.20.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.18.0 → conson_xp-1.20.0}/src/xp/models/__init__.py

@@ -5,6 +5,7 @@ from xp.models.conbus.conbus_client_config import ConbusClientConfig
 from xp.models.conbus.conbus_connection_status import ConbusConnectionStatus
 from xp.models.conbus.conbus_datapoint import ConbusDatapointResponse
 from xp.models.conbus.conbus_discover import ConbusDiscoverResponse
+from xp.models.conbus.conbus_event_list import ConbusEventListResponse
 from xp.models.conbus.conbus_event_raw import ConbusEventRawResponse
 from xp.models.log_entry import LogEntry
 from xp.models.telegram.event_telegram import EventTelegram
@@ -31,6 +32,7 @@ __all__ = [
     "ConbusResponse",
     "ConbusDatapointResponse",
     "ConbusDiscoverResponse",
+    "ConbusEventListResponse",
     "ConbusEventRawResponse",
     "ConbusConnectionStatus",
 ]

{conson_xp-1.18.0 → conson_xp-1.20.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.20.0/src/xp/models/conbus/conbus_event_list.py

@@ -0,0 +1,34 @@
+"""Conbus event list response model."""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class ConbusEventListResponse:
+    """Represents a response from Conbus event list operation.
+
+    Attributes:
+        events: Dict mapping event keys to list of module names.
+        timestamp: Timestamp of the response.
+    """
+
+    events: Dict[str, list[str]]
+    timestamp: Optional[datetime] = None
+
+    def __post_init__(self) -> None:
+        """Initialize timestamp if not provided."""
+        if self.timestamp is None:
+            self.timestamp = datetime.now()
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary representation of the response.
+        """
+        return {
+            "events": self.events,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }

conson_xp-1.20.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.20.0/src/xp/services/conbus/conbus_event_list_service.py

@@ -0,0 +1,91 @@
+"""Conbus Event List Service for listing configured event telegrams.
+
+This service parses action tables from conson.yml and groups events
+by button configuration to show which modules are assigned to each event.
+"""
+
+import logging
+from collections import defaultdict
+from typing import Dict, List
+
+from xp.models import ConbusEventListResponse
+from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
+from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
+
+
+class ConbusEventListService:
+    """Service for listing configured event telegrams from action tables.
+
+    Parses action tables from conson.yml configuration and groups modules
+    by their event keys to identify common button configurations.
+
+    Attributes:
+        conson_config: Configuration containing module action tables.
+        logger: Logger instance for the service.
+    """
+
+    def __init__(self, conson_config: ConsonModuleListConfig) -> None:
+        """Initialize the Conbus event list service.
+
+        Args:
+            conson_config: ConsonModuleListConfig instance with module action tables.
+        """
+        self.conson_config = conson_config
+        self.logger = logging.getLogger(__name__)
+
+    def list_events(self) -> ConbusEventListResponse:
+        """List all configured events from module action tables.
+
+        Parses action tables, extracts event information (module_type, link, input),
+        groups modules by event key, and sorts by usage count.
+
+        Returns:
+            ConbusEventListResponse with events dict mapping event keys to module names.
+        """
+        # Dict to track which modules are assigned to each event
+        # event_key -> set of module names (using set for automatic deduplication)
+        event_modules: Dict[str, set[str]] = defaultdict(set)
+
+        # Process each module's action table
+        for module in self.conson_config.root:
+            # Skip modules without action table
+            if not module.action_table:
+                continue
+
+            # Process each action in the module's action table
+            for action in module.action_table:
+                try:
+                    # Use existing ActionTableSerializer to parse action
+                    entry = ActionTableSerializer.parse_action_string(action)
+
+                    # Extract event data from parsed entry
+                    module_type_name = entry.module_type.name
+                    link = entry.link_number
+                    input_num = entry.module_input
+
+                    # Create event key (space-separated format)
+                    event_key = f"{module_type_name} {link:02d} {input_num:02d}"
+
+                    # Add this module to the event (set automatically deduplicates)
+                    event_modules[event_key].add(
+                        f"{module.serial_number}:{entry.module_output}"
+                    )
+
+                except ValueError as e:
+                    # Invalid action format - log warning and skip
+                    self.logger.warning(
+                        f"Invalid action '{action}' in module '{module.serial_number}': {e}"
+                    )
+                    continue
+
+        # Convert sets to sorted lists and sort events by module count (descending)
+        events_dict: Dict[str, List[str]] = {
+            event_key: sorted(list(modules))
+            for event_key, modules in sorted(
+                event_modules.items(),
+                key=lambda item: len(item[1]),
+                reverse=True,
+            )
+        }
+
+        return ConbusEventListResponse(events=events_dict)