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

django_cfg/modules/django_app_agent/agents/generation/app_generator/main.py

@@ -0,0 +1,99 @@
+"""
+Main App Generator Agent class.
+
+This module contains the primary agent class that orchestrates
+Django application generation using AI.
+"""
+
+from typing import List
+import asyncio
+
+from pydantic_ai import Agent, RunContext
+
+from ...base import DjangoAgent, AgentDependencies
+from ....models.requests import AppGenerationRequest
+from ....core.exceptions import GenerationError
+
+from .models import FileGenerationRequest, GeneratedFileResponse
+from .config_validator import ConfigValidator
+from .prompt_manager import PromptManager
+
+
+class AppGeneratorAgent(DjangoAgent):
+    """AI agent for generating Django application files."""
+    
+    def __init__(self, config):
+        """Initialize the app generator agent."""
+        # Initialize components
+        self.config_validator = ConfigValidator()
+        self.prompt_manager = PromptManager()
+        
+        # Validate API keys and configure model first
+        self.model = self.config_validator.validate_and_configure(config)
+        
+        # Initialize Pydantic AI agent
+        self.pydantic_agent = Agent(
+            model=self.model,
+            retries=2
+        )
+        
+        # Now call super init which will call _register_instructions
+        super().__init__("app_generator", config)
+    
+    async def generate_file(
+        self, 
+        request: FileGenerationRequest
+    ) -> GeneratedFileResponse:
+        """Generate a specific file for the Django application."""
+        try:
+            # Create detailed prompt for the specific feature
+            prompt = self.prompt_manager.create_feature_prompt(request)
+            
+            # Run AI generation
+            result = await self.pydantic_agent.run(prompt)
+            
+            return result.data
+            
+        except Exception as e:
+            raise GenerationError(
+                f"Failed to generate {request.feature.value} file: {e}",
+                app_name=request.app_name,
+                generation_stage=f"generate_{request.feature.value}_file"
+            )
+
+    async def generate_multiple_files(
+        self,
+        app_request: AppGenerationRequest
+    ) -> List[GeneratedFileResponse]:
+        """Generate multiple files for an application."""
+        results = []
+        
+        for feature in app_request.features:
+            request = FileGenerationRequest(
+                app_name=app_request.app_name,
+                description=app_request.description,
+                feature=feature,
+                app_type=app_request.app_type,
+                complexity=app_request.complexity
+            )
+            
+            try:
+                result = await self.generate_file(request)
+                results.append(result)
+            except Exception as e:
+                self.logger.error(f"Failed to generate {feature.value}: {e}")
+                # Continue with other features
+                continue
+        
+        return results
+    
+    def _register_instructions(self) -> None:
+        """Register agent instructions."""
+        @self.pydantic_agent.system_prompt
+        async def agent_instructions(ctx: RunContext[AgentDependencies]) -> str:
+            return self.prompt_manager.get_system_prompt()
+    
+    def _register_tools(self) -> None:
+        """Register agent tools."""
+        # No additional tools needed for basic file generation
+        pass

django_cfg/modules/django_app_agent/agents/generation/app_generator/models.py

@@ -0,0 +1,32 @@
+"""
+Data models for the App Generator Agent.
+
+This module contains Pydantic models used for request/response
+handling in the AI agent.
+"""
+
+from typing import List, Dict, Any
+from pydantic import BaseModel, Field
+
+from ....models.enums import AppFeature, AppType, AppComplexity
+
+
+class FileGenerationRequest(BaseModel):
+    """Request for generating a specific file."""
+    
+    app_name: str = Field(description="Name of the Django application")
+    description: str = Field(description="Application description")
+    feature: AppFeature = Field(description="Feature to generate")
+    app_type: AppType = Field(description="Type of Django application")
+    complexity: AppComplexity = Field(description="Application complexity level")
+    additional_context: Dict[str, Any] = Field(default_factory=dict, description="Additional context")
+
+
+class GeneratedFileResponse(BaseModel):
+    """Response containing generated file content."""
+    
+    filename: str = Field(description="Name of the generated file")
+    content: str = Field(description="File content")
+    imports: List[str] = Field(default_factory=list, description="Required imports")
+    dependencies: List[str] = Field(default_factory=list, description="Package dependencies")
+    description: str = Field(description="File description")

