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/templates/cfg_config.py.j2

@@ -1,44 +0,0 @@
-"""
-Django-CFG configuration for {{ app_name }} application.
-
-{{ description }}
-"""
-
-from django_cfg.config import BaseCfgConfig
-from pydantic import Field
-from typing import Optional, List
-
-
-class {{ app_name|pascal_case }}Config(BaseCfgConfig):
-    """Configuration for {{ app_name }} application."""
-    
-    # Basic settings
-    enabled: bool = Field(default=True, description="Enable {{ app_name }} functionality")
-    debug_mode: bool = Field(default=False, description="Enable debug mode for {{ app_name }}")
-    
-    # Feature toggles
-    {% if features.api %}
-    api_enabled: bool = Field(default=True, description="Enable API endpoints")
-    api_rate_limit: int = Field(default=100, description="API rate limit per hour")
-    {% endif %}
-    
-    {% if features.caching %}
-    cache_timeout: int = Field(default=300, description="Cache timeout in seconds")
-    cache_key_prefix: str = Field(default="{{ app_name }}", description="Cache key prefix")
-    {% endif %}
-    
-    {% if features.notifications %}
-    notifications_enabled: bool = Field(default=True, description="Enable notifications")
-    email_notifications: bool = Field(default=False, description="Send email notifications")
-    {% endif %}
-    
-    # Business logic settings
-    max_items_per_user: Optional[int] = Field(default=None, description="Maximum items per user")
-    allowed_file_types: List[str] = Field(
-        default=["jpg", "png", "pdf"], 
-        description="Allowed file upload types"
-    )
-    
-    class Meta:
-        app_name = "{{ app_name }}"
-        config_prefix = "{{ app_name|upper }}"

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

@@ -1,81 +0,0 @@
-"""
-Django-CFG module for {{ app_name }} application.
-
-{{ description }}
-"""
-
-from django_cfg.modules import BaseCfgModule
-from django_cfg.decorators import cfg_module
-from .config import {{ app_name|pascal_case }}Config
-
-
-@cfg_module
-class {{ app_name|pascal_case }}Module(BaseCfgModule[{{ app_name|pascal_case }}Config]):
-    """Django-CFG module for {{ app_name }}."""
-    
-    config_class = {{ app_name|pascal_case }}Config
-    
-    def __init__(self):
-        """Initialize {{ app_name }} module."""
-        super().__init__()
-        self.name = "{{ app_name }}"
-        self.version = "1.0.0"
-        self.description = "{{ description }}"
-    
-    async def initialize(self):
-        """Initialize module resources."""
-        self.logger.info(f"Initializing {{ app_name }} module")
-        
-        {% if features.database_setup %}
-        # Setup database connections if needed
-        await self._setup_database()
-        {% endif %}
-        
-        {% if features.cache_setup %}
-        # Setup cache if needed
-        await self._setup_cache()
-        {% endif %}
-        
-        self.logger.info(f"{{ app_name|title_case }} module initialized successfully")
-    
-    async def cleanup(self):
-        """Cleanup module resources."""
-        self.logger.info(f"Cleaning up {{ app_name }} module")
-        
-        {% if features.cleanup_tasks %}
-        # Perform cleanup tasks
-        await self._cleanup_resources()
-        {% endif %}
-    
-    def get_health_status(self) -> dict:
-        """Get module health status."""
-        return {
-            "status": "healthy",
-            "module": self.name,
-            "version": self.version,
-            "config_loaded": self.config is not None,
-            {% if features.database_setup %}
-            "database_connected": self._check_database_connection(),
-            {% endif %}
-        }
-    
-    {% if features.database_setup %}
-    async def _setup_database(self):
-        """Setup database connections."""
-        # Implement database setup logic
-        pass
-    {% endif %}
-    
-    {% if features.cache_setup %}
-    async def _setup_cache(self):
-        """Setup cache connections."""
-        # Implement cache setup logic
-        pass
-    {% endif %}
-    
-    {% if features.cleanup_tasks %}
-    async def _cleanup_resources(self):
-        """Cleanup module resources."""
-        # Implement cleanup logic
-        pass
-    {% endif %}

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

