conson-xp 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

xp/services/homekit/homekit_lightbulb.py

@@ -1,3 +1,8 @@
+"""HomeKit Light Bulb Accessory.
+
+This module provides a light bulb accessory for HomeKit integration.
+"""
+
 import logging
 
 from bubus import EventBus
@@ -14,7 +19,18 @@ from xp.models.protocol.conbus_protocol import (
 
 
 class LightBulb(Accessory):
-    """Fake lightbulb, logs what the client sets."""
+    """HomeKit light bulb accessory.
+
+    Attributes:
+        category: HomeKit category (CATEGORY_LIGHTBULB).
+        event_bus: Event bus for inter-service communication.
+        logger: Logger instance.
+        identifier: Unique identifier for the accessory.
+        accessory: Accessory configuration.
+        module: Module configuration.
+        is_on: Current on/off state.
+        char_on: On characteristic.
+    """
 
     category = CATEGORY_LIGHTBULB
     event_bus: EventBus
@@ -26,6 +42,14 @@ class LightBulb(Accessory):
         accessory: HomekitAccessoryConfig,
         event_bus: EventBus,
     ):
+        """Initialize the light bulb accessory.
+
+        Args:
+            driver: HAP accessory driver.
+            module: Module configuration.
+            accessory: Accessory configuration.
+            event_bus: Event bus for inter-service communication.
+        """
         super().__init__(driver, accessory.description)
 
         self.logger = logging.getLogger(__name__)
@@ -56,6 +80,11 @@ class LightBulb(Accessory):
         )
 
     def set_on(self, value: bool) -> None:
+        """Set the on/off state of the light bulb.
+
+        Args:
+            value: True to turn on, False to turn off.
+        """
         # Emit set event
         self.logger.debug(f"set_on {value}")
         if self.is_on != value:
@@ -71,6 +100,11 @@ class LightBulb(Accessory):
             )
 
     def get_on(self) -> bool:
