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

django_cfg/modules/django_app_agent/services/template_manager/jinja_engine.py

@@ -0,0 +1,236 @@
+"""
+Jinja2 Template Engine for Django App Agent.
+
+This module provides a powerful Jinja2-based template engine
+with custom filters and functions for Django code generation.
+"""
+
+from typing import Dict, Any, Set, Optional, List
+import re
+from pathlib import Path
+
+from jinja2 import Environment, BaseLoader, TemplateNotFound, select_autoescape
+from jinja2.exceptions import TemplateError
+
+from ...core.exceptions import ValidationError
+
+
+class StringTemplateLoader(BaseLoader):
+    """Custom Jinja2 loader for string-based templates."""
+    
+    def __init__(self, templates: Dict[str, str]):
+        """Initialize with template dictionary."""
+        self.templates = templates
+    
+    def get_source(self, environment: Environment, template: str) -> tuple:
+        """Get template source."""
+        if template not in self.templates:
+            raise TemplateNotFound(template)
+        
+        source = self.templates[template]
+        return source, None, lambda: True
+
+
+class JinjaTemplateEngine:
+    """Jinja2-based template engine with Django-specific features."""
+    
+    def __init__(self):
+        """Initialize Jinja2 environment with custom filters."""
+        self.templates: Dict[str, str] = {}
+        self.env = self._create_environment()
+    
+    def _create_environment(self) -> Environment:
+        """Create Jinja2 environment with custom filters and functions."""
+        env = Environment(
+            loader=StringTemplateLoader(self.templates),
+            autoescape=select_autoescape(['html', 'xml']),
+            trim_blocks=True,
+            lstrip_blocks=True
+        )
+        
+        # Add custom filters
+        env.filters.update({
+            'snake_case': self._snake_case,
+            'camel_case': self._camel_case,
+            'pascal_case': self._pascal_case,
+            'kebab_case': self._kebab_case,
+            'title_case': self._title_case,
+            'plural': self._pluralize,
+            'singular': self._singularize,
+            'django_field': self._django_field_repr,
+            'python_repr': self._python_repr,
+            'indent': self._indent,
+            'comment_block': self._comment_block
+        })
+        
+        # Add custom functions
+        env.globals.update({
+            'now': self._now,
+            'uuid4': self._uuid4,
+            'range': range,
+            'enumerate': enumerate,
+            'zip': zip
+        })
+        
+        return env
+    
+    def add_template(self, name: str, content: str) -> None:
+        """Add a template to the engine."""
+        self.templates[name] = content
+        # Recreate environment to update loader
+        self.env = self._create_environment()
+    
+    def add_templates(self, templates: Dict[str, str]) -> None:
+        """Add multiple templates to the engine."""
+        self.templates.update(templates)
+        # Recreate environment to update loader
+        self.env = self._create_environment()
+    
+    def render(
+        self, 
+        template_name: str, 
+        variables: Dict[str, Any]
+    ) -> tuple[str, Set[str], Set[str]]:
+        """
+        Render template with variables.
+        
+        Returns:
+            tuple: (rendered_content, variables_used, missing_variables)
+        """
+        try:
+            template = self.env.get_template(template_name)
+            
+            # Get template variables (simplified approach - read template source from file)
+            template_vars = set()
+            try:
+                # Get template source from the loader
+                source, _ = self.env.loader.get_source(self.env, template_name)
+                ast = self.env.parse(source)
+                for node in ast.find_all('Name'):
+                    if node.ctx == 'load':
+                        template_vars.add(node.name)
+            except Exception:
+                # Fallback: assume all provided variables are used
+                template_vars = set(variables.keys())
+            
+            # Remove Jinja2 built-ins and our custom functions
+            builtin_vars = {
+                'range', 'enumerate', 'zip', 'now', 'uuid4',
+                'loop', 'super', 'self', 'varargs', 'kwargs'
+            }
+            template_vars = template_vars - builtin_vars
+            
+            # Check for missing variables
+            missing_vars = template_vars - set(variables.keys())
+            variables_used = template_vars - missing_vars
+            
+            # Render template
+            rendered = template.render(**variables)
+            
+            return rendered, variables_used, missing_vars
+            
+        except TemplateNotFound:
+            raise ValidationError(
+                f"Template '{template_name}' not found",
+                validation_type="template_not_found"
+            )
+        except TemplateError as e:
+            raise ValidationError(
+                f"Template rendering failed: {e}",
+                validation_type="template_rendering"
+            )
+    
+    # Custom filters
+    def _snake_case(self, text: str) -> str:
+        """Convert text to snake_case."""
+        # Handle camelCase and PascalCase
+        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', text)
+        s2 = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1)
+        return s2.lower().replace(' ', '_').replace('-', '_')
+    
+    def _camel_case(self, text: str) -> str:
+        """Convert text to camelCase."""
+        components = re.split(r'[_\s-]+', text.lower())
+        return components[0] + ''.join(word.capitalize() for word in components[1:])
+    
+    def _pascal_case(self, text: str) -> str:
+        """Convert text to PascalCase."""
+        components = re.split(r'[_\s-]+', text.lower())
+        return ''.join(word.capitalize() for word in components)
+    
+    def _kebab_case(self, text: str) -> str:
+        """Convert text to kebab-case."""
+        return self._snake_case(text).replace('_', '-')
+    
+    def _title_case(self, text: str) -> str:
+        """Convert text to Title Case."""
+        return text.replace('_', ' ').replace('-', ' ').title()
+    
+    def _pluralize(self, text: str) -> str:
+        """Simple pluralization."""
+        if text.endswith('y'):
+            return text[:-1] + 'ies'
+        elif text.endswith(('s', 'sh', 'ch', 'x', 'z')):
+            return text + 'es'
+        else:
+            return text + 's'
+    
+    def _singularize(self, text: str) -> str:
+        """Simple singularization."""
+        if text.endswith('ies'):
+            return text[:-3] + 'y'
+        elif text.endswith('es'):
+            return text[:-2]
+        elif text.endswith('s') and not text.endswith('ss'):
+            return text[:-1]
+        else:
+            return text
+    
+    def _django_field_repr(self, field_type: str, **kwargs) -> str:
+        """Generate Django field representation."""
+        args = []
+        for key, value in kwargs.items():
+            if isinstance(value, str):
+                args.append(f"{key}='{value}'")
+            else:
+                args.append(f"{key}={value}")
+        
+        if args:
+            return f"models.{field_type}({', '.join(args)})"
+        else:
+            return f"models.{field_type}()"
+    
+    def _python_repr(self, value: Any) -> str:
+        """Python representation of value."""
+        return repr(value)
+    
+    def _indent(self, text: str, width: int = 4, first: bool = False) -> str:
+        """Indent text by specified width."""
+        lines = text.split('\n')
+        indent_str = ' ' * width
+        
+        if first:
+            return '\n'.join(indent_str + line for line in lines)
+        else:
+            return lines[0] + '\n' + '\n'.join(indent_str + line for line in lines[1:])
+    
+    def _comment_block(self, text: str, style: str = 'python') -> str:
+        """Create comment block in specified style."""
+        if style == 'python':
+            lines = text.split('\n')
+            return '\n'.join(f'# {line}' for line in lines)
+        elif style == 'docstring':
+            return f'"""\n{text}\n"""'
+        else:
+            return text
+    
+    # Custom functions
+    def _now(self) -> str:
+        """Current timestamp."""
+        from datetime import datetime
+        return datetime.now().isoformat()
+    
+    def _uuid4(self) -> str:
+        """Generate UUID4."""
+        import uuid
+        return str(uuid.uuid4())

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

