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

fast_clean_architecture/generators/validation_metrics.py

@@ -0,0 +1,193 @@
+"""Performance monitoring and metrics collection for template validation."""
+
+import time
+import logging
+import threading
+from contextlib import contextmanager
+from typing import Dict, Any, Optional, Generator
+from dataclasses import dataclass, field
+from threading import Lock
+
+from .validation_config import ValidationMetrics
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ValidationStats:
+    """Simplified statistics for template validation operations."""
+
+    total_validations: int = 0
+    successful_validations: int = 0
+    failed_validations: int = 0
+    errors_by_type: Dict[str, int] = field(default_factory=dict)
+    fallback_used_count: int = 0
+    total_time_ms: float = 0.0
+    min_time_ms: float = float("inf")
+    max_time_ms: float = 0.0
+    strategy_usage: Dict[str, int] = field(default_factory=dict)
+    _lock: threading.Lock = field(default_factory=threading.Lock)
+
+    def update(
+        self,
+        metrics: ValidationMetrics,
+        success: bool,
+        error_type: Optional[str] = None,
+    ):
+        """Update statistics with new validation metrics."""
+        with self._lock:
+            self.total_validations += 1
+
+            if success:
+                self.successful_validations += 1
+            else:
+                self.failed_validations += 1
+                if error_type:
+                    self.errors_by_type[error_type] = (
+                        self.errors_by_type.get(error_type, 0) + 1
+                    )
+
+            if metrics.fallback_used:
+                self.fallback_used_count += 1
+
+            # Update timing statistics
+            self.total_time_ms += metrics.validation_time_ms
+            self.min_time_ms = min(self.min_time_ms, metrics.validation_time_ms)
+            self.max_time_ms = max(self.max_time_ms, metrics.validation_time_ms)
+
+            # Update strategy usage
+            strategy = metrics.strategy_used
+            self.strategy_usage[strategy] = self.strategy_usage.get(strategy, 0) + 1
+
+    @property
+    def average_time_ms(self) -> float:
+        """Calculate average validation time."""
+        if self.total_validations == 0:
+            return 0.0
+        return self.total_time_ms / self.total_validations
+
+    @property
+    def success_rate(self) -> float:
+        """Calculate success rate as percentage."""
+        if self.total_validations == 0:
+            return 0.0
+        return (self.successful_validations / self.total_validations) * 100
+
+    @property
+    def fallback_rate(self) -> float:
+        """Calculate fallback usage rate as percentage."""
+        if self.total_validations == 0:
+            return 0.0
+        return (self.fallback_used_count / self.total_validations) * 100
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert statistics to dictionary for reporting."""
+        return {
+            "total_validations": self.total_validations,
+            "successful_validations": self.successful_validations,
+            "failed_validations": self.failed_validations,
+            "success_rate_percent": round(self.success_rate, 2),
+            "fallback_used_count": self.fallback_used_count,
+            "fallback_rate_percent": round(self.fallback_rate, 2),
+            "timing": {
+                "total_time_ms": round(self.total_time_ms, 3),
+                "average_time_ms": round(self.average_time_ms, 3),
+                "min_time_ms": (
+                    round(self.min_time_ms, 3)
+                    if self.min_time_ms != float("inf")
+                    else 0
+                ),
+                "max_time_ms": round(self.max_time_ms, 3),
+            },
+            "strategy_usage": self.strategy_usage,
+            "error_types": self.errors_by_type,
+        }
+
+
+class ValidationMetricsCollector:
+    """Simplified collector for validation metrics."""
+
+    def __init__(self):
+        self.stats = ValidationStats()
+
+    def record_validation(self, success: bool, error_type: Optional[str] = None):
+        """Record a validation operation.
+
+        Args:
+            success: Whether the validation succeeded
+            error_type: Type of error if validation failed
+        """
+        self.stats.total_validations += 1
+        if success:
+            self.stats.successful_validations += 1
+        else:
+            self.stats.failed_validations += 1
+            if error_type:
+                self.stats.errors_by_type[error_type] = (
+                    self.stats.errors_by_type.get(error_type, 0) + 1
+                )
+
+    def get_stats(self) -> ValidationStats:
+        """Get current statistics."""
+        return self.stats
+
+    def reset(self) -> None:
+        """Reset all statistics."""
+        self.stats = ValidationStats()
+
+
+# Global metrics collector instance
+_metrics_collector = ValidationMetricsCollector()
+
+
+def get_metrics_collector() -> ValidationMetricsCollector:
+    """Get the global metrics collector instance."""
+    return _metrics_collector
+
+
+@contextmanager
+def timed_validation(
+    strategy_name: str,
+    template_size: int,
+    variables_count: int,
+    enable_timing: bool = True,
+) -> Generator[ValidationMetrics, None, None]:
+    """Context manager for timing validation operations."""
+    start_time = time.perf_counter()
+
+    metrics = ValidationMetrics(
+        strategy_used=strategy_name,
+        validation_time_ms=0.0,
+        template_size_bytes=template_size,
+        variables_count=variables_count,
+        undefined_variables_found=0,
+    )
+
+    try:
+        yield metrics
+    finally:
+        if enable_timing:
+            end_time = time.perf_counter()
+            metrics.validation_time_ms = (end_time - start_time) * 1000
+
+            # Log slow validations
+            if metrics.validation_time_ms > 100:  # Configurable threshold
+                logger.warning(
+                    f"Slow validation detected: {strategy_name} took {metrics.validation_time_ms:.3f}ms"
+                )
+
+
+@contextmanager
+def validation_timeout(timeout_seconds: float):
+    """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.
+    start_time = time.time()
+    try:
+        yield
+    finally:
+        elapsed = time.time() - start_time
+        if elapsed > timeout_seconds:
+            logger.warning(
+                f"Validation exceeded timeout: {elapsed:.3f}s > {timeout_seconds}s"
+            )

