conson-xp 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

xp/services/homekit/homekit_service.py

@@ -1,3 +1,8 @@
+"""HomeKit Service for Apple HomeKit integration.
+
+This module provides the main service for HomeKit integration.
+"""
+
 # Install asyncio reactor before importing reactor
 
 import asyncio
@@ -29,6 +34,23 @@ from xp.services.protocol.protocol_factory import TelegramFactory
 
 
 class HomeKitService:
+    """Main HomeKit service for Apple HomeKit integration.
+
+    Attributes:
+        cli_config: Conbus client configuration.
+        reactor: Twisted reactor instance.
+        telegram_factory: Telegram factory for protocol.
+        protocol: Telegram protocol instance.
+        event_bus: Event bus for inter-service communication.
+        lightbulb_service: Lightbulb service instance.
+        dimminglight_service: Dimming light service instance.
+        outlet_service: Outlet service instance.
+        cache_service: Cache service instance.
+        conbus_service: Conbus service instance.
+        module_factory: HAP service instance.
+        telegram_service: Telegram service instance.
+        logger: Logger instance.
+    """
 
     def __init__(
         self,
@@ -44,7 +66,21 @@ class HomeKitService:
         module_factory: HomekitHapService,
         telegram_service: TelegramService,
     ):
-
+        """Initialize the HomeKit service.
+
+        Args:
+            cli_config: Conbus client configuration.
+            event_bus: Event bus instance.
+            telegram_factory: Telegram factory instance.
+            reactor: Twisted reactor instance.
+            lightbulb_service: Lightbulb service instance.
+            outlet_service: Outlet service instance.
+            dimminglight_service: Dimming light service instance.
+            cache_service: Cache service instance.
+            conbus_service: Conbus service instance.
+            module_factory: HAP service instance.
+            telegram_service: Telegram service instance.
+        """
         self.cli_config = cli_config.conbus
         self.reactor = reactor
         self.telegram_factory = telegram_factory
@@ -67,23 +103,24 @@ class HomeKitService:
         self.event_bus.on(ModuleDiscoveredEvent, self.handle_module_discovered)
 
     def start(self) -> None:
-        self.logger.info("Starting HomeKit service...")
+        """Start the HomeKit service."""
+        self.logger.info("Starting HomeKit service.")
         self.logger.debug("start")
 
         # Run reactor in its own dedicated thread
-        self.logger.info("Starting reactor in dedicated thread...")
+        self.logger.info("Starting reactor in dedicated thread.")
         reactor_thread = threading.Thread(
             target=self._run_reactor_in_thread, daemon=True, name="ReactorThread"
         )
         reactor_thread.start()
 
         # Keep MainThread alive while reactor thread runs
-        self.logger.info("Reactor thread started, MainThread waiting...")
+        self.logger.info("Reactor thread started, MainThread waiting.")
         reactor_thread.join()
 
     def _run_reactor_in_thread(self) -> None:
-        """Run reactor in dedicated thread with its own event loop"""
-        self.logger.info("Reactor thread starting...")
+        """Run reactor in dedicated thread with its own event loop."""
+        self.logger.info("Reactor thread starting.")
 
         # The asyncio reactor already has an event loop set up
         # We just need to use it
@@ -101,17 +138,21 @@ class HomeKitService:
         self.reactor.callLater(0, self._start_module_factory)
 
         # Run the reactor (which now uses asyncio underneath)
-        self.logger.info("Starting reactor event loop...")
+        self.logger.info("Starting reactor event loop.")
         self.reactor.run()
 
     def _start_module_factory(self) -> None:
-        """Start module factory after reactor starts"""
-        self.logger.info("Starting module factory...")
+        """Start module factory after reactor starts.
+
+        Creates and schedules an async task to start the HAP service.
+        """
+        self.logger.info("Starting module factory.")
         self.logger.debug("callWhenRunning executed, scheduling async task")
 
         # Run HAP-python driver asynchronously in the reactor's event loop
         async def async_start() -> None:
-            self.logger.info("async_start executing...")
+            """Start the HAP service asynchronously."""
+            self.logger.info("async_start executing.")
             try:
                 await self.module_factory.async_start()
                 self.logger.info("Module factory started successfully")
