conson-xp 1.18.0__py3-none-any.whl → 1.20.0__py3-none-any.whl

xp/utils/dependencies.py

@@ -7,6 +7,7 @@ from twisted.internet.interfaces import IConnector
 from twisted.internet.posixbase import PosixReactorBase
 
 from xp.models import ConbusClientConfig
+from xp.models.conbus.conbus_logger_config import ConbusLoggerConfig
 from xp.models.homekit.homekit_config import HomekitConfig
 from xp.models.homekit.homekit_conson_config import ConsonModuleListConfig
 from xp.services.actiontable.actiontable_serializer import ActionTableSerializer
@@ -43,6 +44,7 @@ from xp.services.conbus.conbus_datapoint_service import (
     ConbusDatapointService,
 )
 from xp.services.conbus.conbus_discover_service import ConbusDiscoverService
+from xp.services.conbus.conbus_event_list_service import ConbusEventListService
 from xp.services.conbus.conbus_event_raw_service import ConbusEventRawService
 from xp.services.conbus.conbus_output_service import ConbusOutputService
 from xp.services.conbus.conbus_raw_service import ConbusRawService
@@ -71,6 +73,7 @@ from xp.services.telegram.telegram_discover_service import TelegramDiscoverServi
 from xp.services.telegram.telegram_link_number_service import LinkNumberService
 from xp.services.telegram.telegram_output_service import TelegramOutputService
 from xp.services.telegram.telegram_service import TelegramService
+from xp.utils.logging import LoggerService
 
 asyncioreactor.install()
 from twisted.internet import reactor  # noqa: E402
@@ -86,7 +89,8 @@ class ServiceContainer:
 
     def __init__(
         self,
-        config_path: str = "cli.yml",
+        client_config_path: str = "cli.yml",
+        logger_config_path: str = "logger.yml",
         homekit_config_path: str = "homekit.yml",
         conson_config_path: str = "conson.yml",
         server_port: int = 10001,
@@ -96,14 +100,16 @@ class ServiceContainer:
         Initialize the service container.
 
         Args:
-            config_path: Path to the Conbus CLI configuration file
+            client_config_path: Path to the Conbus CLI configuration file
+            logger_config_path: Path to the Conbus Loggerr configuration file
             homekit_config_path: Path to the HomeKit configuration file
             conson_config_path: Path to the Conson configuration file
             server_port: Port for the server service
             reverse_proxy_port: Port for the reverse proxy service
         """
         self.container = punq.Container()
-        self._config_path = config_path
+        self._client_config_path = client_config_path
+        self._logger_config_path = logger_config_path
         self._homekit_config_path = homekit_config_path
         self._conson_config_path = conson_config_path
         self._server_port = server_port
@@ -116,7 +122,13 @@ class ServiceContainer:
         # ConbusClientConfig
         self.container.register(
             ConbusClientConfig,
-            factory=lambda: ConbusClientConfig.from_yaml(self._config_path),
+            factory=lambda: ConbusClientConfig.from_yaml(self._client_config_path),
+            scope=punq.Scope.singleton,
+        )
+
+        self.container.register(
+            ConbusLoggerConfig,
+            factory=lambda: ConbusLoggerConfig.from_yaml(self._logger_config_path),
             scope=punq.Scope.singleton,
         )
 
@@ -189,6 +201,14 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        self.container.register(
+            ConbusEventListService,
+            factory=lambda: ConbusEventListService(
+                conson_config=self.container.resolve(ConsonModuleListConfig)
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         self.container.register(
             ConbusBlinkService,
             factory=lambda: ConbusBlinkService(
@@ -323,8 +343,7 @@ class ServiceContainer:
         self.container.register(
             ConbusReceiveService,
             factory=lambda: ConbusReceiveService(
-                cli_config=self.container.resolve(ConbusClientConfig),
-                reactor=self.container.resolve(PosixReactorBase),
+                conbus_protocol=self.container.resolve(ConbusEventProtocol)
             ),
             scope=punq.Scope.singleton,
         )
@@ -378,6 +397,15 @@ class ServiceContainer:
             scope=punq.Scope.singleton,
         )
 
+        # Logging
+        self.container.register(
+            LoggerService,
+            factory=lambda: LoggerService(
+                logger_config=self.container.resolve(ConbusLoggerConfig),
+            ),
+            scope=punq.Scope.singleton,
+        )
+
         # Module type services layer
         self.container.register(ModuleTypeService, scope=punq.Scope.singleton)
 

xp/utils/logging.py

@@ -0,0 +1,91 @@
+"""Logging service for XP application."""
+
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+from xp.models.conbus.conbus_logger_config import ConbusLoggerConfig
+
+
+class LoggerService:
+    """Service for managing logging configuration and setup."""
+
+    def __init__(self, logger_config: ConbusLoggerConfig):
+        """Initialize LoggerService with configuration.
+
+        Args:
+            logger_config: Logger configuration object.
+        """
+        self.logging_config = logger_config.log
+        self.logger = logging.getLogger(__name__)
+
+    def setup(self) -> None:
+        """Setup console and file logging with configured levels."""
+        # Setup file logging for term app
+        self.setup_console_logging(
+            self.logging_config.log_format, self.logging_config.date_format
+        )
+        self.setup_file_logging(
+            self.logging_config.log_format, self.logging_config.date_format
+        )
+
+        for module in self.logging_config.levels.keys():
+            logging.getLogger(module).setLevel(self.logging_config.levels[module])
+
+    def setup_console_logging(self, log_format: str, date_format: str) -> None:
+        """Setup console logging with specified format.
+
+        Args:
+            log_format: Log message format string.
+            date_format: Date format string for log timestamps.
+        """
+        # Force format on root logger and all handlers
+        formatter = logging.Formatter(log_format, datefmt=date_format)
+        root_logger = logging.getLogger()
+
+        # Set log level from CLI argument
+        numeric_level = getattr(logging, self.logging_config.default_level.upper())
+        root_logger.setLevel(numeric_level)
+
+        # 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)
+
+    def setup_file_logging(self, log_format: str, date_format: str) -> None:
+        """Setup file logging with rotation for term application.
+
+        Args:
+            log_format: Log message format string.
+            date_format: Date format string for log timestamps.
+        """
+        log_path = Path(self.logging_config.path)
+        log_level = self.logging_config.default_level
+
+        try:
+            # Create log directory if it doesn't exist
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Create rotating file handler
+            file_handler = RotatingFileHandler(
+                log_path,
+                maxBytes=self.logging_config.max_bytes,
+                backupCount=self.logging_config.backup_count,
+            )
+
+            # Configure formatter to match console format
+            formatter = logging.Formatter(log_format, datefmt=date_format)
+            file_handler.setFormatter(formatter)
+            file_handler.setLevel(log_level)
+
+            # Attach to root logger
+            root_logger = logging.getLogger()
+            root_logger.addHandler(file_handler)
+
+        except (OSError, PermissionError) as e:
+            self.logger.warning(f"Failed to setup file logging at {log_path}: {e}")
+            self.logger.warning("Continuing without file logging")