@@ -1,107 +0,0 @@
-"""
-Forms for {{ app_name }} application.
-
-{{ description }}
-"""
-
-from django import forms
-from django.core.exceptions import ValidationError
-{% if features.crispy_forms %}
-from crispy_forms.helper import FormHelper
-from crispy_forms.layout import Layout, Submit, Row, Column
-{% endif %}
-from .models import {{ app_name|pascal_case }}Model
-
-
-class {{ app_name|pascal_case }}Form(forms.ModelForm):
-    """Form for {{ app_name }} model."""
-    
-    class Meta:
-        model = {{ app_name|pascal_case }}Model
-        fields = [
-            'name', 
-            'description',
-            {% if features.status_tracking %}'status',{% endif %}
-        ]
-        widgets = {
-            'description': forms.Textarea(attrs={'rows': 4}),
-            {% if features.status_tracking %}
-            'status': forms.Select(attrs={'class': 'form-select'}),
-            {% endif %}
-        }
-        help_texts = {
-            'name': 'Enter a descriptive name for this {{ app_name|singular }}',
-            'description': 'Provide additional details (optional)',
-        }
-    
-    {% if features.crispy_forms %}
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.helper = FormHelper()
-        self.helper.layout = Layout(
-            Row(
-                Column('name', css_class='form-group col-md-8 mb-0'),
-                {% if features.status_tracking %}
-                Column('status', css_class='form-group col-md-4 mb-0'),
-                {% endif %}
-                css_class='form-row'
-            ),
-            'description',
-            Submit('submit', 'Save {{ app_name|title_case }}', css_class='btn btn-primary')
-        )
-    {% endif %}
-    
-    def clean_name(self):
-        """Validate name field."""
-        name = self.cleaned_data.get('name')
-        if name:
-            # Check for duplicate names (case-insensitive)
-            existing = {{ app_name|pascal_case }}Model.objects.filter(
-                name__iexact=name
-            )
-            if self.instance.pk:
-                existing = existing.exclude(pk=self.instance.pk)
-            
-            if existing.exists():
-                raise ValidationError(
-                    f'A {{ app_name|singular }} with this name already exists.'
-                )
-        
-        return name
-    
-    def clean(self):
-        """Additional form validation."""
-        cleaned_data = super().clean()
-        
-        # Add any cross-field validation here
-        name = cleaned_data.get('name')
-        description = cleaned_data.get('description')
-        
-        if name and description and name.lower() in description.lower():
-            self.add_error('description', 
-                'Description should not just repeat the name.')
-        
-        return cleaned_data
-
-
-{% if features.search_forms %}
-class {{ app_name|pascal_case }}SearchForm(forms.Form):
-    """Search form for {{ app_name }}."""
-    
-    query = forms.CharField(
-        max_length=100,
-        required=False,
-        widget=forms.TextInput(attrs={
-            'placeholder': 'Search {{ app_name|plural }}...',
-            'class': 'form-control'
-        })
-    )
-    
-    {% if features.status_tracking %}
-    status = forms.ChoiceField(
-        choices=[('', 'All')] + {{ app_name|pascal_case }}Model.STATUS_CHOICES,
-        required=False,
-        widget=forms.Select(attrs={'class': 'form-select'})
-    )
-    {% endif %}
-{% endif %}

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