fast_clean_architecture/templates/__init__.py

@@ -0,0 +1,7 @@
+"""Jinja2 templates for Fast Clean Architecture."""
+
+from pathlib import Path
+
+TEMPLATES_DIR = Path(__file__).parent
+
+__all__ = ["TEMPLATES_DIR"]

fast_clean_architecture/templates/__init__.py.j2

@@ -0,0 +1,26 @@
+{% if package_type == "empty" %}
+"""
+{{ package_description }} package for {{ context }}.
+"""
+{% elif package_type == "component" %}
+"""
+{{ component_type|title }} components for {{ module_name }} module.
+"""
+{% for component in components %}
+from .{{ component.file_name }} import {{ component.class_name }}
+{% endfor %}
+
+__all__ = [
+{% for component in components %}
+    "{{ component.class_name }}",
+{% endfor %}
+]
+{% elif package_type == "system" %}
+"""
+{{ system_name|title }} system context.
+"""
+{% elif package_type == "module" %}
+"""
+{{ module_name|title }} module for {{ system_name }} system.
+"""
+{% endif %}

fast_clean_architecture/templates/api.py.j2

@@ -0,0 +1,65 @@
+"""
+{{ router_name }} API router for {{ module_name }} module.
+"""
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List
+from ..schemas.{{ schema_file }} import {{ SchemaName }}Create, {{ SchemaName }}Response
+from ...application.services.{{ service_file }} import {{ ServiceName }}Service
+
+router = APIRouter(prefix="/{{ resource_name }}", tags=["{{ resource_name }}"])
+
+
+@router.post("/", response_model={{ SchemaName }}Response)
+async def create_{{ entity_name }}(
+    data: {{ SchemaName }}Create,
+    service: {{ ServiceName }}Service = Depends()
+):
+    """Create new {{ entity_name }}."""
+    entity = await service.create_{{ entity_name }}(data.model_dump())
+    return {{ SchemaName }}Response.model_validate(entity)
+
+
+@router.get("/", response_model=List[{{ SchemaName }}Response])
+async def list_{{ resource_name }}(
+    service: {{ ServiceName }}Service = Depends()
+):
+    """List all {{ resource_name }}."""
+    entities = await service.list_{{ resource_name }}()
+    return [{{ SchemaName }}Response.model_validate(entity) for entity in entities]
+
+
+@router.get("/{id}", response_model={{ SchemaName }}Response)
+async def get_{{ entity_name }}(
+    id: str,
+    service: {{ ServiceName }}Service = Depends()
+):
+    """Get {{ entity_name }} by ID."""
+    entity = await service.get_{{ entity_name }}_by_id(id)
+    if not entity:
+        raise HTTPException(status_code=404, detail="{{ EntityName }} not found")
+    return {{ SchemaName }}Response.model_validate(entity)
+
+
+@router.put("/{id}", response_model={{ SchemaName }}Response)
+async def update_{{ entity_name }}(
+    id: str,
+    data: {{ SchemaName }}Create,
+    service: {{ ServiceName }}Service = Depends()
+):
+    """Update {{ entity_name }}."""
+    entity = await service.update_{{ entity_name }}(id, data.model_dump())
+    if not entity:
+        raise HTTPException(status_code=404, detail="{{ EntityName }} not found")
+    return {{ SchemaName }}Response.model_validate(entity)
+
+
+@router.delete("/{id}")
+async def delete_{{ entity_name }}(
+    id: str,
+    service: {{ ServiceName }}Service = Depends()
+):
+    """Delete {{ entity_name }}."""
+    success = await service.delete_{{ entity_name }}(id)
+    if not success:
+        raise HTTPException(status_code=404, detail="{{ EntityName }} not found")
+    return {"message": "{{ EntityName }} deleted successfully"}

