fast-clean-architecture 1.0.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

fast_clean_architecture/config.py

@@ -1,9 +1,15 @@
-"""Configuration management for Fast Clean Architecture."""
+"""Configuration management for Fast Clean Architecture.
 
-from pathlib import Path
-from typing import Dict, List, Optional, Union
+This module provides configuration loading, validation, and management
+functionalities for the Fast Clean Architecture framework.
+"""
+
+# mypy: disable-error-code=unreachable
 
 import re
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Protocol, TypedDict, Union
+
 import yaml
 from pydantic import BaseModel, Field
 
@@ -32,7 +38,6 @@ class ComponentsConfig(BaseModel):
     queries: List[ComponentInfo] = Field(default_factory=list)
     models: List[ComponentInfo] = Field(default_factory=list)
     external: List[ComponentInfo] = Field(default_factory=list)
-    internal: List[ComponentInfo] = Field(default_factory=list)
     api: List[ComponentInfo] = Field(default_factory=list)
     schemas: List[ComponentInfo] = Field(default_factory=list)
 
@@ -175,6 +180,10 @@ class Config(BaseModel):
             # Sanitize loaded data before creating config object
             sanitized_data = cls._sanitize_loaded_data(data)
 
+            # Ensure sanitized_data is a dict for Config construction
+            if not isinstance(sanitized_data, dict):
+                raise ConfigurationError("Sanitized data must be a dictionary")
+
             return cls(**sanitized_data)
         except yaml.YAMLError as e:
             raise ConfigurationError(f"Invalid YAML in config file: {e}")
@@ -182,7 +191,9 @@ class Config(BaseModel):
             raise ConfigurationError(f"Error loading config: {e}")
 
     @staticmethod
-    def _sanitize_loaded_data(data: dict) -> dict:
+    def _sanitize_loaded_data(
+        data: Dict[str, Any],
+    ) -> Union[Dict[str, Any], List[Any], str, int, float, bool, None]:
         """Sanitize data loaded from YAML file to prevent injection attacks.
 
         Args:
@@ -192,7 +203,9 @@ class Config(BaseModel):
             Sanitized data safe for Config object creation
         """
 
-        def sanitize_value(value):
+        def sanitize_value(
+            value: Union[Dict[str, Any], List[Any], str, int, float, bool, None],
+        ) -> Union[Dict[str, Any], List[Any], str, int, float, bool, None]:
             if value is None:
                 return None
             elif isinstance(value, bool):
@@ -279,7 +292,10 @@ class Config(BaseModel):
             # Create timestamped backup if file exists
             if config_path.exists():
                 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                backup_path = config_path.with_suffix(f".yaml.backup.{timestamp}")
+                # Create backup directory if it doesn't exist
+                backup_dir = config_path.parent / "fca_config_backups"
+                backup_dir.mkdir(exist_ok=True)
+                backup_path = backup_dir / f"{config_path.stem}.yaml.backup.{timestamp}"
                 backup_path.write_bytes(config_path.read_bytes())
 
                 # Clean up old backups (keep only last 5)
@@ -325,21 +341,21 @@ class Config(BaseModel):
             if temp_path and temp_path.exists():
                 try:
                     temp_path.unlink()
-                except:
+                except (OSError, FileNotFoundError):
                     pass
 
             # Restore from backup if available
             if backup_path and backup_path.exists() and not config_path.exists():
                 try:
                     backup_path.rename(config_path)
