django-cfg 1.3.9__py3-none-any.whl → 1.3.13__py3-none-any.whl

django_cfg/modules/django_app_agent/services/context_builder/models.py

@@ -1,40 +0,0 @@
-"""
-Data Models for Context Builder Service.
-
-This module contains Pydantic models for context building
-requests, results, and related data structures.
-"""
-
-from typing import List, Dict, Any, Optional
-from pathlib import Path
-
-from pydantic import BaseModel, Field, ConfigDict
-
-from ...models.context import ProjectContext, ArchitecturalPattern
-from ...models.requests import AppGenerationRequest
-
-
-class ContextBuildRequest(BaseModel):
-    """Request for building development context."""
-    
-    model_config = ConfigDict(extra='forbid', validate_assignment=True)
-    
-    project_root: Path = Field(description="Root directory of the project")
-    target_app_name: Optional[str] = Field(default=None, description="Name of app being generated")
-    generation_request: Optional[AppGenerationRequest] = Field(default=None, description="App generation request")
-    include_code_samples: bool = Field(default=True, description="Whether to include code samples")
-    max_context_size: int = Field(default=50000, ge=1000, description="Maximum context size in characters")
-    focus_areas: List[str] = Field(default_factory=list, description="Areas to focus context on")
-
-
-class ContextResult(BaseModel):
-    """Result of context building operation."""
-    
-    model_config = ConfigDict(extra='forbid', validate_assignment=True)
-    
-    project_context: ProjectContext = Field(description="Comprehensive project context")
-    relevant_patterns: List[ArchitecturalPattern] = Field(default_factory=list, description="Relevant architectural patterns")
-    code_samples: Dict[str, str] = Field(default_factory=dict, description="Code samples for reference")
-    integration_points: List[Dict[str, Any]] = Field(default_factory=list, description="Potential integration points")
-    recommendations: List[str] = Field(default_factory=list, description="Development recommendations")
-    context_summary: Dict[str, Any] = Field(default_factory=dict, description="Context summary information")

django_cfg/modules/django_app_agent/services/context_builder/pattern_analyzer.py