fast_clean_architecture/templates/command.py.j2

@@ -0,0 +1,26 @@
+"""
+{{ command_name }} command for {{ module_name }} module.
+"""
+from dataclasses import dataclass
+from typing import Any, Dict
+
+
+@dataclass
+class {{ CommandName }}Command:
+    """Command for {{ command_name }} operation."""
+    
+    def __post_init__(self):
+        """Post-initialization validation."""
+        pass
+
+
+class {{ CommandName }}Handler:
+    """Handler for {{ CommandName }}Command."""
+    
+    def __init__(self):
+        pass
+    
+    async def handle(self, command: {{ CommandName }}Command) -> Any:
+        """Handle the {{ command_name }} command."""
+        # Implementation here
+        pass

fast_clean_architecture/templates/entity.py.j2

@@ -0,0 +1,49 @@
+"""
+{{ entity_name }} entity for {{ module_name }} module.
+
+Generated at: {{ generated_at }}
+Generator version: {{ generator_version }}
+"""
+from dataclasses import dataclass, field
+from typing import Optional
+from datetime import datetime
+from uuid import UUID, uuid4
+
+
+@dataclass
+class {{ EntityName }}:
+    """{{ EntityName }} domain entity.
+    
+    Represents a {{ entity_description }} in the {{ module_name }} domain.
+    """
+    
+    # Primary identifier
+    id: Optional[UUID] = field(default_factory=uuid4)
+    
+    # Add your domain-specific fields here
+    # Example:
+    # name: str = ""
+    # description: Optional[str] = None
+    
+    # Audit fields
+    created_at: Optional[datetime] = field(default_factory=lambda: datetime.utcnow())
+    updated_at: Optional[datetime] = field(default_factory=lambda: datetime.utcnow())
+    
+    def __post_init__(self) -> None:
+        """Post-initialization validation and setup."""
+        if self.id is None:
+            self.id = uuid4()
+        
+        now = datetime.utcnow()
+        if self.created_at is None:
+            self.created_at = now
+        if self.updated_at is None:
+            self.updated_at = now
+    
+    def update_timestamp(self) -> None:
+        """Update the updated_at timestamp."""
+        self.updated_at = datetime.utcnow()
+    
+    def is_new(self) -> bool:
+        """Check if this is a new entity (not persisted yet)."""
+        return self.created_at == self.updated_at

fast_clean_architecture/templates/external.py.j2

