conson-xp 1.18.0__py3-none-any.whl

xp/services/log_file_service.py

@@ -0,0 +1,309 @@
+"""Log file parsing service for console bus communication logs."""
+
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from xp.models.log_entry import LogEntry
+from xp.services.telegram.telegram_service import TelegramParsingError, TelegramService
+from xp.utils.time_utils import (
+    TimeParsingError,
+    calculate_duration_ms,
+    parse_log_timestamp,
+)
+
+
+class LogFileParsingError(Exception):
+    """Raised when log file parsing fails."""
+
+    pass
+
+
+class LogFileService:
+    """
+    Service for parsing console bus log files.
+
+    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>
+    LOG_LINE_PATTERN = re.compile(
+        r"^(\d{2}:\d{2}:\d{2},\d{3})\s+\[([TR]X)\]\s+(<[^>]+>)\s*$"
+    )
+
+    def __init__(self, telegram_service: TelegramService):
+        """Initialize the log file service.
+
+        Args:
+            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.
+
+        Args:
+            file_path: Path to the log file.
+            base_date: Base date for timestamps (defaults to today).
+
+        Returns:
+            List of parsed LogEntry objects.
+
+        Raises:
+            LogFileParsingError: If file cannot be read or parsed.
+        """
+        try:
+            path = Path(file_path)
+            if not path.exists():
+                raise LogFileParsingError(f"Log file not found: {file_path}")
+
+            if not path.is_file():
+                raise LogFileParsingError(f"Path is not a file: {file_path}")
+
+            with Path(path).open("r", encoding="utf-8", errors="replace") as f:
+                lines = f.readlines()
+
+            return self.parse_log_lines(lines, base_date)
+
+        except IOError as e:
+            raise LogFileParsingError(f"Error reading log file {file_path}: {e}")
+
+    def parse_log_lines(
+        self, lines: List[str], base_date: Optional[datetime] = None
+    ) -> List[LogEntry]:
+        """Parse log lines into LogEntry objects.
+
+        Args:
+            lines: List of log lines to parse.
+            base_date: Base date for timestamps.
+
+        Returns:
+            List of parsed LogEntry objects.
+        """
+        entries = []
+
+        for line_number, line in enumerate(lines, 1):
+            line = line.strip()
+            if not line:  # Skip empty lines
+                continue
+
+            try:
+                entry = self._parse_log_line(line, line_number, base_date)
+                if entry:
+                    entries.append(entry)
+            except Exception as e:
+                # Create entry with parse error for malformed lines
+                entry = LogEntry(
+                    timestamp=base_date or datetime.now(),
+                    direction="UNKNOWN",
+                    raw_telegram=line,
+                    parse_error=f"Line parsing failed: {e}",
+                    line_number=line_number,
+                )
+                entries.append(entry)
+
+        return entries
+
+    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.
+
+        Args:
+            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.
+        """
+        match = self.LOG_LINE_PATTERN.match(line)
+        if not match:
+            raise LogFileParsingError(f"Invalid log line format: {line}")
+
+        timestamp_str = match.group(1)
+        direction = match.group(2)
+        telegram_str = match.group(3)
+
+        # Parse timestamp
+        try:
+            timestamp = parse_log_timestamp(timestamp_str, base_date)
+        except TimeParsingError as e:
+            raise LogFileParsingError(f"Invalid timestamp in line {line_number}: {e}")
+
+        # Create initial log entry
+        entry = LogEntry(
+            timestamp=timestamp,
+            direction=direction,
+            raw_telegram=telegram_str,
+            line_number=line_number,
+        )
+
+        # Try to parse the telegram
+        try:
+            parsed_telegram = self.telegram_service.parse_telegram(telegram_str)
+            entry.parsed_telegram = parsed_telegram
+        except TelegramParsingError as e:
+            entry.parse_error = str(e)
+
+        return entry
+
+    def validate_log_format(self, file_path: str) -> bool:
+        """Validate that a file follows the expected log format.
+
+        Args:
+            file_path: Path to the log file.
+
+        Returns:
+            True if format is valid, False otherwise.
+        """
+        try:
+            entries = self.parse_log_file(file_path)
+            # Check if at least some entries parsed successfully
+            valid_entries = [e for e in entries if e.is_valid_parse]
+            return len(valid_entries) > 0
+        except LogFileParsingError:
+            return False
+
+    def extract_telegrams(self, file_path: str) -> List[str]:
+        """Extract all telegram strings from a log file.
+
+        Args:
+            file_path: Path to the log file.
+
+        Returns:
+            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.
+
+        Args:
+            entries: List of LogEntry objects.
+
+        Returns:
+            Dictionary containing statistics.
+        """
+        if not entries:
+            return {"total_entries": 0}
+
+        # Basic counts
+        total_entries = len(entries)
+        valid_parses = len([e for e in entries if e.is_valid_parse])
+        parse_errors = total_entries - valid_parses
+
+        # Direction counts
+        tx_count = len([e for e in entries if e.direction == "TX"])
+        rx_count = len([e for e in entries if e.direction == "RX"])
+
+        # Type counts
+        event_count = len([e for e in entries if e.telegram_type == "E"])
+        system_count = len([e for e in entries if e.telegram_type == "S"])
+        reply_count = len([e for e in entries if e.telegram_type == "R"])
+        unknown_count = len([e for e in entries if e.telegram_type == "unknown"])
+
+        # Checksum validation
+        validated_entries = [e for e in entries if e.checksum_validated is not None]
+        valid_checksums = len([e for e in validated_entries if e.checksum_validated])
+        invalid_checksums = len(validated_entries) - valid_checksums
+
+        # Time range
+        timestamps = [e.timestamp for e in entries]
+        start_time = min(timestamps) if timestamps else None
+        end_time = max(timestamps) if timestamps else None
+        duration_ms = (
+            calculate_duration_ms(start_time, end_time)
+            if start_time and end_time
+            else 0
+        )
+
+        # Device analysis
+        devices = set()
+        for entry in entries:
+            if entry.parsed_telegram:
+                if hasattr(entry.parsed_telegram, "serial_number"):
+                    devices.add(entry.parsed_telegram.serial_number)
+                elif hasattr(entry.parsed_telegram, "module_type"):
+                    devices.add(f"Module_{entry.parsed_telegram.module_type}")
+
+        return {
+            "total_entries": total_entries,
+            "valid_parses": valid_parses,
+            "parse_errors": parse_errors,
+            "parse_success_rate": (
+                (valid_parses / total_entries * 100) if total_entries > 0 else 0
+            ),
+            "direction_counts": {"tx": tx_count, "rx": rx_count},
+            "telegram_type_counts": {
+                "event": event_count,
+                "system": system_count,
+                "reply": reply_count,
+                "unknown": unknown_count,
+            },
+            "checksum_validation": {
+                "validated_count": len(validated_entries),
+                "valid_checksums": valid_checksums,
+                "invalid_checksums": invalid_checksums,
+                "validation_success_rate": (
+                    (valid_checksums / len(validated_entries) * 100)
+                    if validated_entries
+                    else 0
+                ),
+            },
+            "time_range": {
+                "start": (
+                    start_time.strftime("%H:%M:%S.%f")[:-3] if start_time else None
+                ),
+                "end": end_time.strftime("%H:%M:%S.%f")[:-3] if end_time else None,
+                "duration_ms": duration_ms,
+                "duration_seconds": duration_ms / 1000 if duration_ms > 0 else 0,
+            },
+            "devices": sorted(list(devices)),
+        }
+
+    @staticmethod
+    def filter_entries(
+        entries: List[LogEntry],
+        telegram_type: Optional[str] = None,
+        direction: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+    ) -> List[LogEntry]:
+        """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.
+
+        Returns:
+            Filtered list of LogEntry objects.
+        """
+        filtered = entries.copy()
+
+        if telegram_type:
+            filtered = [e for e in filtered if e.telegram_type == telegram_type.lower()]
+
+        if direction:
+            filtered = [e for e in filtered if e.direction == direction.upper()]
+
+        if start_time:
+            filtered = [e for e in filtered if e.timestamp >= start_time]
+
+        if end_time:
+            filtered = [e for e in filtered if e.timestamp <= end_time]
+
+        return filtered