@@ -1,85 +0,0 @@
-"""
-Pattern Analysis Module for Context Builder.
-
-This module handles identification and analysis of architectural
-patterns relevant to the development context.
-"""
-
-from typing import Set, List, Dict, Any
-
-from ...models.context import ArchitecturalPattern
-from ..base import ServiceDependencies
-from .models import ContextBuildRequest, ContextResult
-
-
-class PatternAnalyzer:
-    """Handles analysis of architectural patterns for context building."""
-    
-    def __init__(self):
-        """Initialize pattern analyzer."""
-        # Pattern relevance mapping
-        self.pattern_relevance = {
-            "service_layer": {"models", "api", "business_logic"},
-            "repository_pattern": {"models", "data_access"},
-            "factory_pattern": {"models", "objects"},
-            "observer_pattern": {"signals", "events"},
-            "command_pattern": {"management_commands", "tasks"},
-            "mvc_pattern": {"models", "views", "urls"},
-            "api_pattern": {"api", "serializers", "viewsets"},
-            "rest_api": {"api", "serializers", "viewsets", "rest_framework"},
-            "graphql_api": {"api", "graphql", "schema"},
-            "celery_tasks": {"tasks", "background_jobs"},
-            "testing_pattern": {"tests", "testing"},
-            "django_cfg_pattern": {"config", "modules", "django_cfg"}
-        }
-    
-    async def identify_relevant_patterns(
-        self,
-        request: ContextBuildRequest,
-        scan_result,
-        result: ContextResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Identify architectural patterns relevant to the generation request."""
-        all_patterns = scan_result.architectural_patterns
-        
-        if not request.generation_request:
-            # If no specific request, include all high-confidence patterns
-            result.relevant_patterns = [p for p in all_patterns if p.confidence >= 0.7]
-            return
-        
-        # Filter patterns based on requested features
-        relevant_patterns = []
-        requested_features = {f.value for f in request.generation_request.features}
-        
-        for pattern in all_patterns:
-            # Check if pattern is relevant to requested features
-            if self._is_pattern_relevant(pattern, requested_features):
-                relevant_patterns.append(pattern)
-        
-        result.relevant_patterns = relevant_patterns
-    
-    def _is_pattern_relevant(self, pattern: ArchitecturalPattern, features: Set[str]) -> bool:
-        """Check if architectural pattern is relevant to requested features."""
-        relevant_features = self.pattern_relevance.get(pattern.name, set())
-        return bool(relevant_features.intersection(features))
-    
-    def analyze_pattern_compatibility(
-        self,
-        patterns: List[ArchitecturalPattern],
-        requested_features: Set[str]
-    ) -> Dict[str, float]:
-        """Analyze compatibility between patterns and requested features."""
-        compatibility_scores = {}
-        
-        for pattern in patterns:
-            relevant_features = self.pattern_relevance.get(pattern.name, set())
-            overlap = len(relevant_features.intersection(requested_features))
-            total_relevant = len(relevant_features)
-            
-            if total_relevant > 0:
-                compatibility_scores[pattern.name] = (overlap / total_relevant) * pattern.confidence
-            else:
-                compatibility_scores[pattern.name] = 0.0
-        
-        return compatibility_scores

django_cfg/modules/django_app_agent/services/project_scanner/__init__.py

@@ -1,31 +0,0 @@
-"""
-Project Scanner Module for Django App Agent.
-
-This module provides comprehensive project analysis capabilities
-for Django and django-cfg projects, including app discovery,
-dependency analysis, and architectural pattern detection.
-
-Components:
-- models: Data models for requests and results
-- app_discovery: Django application discovery and analysis
-- pattern_detection: Architectural pattern detection
-- main: Main orchestration service
-"""
-
-from .main import ProjectScannerService
-from .models import ProjectScanRequest, ScanResult
-from .app_discovery import AppDiscoveryEngine
-from .pattern_detection import PatternDetectionEngine
-
-__all__ = [
-    # Main service
-    "ProjectScannerService",
-    
-    # Data models
-    "ProjectScanRequest",
-    "ScanResult",
-    
-    # Core engines
-    "AppDiscoveryEngine",
-    "PatternDetectionEngine",
-]

django_cfg/modules/django_app_agent/services/project_scanner/app_discovery.py

@@ -1,311 +0,0 @@
-"""
-Django App Discovery Module for Project Scanner.
-
-This module handles discovery and analysis of Django applications
-within a project structure.
-"""
-
-from typing import List, Optional, Dict, Any
-from pathlib import Path
-import ast
-import re
-
-from ...models.context import DjangoAppInfo
-from ...models.enums import AppType
-from ..base import ServiceDependencies
-from .models import ProjectScanRequest, ScanResult
-
-
-class AppDiscoveryEngine:
-    """Handles discovery and analysis of Django applications."""
-    
-    def __init__(self):
-        """Initialize app discovery engine."""
-        # Django file patterns
-        self.django_files = {
-            "models.py": "models",
-            "views.py": "views", 
-            "urls.py": "urls",
-            "admin.py": "admin",
-            "forms.py": "forms",
-            "tests.py": "tests",
-            "apps.py": "apps",
-            "serializers.py": "serializers",
-            "signals.py": "signals",
-            "middleware.py": "middleware",
-            "management": "management_commands"
-        }
-    
-    async def discover_django_apps(
-        self,
-        request: ProjectScanRequest,
-        result: ScanResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Discover Django applications in the project."""
-        apps_found = []
-        
-        try:
-            # Look for Django app indicators
-            for path in request.project_root.rglob("apps.py"):
-                app_dir = path.parent
-                
-                # Skip if too deep or excluded
-                if len(app_dir.relative_to(request.project_root).parts) > request.scan_depth:
-                    continue
-                
-                if self._is_excluded(app_dir.name, request.exclude_patterns):
-                    continue
-                
-                # Analyze app structure
-                app_info = await self.analyze_django_app(app_dir, request, dependencies)
-                if app_info:
-                    apps_found.append(app_info)
-            
-            # Also look for directories with Django files (even without apps.py)
-            for django_file in self.django_files.keys():
-                for path in request.project_root.rglob(django_file):
-                    app_dir = path.parent
-                    
-                    # Skip if already found or excluded
-                    if any(app.path == str(app_dir) for app in apps_found):
-                        continue
-                    
-                    if self._is_excluded(app_dir.name, request.exclude_patterns):
-                        continue
-                    
-                    # Check if it looks like a Django app
-                    if self._looks_like_django_app(app_dir):
-                        app_info = await self.analyze_django_app(app_dir, request, dependencies)
-                        if app_info:
-                            apps_found.append(app_info)
-            
-            result.discovered_apps = apps_found
-            
-        except Exception as e:
-            dependencies.log_error("Failed to discover Django apps", e)
-            # Don't fail the entire scan, just log the error
-    
-    async def analyze_django_app(
-        self,
-        app_dir: Path,
-        request: ProjectScanRequest,
-        dependencies: ServiceDependencies
-    ) -> Optional[DjangoAppInfo]:
-        """Analyze a single Django application."""
-        try:
-            app_name = app_dir.name
-            
-            # Count Django components
-            models_count = self._count_models(app_dir)
-            views_count = self._count_views(app_dir)
-            urls_count = self._count_urls(app_dir)
-            admin_registered = self._count_admin_registrations(app_dir)
-            
-            # Check for migrations
-            has_migrations = (app_dir / "migrations").exists() and \
-                           any((app_dir / "migrations").glob("*.py"))
-            
-            # Detect if it's a django-cfg app
-            is_django_cfg_app = self._is_django_cfg_app(app_dir)
-            
-            # Analyze dependencies
-            dependencies_list = self._analyze_app_dependencies(app_dir)
-            
-            return DjangoAppInfo(
-                name=app_name,
-                path=str(app_dir),
-                is_django_cfg_app=is_django_cfg_app,
-                models_count=models_count,
-                views_count=views_count,
-                urls_count=urls_count,
-                admin_registered_models=admin_registered,
-                has_migrations=has_migrations,
-                dependencies=dependencies_list,
-                description=self._extract_app_description(app_dir)
-            )
-            
-        except Exception as e:
-            dependencies.log_error(f"Failed to analyze app {app_dir.name}", e)
-            return None
-    
-    def _is_excluded(self, name: str, exclude_patterns: List[str]) -> bool:
-        """Check if name matches any exclude pattern."""
-        for pattern in exclude_patterns:
-            if pattern.startswith("*") and name.endswith(pattern[1:]):
-                return True
-            elif pattern.endswith("*") and name.startswith(pattern[:-1]):
-                return True
-            elif pattern == name:
-                return True
-        return False
-    
-    def _looks_like_django_app(self, app_dir: Path) -> bool:
-        """Check if directory looks like a Django app."""
-        django_indicators = ["models.py", "views.py", "apps.py", "admin.py"]
-        found_indicators = sum(1 for indicator in django_indicators if (app_dir / indicator).exists())
-        return found_indicators >= 2  # At least 2 Django files
-    
-    def _is_django_cfg_app(self, app_dir: Path) -> bool:
-        """Check if app is a django-cfg app."""
-        # Look for django-cfg specific patterns
-        cfg_indicators = [
-            "config.py",
-            "cfg_config.py", 
-            "modules/",
-            "__cfg__.py"
-        ]
-        
-        for indicator in cfg_indicators:
-            if (app_dir / indicator).exists():
-                return True
-        
-        # Check for django-cfg imports in apps.py
-        apps_file = app_dir / "apps.py"
-        if apps_file.exists():
-            try:
-                content = apps_file.read_text()
-                if "django_cfg" in content or "BaseCfgModule" in content:
-                    return True
-            except Exception:
-                pass
-        
-        return False
-    
-    def _count_models(self, app_dir: Path) -> int:
-        """Count models in models.py."""
-        models_file = app_dir / "models.py"
-        if not models_file.exists():
-            return 0
-        
-        try:
-            content = models_file.read_text()
-            tree = ast.parse(content)
-            
-            model_count = 0
-            for node in ast.walk(tree):
-                if isinstance(node, ast.ClassDef):
-                    # Check if it inherits from Model
-                    for base in node.bases:
-                        if isinstance(base, ast.Attribute) and base.attr == "Model":
-                            model_count += 1
-                        elif isinstance(base, ast.Name) and "Model" in base.id:
-                            model_count += 1
-            
-            return model_count
-        except Exception:
-            return 0
-    
-    def _count_views(self, app_dir: Path) -> int:
-        """Count views in views.py."""
-        views_file = app_dir / "views.py"
-        if not views_file.exists():
-            return 0
-        
-        try:
-            content = views_file.read_text()
-            tree = ast.parse(content)
-            
-            view_count = 0
-            for node in ast.walk(tree):
-                if isinstance(node, ast.FunctionDef):
-                    view_count += 1
-                elif isinstance(node, ast.ClassDef):
-                    # Check if it's a class-based view
-                    for base in node.bases:
-                        if isinstance(base, ast.Attribute) and "View" in base.attr:
-                            view_count += 1
-                        elif isinstance(base, ast.Name) and "View" in base.id:
-                            view_count += 1
-            
-            return view_count
-        except Exception:
-            return 0
-    
-    def _count_urls(self, app_dir: Path) -> int:
-        """Count URL patterns in urls.py."""
-        urls_file = app_dir / "urls.py"
-        if not urls_file.exists():
-            return 0
-        
-        try:
-            content = urls_file.read_text()
-            # Count path() and url() calls
-            path_count = content.count("path(")
-            url_count = content.count("url(")
-            return path_count + url_count
-        except Exception:
-            return 0
-    
-    def _count_admin_registrations(self, app_dir: Path) -> int:
-        """Count admin registrations in admin.py."""
-        admin_file = app_dir / "admin.py"
-        if not admin_file.exists():
-            return 0
-        
-        try:
-            content = admin_file.read_text()
-            # Count admin.register calls and @admin.register decorators
-            register_count = content.count("admin.register(")
-            decorator_count = content.count("@admin.register")
-            return register_count + decorator_count
-        except Exception:
-            return 0
-    
-    def _analyze_app_dependencies(self, app_dir: Path) -> List[str]:
-        """Analyze app dependencies from imports."""
-        dependencies = set()
-        
-        # Analyze Python files for imports
-        for py_file in app_dir.rglob("*.py"):
-            try:
-                content = py_file.read_text()
-                tree = ast.parse(content)
-                
-                for node in ast.walk(tree):
-                    if isinstance(node, ast.Import):
-                        for alias in node.names:
-                            if "." in alias.name:
-                                dependencies.add(alias.name.split(".")[0])
-                    elif isinstance(node, ast.ImportFrom):
-                        if node.module:
-                            if "." in node.module:
-                                dependencies.add(node.module.split(".")[0])
-                            else:
-                                dependencies.add(node.module)
-            except Exception:
-                continue
-        
-        # Filter to keep only relevant dependencies
-        relevant_deps = []
-        for dep in dependencies:
-            if dep in ["django", "rest_framework", "django_cfg"] or dep.startswith("django_"):
-                relevant_deps.append(dep)
-        
-        return relevant_deps
-    
-    def _extract_app_description(self, app_dir: Path) -> Optional[str]:
-        """Extract app description from apps.py or docstrings."""
-        apps_file = app_dir / "apps.py"
-        if apps_file.exists():
-            try:
-                content = apps_file.read_text()
-                tree = ast.parse(content)
-                
-                for node in ast.walk(tree):
-                    if isinstance(node, ast.ClassDef):
-                        # Look for verbose_name in Config class
-                        for item in node.body:
-                            if isinstance(item, ast.Assign):
-                                for target in item.targets:
-                                    if isinstance(target, ast.Name) and target.id == "verbose_name":
-                                        if isinstance(item.value, ast.Constant):
-                                            return item.value.value
-                        
-                        # Use class docstring as fallback
-                        if ast.get_docstring(node):
-                            return ast.get_docstring(node)
-            except Exception:
-                pass
-        
-        return None

django_cfg/modules/django_app_agent/services/project_scanner/main.py

@@ -1,221 +0,0 @@
-"""
-Main Project Scanner Service for Django App Agent Module.
-
-This service provides comprehensive project structure analysis,
-coordinating app discovery, dependency analysis, and pattern detection.
-"""
-
-from typing import Dict, Any
-from pathlib import Path
-
-from ..base import BaseService, ServiceDependencies
-from ...models.context import ProjectContext
-from ...core.exceptions import FileSystemError
-
-from .models import ProjectScanRequest, ScanResult
-from .app_discovery import AppDiscoveryEngine
-from .pattern_detection import PatternDetectionEngine
-
-
-class ProjectScannerService(BaseService[ProjectScanRequest, ScanResult]):
-    """
-    Service for comprehensive Django/django-cfg project analysis.
-    
-    Capabilities:
-    - Discover Django applications and their structure
-    - Analyze project dependencies and relationships
-    - Detect architectural patterns and conventions
-    - Generate comprehensive project context
-    - Identify integration opportunities
-    """
-    
-    def __init__(self, config):
-        """Initialize project scanner service."""
-        super().__init__("project_scanner", config)
-        
-        # Initialize sub-engines
-        self.app_discovery = AppDiscoveryEngine()
-        self.pattern_detection = PatternDetectionEngine()
-    
-    async def process(
-        self, 
-        request: ProjectScanRequest, 
-        dependencies: ServiceDependencies
-    ) -> ScanResult:
-        """
-        Process project scanning request.
-        
-        Args:
-            request: Project scanning request
-            dependencies: Service dependencies for logging and operations
-            
-        Returns:
-            ScanResult with comprehensive project analysis
-        """
-        try:
-            dependencies.log_operation(
-                f"Starting project scan for '{request.project_root}'",
-                project_root=str(request.project_root),
-                scan_depth=request.scan_depth
-            )
-            
-            # Initialize result with basic project context
-            result = ScanResult(
-                project_context=ProjectContext(
-                    project_root=str(request.project_root),
-                    project_name=request.project_root.name,
-                    django_version="Unknown",
-                    is_django_cfg_project=False,
-                    apps=[],
-                    architectural_patterns=[],
-                    integration_opportunities=[]
-                )
-            )
-            
-            # Scan project structure
-            await self._scan_project_structure(request, result, dependencies)
-            
-            # Discover Django applications
-            await self.app_discovery.discover_django_apps(request, result, dependencies)
-            
-            # Analyze dependencies if requested
-            if request.analyze_dependencies:
-                await self._analyze_dependencies(request, result, dependencies)
-            
-            # Detect architectural patterns if requested
-            if request.detect_patterns:
-                await self.pattern_detection.detect_patterns(request, result, dependencies)
-            
-            # Update project context with findings
-            self._update_project_context(result)
-            
-            dependencies.log_operation(
-                "Project scan completed successfully",
-                apps_found=len(result.discovered_apps),
-                patterns_detected=len(result.architectural_patterns)
-            )
-            
-            return result
-            
-        except Exception as e:
-            raise FileSystemError(
-                f"Failed to scan project structure: {e}",
-                file_path=str(request.project_root),
-                operation="scan_project"
-            )
-    
-    async def _scan_project_structure(
-        self,
-        request: ProjectScanRequest,
-        result: ScanResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Scan basic project structure and collect file statistics."""
-        try:
-            file_counts = {}
-            total_files = 0
-            total_directories = 0
-            directories_scanned = 0
-            
-            # Walk through project directory
-            for path in request.project_root.rglob("*"):
-                # Check depth limit
-                relative_path = path.relative_to(request.project_root)
-                if len(relative_path.parts) > request.scan_depth:
-                    continue
-                
-                # Check exclusion patterns
-                if self._is_excluded(path.name, request.exclude_patterns):
-                    continue
-                
-                if path.is_file():
-                    total_files += 1
-                    suffix = path.suffix.lower()
-                    file_counts[suffix] = file_counts.get(suffix, 0) + 1
-                elif path.is_dir():
-                    total_directories += 1
-                    directories_scanned += 1
-            
-            # Store file summary
-            result.file_summary = {
-                "total_files": total_files,
-                "total_directories": total_directories,
-                "file_types": file_counts,
-                "python_files": file_counts.get(".py", 0),
-                "template_files": file_counts.get(".html", 0) + file_counts.get(".htm", 0),
-                "static_files": file_counts.get(".css", 0) + file_counts.get(".js", 0) + file_counts.get(".scss", 0),
-                "config_files": file_counts.get(".yml", 0) + file_counts.get(".yaml", 0) + file_counts.get(".json", 0)
-            }
-            
-            # Store scan statistics
-            result.scan_statistics = {
-                "files_scanned": total_files,
-                "directories_scanned": directories_scanned,
-                "scan_depth": request.scan_depth
-            }
-            
-        except Exception as e:
-            raise FileSystemError(
-                f"Failed to scan project structure: {e}",
-                file_path=str(request.project_root),
-                operation="scan_project"
-            )
-    
-    async def _analyze_dependencies(
-        self,
-        request: ProjectScanRequest,
-        result: ScanResult,
-        dependencies: ServiceDependencies
-    ) -> None:
-        """Analyze dependencies between discovered apps."""
-        try:
-            dependency_graph = {}
-            
-            for app in result.discovered_apps:
-                app_deps = []
-                
-                # Find dependencies to other discovered apps
-                for other_app in result.discovered_apps:
-                    if app.name != other_app.name:
-                        # Check if app imports from other_app
-                        if other_app.name in app.dependencies:
-                            app_deps.append(other_app.name)
-                
-                dependency_graph[app.name] = app_deps
-            
-            result.dependency_graph = dependency_graph
-            
-        except Exception as e:
-            dependencies.log_error("Failed to analyze dependencies", e)
-    
-    def _update_project_context(self, result: ScanResult) -> None:
-        """Update project context with scan results."""
-        # Check if it's a django-cfg project
-        is_django_cfg = any(app.is_django_cfg_app for app in result.discovered_apps)
-        
-        # Detect Django version (placeholder)
-        django_version = self.pattern_detection.detect_django_version(result.discovered_apps)
-        
-        # Update project context
-        result.project_context.django_version = django_version
-        result.project_context.is_django_cfg_project = is_django_cfg
-        result.project_context.apps = result.discovered_apps
-        result.project_context.architectural_patterns = result.architectural_patterns
-        
-        # Generate integration opportunities (placeholder)
-        result.project_context.integration_opportunities = [
-            "Consider adding API endpoints for existing models",
-            "Implement caching for frequently accessed data",
-            "Add comprehensive test coverage"
-        ]
-    
-    def _is_excluded(self, name: str, exclude_patterns: list[str]) -> bool:
-        """Check if name matches any exclude pattern."""
-        for pattern in exclude_patterns:
-            if pattern.startswith("*") and name.endswith(pattern[1:]):
-                return True
-            elif pattern.endswith("*") and name.startswith(pattern[:-1]):
-                return True
-            elif pattern == name:
-                return True
-        return False