+        """Get the on/off state of the light bulb.
+
+        Returns:
+            True if on, False if off.
+        """
         # Emit event and get response
         self.logger.debug("get_on")
         self.event_bus.dispatch(

xp/services/homekit/homekit_lightbulb_service.py

@@ -1,3 +1,8 @@
+"""HomeKit Light Bulb Service.
+
+This module provides service implementation for light bulb accessories.
+"""
+
 import logging
 
 from bubus import EventBus
@@ -12,11 +17,21 @@ from xp.models.telegram.datapoint_type import DataPointType
 
 
 class HomeKitLightbulbService:
-    """Lightbulb service for HomeKit"""
+    """Lightbulb service for HomeKit.
+
+    Attributes:
+        event_bus: Event bus for inter-service communication.
+        logger: Logger instance.
+    """
 
     event_bus: EventBus
 
     def __init__(self, event_bus: EventBus):
+        """Initialize the lightbulb service.
+
+        Args:
+            event_bus: Event bus instance.
+        """
         self.event_bus = event_bus
         self.logger = logging.getLogger(__name__)
 
@@ -25,6 +40,11 @@ class HomeKitLightbulbService:
         self.event_bus.on(LightBulbSetOnEvent, self.handle_lightbulb_set_on)
 
     def handle_lightbulb_get_on(self, event: LightBulbGetOnEvent) -> None:
+        """Handle lightbulb get on event.
+
+        Args:
+            event: Lightbulb get on event.
+        """
         self.logger.info(
             f"Getting lightbulb state for serial {event.serial_number}, output {event.output_number}"
         )
@@ -40,8 +60,16 @@ class HomeKitLightbulbService:
         self.logger.debug(f"Dispatched ReadDatapointEvent for {event.serial_number}")
 
     def handle_lightbulb_set_on(self, event: LightBulbSetOnEvent) -> None:
+        """Handle lightbulb set on event.
+
+        Args:
+            event: Lightbulb set on event.
+        """
         self.logger.info(
-            f"Setting lightbulb for serial {event.serial_number}, output {event.output_number} to {'ON' if event.value else 'OFF'}"
+            f"Setting lightbulb "
+            f"for serial {event.serial_number}, "
+            f"output {event.output_number} "
+            f"to {'ON' if event.value else 'OFF'}"
         )
         self.logger.debug(f"lightbulb_set_on {event}")
 

xp/services/homekit/homekit_module_service.py

@@ -1,3 +1,8 @@
+"""HomeKit Module Service.
+
+This module provides service implementation for HomeKit module management.
+"""
+
 import logging
 from typing import Optional
 
@@ -8,18 +13,35 @@ from xp.models.homekit.homekit_conson_config import (
 
 
 class HomekitModuleService:
+    """Service for managing HomeKit module configurations.
+
+    Attributes:
+        logger: Logger instance.
+        conson_modules_config: Conson module list configuration.
+    """
 
     def __init__(
         self,
         conson_modules_config: ConsonModuleListConfig,
     ):
+        """Initialize the HomeKit module service.
 
+        Args:
+            conson_modules_config: Conson module list configuration.
+        """
         # Set up logging
         self.logger = logging.getLogger(__name__)
         self.conson_modules_config = conson_modules_config
 
     def get_module_by_serial(self, serial_number: str) -> Optional[ConsonModuleConfig]:
-        """Get a module by its serial number"""
+        """Get a module by its serial number.
+
+        Args:
+            serial_number: Serial number of the module to find.
+
+        Returns:
+            Module configuration if found, None otherwise.
+        """
         module = next(
             (
                 module

xp/services/homekit/homekit_outlet.py

@@ -1,3 +1,8 @@
+"""HomeKit Outlet Accessory.
+
+This module provides an outlet accessory for HomeKit integration.
+"""
+
 import logging
 
 from bubus import EventBus
@@ -16,7 +21,20 @@ from xp.models.protocol.conbus_protocol import (
 
 
 class Outlet(Accessory):
-    """Fake lightbulb, logs what the client sets."""
+    """HomeKit outlet accessory.
+
+    Attributes:
+        category: HomeKit category (CATEGORY_OUTLET).
+        event_bus: Event bus for inter-service communication.
+        logger: Logger instance.
+        identifier: Unique identifier for the accessory.
+        accessory: Accessory configuration.
+        module: Module configuration.
+        is_on: Current on/off state.
+        is_in_use: Current in-use state.
+        char_on: On characteristic.
+        char_outlet_in_use: Outlet in-use characteristic.
+    """
 
     category = CATEGORY_OUTLET
     event_bus: EventBus
@@ -28,6 +46,14 @@ class Outlet(Accessory):
         accessory: HomekitAccessoryConfig,
         event_bus: EventBus,
     ):
+        """Initialize the outlet accessory.
+
+        Args:
+            driver: HAP accessory driver.
+            module: Module configuration.
+            accessory: Accessory configuration.
+            event_bus: Event bus for inter-service communication.
+        """
         super().__init__(driver=driver, display_name=accessory.description)
 
         self.logger = logging.getLogger(__name__)
@@ -62,6 +88,11 @@ class Outlet(Accessory):
         )
 
     def set_outlet_in_use(self, value: bool) -> None:
+        """Set the in-use state of the outlet.
+
+        Args:
+            value: True if in use, False otherwise.
+        """
         self.logger.debug(f"set_outlet_in_use {value}")
 
         self.is_in_use = value
@@ -77,6 +108,11 @@ class Outlet(Accessory):
         self.logger.debug(f"set_outlet_in_use {value} end")
 
     def get_outlet_in_use(self) -> bool:
+        """Get the in-use state of the outlet.
+
+        Returns:
+            True if in use, False otherwise.
+        """
         # Emit event and get response
         self.logger.debug("get_outlet_in_use")
 
@@ -92,6 +128,11 @@ class Outlet(Accessory):
         return self.is_in_use
 
     def set_on(self, value: bool) -> None:
+        """Set the on/off state of the outlet.
+
+        Args:
+            value: True to turn on, False to turn off.
+        """
         # Emit set event
         self.logger.debug(f"set_on {value}")
 
@@ -108,6 +149,11 @@ class Outlet(Accessory):
             )
 
     def get_on(self) -> bool:
+        """Get the on/off state of the outlet.
+
+        Returns:
+            True if on, False if off.
+        """
         # Emit event and get response
         self.logger.debug("get_on")
 

xp/services/homekit/homekit_outlet_service.py

@@ -1,3 +1,8 @@
+"""HomeKit Outlet Service.
+
+This module provides service implementation for outlet accessories.
+"""
+
 import logging
 
 from bubus import EventBus
@@ -13,11 +18,21 @@ from xp.models.telegram.datapoint_type import DataPointType
 
 
 class HomeKitOutletService:
-    """Outlet service for HomeKit"""
+    """Outlet service for HomeKit.
+
+    Attributes:
+        event_bus: Event bus for inter-service communication.
+        logger: Logger instance.
+    """
 
     event_bus: EventBus
 
     def __init__(self, event_bus: EventBus):
+        """Initialize the outlet service.
+
+        Args:
+            event_bus: Event bus instance.
+        """
         self.event_bus = event_bus
         self.logger = logging.getLogger(__name__)
 
@@ -27,6 +42,14 @@ class HomeKitOutletService:
         self.event_bus.on(OutletGetInUseEvent, self.handle_outlet_get_in_use)
 
     def handle_outlet_get_on(self, event: OutletGetOnEvent) -> bool:
+        """Handle outlet get on event.
+
+        Args:
+            event: Outlet get on event.
+
+        Returns:
+            True if request was dispatched successfully.
+        """
         self.logger.debug(
             f"Getting outlet state for serial {event.serial_number}, output {event.output_number}"
         )
@@ -42,8 +65,19 @@ class HomeKitOutletService:
         return True
 
     def handle_outlet_set_on(self, event: OutletSetOnEvent) -> bool:
+        """Handle outlet set on event.
+
+        Args:
+            event: Outlet set on event.
+
+        Returns:
+            True if command was sent successfully.
+        """
         self.logger.info(
-            f"Setting outlet for serial {event.serial_number}, output {event.output_number} to {'ON' if event.value else 'OFF'}"
+            f"Setting outlet "
+            f"for serial {event.serial_number}, "
+            f"output {event.output_number} "
+            f"to {'ON' if event.value else 'OFF'}"
         )
         self.logger.debug(f"outlet_set_on {event}")
 
@@ -61,6 +95,14 @@ class HomeKitOutletService:
         return True
 
     def handle_outlet_get_in_use(self, event: OutletGetInUseEvent) -> bool:
+        """Handle outlet get in-use event.
+
+        Args:
+            event: Outlet get in-use event.
+
+        Returns:
+            True if request was dispatched successfully.
+        """
         self.logger.info(
             f"Getting outlet in-use status for serial {event.serial_number}"
         )

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