@@ -0,0 +1,159 @@
+"""
+Template Manager Service for Django App Agent Module.
+
+This service provides sophisticated Jinja2-based template rendering
+with feature-driven code generation capabilities.
+"""
+
+from typing import Dict, Any, Set, Optional, List
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from ...core.config import AgentConfig
+from ...core.exceptions import ValidationError
+from ...models.enums import AppType, AppFeature
+from ...models.requests import TemplateRequest
+from ...models.responses import TemplateResult
+from ..base import BaseService, ServiceDependencies
+from .jinja_engine import JinjaTemplateEngine
+from .template_loader import TemplateLoader
+from .variable_processor import VariableProcessor
+
+
+class TemplateManagerService(BaseService[TemplateRequest, TemplateResult]):
+    """
+    Advanced template management service with Jinja2 support.
+    
+    Features:
+    - Jinja2 template engine with custom filters
+    - File-based template loading
+    - Feature-driven template selection
+    - Variable processing and validation
+    - Template caching and optimization
+    """
+    
+    def __init__(self, config: AgentConfig):
+        """Initialize template manager service."""
+        super().__init__("template_manager", config)
+        self.config = config
+        
+        # Initialize components
+        self.template_loader = TemplateLoader()
+        self.jinja_engine = JinjaTemplateEngine()
+        self.variable_processor = VariableProcessor()
+        
+        # Load all templates into engine
+        self._load_templates()
+    
+    async def process(
+        self,
+        request: TemplateRequest,
+        dependencies: ServiceDependencies
+    ) -> TemplateResult:
+        """
+        Process template rendering request.
+        
+        Args:
+            request: Template processing request
+            dependencies: Service dependencies
+            
+        Returns:
+            TemplateResult with rendered content
+        """
+        dependencies.log_operation(
+            f"Processing template '{request.template_name}'",
+            app_type=request.app_type if isinstance(request.app_type, str) else request.app_type.value,
+            features_count=len(request.features),
+            variables_count=len(request.variables)
+        )
+        
+        try:
+            # Determine template name
+            template_name = self._resolve_template_name(request, dependencies)
+            
+            # Process variables
+            processed_variables = await self.variable_processor.process_variables(
+                request, dependencies
+            )
+            
+            # Render template
+            rendered_content, variables_used, missing_vars = self.jinja_engine.render(
+                template_name, processed_variables
+            )
+            
+            # Create result
+            result = TemplateResult(
+                rendered_content=rendered_content,
+                template_name=template_name,
+                variables_used=list(variables_used),
+                missing_variables=list(missing_vars),
+                template_metadata={
+                    "app_type": request.app_type if isinstance(request.app_type, str) else request.app_type.value,
+                    "features": [(f.value if hasattr(f, 'value') else f) for f in request.features],
+                    "template_engine": "jinja2",
+                    "rendered_size": len(rendered_content),
+                    "variables_processed": len(processed_variables)
+                }
+            )
+            
+            dependencies.log_operation(
+                "Template processing completed successfully",
+                template_name=template_name,
+                rendered_size=len(rendered_content),
+                variables_used=len(variables_used),
+                missing_variables=len(missing_vars)
+            )
+            
+            return result
+            
+        except Exception as e:
+            dependencies.log_error("Template processing failed", e)
+            raise
+    
+    def _load_templates(self) -> None:
+        """Load all templates into the Jinja2 engine."""
+        templates = self.template_loader.load_all_templates()
+        self.jinja_engine.add_templates(templates)
+    
+    def _resolve_template_name(
+        self,
+        request: TemplateRequest,
+        dependencies: ServiceDependencies
+    ) -> str:
+        """Resolve the actual template name to use."""
+        template_name = request.template_name
+        
+        # If template_name doesn't end with .j2, add it
+        if not template_name.endswith('.j2'):
+            template_name = f"{template_name}.j2"
+        
+        # Check if template exists
+        available_templates = self.template_loader.get_available_templates()
+        
+        if template_name not in available_templates:
+            # Try app-type specific template
+            app_type_str = request.app_type if isinstance(request.app_type, str) else request.app_type.value
+            app_specific_name = f"{app_type_str}_{template_name}"
+            if app_specific_name in available_templates:
+                template_name = app_specific_name
+            else:
+                raise ValidationError(
+                    f"Template '{template_name}' not found. Available templates: {available_templates}",
+                    validation_type="template_not_found"
+                )
+        
+        return template_name
+    
+    def reload_templates(self) -> None:
+        """Reload all templates from disk."""
+        self.template_loader.clear_cache()
+        self._load_templates()
+    
+    def get_available_templates(self) -> List[str]:
+        """Get list of available template names."""
+        return self.template_loader.get_available_templates()
+    
+    def add_custom_template(self, name: str, content: str) -> None:
+        """Add a custom template at runtime."""
+        self.jinja_engine.add_template(name, content)

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