-                except:
+                except (OSError, FileExistsError):
                     pass
 
             raise ConfigurationError(f"Error saving config: {e}")
 
     def _sanitize_config_data(
-        self, data: Union[dict, list, str, int, float, bool, None]
-    ) -> Union[dict, list, str, int, float, bool, None]:
+        self, data: Union[Dict[str, Any], List[Any], str, int, float, bool, None]
+    ) -> Union[Dict[str, Any], List[Any], str, int, float, bool, None]:
         """Sanitize configuration data to prevent injection attacks and ensure safe YAML output.
 
         Args:
@@ -397,8 +413,12 @@ class Config(BaseModel):
     def _cleanup_old_backups(self, config_path: Path, keep_count: int = 5) -> None:
         """Clean up old backup files, keeping only the most recent ones."""
         try:
-            backup_pattern = f"{config_path.name}.backup.*"
-            backup_files = list(config_path.parent.glob(backup_pattern))
+            backup_dir = config_path.parent / "fca_config_backups"
+            if not backup_dir.exists():
+                return
+
+            backup_pattern = f"{config_path.stem}.yaml.backup.*"
+            backup_files = list(backup_dir.glob(backup_pattern))
 
             if len(backup_files) > keep_count:
                 # Sort by modification time (newest first)
@@ -411,7 +431,7 @@ class Config(BaseModel):
                     except OSError:
                         # Ignore errors when cleaning up old backups
                         pass
-        except Exception:
+        except OSError:
             # Don't fail the main operation if backup cleanup fails
             pass
 
@@ -420,14 +440,16 @@ class Config(BaseModel):
         if system_name in self.project.systems:
             raise ValidationError(f"System '{system_name}' already exists")
 
-        timestamp = generate_timestamp()
+        # Generate fresh timestamp for the new system
+        current_time = generate_timestamp()
 
         self.project.systems[system_name] = SystemConfig(
             description=description,
-            created_at=timestamp,
-            updated_at=timestamp,
+            created_at=current_time,
+            updated_at=current_time,
         )
-        self.project.updated_at = timestamp
+        # Update project timestamp with fresh timestamp
+        self.project.updated_at = current_time
 
     def add_module(
         self, system_name: str, module_name: str, description: str = ""
@@ -439,15 +461,17 @@ class Config(BaseModel):
         if module_name in self.project.systems[system_name].modules:
             raise ValidationError(f"Module '{module_name}' already exists")
 
-        timestamp = generate_timestamp()
+        # Generate fresh timestamps for the new module
+        current_time = generate_timestamp()
 
         self.project.systems[system_name].modules[module_name] = ModuleConfig(
             description=description,
-            created_at=timestamp,
-            updated_at=timestamp,
+            created_at=current_time,
+            updated_at=current_time,
         )
-        self.project.systems[system_name].updated_at = timestamp
-        self.project.updated_at = timestamp
+        # Update parent timestamps with fresh timestamp
+        self.project.systems[system_name].updated_at = current_time
+        self.project.updated_at = current_time
 
     def add_component(
         self,

fast_clean_architecture/error_tracking.py

@@ -0,0 +1,201 @@
+"""Error tracking and analytics for fast-clean-architecture."""
+
+import hashlib
+import traceback
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Type
+
+from .logging_config import get_logger
+
+# Set up logger
+logger = get_logger(__name__)
+
+
+class ErrorTracker:
+    """Track and analyze errors for debugging and monitoring."""
+
+    def __init__(self) -> None:
+        """Initialize error tracker."""
+        self.error_counts: Counter[str] = Counter()
+        self.error_details: Dict[str, List[Dict[str, Any]]] = defaultdict(list)
+        self.error_patterns: Dict[str, int] = defaultdict(int)
+
+    def track_error(
+        self,
+        error: Exception,
+        context: Optional[Dict[str, Any]] = None,
+        operation: Optional[str] = None,
+    ) -> str:
+        """Track an error occurrence.
+
+        Args:
+            error: The exception that occurred
+            context: Additional context about the error
+            operation: The operation that was being performed
+
+        Returns:
+            Error ID for tracking
+        """
+        # Generate error ID based on error type and message
+        error_signature = f"{type(error).__name__}:{str(error)}"
+        error_id = hashlib.sha256(error_signature.encode()).hexdigest()[:8]
+
+        # Get stack trace
+        stack_trace = traceback.format_exc()
+
+        # Create error record
+        error_record = {
+            "error_id": error_id,
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "error_type": type(error).__name__,
+            "error_message": str(error),
+            "operation": operation,
+            "context": context or {},
+            "stack_trace": stack_trace,
+        }
+
+        # Update counters and storage
+        self.error_counts[error_signature] += 1
+        self.error_details[error_id].append(error_record)
+
+        # Track error patterns
+        error_pattern = f"{type(error).__name__}:{operation or 'unknown'}"
+        self.error_patterns[error_pattern] += 1
+
+        # Log the error with structured data
+        logger.error(
+            "Error tracked",
+            operation="error_tracking",
+            error_id=error_id,
+            error_type=type(error).__name__,
+            error_message=str(error),
+            error_operation=operation,
+            error_context=context,
+            occurrence_count=self.error_counts[error_signature],
+        )
+
+        return error_id
+
+    def get_error_summary(self) -> Dict[str, Any]:
+        """Get summary of tracked errors.
+
+        Returns:
+            Dictionary containing error statistics
+        """
+        total_errors = sum(self.error_counts.values())
+        unique_errors = len(self.error_counts)
+
+        # Get most common errors
+        most_common_errors = self.error_counts.most_common(5)
+
+        # Get most common error patterns
+        most_common_patterns = dict(Counter(self.error_patterns).most_common(5))
+
+        summary = {
+            "total_errors": total_errors,
+            "unique_errors": unique_errors,
+            "most_common_errors": [
+                {"signature": sig, "count": count} for sig, count in most_common_errors
+            ],
+            "most_common_patterns": most_common_patterns,
+            "timestamp": datetime.utcnow().isoformat(),
+        }
+
+        return summary
+
+    def get_error_details(self, error_id: str) -> List[Dict[str, Any]]:
+        """Get detailed information about a specific error.
+
+        Args:
+            error_id: The error ID to look up
+
+        Returns:
+            List of error occurrences for the given ID
+        """
+        return self.error_details.get(error_id, [])
+
+    def log_error_summary(self) -> None:
+        """Log current error summary."""
+        summary = self.get_error_summary()
+
+        logger.info("Error tracking summary", operation="error_summary", **summary)
+
+
+def track_exception(
+    operation: Optional[str] = None, context: Optional[Dict[str, Any]] = None
+) -> Any:
+    """Decorator to automatically track exceptions.
+
+    Args:
+        operation: Name of the operation being performed
+        context: Additional context to include
+    """
+
+    def decorator(func: Any) -> Any:
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                # Get the global error tracker
+                error_tracker = get_error_tracker()
+
+                # Add function context
+                func_context = {
+                    "function": func.__name__,
+                    "module": func.__module__,
+                    **(context or {}),
+                }
+
+                # Track the error
+                error_id = error_tracker.track_error(
+                    error=e, context=func_context, operation=operation or func.__name__
+                )
+
+                # Re-raise the exception
+                raise
+
+        return wrapper
+
+    return decorator
+
+
+# Global error tracker instance
+_error_tracker: Optional[ErrorTracker] = None
+
+
+def get_error_tracker() -> ErrorTracker:
+    """Get the global error tracker instance.
+
+    Returns:
+        Global ErrorTracker instance
+    """
+    global _error_tracker
+    if _error_tracker is None:
+        _error_tracker = ErrorTracker()
+    return _error_tracker
+
+
+def track_error(
+    error: Exception,
+    context: Optional[Dict[str, Any]] = None,
+    operation: Optional[str] = None,
+) -> str:
+    """Track an error using the global error tracker.
+
+    Args:
+        error: The exception that occurred
+        context: Additional context about the error
+        operation: The operation that was being performed
+
+    Returns:
+        Error ID for tracking
+    """
+    tracker = get_error_tracker()
+    return tracker.track_error(error, context, operation)
+
+
+def log_error_summary() -> None:
+    """Log error summary using the global error tracker."""
+    tracker = get_error_tracker()
+    tracker.log_error_summary()