xp/services/module_type_service.py

@@ -0,0 +1,257 @@
+"""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 (
+    ModuleType,
+    get_all_module_types,
+    get_module_types_by_category,
+    is_valid_module_code,
+)
+
+
+class ModuleTypeNotFoundError(Exception):
+    """Raised when a module type cannot be found."""
+
+    pass
+
+
+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."""
+        pass
+
+    @staticmethod
+    def get_module_type(identifier: Union[int, str]) -> ModuleType:
+        """
+        Get module type by code or name.
+
+        Args:
+            identifier: Module code (int) or name (str)
+
+        Returns:
+            ModuleType instance
+
+        Raises:
+            ModuleTypeNotFoundError: If module type is not found
+        """
+        if isinstance(identifier, int):
+            module_type = ModuleType.from_code(identifier)
+            if not module_type:
+                raise ModuleTypeNotFoundError(
+                    f"Module type with code {identifier} not found"
+                )
+        elif isinstance(identifier, str):
+            module_type = ModuleType.from_name(identifier)
+            if not module_type:
+                raise ModuleTypeNotFoundError(
+                    f"Module type with name '{identifier}' not found"
+                )
+        else:
+            raise ModuleTypeNotFoundError(
+                f"Invalid identifier type: {type(identifier)}"
+            )
+
+        return module_type
+
+    @staticmethod
+    def list_all_modules() -> List[ModuleType]:
+        """
+        Get all available module types.
+
+        Returns:
+            List of all ModuleType instances
+        """
+        return get_all_module_types()
+
+    @staticmethod
+    def list_modules_by_category() -> Dict[str, List[ModuleType]]:
+        """
+        Get module types grouped by category.
+
+        Returns:
+            Dictionary with category names as keys and lists of ModuleType as values
+        """
+        return get_module_types_by_category()
+
+    @staticmethod
+    def search_modules(
+        query: str, search_fields: Optional[List[str]] = None
+    ) -> List[ModuleType]:
+        """
+        Search for module types matching a query string.
+
+        Args:
+            query: Search query string
+            search_fields: Fields to search in ('name', 'description'). Defaults to both.
+
+        Returns:
+            List of matching ModuleType instances
+        """
+        if search_fields is None:
+            search_fields = ["name", "description"]
+
+        query_lower = query.lower()
+        matching_modules = []
+
+        for module_type in get_all_module_types():
+            match_found = False
+
+            if "name" in search_fields and query_lower in module_type.name.lower():
+                match_found = True
+            elif (
+                "description" in search_fields
+                and query_lower in module_type.description.lower()
+            ):
+                match_found = True
+
+            if match_found:
+                matching_modules.append(module_type)
+
+        return matching_modules
+
+    @staticmethod
+    def get_modules_by_category(category: str) -> List[ModuleType]:
+        """
+        Get all module types in a specific category.
+
+        Args:
+            category: Category name
+
+        Returns:
+            List of ModuleType instances in the category
+        """
+        return get_module_types_by_category().get(category, [])
+
+    @staticmethod
+    def get_push_button_panels() -> List[ModuleType]:
+        """
+        Get all push button panel module types.
+
+        Returns:
+            List of push button panel ModuleType instances
+        """
+        return [
+            module for module in get_all_module_types() if module.is_push_button_panel
+        ]
+
+    @staticmethod
+    def get_ir_capable_modules() -> List[ModuleType]:
+        """
+        Get all IR-capable module types.
+
+        Returns:
+            List of IR-capable ModuleType instances
+        """
+        return [module for module in get_all_module_types() if module.is_ir_capable]
+
+    @staticmethod
+    def validate_module_code(code: int) -> bool:
+        """
+        Validate if a module code is valid.
+
+        Args:
+            code: Module type code to validate
+
+        Returns:
+            True if valid, False otherwise
+        """
+        return is_valid_module_code(code)
+
+    def get_module_info_summary(self, identifier: Union[int, str]) -> str:
+        """
+        Get a human-readable summary of a module type.
+
+        Args:
+            identifier: Module code (int) or name (str)
+
+        Returns:
+            Formatted string with module information
+        """
+        try:
+            module_type = self.get_module_type(identifier)
+            return self._format_module_summary(module_type)
+        except ModuleTypeNotFoundError as e:
+            return f"Error: {e}"
+
+    def get_all_modules_summary(self, group_by_category: bool = False) -> str:
+        """
+        Get a formatted summary of all module types.
+
+        Args:
+            group_by_category: Whether to group modules by category
+
+        Returns:
+            Formatted string with all module information
+        """
+        if group_by_category:
+            return self._format_modules_by_category()
+        return self._format_all_modules()
+
+    @staticmethod
+    def _format_module_summary(module_type: ModuleType) -> str:
+        """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"
+
+        features = []
+        if module_type.is_push_button_panel:
+            features.append("Push Button Panel")
+        if module_type.is_ir_capable:
+            features.append("IR Capable")
+        if module_type.is_reserved:
+            features.append("Reserved")
+
+        if features:
+            summary += f"Features: {', '.join(features)}\n"
+
+        return summary.strip()
+
+    @staticmethod
+    def _format_all_modules() -> str:
+        """Format all modules in a simple list.
+
+        Returns:
+            Formatted string with all modules.
+        """
+        modules = get_all_module_types()
+        lines = ["Code | Name       | Description", "-" * 60]
+
+        for module in modules:
+            lines.append(f"{module.code:4} | {module.name:10} | {module.description}")
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def _format_modules_by_category() -> str:
+        """Format modules grouped by category.
+
+        Returns:
+            Formatted string with modules grouped by category.
+        """
+        categories = get_module_types_by_category()
+        lines = []
+
+        for category, modules in categories.items():
+            lines.append(f"\n=== {category} ===")
+            for module in modules:
+                lines.append(f"  {module.code:2} - {module.name}: {module.description}")
+
+        return "\n".join(lines).strip()

xp/services/protocol/__init__.py

@@ -0,0 +1,21 @@
+"""Protocol layer services for XP."""
+
+from xp.models.protocol.conbus_protocol import (
+    ConnectionMadeEvent,
+    EventTelegramReceivedEvent,
+    InvalidTelegramReceivedEvent,
+    ModuleDiscoveredEvent,
+    TelegramReceivedEvent,
+)
+from xp.services.protocol.conbus_event_protocol import ConbusEventProtocol
+from xp.services.protocol.conbus_protocol import ConbusProtocol
+from xp.services.protocol.telegram_protocol import TelegramProtocol
+
+__all__ = ["TelegramProtocol", "ConbusProtocol", "ConbusEventProtocol"]
+
+# Rebuild models after TelegramProtocol and ConbusProtocol are imported to resolve forward references
+ConnectionMadeEvent.model_rebuild()
+InvalidTelegramReceivedEvent.model_rebuild()
+ModuleDiscoveredEvent.model_rebuild()
+TelegramReceivedEvent.model_rebuild()
+EventTelegramReceivedEvent.model_rebuild()