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

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

@@ -1,236 +0,0 @@
-"""
-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

@@ -1,159 +0,0 @@
-"""
-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

@@ -1,36 +0,0 @@
-"""
-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

@@ -1,100 +0,0 @@
-"""
-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

@@ -1,105 +0,0 @@
-"""
-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

@@ -1,31 +0,0 @@
-"""
-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 %}