@@ -130,23 +171,42 @@ class HomeKitService:
 
     # Event handlers
     def handle_connection_made(self, event: ConnectionMadeEvent) -> None:
-        """Handle connection established - send initial telegram"""
+        """Handle connection established - send initial telegram.
+
+        Args:
+            event: Connection made event.
+        """
         self.logger.debug("Connection established successfully")
         self.logger.debug("Sending initial discovery telegram: S0000000000F01D00")
         event.protocol.sendFrame(b"S0000000000F01D00")
 
     def handle_connection_failed(self, event: ConnectionFailedEvent) -> None:
-        """Handle connection failed"""
+        """Handle connection failed.
+
+        Args:
+            event: Connection failed event.
+        """
         self.logger.error(f"Connection failed: {event.reason}")
 
     def handle_connection_lost(self, event: ConnectionLostEvent) -> None:
-        """Handle connection lost"""
+        """Handle connection lost.
+
+        Args:
+            event: Connection lost event.
+        """
         self.logger.warning(
             f"Connection lost: {event.reason if hasattr(event, 'reason') else 'Unknown reason'}"
         )
 
     def handle_telegram_received(self, event: TelegramReceivedEvent) -> str:
-        """Handle received telegram events"""
+        """Handle received telegram events.
+
+        Args:
+            event: Telegram received event.
+
+        Returns:
+            Frame data from the event.
+        """
         self.logger.debug(
             f"handle_telegram_received ENTERED with telegram: {event.telegram}"
         )
@@ -176,10 +236,18 @@ class HomeKitService:
         return event.frame
 
     def dispatch_light_level_event(self, event: TelegramReceivedEvent) -> None:
-        self.logger.debug("Light level Datapoint, parsing telegram...")
+        """Dispatch light level received event.
+
+        Args:
+            event: Telegram received event.
+        """
+        self.logger.debug("Light level Datapoint, parsing telegram.")
         reply_telegram = self.telegram_service.parse_reply_telegram(event.frame)
         self.logger.debug(
-            f"Parsed telegram: serial={reply_telegram.serial_number}, type={reply_telegram.datapoint_type}, value={reply_telegram.data_value}"
+            f"Parsed telegram: "
+            f"serial={reply_telegram.serial_number}, "
+            f"type={reply_telegram.datapoint_type}, "
+            f"value={reply_telegram.data_value}"
         )
         self.logger.debug("About to dispatch LightLevelReceivedEvent")
         self.event_bus.dispatch(
@@ -192,10 +260,18 @@ class HomeKitService:
         self.logger.debug("LightLevelReceivedEvent dispatched successfully")
 
     def dispatch_output_state_event(self, event: TelegramReceivedEvent) -> None:
-        self.logger.debug("Module Read Datapoint, parsing telegram...")
+        """Dispatch output state received event.
+
+        Args:
+            event: Telegram received event.
+        """
+        self.logger.debug("Module Read Datapoint, parsing telegram.")
         reply_telegram = self.telegram_service.parse_reply_telegram(event.frame)
         self.logger.debug(
-            f"Parsed telegram: serial={reply_telegram.serial_number}, type={reply_telegram.datapoint_type}, value={reply_telegram.data_value}"
+            f"Parsed telegram: "
+            f"serial={reply_telegram.serial_number}, "
+            f"type={reply_telegram.datapoint_type}, "
+            f"value={reply_telegram.data_value}"
         )
         self.logger.debug("About to dispatch OutputStateReceivedEvent")
         self.event_bus.dispatch(
@@ -210,7 +286,12 @@ class HomeKitService:
     def dispatch_event_telegram_received_event(
         self, event: TelegramReceivedEvent
     ) -> None:
-        self.logger.debug("Event telegram received, parsing...")
+        """Dispatch event telegram received event.
+
+        Args:
+            event: Telegram received event.
+        """
+        self.logger.debug("Event telegram received, parsing.")
 
         # Parse event telegram to extract module information
         event_telegram = self.telegram_service.parse_event_telegram(event.frame)
@@ -238,6 +319,11 @@ class HomeKitService:
         self.logger.debug("ModuleStateChangedEvent dispatched successfully")
 
     def dispatch_module_discovered_event(self, event: TelegramReceivedEvent) -> None:
+        """Dispatch module discovered event.
+
+        Args:
+            event: Telegram received event.
+        """
         self.logger.debug("Module discovered, dispatching ModuleDiscoveredEvent")
         self.event_bus.dispatch(
             ModuleDiscoveredEvent(
@@ -253,6 +339,14 @@ class HomeKitService:
         self.logger.debug("ModuleDiscoveredEvent dispatched successfully")
 
     def handle_module_discovered(self, event: ModuleDiscoveredEvent) -> str:
+        """Handle module discovered event.
+
+        Args:
+            event: Module discovered event.
+
+        Returns:
+            Serial number of the discovered module.
+        """
         self.logger.debug("Handling module discovered event")
 
         # Replace R with S and F01D with F02D00

xp/services/log_file_service.py

@@ -15,7 +15,7 @@ from xp.utils.time_utils import (
 
 
 class LogFileParsingError(Exception):
-    """Raised when log file parsing fails"""
+    """Raised when log file parsing fails."""
 
     pass
 
@@ -26,6 +26,10 @@ class LogFileService:
 
     Handles parsing of log files containing timestamped telegram transmissions
     and receptions with automatic telegram parsing and validation.
+
+    Attributes:
+        telegram_service: Telegram service for parsing telegrams.
+        LOG_LINE_PATTERN: Regex pattern for log line format.
     """
 
     # Regex pattern for log line format: HH:MM:SS,mmm [TX/RX] <telegram>
@@ -34,29 +38,27 @@ class LogFileService:
     )
 
     def __init__(self, telegram_service: TelegramService):
-        """
-        Initialize the log file service
+        """Initialize the log file service.
 
         Args:
-            telegram_service: Telegram service for parsing telegrams
+            telegram_service: Telegram service for parsing telegrams.
         """
         self.telegram_service = telegram_service
 
     def parse_log_file(
         self, file_path: str, base_date: Optional[datetime] = None
     ) -> List[LogEntry]:
-        """
-        Parse a console bus log file into LogEntry objects
+        """Parse a console bus log file into LogEntry objects.
 
         Args:
-            file_path: Path to the log file
-            base_date: Base date for timestamps (defaults to today)
+            file_path: Path to the log file.
+            base_date: Base date for timestamps (defaults to today).
 
         Returns:
-            List of parsed LogEntry objects
+            List of parsed LogEntry objects.
 
         Raises:
-            LogFileParsingError: If file cannot be read or parsed
+            LogFileParsingError: If file cannot be read or parsed.
         """
         try:
             path = Path(file_path)
@@ -77,15 +79,14 @@ class LogFileService:
     def parse_log_lines(
         self, lines: List[str], base_date: Optional[datetime] = None
     ) -> List[LogEntry]:
-        """
-        Parse log lines into LogEntry objects
+        """Parse log lines into LogEntry objects.
 
         Args:
-            lines: List of log lines to parse
-            base_date: Base date for timestamps
+            lines: List of log lines to parse.
+            base_date: Base date for timestamps.
 
         Returns:
-            List of parsed LogEntry objects
+            List of parsed LogEntry objects.
         """
         entries = []
 
@@ -114,16 +115,15 @@ class LogFileService:
     def _parse_log_line(
         self, line: str, line_number: int, base_date: Optional[datetime] = None
     ) -> Optional[LogEntry]:
-        """
-        Parse a single log line into a LogEntry
+        """Parse a single log line into a LogEntry.
 
         Args:
-            line: Log line to parse
-            line_number: Line number in the file
-            base_date: Base date for timestamp
+            line: Log line to parse.
+            line_number: Line number in the file.
+            base_date: Base date for timestamp.
 
         Returns:
-            LogEntry object or None if line format is invalid
+            LogEntry object or None if line format is invalid.
         """
         match = self.LOG_LINE_PATTERN.match(line)
         if not match:
@@ -157,14 +157,13 @@ class LogFileService:
         return entry
 
     def validate_log_format(self, file_path: str) -> bool:
-        """
-        Validate that a file follows the expected log format
+        """Validate that a file follows the expected log format.
 
         Args:
-            file_path: Path to the log file
+            file_path: Path to the log file.
 
         Returns:
-            True if format is valid, False otherwise
+            True if format is valid, False otherwise.
         """
         try:
             entries = self.parse_log_file(file_path)
@@ -175,28 +174,26 @@ class LogFileService:
             return False
 
     def extract_telegrams(self, file_path: str) -> List[str]:
-        """
-        Extract all telegram strings from a log file
+        """Extract all telegram strings from a log file.
 
         Args:
-            file_path: Path to the log file
+            file_path: Path to the log file.
 
         Returns:
-            List of telegram strings
+            List of telegram strings.
         """
         entries = self.parse_log_file(file_path)
         return [entry.raw_telegram for entry in entries]
 
     @staticmethod
     def get_file_statistics(entries: List[LogEntry]) -> Dict[str, Any]:
-        """
-        Generate statistics for a list of log entries
+        """Generate statistics for a list of log entries.
 
         Args:
-            entries: List of LogEntry objects
+            entries: List of LogEntry objects.
 
         Returns:
-            Dictionary containing statistics
+            Dictionary containing statistics.
         """
         if not entries:
             return {"total_entries": 0}
@@ -283,18 +280,17 @@ class LogFileService:
         start_time: Optional[datetime] = None,
         end_time: Optional[datetime] = None,
     ) -> List[LogEntry]:
-        """
-        Filter log entries based on criteria
+        """Filter log entries based on criteria.
 
         Args:
-            entries: List of LogEntry objects to filter
-            telegram_type: Filter by telegram type (event, system, reply)
-            direction: Filter by direction (TX, RX)
-            start_time: Filter entries after this time
-            end_time: Filter entries before this time
+            entries: List of LogEntry objects to filter.
+            telegram_type: Filter by telegram type (event, system, reply).
+            direction: Filter by direction (TX, RX).
+            start_time: Filter entries after this time.
+            end_time: Filter entries before this time.
 
         Returns:
-            Filtered list of LogEntry objects
+            Filtered list of LogEntry objects.
         """
         filtered = entries.copy()
 

xp/services/module_type_service.py

@@ -1,3 +1,8 @@
+"""Module Type Service for XP module management.
+
+This module provides lookup, validation, and search functionality for XP system module types.
+"""
+
 from typing import Dict, List, Optional, Union
 
 from xp.models.telegram.module_type import (
@@ -9,7 +14,7 @@ from xp.models.telegram.module_type import (
 
 
 class ModuleTypeNotFoundError(Exception):
-    """Raised when a module type cannot be found"""
+    """Raised when a module type cannot be found."""
 
     pass
 
@@ -17,11 +22,12 @@ class ModuleTypeNotFoundError(Exception):
 class ModuleTypeService:
     """
     Service for managing module type operations.
+
     Provides lookup, validation, and search functionality for XP system module types.
     """
 
     def __init__(self) -> None:
-        """Initialize the module type service"""
+        """Initialize the module type service."""
         pass
 
     @staticmethod
@@ -193,7 +199,14 @@ class ModuleTypeService:
 
     @staticmethod
     def _format_module_summary(module_type: ModuleType) -> str:
-        """Format a single module type for display"""
+        """Format a single module type for display.
+
+        Args:
+            module_type: The module type to format.
+
+        Returns:
+            Formatted string with module information.
+        """
         summary = f"Module: {module_type.name} (Code {module_type.code})\n"
         summary += f"Description: {module_type.description}\n"
         summary += f"Category: {module_type.category}\n"
@@ -213,7 +226,11 @@ class ModuleTypeService:
 
     @staticmethod
     def _format_all_modules() -> str:
-        """Format all modules in a simple list"""
+        """Format all modules in a simple list.
+
+        Returns:
+            Formatted string with all modules.
+        """
         modules = get_all_module_types()
         lines = ["Code | Name       | Description", "-" * 60]
 
@@ -224,7 +241,11 @@ class ModuleTypeService:
 
     @staticmethod
     def _format_modules_by_category() -> str:
-        """Format modules grouped by category"""
+        """Format modules grouped by category.
+
+        Returns:
+            Formatted string with modules grouped by category.
+        """
         categories = get_module_types_by_category()
         lines = []
 

xp/services/protocol/__init__.py

@@ -1,4 +1,4 @@
-"""Protocol layer services for XP"""
+"""Protocol layer services for XP."""
 
 from xp.models.protocol.conbus_protocol import (
     ConnectionMadeEvent,