@@ -1,139 +0,0 @@
-"""
-Models for {{ app_name }} application.
-
-{{ description }}
-"""
-
-from django.db import models
-from django.urls import reverse
-from django.core.validators import MinLengthValidator, MaxLengthValidator
-{% if app_type == 'django_cfg' %}
-from django_cfg.models import BaseCfgModel
-{% endif %}
-{% if features.user_relations %}
-from django.contrib.auth.models import User
-{% endif %}
-{% if features.uuid_primary_keys %}
-import uuid
-{% endif %}
-
-
-{% if app_type == 'django_cfg' %}
-class {{ app_name|pascal_case }}Model(BaseCfgModel):
-{% else %}
-class {{ app_name|pascal_case }}Model(models.Model):
-{% endif %}
-    """Main model for {{ app_name }} application."""
-    
-    {% if features.uuid_primary_keys %}
-    id = models.UUIDField(
-        primary_key=True,
-        default=uuid.uuid4,
-        editable=False,
-        help_text="Unique identifier"
-    )
-    {% endif %}
-    
-    name = models.CharField(
-        max_length=100,
-        validators=[MinLengthValidator(2)],
-        help_text="Name of the {{ app_name|singular|title_case }}"
-    )
-    
-    description = models.TextField(
-        blank=True,
-        help_text="Detailed description"
-    )
-    
-    {% if features.status_tracking %}
-    STATUS_CHOICES = [
-        ('draft', 'Draft'),
-        ('published', 'Published'),
-        ('archived', 'Archived'),
-    ]
-    
-    status = models.CharField(
-        max_length=20,
-        choices=STATUS_CHOICES,
-        default='draft',
-        help_text="Current status"
-    )
-    {% endif %}
-    
-    {% if features.user_relations %}
-    owner = models.ForeignKey(
-        User,
-        on_delete=models.CASCADE,
-        related_name="{{ app_name }}_owned",
-        help_text="Owner of this {{ app_name|singular }}"
-    )
-    {% endif %}
-    
-    {% if not app_type == 'django_cfg' %}
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-    {% endif %}
-    
-    class Meta:
-        verbose_name = "{{ app_name|singular|title_case }}"
-        verbose_name_plural = "{{ app_name|plural|title_case }}"
-        ordering = ['-created_at']
-        {% if features.database_indexes %}
-        indexes = [
-            models.Index(fields=['name']),
-            models.Index(fields=['created_at']),
-            {% if features.status_tracking %}
-            models.Index(fields=['status']),
-            {% endif %}
-        ]
-        {% endif %}
-    
-    def __str__(self):
-        return self.name
-    
-    def get_absolute_url(self):
-        return reverse('{{ app_name }}:detail', kwargs={'pk': self.pk})
-    
-    {% if features.custom_methods %}
-    def is_published(self):
-        """Check if the item is published."""
-        {% if features.status_tracking %}
-        return self.status == 'published'
-        {% else %}
-        return True
-        {% endif %}
-    
-    def get_display_name(self):
-        """Get formatted display name."""
-        return self.name.title()
-    {% endif %}
-
-
-{% if features.related_models %}
-class {{ app_name|pascal_case }}Category(models.Model):
-    """Category model for {{ app_name }}."""
-    
-    name = models.CharField(max_length=50, unique=True)
-    slug = models.SlugField(unique=True)
-    description = models.TextField(blank=True)
-    
-    class Meta:
-        verbose_name_plural = "Categories"
-        ordering = ['name']
-    
-    def __str__(self):
-        return self.name
-
-
-class {{ app_name|pascal_case }}Tag(models.Model):
-    """Tag model for {{ app_name }}."""
-    
-    name = models.CharField(max_length=30, unique=True)
-    color = models.CharField(max_length=7, default='#007bff')  # Hex color
-    
-    class Meta:
-        ordering = ['name']
-    
-    def __str__(self):
-        return self.name
-{% endif %}

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

@@ -1,91 +0,0 @@
-"""
-DRF Serializers for {{ app_name }} application.
-
-{{ description }}
-"""
-
-from rest_framework import serializers
-{% if features.nested_serializers %}
-from rest_framework.fields import SerializerMethodField
-{% 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 %}
-
-
-class {{ app_name|pascal_case }}Serializer(serializers.ModelSerializer):
-    """Serializer for {{ app_name }} model."""
-    
-    {% if features.computed_fields %}
-    display_name = serializers.SerializerMethodField()
-    is_published = serializers.SerializerMethodField()
-    {% endif %}
-    
-    class Meta:
-        model = {{ app_name|pascal_case }}Model
-        fields = [
-            'id',
-            'name',
-            'description',
-            {% if features.status_tracking %}'status',{% endif %}
-            {% if features.user_relations %}'owner',{% endif %}
-            'created_at',
-            'updated_at',
-            {% if features.computed_fields %}
-            'display_name',
-            'is_published',
-            {% endif %}
-        ]
-        read_only_fields = ['id', 'created_at', 'updated_at']
-    
-    {% if features.computed_fields %}
-    def get_display_name(self, obj):
-        """Get formatted display name."""
-        return obj.get_display_name()
-    
-    def get_is_published(self, obj):
-        """Check if item is published."""
-        return obj.is_published()
-    {% endif %}
-    
-    def validate_name(self, value):
-        """Validate name field."""
-        if len(value.strip()) < 2:
-            raise serializers.ValidationError(
-                "Name must be at least 2 characters long."
-            )
-        return value.strip()
-
-
-{% if features.list_serializers %}
-class {{ app_name|pascal_case }}ListSerializer(serializers.ModelSerializer):
-    """Lightweight serializer for {{ app_name }} lists."""
-    
-    class Meta:
-        model = {{ app_name|pascal_case }}Model
-        fields = [
-            'id',
-            'name',
-            {% if features.status_tracking %}'status',{% endif %}
-            'created_at'
-        ]
-{% endif %}
-
-
-{% if features.related_models %}
-class {{ app_name|pascal_case }}CategorySerializer(serializers.ModelSerializer):
-    """Serializer for {{ app_name }} categories."""
-    
-    class Meta:
-        model = {{ app_name|pascal_case }}Category
-        fields = ['id', 'name', 'slug', 'description']
-
-
-class {{ app_name|pascal_case }}TagSerializer(serializers.ModelSerializer):
-    """Serializer for {{ app_name }} tags."""
-    
-    class Meta:
-        model = {{ app_name|pascal_case }}Tag
-        fields = ['id', 'name', 'color']
-{% endif %}

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