@@ -0,0 +1,61 @@
+"""
+{{ external_service_name }} client for {{ module_name }} module.
+"""
+import httpx
+from typing import Any, Dict, Optional
+from pydantic import BaseModel
+
+
+class {{ ExternalServiceName }}Config(BaseModel):
+    """Configuration for {{ ExternalServiceName }} client."""
+    
+    base_url: str
+    api_key: Optional[str] = None
+    timeout: int = 30
+
+
+class {{ ExternalServiceName }}Client:
+    """Client for {{ external_service_name }} external service."""
+    
+    def __init__(self, config: {{ ExternalServiceName }}Config):
+        self._config = config
+        self._client = httpx.AsyncClient(
+            base_url=config.base_url,
+            timeout=config.timeout,
+        )
+    
+    async def __aenter__(self):
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self._client.aclose()
+    
+    async def get_data(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Get data from external service."""
+        headers = {}
+        if self._config.api_key:
+            headers["Authorization"] = f"Bearer {self._config.api_key}"
+        
+        response = await self._client.get(
+            endpoint,
+            params=params,
+            headers=headers,
+        )
+        response.raise_for_status()
+        
+        return response.json()
+    
+    async def post_data(self, endpoint: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Post data to external service."""
+        headers = {"Content-Type": "application/json"}
+        if self._config.api_key:
+            headers["Authorization"] = f"Bearer {self._config.api_key}"
+        
+        response = await self._client.post(
+            endpoint,
+            json=data,
+            headers=headers,
+        )
+        response.raise_for_status()
+        
+        return response.json()

fast_clean_architecture/templates/infrastructure_repository.py.j2

@@ -0,0 +1,69 @@
+"""
+SQLAlchemy {{ repository_name }} repository implementation for {{ module_name }} module.
+"""
+from typing import List, Optional
+from sqlalchemy.orm import Session
+from ...domain.entities.{{ entity_file }} import {{ EntityName }}
+from ...domain.repositories.{{ repository_file }} import {{ RepositoryName }}Repository
+from ..models.{{ model_file }} import {{ ModelName }}Model
+
+
+class SQLAlchemy{{ RepositoryName }}Repository({{ RepositoryName }}Repository):
+    """SQLAlchemy implementation of {{ RepositoryName }}Repository."""
+    
+    def __init__(self, session: Session):
+        self._session = session
+    
+    async def get_by_id(self, id: str) -> Optional[{{ EntityName }}]:
+        """Retrieve {{ entity_name }} by ID."""
+        model = self._session.query({{ ModelName }}Model).filter(
+            {{ ModelName }}Model.id == id
+        ).first()
+        
+        return model.to_entity() if model else None
+    
+    async def save(self, entity: {{ EntityName }}) -> {{ EntityName }}:
+        """Save {{ entity_name }} entity."""
+        if entity.id:
+            # Update existing
+            model = self._session.query({{ ModelName }}Model).filter(
+                {{ ModelName }}Model.id == entity.id
+            ).first()
+            
+            if model:
+                # Update model from entity
+                for key, value in entity.__dict__.items():
+                    if hasattr(model, key) and key != 'id':
+                        setattr(model, key, value)
+            else:
+                model = {{ ModelName }}Model.from_entity(entity)
+                self._session.add(model)
+        else:
+            # Create new
+            import uuid
+            entity.id = str(uuid.uuid4())
+            model = {{ ModelName }}Model.from_entity(entity)
+            self._session.add(model)
+        
+        self._session.commit()
+        self._session.refresh(model)
+        
+        return model.to_entity()
+    
+    async def delete(self, id: str) -> bool:
+        """Delete {{ entity_name }} by ID."""
+        model = self._session.query({{ ModelName }}Model).filter(
+            {{ ModelName }}Model.id == id
+        ).first()
+        
+        if model:
+            self._session.delete(model)
+            self._session.commit()
+            return True
+        
+        return False
+    
+    async def list_all(self) -> List[{{ EntityName }}]:
+        """List all {{ entity_name }} entities."""
+        models = self._session.query({{ ModelName }}Model).all()
+        return [model.to_entity() for model in models]

fast_clean_architecture/templates/model.py.j2

@@ -0,0 +1,38 @@
+"""
+{{ model_name }} model for {{ module_name }} module.
+"""
+from datetime import datetime
+from typing import Optional
+from sqlalchemy import Column, String, DateTime, func
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+
+class {{ ModelName }}Model(Base):
+    """SQLAlchemy model for {{ entity_name }}."""
+    
+    __tablename__ = "{{ resource_name }}"
+    
+    id = Column(String, primary_key=True)
+    created_at = Column(DateTime, default=func.now())
+    updated_at = Column(DateTime, default=func.now(), onupdate=func.now())
+    
+    def to_entity(self):
+        """Convert model to domain entity."""
+        from ...domain.entities.{{ entity_file }} import {{ EntityName }}
+        
+        return {{ EntityName }}(
+            id=self.id,
+            created_at=self.created_at,
+            updated_at=self.updated_at,
+        )
+    
+    @classmethod
+    def from_entity(cls, entity):
+        """Create model from domain entity."""
+        return cls(
+            id=entity.id,
+            created_at=entity.created_at,
+            updated_at=entity.updated_at,
+        )

fast_clean_architecture/templates/query.py.j2

@@ -0,0 +1,26 @@
+"""
+{{ query_name }} query for {{ module_name }} module.
+"""
+from dataclasses import dataclass
+from typing import Any, List, Optional
+
+
+@dataclass
+class {{ QueryName }}Query:
+    """Query for {{ query_name }} operation."""
+    
+    def __post_init__(self):
+        """Post-initialization validation."""
+        pass
+
+
+class {{ QueryName }}Handler:
+    """Handler for {{ QueryName }}Query."""
+    
+    def __init__(self):
+        pass
+    
+    async def handle(self, query: {{ QueryName }}Query) -> Any:
+        """Handle the {{ query_name }} query."""
+        # Implementation here
+        pass

fast_clean_architecture/templates/repository.py.j2

@@ -0,0 +1,57 @@
+"""{{ repository_name }} repository interface for {{ module_name }} module."""
+from abc import ABC, abstractmethod
+from typing import List, Optional
+from ..entities.{{ entity_file }} import {{ EntityName }}
+
+
+class {{ RepositoryName }}Repository(ABC):
+    """Abstract repository interface for {{ entity_name }} operations.
+    
+    This is an abstract base class that enforces implementation of all methods
+    in concrete repository classes.
+    """
+    
+    @abstractmethod
+    async def get_by_id(self, id: str) -> Optional[{{ EntityName }}]:
+        """Retrieve {{ entity_name }} by ID.
+        
+        Args:
+            id: The unique identifier of the {{ entity_name }}
+            
+        Returns:
+            The {{ entity_name }} entity if found, None otherwise
+        """
+        pass
+    
+    @abstractmethod
+    async def save(self, entity: {{ EntityName }}) -> {{ EntityName }}:
+        """Save {{ entity_name }} entity.
+        
+        Args:
+            entity: The {{ entity_name }} entity to save
+            
+        Returns:
+            The saved {{ entity_name }} entity with updated fields
+        """
+        pass
+    
+    @abstractmethod
+    async def delete(self, id: str) -> bool:
+        """Delete {{ entity_name }} by ID.
+        
+        Args:
+            id: The unique identifier of the {{ entity_name }} to delete
+            
+        Returns:
+            True if deletion was successful, False otherwise
+        """
+        pass
+    
+    @abstractmethod
+    async def list_all(self) -> List[{{ EntityName }}]:
+        """List all {{ entity_name }} entities.
+        
+        Returns:
+            List of all {{ entity_name }} entities
+        """
+        pass

fast_clean_architecture/templates/schemas.py.j2

@@ -0,0 +1,32 @@
+"""
+{{ schema_name }} schemas for {{ module_name }} module.
+"""
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class {{ SchemaName }}Base(BaseModel):
+    """Base schema for {{ entity_name }}."""
+    pass
+
+
+class {{ SchemaName }}Create({{ SchemaName }}Base):
+    """Schema for creating {{ entity_name }}."""
+    pass
+
+
+class {{ SchemaName }}Update({{ SchemaName }}Base):
+    """Schema for updating {{ entity_name }}."""
+    pass
+
+
+class {{ SchemaName }}Response({{ SchemaName }}Base):
+    """Schema for {{ entity_name }} response."""
+    
+    id: Optional[str] = None
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+    
+    class Config:
+        from_attributes = True