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

xp/services/telegram/telegram_blink_service.py

@@ -11,7 +11,7 @@ from xp.utils.checksum import calculate_checksum
 
 
 class BlinkError(Exception):
-    """Raised when blink/unblink operations fail"""
+    """Raised when blink/unblink operations fail."""
 
     pass
 
@@ -26,24 +26,22 @@ class TelegramBlinkService:
     """
 
     def __init__(self) -> None:
-        """Initialize the blink service"""
+        """Initialize the blink service."""
         pass
 
     @staticmethod
     def generate_blink_telegram(serial_number: str, on_or_off: str) -> str:
-        """
-        Generate a telegram to start blinking a module's LED.
+        """Generate a telegram to start blinking a module's LED.
 
         Args:
-            serial_number: The 10-digit module serial number
+            serial_number: The 10-digit module serial number.
+            on_or_off: The action to perform ('on' for blink, 'off' for unblink).
 
         Returns:
-            Formatted telegram string (e.g., "<S0012345008F05D00FN>")
+            Formatted telegram string (e.g., "<S0012345008F05D00FN>").
 
         Raises:
-            BlinkError: If parameters are invalid
-            :param serial_number:
-            :param on_or_off:
+            BlinkError: If parameters are invalid.
         """
         # Validate serial number
         if not serial_number or len(serial_number) != 10:
@@ -68,17 +66,13 @@ class TelegramBlinkService:
         return telegram
 
     def create_blink_telegram_object(self, serial_number: str) -> SystemTelegram:
-        """
-        Create a SystemTelegram object for blinking LED.
+        """Create a SystemTelegram object for blinking LED.
 
         Args:
-            serial_number: The 10-digit module serial number
+            serial_number: The 10-digit module serial number.
 
         Returns:
-            SystemTelegram object representing the blink command
-
-        Raises:
-            BlinkError: If parameters are invalid
+            SystemTelegram object representing the blink command.
         """
         raw_telegram = self.generate_blink_telegram(serial_number, "on")
 
@@ -96,17 +90,13 @@ class TelegramBlinkService:
         return telegram
 
     def create_unblink_telegram_object(self, serial_number: str) -> SystemTelegram:
-        """
-        Create a SystemTelegram object for unblink LED.
+        """Create a SystemTelegram object for unblink LED.
 
         Args:
-            serial_number: The 10-digit module serial number
+            serial_number: The 10-digit module serial number.
 
         Returns:
-            SystemTelegram object representing the unblink command
-
-        Raises:
-            BlinkError: If parameters are invalid
+            SystemTelegram object representing the unblink command.
         """
         raw_telegram = self.generate_blink_telegram(serial_number, "off")
 
@@ -125,26 +115,24 @@ class TelegramBlinkService:
 
     @staticmethod
     def is_ack_response(reply_telegram: ReplyTelegram) -> bool:
-        """
-        Check if a reply telegram is an ACK response.
+        """Check if a reply telegram is an ACK response.
 
         Args:
-            reply_telegram: Reply telegram to check
+            reply_telegram: Reply telegram to check.
 
         Returns:
-            True if this is an ACK response (F18D), False otherwise
+            True if this is an ACK response (F18D), False otherwise.
         """
         return reply_telegram.system_function == SystemFunction.ACK
 
     @staticmethod
     def is_nak_response(reply_telegram: ReplyTelegram) -> bool:
-        """
-        Check if a reply telegram is a NAK response.
+        """Check if a reply telegram is a NAK response.
 
         Args:
-            reply_telegram: Reply telegram to check
+            reply_telegram: Reply telegram to check.
 
         Returns:
-            True if this is a NAK response (F19D), False otherwise
+            True if this is a NAK response (F19D), False otherwise.
         """
         return reply_telegram.system_function == SystemFunction.NAK

xp/services/telegram/telegram_checksum_service.py

@@ -22,10 +22,10 @@ class TelegramChecksumService:
         """Calculate simple XOR checksum for string data.
 
         Args:
-            data: String data to calculate checksum for
+            data: String data to calculate checksum for.
 
         Returns:
-            Response object with checksum result
+            Response object with checksum result.
         """
         try:
             checksum = calculate_checksum(data)