@@ -1,195 +0,0 @@
-"""
-Tests for {{ app_name }} application.
-
-{{ description }}
-"""
-
-from django.test import TestCase, Client
-from django.urls import reverse
-{% if features.user_relations %}
-from django.contrib.auth.models import User
-{% endif %}
-{% if features.api_tests %}
-from rest_framework.test import APITestCase
-from rest_framework import status
-{% endif %}
-from .models import {{ app_name|pascal_case }}Model
-
-
-class {{ app_name|pascal_case }}ModelTest(TestCase):
-    """Test cases for {{ app_name }} model."""
-    
-    def setUp(self):
-        """Set up test data."""
-        {% if features.user_relations %}
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123'
-        )
-        {% endif %}
-        
-        self.{{ app_name|snake_case }} = {{ app_name|pascal_case }}Model.objects.create(
-            name='Test {{ app_name|title_case }}',
-            description='Test description',
-            {% if features.status_tracking %}status='draft',{% endif %}
-            {% if features.user_relations %}owner=self.user{% endif %}
-        )
-    
-    def test_string_representation(self):
-        """Test string representation of model."""
-        self.assertEqual(str(self.{{ app_name|snake_case }}), 'Test {{ app_name|title_case }}')
-    
-    def test_get_absolute_url(self):
-        """Test get_absolute_url method."""
-        url = self.{{ app_name|snake_case }}.get_absolute_url()
-        expected_url = reverse('{{ app_name }}:detail', kwargs={'pk': self.{{ app_name|snake_case }}.pk})
-        self.assertEqual(url, expected_url)
-    
-    {% if features.custom_methods %}
-    def test_is_published(self):
-        """Test is_published method."""
-        {% if features.status_tracking %}
-        self.assertFalse(self.{{ app_name|snake_case }}.is_published())
-        
-        self.{{ app_name|snake_case }}.status = 'published'
-        self.{{ app_name|snake_case }}.save()
-        self.assertTrue(self.{{ app_name|snake_case }}.is_published())
-        {% else %}
-        self.assertTrue(self.{{ app_name|snake_case }}.is_published())
-        {% endif %}
-    
-    def test_get_display_name(self):
-        """Test get_display_name method."""
-        display_name = self.{{ app_name|snake_case }}.get_display_name()
-        self.assertEqual(display_name, 'Test {{ app_name|title_case }}')
-    {% endif %}
-
-
-{% if features.view_tests %}
-class {{ app_name|pascal_case }}ViewTest(TestCase):
-    """Test cases for {{ app_name }} views."""
-    
-    def setUp(self):
-        """Set up test data."""
-        self.client = Client()
-        {% if features.user_relations %}
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123'
-        )
-        {% endif %}
-        
-        self.{{ app_name|snake_case }} = {{ app_name|pascal_case }}Model.objects.create(
-            name='Test {{ app_name|title_case }}',
-            description='Test description',
-            {% if features.status_tracking %}status='published',{% endif %}
-            {% if features.user_relations %}owner=self.user{% endif %}
-        )
-    
-    {% if features.function_based_views %}
-    def test_index_view(self):
-        """Test index view."""
-        {% if features.authentication %}
-        self.client.login(username='testuser', password='testpass123')
-        {% endif %}
-        
-        url = reverse('{{ app_name }}:index')
-        response = self.client.get(url)
-        
-        self.assertEqual(response.status_code, 200)
-        self.assertContains(response, 'Test {{ app_name|title_case }}')
-    
-    def test_detail_view(self):
-        """Test detail view."""
-        {% if features.authentication %}
-        self.client.login(username='testuser', password='testpass123')
-        {% endif %}
-        
-        url = reverse('{{ app_name }}:detail', kwargs={'pk': self.{{ app_name|snake_case }}.pk})
-        response = self.client.get(url)
-        
-        self.assertEqual(response.status_code, 200)
-        self.assertContains(response, self.{{ app_name|snake_case }}.name)
-    {% endif %}
-    
-    {% if features.class_based_views %}
-    def test_list_view(self):
-        """Test list view."""
-        {% if features.authentication %}
-        self.client.login(username='testuser', password='testpass123')
-        {% endif %}
-        
-        url = reverse('{{ app_name }}:list')
-        response = self.client.get(url)
-        
-        self.assertEqual(response.status_code, 200)
-        self.assertContains(response, self.{{ app_name|snake_case }}.name)
-    {% endif %}
-    
-    {% if features.crud_views %}
-    def test_create_view(self):
-        """Test create view."""
-        {% if features.authentication %}
-        self.client.login(username='testuser', password='testpass123')
-        {% endif %}
-        
-        url = reverse('{{ app_name }}:create')
-        
-        # Test GET request
-        response = self.client.get(url)
-        self.assertEqual(response.status_code, 200)
-        
-        # Test POST request
-        data = {
-            'name': 'New {{ app_name|title_case }}',
-            'description': 'New description',
-            {% if features.status_tracking %}'status': 'draft'{% endif %}
-        }
-        response = self.client.post(url, data)
-        self.assertEqual(response.status_code, 302)  # Redirect after success
-        
-        # Verify object was created
-        self.assertTrue(
-            {{ app_name|pascal_case }}Model.objects.filter(name='New {{ app_name|title_case }}').exists()
-        )
-    {% endif %}
-{% endif %}
-
-
-{% if features.api_tests %}
-class {{ app_name|pascal_case }}APITest(APITestCase):
-    """Test cases for {{ app_name }} API."""
-    
-    def setUp(self):
-        """Set up test data."""
-        {% if features.user_relations %}
-        self.user = User.objects.create_user(
-            username='testuser',
-            email='test@example.com',
-            password='testpass123'
-        )
-        {% endif %}
-        
-        self.{{ app_name|snake_case }} = {{ app_name|pascal_case }}Model.objects.create(
-            name='Test {{ app_name|title_case }}',
-            description='Test description',
-            {% if features.status_tracking %}status='published',{% endif %}
-            {% if features.user_relations %}owner=self.user{% endif %}
-        )
-    
-    def test_api_view(self):
-        """Test API view."""
-        {% if features.authentication %}
-        self.client.force_authenticate(user=self.user)
-        {% endif %}
-        
-        url = reverse('{{ app_name }}:api')
-        response = self.client.get(url)
-        
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertTrue(response.data['success'])
-        self.assertEqual(len(response.data['data']), 1)
-        self.assertEqual(response.data['data'][0]['name'], 'Test {{ app_name|title_case }}')
-{% endif %}

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