django_cfg/modules/django_app_agent/agents/generation/app_generator/prompt_manager.py

@@ -0,0 +1,290 @@
+"""
+Prompt management for the App Generator Agent.
+
+This module handles all AI prompts for different Django features
+and provides intelligent prompt generation based on requirements.
+"""
+
+from .models import FileGenerationRequest
+from ....models.enums import AppFeature
+
+
+class PromptManager:
+    """Manages AI prompts for different Django features."""
+    
+    def get_system_prompt(self) -> str:
+        """Get the system prompt for the AI agent."""
+        return """You are an expert Django developer with deep knowledge of Django best practices, 
+design patterns, and modern Python development.
+
+Your task is to generate high-quality Django application files based on user requirements.
+
+Guidelines:
+1. Follow Django best practices and conventions
+2. Use proper Python type hints
+3. Include comprehensive docstrings
+4. Add appropriate error handling
+5. Follow PEP 8 style guidelines
+6. Use modern Django features (Django 5.x)
+7. Include proper imports and dependencies
+8. Generate production-ready code
+9. Add meaningful comments where needed
+10. Consider security best practices
+
+For django-cfg applications, also:
+- Use django-cfg patterns and conventions
+- Leverage django-cfg modules when appropriate
+- Follow the infrastructural layer approach
+- Use proper configuration management
+
+Always generate complete, working code that can be used immediately."""
+
+    def create_feature_prompt(self, request: FileGenerationRequest) -> str:
+        """Create a detailed prompt for generating a specific feature."""
+        feature_prompts = {
+            AppFeature.MODELS: self._get_models_prompt(request),
+            AppFeature.VIEWS: self._get_views_prompt(request),
+            AppFeature.ADMIN: self._get_admin_prompt(request),
+            AppFeature.URLS: self._get_urls_prompt(request),
+            AppFeature.FORMS: self._get_forms_prompt(request),
+            AppFeature.API: self._get_api_prompt(request),
+            AppFeature.TESTS: self._get_tests_prompt(request),
+            AppFeature.TASKS: self._get_tasks_prompt(request),
+            AppFeature.SIGNALS: self._get_signals_prompt(request),
+        }
+        
+        return feature_prompts.get(request.feature, self._get_generic_prompt(request))
+    
+    def _get_models_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating models.py."""
+        return f"""Generate a Django models.py file for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create relevant models based on the application description
+2. Use appropriate field types and relationships
+3. Include proper Meta classes with ordering, verbose names
+4. Add __str__ methods for all models
+5. Use abstract base models where appropriate
+6. Include created_at/updated_at timestamps
+7. Add proper model validation
+8. Include relevant indexes for performance
+9. Use proper related_name for relationships
+10. Add comprehensive docstrings
+
+For django-cfg apps, also consider:
+- Using django-cfg base models if appropriate
+- Following django-cfg naming conventions
+- Including proper configuration fields
+
+Generate complete, production-ready models with proper imports."""
+
+    def _get_views_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating views.py."""
+        return f"""Generate a Django views.py file for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create appropriate view classes/functions based on the app purpose
+2. Use class-based views where appropriate
+3. Include proper permission checks
+4. Add error handling and validation
+5. Use proper HTTP status codes
+6. Include pagination for list views
+7. Add proper context data
+8. Use Django's built-in mixins
+9. Include proper docstrings
+10. Add type hints
+
+Generate complete, secure views with proper imports and error handling."""
+
+    def _get_admin_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating admin.py."""
+        return f"""Generate a Django admin.py file for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Register all models with appropriate admin classes
+2. Configure list_display, list_filter, search_fields
+3. Add proper fieldsets for complex models
+4. Include inline admin for related models
+5. Add custom admin actions where useful
+6. Use proper admin permissions
+7. Include admin-specific methods
+8. Add proper docstrings
+9. Configure admin ordering and pagination
+10. Add custom admin templates if needed
+
+Generate a complete admin configuration with good UX."""
+
+    def _get_urls_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating urls.py."""
+        return f"""Generate a Django urls.py file for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create appropriate URL patterns for the application
+2. Use proper URL naming conventions
+3. Include namespace for the app
+4. Add URL patterns for all major views
+5. Use path() instead of url() (modern Django)
+6. Include proper parameter types in URLs
+7. Add API endpoints if this is an API app
+8. Consider SEO-friendly URLs
+9. Include proper docstrings
+10. Group related URLs logically
+
+Generate complete URL configuration with proper imports."""
+
+    def _get_forms_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating forms.py."""
+        return f"""Generate a Django forms.py file for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create ModelForm classes for main models
+2. Add proper field validation
+3. Include custom clean methods
+4. Use appropriate widgets
+5. Add form styling classes
+6. Include proper error messages
+7. Add form helpers if using crispy forms
+8. Include proper docstrings
+9. Add custom form fields if needed
+10. Consider accessibility
+
+Generate complete, user-friendly forms with proper validation."""
+
+    def _get_api_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating API files (serializers.py)."""
+        return f"""Generate Django REST Framework serializers.py for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create ModelSerializer classes for main models
+2. Include proper field validation
+3. Add custom serializer methods
+4. Use nested serializers for relationships
+5. Include proper read-only fields
+6. Add custom create/update methods
+7. Include proper docstrings
+8. Add API versioning considerations
+9. Use proper field representations
+10. Include permission-aware serialization
+
+Generate complete REST API serializers with proper validation."""
+
+    def _get_tests_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating tests.py."""
+        return f"""Generate comprehensive Django tests.py for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create test classes for models, views, forms
+2. Use Django's TestCase and test client
+3. Include proper test data setup
+4. Test all major functionality
+5. Add negative test cases
+6. Test permissions and security
+7. Include API tests if applicable
+8. Use proper assertions
+9. Add performance tests for complex operations
+10. Include integration tests
+
+Generate comprehensive test coverage with proper test organization."""
+
+    def _get_tasks_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating tasks.py (Celery/background tasks)."""
+        return f"""Generate Django tasks.py for background processing in the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create Celery tasks for background processing
+2. Include proper error handling and retries
+3. Add task monitoring and logging
+4. Use proper task signatures
+5. Include task result handling
+6. Add periodic tasks if needed
+7. Include proper docstrings
+8. Add task progress tracking
+9. Use proper task queues
+10. Include task testing utilities
+
+Generate production-ready background tasks with proper error handling."""
+
+    def _get_signals_prompt(self, request: FileGenerationRequest) -> str:
+        """Get prompt for generating signals.py."""
+        return f"""Generate Django signals.py for the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Requirements:
+1. Create appropriate signal handlers
+2. Use proper signal decorators
+3. Include error handling in signals
+4. Add proper logging
+5. Consider signal performance impact
+6. Include proper docstrings
+7. Use weak references where appropriate
+8. Add signal testing
+9. Consider signal ordering
+10. Include proper cleanup
+
+Generate efficient signal handlers with proper error handling."""
+
+    def _get_generic_prompt(self, request: FileGenerationRequest) -> str:
+        """Get generic prompt for other features."""
+        return f"""Generate a Django file for the '{request.feature.value}' feature in the '{request.app_name}' application.
+
+Application Details:
+- Name: {request.app_name}
+- Description: {request.description}
+- Feature: {request.feature.value}
+- Type: {request.app_type.value}
+- Complexity: {request.complexity.value}
+
+Generate appropriate, production-ready code following Django best practices."""