@@ -45,10 +45,10 @@ class TelegramChecksumService:
         """Calculate CRC32 checksum for data.
 
         Args:
-            data: String or bytes data to calculate checksum for
+            data: String or bytes data to calculate checksum for.
 
         Returns:
-            Response object with checksum result
+            Response object with checksum result.
         """
         try:
             # Convert string to bytes if needed
@@ -82,11 +82,11 @@ class TelegramChecksumService:
         """Validate data against expected simple checksum.
 
         Args:
-            data: Original data
-            expected_checksum: Expected checksum value
+            data: Original data.
+            expected_checksum: Expected checksum value.
 
         Returns:
-            Response object with validation result
+            Response object with validation result.
         """
         try:
             calculated_checksum = calculate_checksum(data)
@@ -114,11 +114,11 @@ class TelegramChecksumService:
         """Validate data against expected CRC32 checksum.
 
         Args:
-            data: Original data (string or bytes)
-            expected_checksum: Expected CRC32 checksum value
+            data: Original data (string or bytes).
+            expected_checksum: Expected CRC32 checksum value.
 
         Returns:
-            Response object with validation result
+            Response object with validation result.
         """
         try:
             # Convert string to bytes if needed

xp/services/telegram/telegram_discover_service.py

@@ -13,30 +13,51 @@ from xp.utils.checksum import calculate_checksum
 
 
 class DiscoverError(Exception):
-    """Raised when discover operations fail"""
+    """Raised when discover operations fail."""
 
     pass
 
 
 class DeviceInfo:
-    """Information about a discovered device"""
+    """Information about a discovered device."""
 
     def __init__(
         self, serial_number: str, checksum_valid: bool = True, raw_telegram: str = ""
     ):
+        """Initialize device info.
+
+        Args:
+            serial_number: 10-digit module serial number.
+            checksum_valid: Whether the telegram checksum is valid.
+            raw_telegram: Raw telegram string.
+        """
         self.serial_number = serial_number
         self.checksum_valid = checksum_valid
         self.raw_telegram = raw_telegram
 
     def __str__(self) -> str:
+        """Return string representation of device.
+
+        Returns:
+            String with serial number and checksum status.
+        """
         status = "✓" if self.checksum_valid else "✗"
         return f"Device {self.serial_number} ({status})"
 
     def __repr__(self) -> str:
+        """Return repr representation of device.
+
+        Returns:
+            DeviceInfo constructor representation.
+        """
         return f"DeviceInfo(serial='{self.serial_number}', checksum_valid={self.checksum_valid})"
 
     def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization"""
+        """Convert to dictionary for JSON serialization.
+
+        Returns:
+            Dictionary with device information.
+        """
         return {
             "serial_number": self.serial_number,
             "checksum_valid": self.checksum_valid,
@@ -54,7 +75,7 @@ class TelegramDiscoverService:
     """
 
     def __init__(self) -> None:
-        """Initialize the discover service"""
+        """Initialize the discover service."""
         pass
 
     @staticmethod
@@ -78,11 +99,10 @@ class TelegramDiscoverService:
         return telegram
 
     def create_discover_telegram_object(self) -> SystemTelegram:
-        """
-        Create a SystemTelegram object for discover broadcast.
+        """Create a SystemTelegram object for discover broadcast.
 
         Returns:
-            SystemTelegram object representing the discover command
+            SystemTelegram object representing the discover command.
         """
         raw_telegram = self.generate_discover_telegram()
 
@@ -101,20 +121,26 @@ class TelegramDiscoverService:
 
     @staticmethod
     def is_discover_response(reply_telegram: ReplyTelegram) -> bool:
-        """
-        Check if a reply telegram is a discover response.
+        """Check if a reply telegram is a discover response.
 
         Args:
-            reply_telegram: Reply telegram to check
+            reply_telegram: Reply telegram to check.
 
         Returns:
-            True if this is a discover response, False otherwise
+            True if this is a discover response, False otherwise.
         """
         return reply_telegram.system_function == SystemFunction.DISCOVERY
 
     @staticmethod
     def _generate_discover_response(serial_number: str) -> str:
-        """Generate discover response telegram for a device"""
+        """Generate discover response telegram for a device.
+
+        Args:
+            serial_number: 10-digit module serial number.
+
+        Returns:
+            Formatted discover response telegram.
+        """
         # Format: <R{serial}F01D{checksum}>
         data_part = f"R{serial_number}F01D"
         checksum = calculate_checksum(data_part)
@@ -123,14 +149,13 @@ class TelegramDiscoverService:
 
     @staticmethod
     def get_unique_devices(devices: List[DeviceInfo]) -> List[DeviceInfo]:
-        """
-        Filter out duplicate devices based on serial number.
+        """Filter out duplicate devices based on serial number.
 
         Args:
-            devices: List of discovered devices
+            devices: List of discovered devices.
 
         Returns:
-            List of unique devices (first occurrence of each serial number)
+            List of unique devices (first occurrence of each serial number).
         """
         seen_serials: Set[str] = set()
         unique_devices = []
@@ -144,14 +169,13 @@ class TelegramDiscoverService:
 
     @staticmethod
     def validate_discover_response_format(raw_telegram: str) -> bool:
-        """
-        Validate if a raw telegram matches discover response format.
+        """Validate if a raw telegram matches discover response format.
 
         Args:
-            raw_telegram: Raw telegram string to validate
+            raw_telegram: Raw telegram string to validate.
 
         Returns:
-            True if format matches discover response pattern
+            True if format matches discover response pattern.
         """
         # Discover response format: <R{10-digit-serial}F01D{2-char-checksum}>
         import re
@@ -163,14 +187,13 @@ class TelegramDiscoverService:
         return match is not None
 
     def generate_discover_summary(self, devices: List[DeviceInfo]) -> dict:
-        """
-        Generate a summary of a discover results.
+        """Generate a summary of a discover results.
 
         Args:
-            devices: List of discovered devices
+            devices: List of discovered devices.
 
         Returns:
-            Dictionary with discover statistics
+            Dictionary with discover statistics.
         """
         unique_devices = self.get_unique_devices(devices)
         valid_devices = [d for d in unique_devices if d.checksum_valid]
@@ -200,14 +223,13 @@ class TelegramDiscoverService:
         }
 
     def format_discover_results(self, devices: List[DeviceInfo]) -> str:
-        """
-        Format discover results for human-readable output.
+        """Format discover results for human-readable output.
 
         Args:
-            devices: List of discovered devices
+            devices: List of discovered devices.
 
         Returns:
-            Formatted string summary
+            Formatted string summary.
         """
         if not devices:
             return "No devices discovered"
@@ -241,7 +263,14 @@ class TelegramDiscoverService:
 
     @staticmethod
     def is_discover_request(telegram: SystemTelegram) -> bool:
-        """Check if telegram is a discover request"""
+        """Check if telegram is a discover request.
+
+        Args:
+            telegram: System telegram to check.
+
+        Returns:
+            True if this is a discover request, False otherwise.
+        """
         return (
             telegram.system_function == SystemFunction.DISCOVERY
             and telegram.serial_number == "0000000000"

xp/services/telegram/telegram_link_number_service.py

@@ -15,7 +15,7 @@ from xp.utils.checksum import calculate_checksum
 
 
 class LinkNumberError(Exception):
-    """Raised when link number operations fail"""
+    """Raised when link number operations fail."""
 
     pass
 
@@ -29,23 +29,22 @@ class LinkNumberService:
     """
 
     def __init__(self) -> None:
-        """Initialize the link number service"""
+        """Initialize the link number service."""
         pass
 
     @staticmethod
     def generate_set_link_number_telegram(serial_number: str, link_number: int) -> str:
-        """
-        Generate a telegram to set a module's link number.
+        """Generate a telegram to set a module's link number.
 
         Args:
-            serial_number: The 10-digit module serial number
-            link_number: The link number to set (0-99)
+            serial_number: The 10-digit module serial number.
+            link_number: The link number to set (0-99).
 
         Returns:
-            Formatted telegram string (e.g., "<S0012345005F04D0425FO>")
+            Formatted telegram string (e.g., "<S0012345005F04D0425FO>").
 
         Raises:
-            LinkNumberError: If parameters are invalid
+            LinkNumberError: If parameters are invalid.
         """
         # Validate serial number
         if not serial_number or len(serial_number) != 10:
@@ -80,17 +79,16 @@ class LinkNumberService:
 
     @staticmethod
     def generate_read_link_number_telegram(serial_number: str) -> str:
-        """
-        Generate a telegram to read a module's current link number.
+        """Generate a telegram to read a module's current link number.
 
         Args:
-            serial_number: The 10-digit module serial number
+            serial_number: The 10-digit module serial number.
 
         Returns:
-            Formatted telegram string for reading link number
+            Formatted telegram string for reading link number.
 
         Raises:
-            LinkNumberError: If serial number is invalid
+            LinkNumberError: If serial number is invalid.
         """
         # Validate serial number
         if not serial_number or len(serial_number) != 10:
@@ -117,18 +115,14 @@ class LinkNumberService:
     def create_set_link_number_telegram_object(
         self, serial_number: str, link_number: int
     ) -> SystemTelegram:
-        """
-        Create a SystemTelegram object for setting link number.
+        """Create a SystemTelegram object for setting link number.
 
         Args:
-            serial_number: The 10-digit module serial number
-            link_number: The link number to set (0-99)
+            serial_number: The 10-digit module serial number.
+            link_number: The link number to set (0-99).
 
         Returns:
-            SystemTelegram object representing the set link number command
-
-        Raises:
-            LinkNumberError: If parameters are invalid
+            SystemTelegram object representing the set link number command.
         """
         raw_telegram = self.generate_set_link_number_telegram(
             serial_number, link_number
@@ -150,17 +144,13 @@ class LinkNumberService:
     def create_read_link_number_telegram_object(
         self, serial_number: str
     ) -> SystemTelegram:
-        """
-        Create a SystemTelegram object for reading link number.
+        """Create a SystemTelegram object for reading link number.
 
         Args:
-            serial_number: The 10-digit module serial number
+            serial_number: The 10-digit module serial number.
 
         Returns:
-            SystemTelegram object representing the read link number command
-
-        Raises:
-            LinkNumberError: If serial number is invalid
+            SystemTelegram object representing the read link number command.
         """
         raw_telegram = self.generate_read_link_number_telegram(serial_number)
 
@@ -179,14 +169,13 @@ class LinkNumberService:
 
     @staticmethod
     def parse_link_number_from_reply(reply_telegram: ReplyTelegram) -> Optional[int]:
-        """
-        Parse the link number value from a reply telegram.
+        """Parse the link number value from a reply telegram.
 
         Args:
-            reply_telegram: Reply telegram containing link number data
+            reply_telegram: Reply telegram containing link number data.
 
         Returns:
-            Link number if successfully parsed, None otherwise
+            Link number if successfully parsed, None otherwise.
         """
         if (
             reply_telegram.datapoint_type != DataPointType.LINK_NUMBER
@@ -204,26 +193,24 @@ class LinkNumberService:
 
     @staticmethod
     def is_ack_response(reply_telegram: ReplyTelegram) -> bool:
-        """
-        Check if a reply telegram is an ACK response.
+        """Check if a reply telegram is an ACK response.
 
         Args:
-            reply_telegram: Reply telegram to check
+            reply_telegram: Reply telegram to check.
 
         Returns:
-            True if this is an ACK response (F18D), False otherwise
+            True if this is an ACK response (F18D), False otherwise.
         """
         return reply_telegram.system_function == SystemFunction.ACK
 
     @staticmethod
     def is_nak_response(reply_telegram: ReplyTelegram) -> bool:
-        """
-        Check if a reply telegram is a NAK response.
+        """Check if a reply telegram is a NAK response.
 
         Args:
-            reply_telegram: Reply telegram to check
+            reply_telegram: Reply telegram to check.
 
         Returns:
-            True if this is a NAK response (F19D), False otherwise
+            True if this is a NAK response (F19D), False otherwise.
         """
         return reply_telegram.system_function == SystemFunction.NAK