@@ -1,35 +0,0 @@
-"""
-URL configuration for {{ app_name }} application.
-
-{{ description }}
-"""
-
-from django.urls import path, include
-{% if features.api_views %}
-from django.urls import re_path
-{% endif %}
-from . import views
-
-app_name = '{{ app_name }}'
-
-urlpatterns = [
-    {% if features.function_based_views %}
-    path('', views.{{ app_name }}_index, name='index'),
-    path('<int:pk>/', views.{{ app_name }}_detail, name='detail'),
-    {% endif %}
-    
-    {% if features.class_based_views %}
-    path('list/', views.{{ app_name|pascal_case }}ListView.as_view(), name='list'),
-    path('detail/<int:pk>/', views.{{ app_name|pascal_case }}DetailView.as_view(), name='detail'),
-    
-    {% if features.crud_views %}
-    path('create/', views.{{ app_name|pascal_case }}CreateView.as_view(), name='create'),
-    path('update/<int:pk>/', views.{{ app_name|pascal_case }}UpdateView.as_view(), name='update'),
-    path('delete/<int:pk>/', views.{{ app_name|pascal_case }}DeleteView.as_view(), name='delete'),
-    {% endif %}
-    {% endif %}
-    
-    {% if features.api_views %}
-    path('api/', views.{{ app_name|pascal_case }}APIView.as_view(), name='api'),
-    {% endif %}
-]