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

fast_clean_architecture/generators/template_validator.py

@@ -3,24 +3,24 @@
 import logging
 import time
 from abc import ABC, abstractmethod
-from typing import Dict, Any, Set, Optional, List, Protocol, TypeVar
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Protocol, Set, TypeVar
 
 import jinja2
-from jinja2 import meta, Environment, TemplateSyntaxError, UndefinedError
+from jinja2 import Environment, TemplateSyntaxError, UndefinedError, meta
 from jinja2.sandbox import SandboxedEnvironment
 
 from ..exceptions import (
     TemplateError,
-    TemplateValidationError,
     TemplateMissingVariablesError,
     TemplateUndefinedVariableError,
+    TemplateValidationError,
 )
 from .validation_config import ValidationConfig
 from .validation_metrics import (
-    timed_validation,
-    get_metrics_collector,
     ValidationMetrics,
+    get_metrics_collector,
+    timed_validation,
     validation_timeout,
 )
 
@@ -46,18 +46,35 @@ class TemplateValidationStrategy(ABC):
     """Abstract base class for template validation strategies."""
 
     @abstractmethod
-    def validate(self, template_source: str, template_vars: Dict[str, Any]) -> None:
+    def validate(
+        self, template_source: str, template_vars: Dict[str, Any]
+    ) -> "ValidationMetrics":
         """Validate template with given variables.
 
         Args:
             template_source: The template source code
             template_vars: Variables to validate against
 
+        Returns:
+            ValidationMetrics: Metrics about the validation process
+
         Raises:
             TemplateError: If validation fails
         """
         pass
 
+    @abstractmethod
+    def sanitize_variables(self, variables: Dict[str, Any]) -> Dict[str, Any]:
+        """Sanitize template variables for safe processing.
+
+        Args:
+            variables: Raw template variables
+
+        Returns:
+            Dict[str, Any]: Sanitized variables safe for template processing
+        """
+        pass
+
 
 class SimpleTemplateValidator:
     """Simplified template validator with essential security features.
@@ -74,7 +91,9 @@ class SimpleTemplateValidator:
             get_metrics_collector() if config and config.enable_metrics else None
         )
 
-    def validate(self, template_source: str, template_vars: Dict[str, Any]) -> None:
+    def validate(
+        self, template_source: str, template_vars: Dict[str, Any]
+    ) -> "ValidationMetrics":
         """Validate template with essential security checks.
 
         Args:
@@ -129,6 +148,16 @@ class SimpleTemplateValidator:
             if self._metrics_collector:
                 self._metrics_collector.record_validation(True)
 