@@ -0,0 +1,36 @@
+"""
+Data Models for Template Manager Service.
+
+This module contains Pydantic models for template processing
+requests, results, and related data structures.
+"""
+
+from typing import Dict, Any, Optional, List, Set
+
+from pydantic import BaseModel, Field, ConfigDict
+
+from ...models.enums import AppType, AppFeature
+
+
+class TemplateRequest(BaseModel):
+    """Request for template processing."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    template_name: str = Field(description="Name of the template to process")
+    app_type: AppType = Field(description="Type of application")
+    variables: Dict[str, Any] = Field(default_factory=dict, description="Template variables")
+    features: List[AppFeature] = Field(default_factory=list, description="Requested features")
+    custom_templates: Dict[str, str] = Field(default_factory=dict, description="Custom template overrides")
+
+
+class TemplateResult(BaseModel):
+    """Result of template processing."""
+    
+    model_config = ConfigDict(extra='forbid', validate_assignment=True)
+    
+    rendered_content: str = Field(description="Rendered template content")
+    template_name: str = Field(description="Name of the processed template")
+    variables_used: Set[str] = Field(default_factory=set, description="Variables that were used in rendering")
+    missing_variables: Set[str] = Field(default_factory=set, description="Variables that were missing")
+    template_metadata: Dict[str, Any] = Field(default_factory=dict, description="Template processing metadata")

django_cfg/modules/django_app_agent/services/template_manager/template_loader.py

@@ -0,0 +1,100 @@
+"""
+Template Loader for Django App Agent.
+
+This module handles loading Jinja2 templates from files and
+providing them to the template engine.
+"""
+
+from typing import Dict, Optional
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from ...core.exceptions import ValidationError
+
+
+class TemplateLoader(BaseModel):
+    """Loads Jinja2 templates from the templates directory."""
+    
+    templates_dir: Path = Field(description="Directory containing template files")
+    template_cache: Dict[str, str] = Field(default_factory=dict, description="Template cache")
+    
+    def __init__(self, **data):
+        """Initialize template loader."""
+        if 'templates_dir' not in data:
+            # Default to templates directory relative to this file
+            current_dir = Path(__file__).parent
+            data['templates_dir'] = current_dir / "templates"
+        
+        super().__init__(**data)
+        
+        # Validate templates directory exists
+        if not self.templates_dir.exists():
+            raise ValidationError(
+                f"Templates directory does not exist: {self.templates_dir}",
+                validation_type="template_directory"
+            )
+    
+    def load_template(self, template_name: str) -> str:
+        """Load a template by name."""
+        # Check cache first
+        if template_name in self.template_cache:
+            return self.template_cache[template_name]
+        
+        # Try to load from file
+        template_path = self.templates_dir / template_name
+        
+        if not template_path.exists():
+            # Try with .j2 extension if not provided
+            if not template_name.endswith('.j2'):
+                template_path = self.templates_dir / f"{template_name}.j2"
+        
+        if not template_path.exists():
+            raise ValidationError(
+                f"Template file not found: {template_name}",
+                validation_type="template_not_found"
+            )
+        
+        try:
+            content = template_path.read_text(encoding='utf-8')
+            # Cache the template
+            self.template_cache[template_name] = content
+            return content
+            
+        except Exception as e:
+            raise ValidationError(
+                f"Failed to read template file {template_name}: {e}",
+                validation_type="template_read_error"
+            )
+    
+    def load_all_templates(self) -> Dict[str, str]:
+        """Load all templates from the templates directory."""
+        templates = {}
+        
+        for template_path in self.templates_dir.glob("*.j2"):
+            template_name = template_path.name
+            try:
+                content = self.load_template(template_name)
+                templates[template_name] = content
+            except ValidationError:
+                # Skip templates that can't be loaded
+                continue
+        
+        return templates
+    
+    def get_available_templates(self) -> list[str]:
+        """Get list of available template names."""
+        return [p.name for p in self.templates_dir.glob("*.j2")]
+    
+    def clear_cache(self) -> None:
+        """Clear the template cache."""
+        self.template_cache.clear()
+    
+    def reload_template(self, template_name: str) -> str:
+        """Reload a template, bypassing cache."""
+        # Remove from cache if present
+        if template_name in self.template_cache:
+            del self.template_cache[template_name]
+        
+        # Load fresh copy
+        return self.load_template(template_name)

django_cfg/modules/django_app_agent/services/template_manager/templates/admin.py.j2

@@ -0,0 +1,105 @@
+"""
+Admin configuration for {{ app_name }} application.
+
+{{ description }}
+"""
+
+from django.contrib import admin
+{% if features.advanced_admin %}
+from django.utils.html import format_html
+from django.urls import reverse
+from django.utils.safestring import mark_safe
+{% endif %}
+from .models import {{ app_name|pascal_case }}Model
+{% if features.related_models %}
+from .models import {{ app_name|pascal_case }}Category, {{ app_name|pascal_case }}Tag
+{% endif %}
+
+
+@admin.register({{ app_name|pascal_case }}Model)
+class {{ app_name|pascal_case }}Admin(admin.ModelAdmin):
+    """Admin interface for {{ app_name }} model."""
+    
+    list_display = [
+        'name', 
+        {% if features.status_tracking %}'status', {% endif %}
+        {% if features.user_relations %}'owner', {% endif %}
+        'created_at', 
+        'updated_at'
+    ]
+    
+    list_filter = [
+        {% if features.status_tracking %}'status', {% endif %}
+        'created_at',
+        {% if features.user_relations %}'owner', {% endif %}
+    ]
+    
+    search_fields = ['name', 'description']
+    
+    {% if features.status_tracking %}
+    list_editable = ['status']
+    {% endif %}
+    
+    readonly_fields = ['created_at', 'updated_at']
+    
+    {% if features.advanced_admin %}
+    fieldsets = (
+        ('Basic Information', {
+            'fields': ('name', 'description')
+        }),
+        {% if features.status_tracking %}
+        ('Status', {
+            'fields': ('status',)
+        }),
+        {% endif %}
+        {% if features.user_relations %}
+        ('Ownership', {
+            'fields': ('owner',)
+        }),
+        {% endif %}
+        ('Timestamps', {
+            'fields': ('created_at', 'updated_at'),
+            'classes': ('collapse',)
+        }),
+    )
+    {% endif %}
+    
+    {% if features.user_relations %}
+    def save_model(self, request, obj, form, change):
+        if not change:  # Creating new object
+            obj.owner = request.user
+        super().save_model(request, obj, form, change)
+    
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        if request.user.is_superuser:
+            return qs
+        return qs.filter(owner=request.user)
+    {% endif %}
+    
+    {% if features.advanced_admin %}
+    def get_readonly_fields(self, request, obj=None):
+        if obj:  # Editing existing object
+            return self.readonly_fields + ['name']
+        return self.readonly_fields
+    {% endif %}
+
+
+{% if features.related_models %}
+@admin.register({{ app_name|pascal_case }}Category)
+class {{ app_name|pascal_case }}CategoryAdmin(admin.ModelAdmin):
+    """Admin interface for {{ app_name }} categories."""
+    
+    list_display = ['name', 'slug', 'description']
+    search_fields = ['name', 'description']
+    prepopulated_fields = {'slug': ('name',)}
+
+
+@admin.register({{ app_name|pascal_case }}Tag)
+class {{ app_name|pascal_case }}TagAdmin(admin.ModelAdmin):
+    """Admin interface for {{ app_name }} tags."""
+    
+    list_display = ['name', 'color']
+    search_fields = ['name']
+    list_editable = ['color']
+{% endif %}

django_cfg/modules/django_app_agent/services/template_manager/templates/apps.py.j2

@@ -0,0 +1,31 @@
+"""
+App configuration for {{ app_name }}.
+
+{{ description }}
+"""
+
+from django.apps import AppConfig
+{% if app_type == 'django_cfg' %}
+from django_cfg.apps import BaseCfgAppConfig
+{% endif %}
+
+
+{% if app_type == 'django_cfg' %}
+class {{ app_name|pascal_case }}Config(BaseCfgAppConfig):
+{% else %}
+class {{ app_name|pascal_case }}Config(AppConfig):
+{% endif %}
+    """Configuration for {{ app_name }} application."""
+    
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = '{{ app_name }}'
+    verbose_name = '{{ app_name|title_case }}'
+    
+    {% if features.signals %}
+    def ready(self):
+        """Import signals when app is ready."""
+        try:
+            import {{ app_name }}.signals  # noqa F401
+        except ImportError:
+            pass
+    {% endif %}