+            # Return success metrics
+            return ValidationMetrics(
+                strategy_used="simple",
+                validation_time_ms=0,  # Not tracked in simple validator
+                template_size_bytes=template_size,
+                variables_count=len(template_vars),
+                undefined_variables_found=0,
+                fallback_used=False,
+            )
+
         except (
             TemplateSyntaxError,
             TemplateValidationError,
@@ -142,7 +171,9 @@ class SimpleTemplateValidator:
                 self._metrics_collector.record_validation(False, type(e).__name__)
             raise TemplateValidationError(f"Template validation error: {e}")
 
-    def _find_optional_variables(self, template_source: str, missing_vars: set) -> set:
+    def _find_optional_variables(
+        self, template_source: str, missing_vars: Set[str]
+    ) -> Set[str]:
         """Find variables that are optional (have default filters or are in conditionals)."""
         import re
 
@@ -173,6 +204,27 @@ class SimpleTemplateValidator:
 
         return optional_vars
 
+    def sanitize_variables(self, variables: Dict[str, Any]) -> Dict[str, Any]:
+        """Sanitize template variables for security.
+
+        Args:
+            variables: Raw template variables
+
+        Returns:
+            Sanitized variables
+        """
+        # Basic sanitization - remove potentially dangerous values
+        sanitized = {}
+        for key, value in variables.items():
+            if isinstance(value, str):
+                # Remove null bytes and control characters
+                sanitized[key] = "".join(
+                    char for char in value if ord(char) >= 32 or char in "\t\n\r"
+                )
+            else:
+                sanitized[key] = value
+        return sanitized
+
 
 class RuntimeValidator(TemplateValidationStrategy):
     """Validates templates by attempting to render them.
@@ -192,13 +244,18 @@ class RuntimeValidator(TemplateValidationStrategy):
         self.config = config or ValidationConfig()
         self._metrics_collector = get_metrics_collector()
 
-    def validate(self, template_source: str, template_vars: Dict[str, Any]) -> None:
+    def validate(
+        self, template_source: str, template_vars: Dict[str, Any]
+    ) -> ValidationMetrics:
         """Validate by attempting to render the template.
 
         Args:
             template_source: The template source code
             template_vars: Variables to use for rendering
 
+        Returns:
+            ValidationMetrics: Metrics from the validation process
+
         Raises:
             TemplateSyntaxError: If template has syntax errors
             TemplateUndefinedVariableError: If undefined variables are encountered
@@ -254,6 +311,29 @@ class RuntimeValidator(TemplateValidationStrategy):
                 self._metrics_collector.record_validation(False, type(e).__name__)
                 raise TemplateValidationError(f"Template rendering error: {e}")
 
+        return metrics
+
+    def sanitize_variables(self, variables: Dict[str, Any]) -> Dict[str, Any]:
+        """Sanitize template variables for safe processing.
+
+        Args:
+            variables: Raw template variables
+
+        Returns:
+            Dict[str, Any]: Sanitized variables safe for template processing
+        """
+        # Basic sanitization - remove potentially dangerous values
+        sanitized = {}
+        for key, value in variables.items():
+            if isinstance(value, str):
+                # Remove null bytes and control characters
+                sanitized[key] = "".join(
+                    char for char in value if ord(char) >= 32 or char in "\t\n\r"
+                )
+            else:
+                sanitized[key] = value
+        return sanitized
+
 
 class TemplateSourceResolver:
     """Resolves template source from various inputs."""
@@ -430,6 +510,26 @@ class TemplateValidator:
         """Reset validation metrics."""
         self._metrics_collector.reset()
 
+    def sanitize_variables(self, variables: Dict[str, Any]) -> Dict[str, Any]:
+        """Sanitize template variables for safe processing.
+
+        Args:
+            variables: Raw template variables
+
+        Returns:
+            Dict[str, Any]: Sanitized variables safe for template processing
+        """
+        # Use the static validator's sanitize method if available
+        if hasattr(self.static_validator, "sanitize_variables"):
+            return self.static_validator.sanitize_variables(variables)
+
+        # Basic sanitization fallback
+        sanitized = {}
+        for key, value in variables.items():
+            if isinstance(key, str) and key.isidentifier():
+                sanitized[key] = value
+        return sanitized
+
 
 class TemplateValidatorFactory:
     """Factory for creating template validators with different configurations.

fast_clean_architecture/generators/validation_config.py

@@ -1,8 +1,8 @@
 """Configuration classes for template validation."""
 
 from dataclasses import dataclass
-from typing import Optional, Dict, Any
 from enum import Enum
+from typing import Any, Dict, Literal, Optional, Union
 
 
 class ValidationStrategy(Enum):
@@ -39,9 +39,11 @@ class ValidationConfig:
 
     # Basic monitoring
     enable_metrics: bool = False  # Disabled by default to reduce complexity
-    log_level: str = "WARNING"  # Reduced logging
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR"] = (
+        "WARNING"  # Reduced logging
+    )
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         """Validate configuration after initialization."""
         if self.max_variable_nesting_depth < 1:
             raise ValueError("max_variable_nesting_depth must be at least 1")

fast_clean_architecture/generators/validation_metrics.py

@@ -1,15 +1,17 @@
 """Performance monitoring and metrics collection for template validation."""
 
-import time
 import logging
 import threading
+import time
 from contextlib import contextmanager
-from typing import Dict, Any, Optional, Generator
 from dataclasses import dataclass, field
 from threading import Lock
+from typing import Any, Dict, Generator, Optional
 
 from .validation_config import ValidationMetrics
 
+__all__ = ["ValidationMetrics", "ValidationStats", "ValidationMetricsCollector"]
+
 logger = logging.getLogger(__name__)
 
 
@@ -33,7 +35,7 @@ class ValidationStats:
         metrics: ValidationMetrics,
         success: bool,
         error_type: Optional[str] = None,
-    ):
+    ) -> None:
         """Update statistics with new validation metrics."""
         with self._lock:
             self.total_validations += 1
@@ -107,10 +109,12 @@ class ValidationStats:
 class ValidationMetricsCollector:
     """Simplified collector for validation metrics."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.stats = ValidationStats()
 
-    def record_validation(self, success: bool, error_type: Optional[str] = None):
+    def record_validation(
+        self, success: bool, error_type: Optional[str] = None
+    ) -> None:
         """Record a validation operation.
 
         Args:
@@ -178,7 +182,7 @@ def timed_validation(
 
 
 @contextmanager
-def validation_timeout(timeout_seconds: float):
+def validation_timeout(timeout_seconds: float) -> Generator[None, None, None]:
     """Context manager for validation timeout (placeholder for future implementation)."""
     # Note: This is a placeholder. Full timeout implementation would require
     # threading or async support, which depends on the application architecture.

fast_clean_architecture/health.py

@@ -0,0 +1,169 @@
+"""Health monitoring for fast-clean-architecture."""
+
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import psutil  # type: ignore
+
+from .logging_config import get_logger
+
+# Set up logger
+logger = get_logger(__name__)
+
+
+class HealthMonitor:
+    """Monitor system health and resource usage."""
+
+    def __init__(self) -> None:
+        """Initialize health monitor."""
+        self.start_time = time.time()
+
+    def get_system_health(self) -> Dict[str, Any]:
+        """Get current system health metrics.
+
+        Returns:
+            Dictionary containing system health information
+        """
+        try:
+            # Get process information
+            process = psutil.Process()
+
+            # Memory usage
+            memory_info = process.memory_info()
+            memory_percent = process.memory_percent()
+
+            # CPU usage
+            cpu_percent = process.cpu_percent()
+
+            # System memory
+            system_memory = psutil.virtual_memory()
+
+            # Disk usage for current directory
+            disk_usage = psutil.disk_usage(".")
+
+            health_data = {
+                "timestamp": time.time(),
+                "uptime_seconds": time.time() - self.start_time,
+                "process": {
+                    "pid": os.getpid(),
+                    "memory_rss_mb": round(memory_info.rss / 1024 / 1024, 2),
+                    "memory_vms_mb": round(memory_info.vms / 1024 / 1024, 2),
+                    "memory_percent": round(memory_percent, 2),
+                    "cpu_percent": round(cpu_percent, 2),
+                },
+                "system": {
+                    "memory_total_gb": round(
+                        system_memory.total / 1024 / 1024 / 1024, 2
+                    ),
+                    "memory_available_gb": round(
+                        system_memory.available / 1024 / 1024 / 1024, 2
+                    ),
+                    "memory_used_percent": round(system_memory.percent, 2),
+                    "disk_total_gb": round(disk_usage.total / 1024 / 1024 / 1024, 2),
+                    "disk_free_gb": round(disk_usage.free / 1024 / 1024 / 1024, 2),
+                    "disk_used_percent": round(
+                        (disk_usage.used / disk_usage.total) * 100, 2
+                    ),
+                },
+                "python": {
+                    "version": sys.version,
+                    "executable": sys.executable,
+                },
+            }
+
+            return health_data
+
+        except Exception as e:
+            logger.error(
+                "Failed to get system health metrics",
+                operation="get_system_health",
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            return {"timestamp": time.time(), "error": str(e), "status": "unhealthy"}
+
+    def log_health_status(self) -> None:
+        """Log current health status."""
+        health_data = self.get_system_health()
+
+        if "error" in health_data:
+            logger.error(
+                "System health check failed", operation="health_check", **health_data
+            )
+        else:
+            logger.info("System health check", operation="health_check", **health_data)
+
+    def check_resource_limits(
+        self,
+        max_memory_mb: Optional[int] = None,
+        max_cpu_percent: Optional[float] = None,
+    ) -> bool:
+        """Check if resource usage is within limits.
+
+        Args:
+            max_memory_mb: Maximum memory usage in MB
+            max_cpu_percent: Maximum CPU usage percentage
+
+        Returns:
+            True if within limits, False otherwise
+        """
+        health_data = self.get_system_health()
+
+        if "error" in health_data:
+            return False
+
+        process_data = health_data.get("process", {})
+
+        # Check memory limit
+        if max_memory_mb and process_data.get("memory_rss_mb", 0) > max_memory_mb:
+            logger.warning(
+                "Memory usage exceeds limit",
+                operation="resource_check",
+                current_memory_mb=process_data.get("memory_rss_mb"),
+                limit_memory_mb=max_memory_mb,
+            )
+            return False
+
+        # Check CPU limit
+        if max_cpu_percent and process_data.get("cpu_percent", 0) > max_cpu_percent:
+            logger.warning(
+                "CPU usage exceeds limit",
+                operation="resource_check",
+                current_cpu_percent=process_data.get("cpu_percent"),
+                limit_cpu_percent=max_cpu_percent,
+            )
+            return False
+
+        return True
+
+
+# Global health monitor instance
+_health_monitor: Optional[HealthMonitor] = None
+
+
+def get_health_monitor() -> HealthMonitor:
+    """Get the global health monitor instance.
+
+    Returns:
+        Global HealthMonitor instance
+    """
+    global _health_monitor
+    if _health_monitor is None:
+        _health_monitor = HealthMonitor()
+    return _health_monitor
+
+
+def log_startup_health() -> None:
+    """Log health status at application startup."""
+    monitor = get_health_monitor()
+    monitor.log_health_status()
+
+    logger.info(
+        "Application started",
+        operation="startup",
+        pid=os.getpid(),
+        python_version=sys.version.split()[0],
+    )

fast_clean_architecture/logging_config.py

@@ -0,0 +1,52 @@
+"""Structured logging configuration for fast-clean-architecture."""
+
+import sys
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+import structlog
+from structlog.typing import EventDict
+
+
+def add_timestamp(logger: Any, method_name: str, event_dict: EventDict) -> EventDict:
+    """Add ISO timestamp to log events."""
+    event_dict["timestamp"] = datetime.now(timezone.utc).isoformat()
+    return event_dict
+
+
+def add_log_level(logger: Any, method_name: str, event_dict: EventDict) -> EventDict:
+    """Add log level to event dict."""
+    event_dict["level"] = method_name.upper()
+    return event_dict
+
+
+def configure_logging() -> None:
+    """Configure structured logging for the application."""
+    structlog.configure(
+        processors=[
+            structlog.contextvars.merge_contextvars,
+            add_timestamp,
+            add_log_level,
+            structlog.processors.add_log_level,
+            structlog.processors.StackInfoRenderer(),
+            structlog.dev.set_exc_info,
+            structlog.processors.JSONRenderer(),
+        ],
+        wrapper_class=structlog.make_filtering_bound_logger(30),  # INFO level
+        logger_factory=structlog.WriteLoggerFactory(file=sys.stdout),
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_logger(name: Optional[str] = None) -> Any:
+    """Get a configured structured logger.
+
+    Args:
+        name: Logger name (typically __name__)
+
+    Returns:
+        Configured structured logger
+    """
+    if name:
+        return structlog.get_logger(name)
+    return structlog.get_logger()

fast_clean_architecture/metrics.py

@@ -0,0 +1,108 @@
+"""Performance metrics for fast-clean-architecture."""
+
+import functools
+import time
+from typing import Any, Callable, Dict, Optional, TypeVar, cast
+
+import structlog
+from structlog.typing import EventDict
+
+from .logging_config import get_logger
+
+# Type variables for generic function decorators
+F = TypeVar("F", bound=Callable[..., Any])
+R = TypeVar("R")
+
+# Set up logger
+logger = get_logger(__name__)
+
+
+def measure_execution_time(operation_name: str) -> Callable[[F], F]:
+    """Decorator to measure and log execution time of functions.
+
+    Args:
+        operation_name: Name of the operation being measured
+
+    Returns:
+        Decorator function that measures execution time
+    """
+
+    def decorator(func: F) -> F:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            start_time = time.time()
+
+            try:
+                result = func(*args, **kwargs)
+                execution_time = time.time() - start_time
+
+                # Log performance metrics
+                logger.info(
+                    f"{operation_name} completed",
+                    operation=operation_name,
+                    execution_time_ms=round(execution_time * 1000, 2),
+                    success=True,
+                )
+
+                return result
+            except Exception as e:
+                execution_time = time.time() - start_time
+
+                # Log performance metrics with error
+                logger.error(
+                    f"{operation_name} failed",
+                    operation=operation_name,
+                    execution_time_ms=round(execution_time * 1000, 2),
+                    error=str(e),
+                    error_type=type(e).__name__,
+                    success=False,
+                )
+
+                # Re-raise the exception
+                raise
+
+        return cast(F, wrapper)
+
+    return decorator
+
+
+class PerformanceTracker:
+    """Context manager for tracking performance of code blocks."""
+
+    def __init__(self, operation_name: str, **context: Any):
+        """Initialize performance tracker.
+
+        Args:
+            operation_name: Name of the operation being tracked
+            context: Additional context to include in logs
+        """
+        self.operation_name = operation_name
+        self.context = context
+        self.start_time: float = 0
+
+    def __enter__(self) -> "PerformanceTracker":
+        self.start_time = time.time()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        execution_time = time.time() - self.start_time
+
+        # Prepare log context
+        log_context = {
+            "operation": self.operation_name,
+            "execution_time_ms": round(execution_time * 1000, 2),
+            "success": exc_type is None,
+            **self.context,
+        }
+
+        if exc_type is None:
+            # Log successful completion
+            logger.info(f"{self.operation_name} completed", **log_context)
+        else:
+            # Log error
+            logger.error(
+                f"{self.operation_name} failed",
+                error=str(exc_val),
+                error_type=exc_type.__name__,
+                **log_context,
+            )