django-cfg 1.3.11__py3-none-any.whl → 1.4.0__py3-none-any.whl

django_cfg/apps/knowbase/mixins/generators/__init__.py

@@ -0,0 +1,16 @@
+"""
+Generators for ExternalData auto-generation.
+
+Content, metadata, and field analysis utilities for automatic generation
+of ExternalData from Django model instances.
+"""
+
+from .content_generator import ExternalDataContentGenerator
+from .metadata_generator import ExternalDataMetadataGenerator
+from .field_analyzer import ExternalDataFieldAnalyzer
+
+__all__ = [
+    'ExternalDataContentGenerator',
+    'ExternalDataMetadataGenerator',
+    'ExternalDataFieldAnalyzer',
+]

django_cfg/apps/knowbase/mixins/generators/content_generator.py

@@ -0,0 +1,218 @@
+"""
+Content and title generation for ExternalData.
+
+Handles automatic generation of titles and markdown content from model instances.
+"""
+
+from typing import List, Dict, Any, Tuple
+
+
+class ExternalDataContentGenerator:
+    """
+    Generate content and titles for model instances.
+
+    Provides smart auto-generation of titles and comprehensive markdown content
+    based on model fields and metadata.
+    """
+
+    def __init__(self, instance):
+        """
+        Initialize content generator for a model instance.
+
+        Args:
+            instance: Django model instance to generate content for
+        """
+        self.instance = instance
+        self.model_class = instance.__class__
+
+    def generate_title(self) -> str:
+        """
+        Auto-generate title based on model fields.
+
+        Tries common title fields first (title, name, etc.), then falls back
+        to string representation with model name.
+
+        Returns:
+            Generated title string (e.g., "Product: iPhone 15")
+        """
+        # Try common title fields first
+        title_fields = ['title', 'name', 'full_name', 'display_name', 'label']
+
+        for field_name in title_fields:
+            if hasattr(self.instance, field_name):
+                value = getattr(self.instance, field_name, None)
+                if value and str(value).strip():
+                    # Add model context for clarity
+                    model_name = self.model_class._meta.verbose_name or self.model_class.__name__
+                    return f"{model_name}: {value}"
+
+        # Fallback: use string representation with model name
+        model_name = self.model_class._meta.verbose_name or self.model_class.__name__
+        return f"{model_name}: {self.instance}"
+
+    def generate_content(self) -> str:
+        """
+        Auto-generate comprehensive markdown content.
+
+        Generates structured markdown content with:
+        - Header with title
+        - Basic Information section with key fields
+        - Related Information section with relationships
+        - Statistics section if available
+        - Technical Information section with metadata
+
+        Returns:
+            Generated markdown content as string
+        """
+        content_parts = []
+
+        # Header with title
+        title = self.generate_title()
+        content_parts.append(f"# {title}")
+        content_parts.append("")
+
+        # Basic Information section
+        content_parts.append("## Basic Information")
+
+        # Add key fields
+        key_fields = self._get_content_fields()
+        for field_name, field_value, field_label in key_fields:
+            if field_value is not None and str(field_value).strip():
+                content_parts.append(f"- **{field_label}**: {field_value}")
+
+        content_parts.append("")
+
+        # Add relationships section if any
+        relationships = self._get_relationship_info()
+        if relationships:
+            content_parts.append("## Related Information")
+            for rel_name, rel_info in relationships.items():
+                content_parts.append(f"- **{rel_name}**: {rel_info}")
+            content_parts.append("")
+
+        # Add statistics if available
+        stats = self._get_statistics_info()
+        if stats:
+            content_parts.append("## Statistics")
+            for stat_name, stat_value in stats.items():
+                content_parts.append(f"- **{stat_name}**: {stat_value}")
+            content_parts.append("")
+
+        # Add metadata section
+        content_parts.append("## Technical Information")
+        content_parts.append(
+            f"This data is automatically synchronized from the {self.model_class.__name__} "
+            f"model using ExternalDataMixin."
+        )
+        content_parts.append(f"")
+        content_parts.append(f"**Model**: {self.model_class._meta.label}")
+        content_parts.append(f"**ID**: {self.instance.pk}")
+
+        if hasattr(self.instance, 'created_at') and self.instance.created_at:
+            created_str = self.instance.created_at.strftime('%Y-%m-%d %H:%M:%S')
+            content_parts.append(f"**Created**: {created_str}")
+
+        if hasattr(self.instance, 'updated_at') and self.instance.updated_at:
+            updated_str = self.instance.updated_at.strftime('%Y-%m-%d %H:%M:%S')
+            content_parts.append(f"**Updated**: {updated_str}")
+
+        return "\n".join(content_parts)
+
+    def _get_content_fields(self) -> List[Tuple[str, Any, str]]:
+        """
+        Get fields to include in content generation.
+
+        Returns priority fields with their values and labels.
+
+        Returns:
+            List of tuples: (field_name, field_value, field_label)
+        """
+        fields_info = []
+
+        # Define field priority and labels
+        priority_fields = {
+            'name': 'Name',
+            'title': 'Title',
+            'code': 'Code',
+            'description': 'Description',
+            'summary': 'Summary',
+            'body_type': 'Body Type',
+            'segment': 'Segment',
+            'category': 'Category',
+            'type': 'Type',
+            'status': 'Status',
+            'is_active': 'Active',
+            'is_public': 'Public',
+            'price': 'Price',
+            'year': 'Year',
+            'fuel_type': 'Fuel Type',
+        }
+
+        # Add priority fields first
+        for field_name, field_label in priority_fields.items():
+            if hasattr(self.instance, field_name):
+                value = getattr(self.instance, field_name, None)
+                if value is not None:
+                    # Format boolean fields
+                    if isinstance(value, bool):
+                        value = "Yes" if value else "No"
+                    # Format choice fields
+                    elif hasattr(self.instance, f'get_{field_name}_display'):
+                        display_value = getattr(self.instance, f'get_{field_name}_display')()
+                        if display_value:
+                            value = display_value
+                    # Format foreign key relationships
+                    elif hasattr(value, '__str__'):
+                        value = str(value)
+
+                    fields_info.append((field_name, value, field_label))
+
+        return fields_info
+
+    def _get_relationship_info(self) -> Dict[str, str]:
+        """
+        Get relationship information for content.
+
+        Extracts foreign key relationships from common field names.
+
+        Returns:
+            Dictionary mapping relationship names to string values
+        """
+        relationships = {}
+
+        # Common relationship field names
+        rel_fields = ['brand', 'category', 'parent', 'owner', 'user', 'created_by']
+
+        for field_name in rel_fields:
+            if hasattr(self.instance, field_name):
+                value = getattr(self.instance, field_name, None)
+                if value:
+                    relationships[field_name.replace('_', ' ').title()] = str(value)
+
+        return relationships
+
+    def _get_statistics_info(self) -> Dict[str, Any]:
+        """
+        Get statistics information for content.
+
+        Extracts numeric statistics from common field names.
+
+        Returns:
+            Dictionary mapping statistic names to formatted values
+        """
+        stats = {}
+
+        # Common statistics field names
+        stat_fields = ['total_vehicles', 'total_models', 'total_items', 'count', 'views', 'likes']
+
+        for field_name in stat_fields:
+            if hasattr(self.instance, field_name):
+                value = getattr(self.instance, field_name, None)
+                if value is not None and (isinstance(value, (int, float)) and value > 0):
+                    label = field_name.replace('_', ' ').title()
+                    if isinstance(value, float):
+                        stats[label] = f"{value:,.2f}"
+                    else:
+                        stats[label] = f"{value:,}"
+
+        return stats

django_cfg/apps/knowbase/mixins/generators/field_analyzer.py

@@ -0,0 +1,76 @@
+"""
+Field analysis and detection for ExternalData.
+
+Handles automatic detection of important fields to watch and analyze.
+"""
+
+from typing import List
+
+
+class ExternalDataFieldAnalyzer:
+    """
+    Analyze model fields for auto-generation and change detection.
+
+    Provides utilities to detect important fields that should be watched
+    for changes and included in content generation.
+    """
+
+    def __init__(self, model_class):
+        """
+        Initialize field analyzer for a model class.
+
+        Args:
+            model_class: Django model class to analyze
+        """
+        self.model_class = model_class
+
+    def auto_detect_watch_fields(self) -> List[str]:
+        """
+        Auto-detect important fields to watch for changes.
+
+        Analyzes model fields and returns list of field names that should
+        trigger ExternalData updates when changed.
+
+        Returns:
+            List of field names to watch (max 10 fields)
+        """
+        watch_fields = []
+
+        # Get all model fields
+        for field in self.model_class._meta.get_fields():
+            if hasattr(field, 'name') and not field.name.startswith('_'):
+                field_name = field.name
+
+                # Skip auto-generated and system fields
+                skip_fields = {
+                    'id', 'pk', 'created_at', 'updated_at', 'external_source_id',
+                    '_external_content_hash', 'slug'
+                }
+                if field_name in skip_fields:
+                    continue
+
+                # Skip reverse foreign keys and many-to-many
+                if hasattr(field, 'related_model') and field.many_to_many:
+                    continue
+                if hasattr(field, 'remote_field') and field.remote_field:
+                    if hasattr(field.remote_field, 'related_name'):
+                        continue
+
+                # Include important field types
+                if hasattr(field, '__class__'):
+                    field_type = field.__class__.__name__
+                    important_types = {
+                        'CharField', 'TextField', 'BooleanField', 'IntegerField',
+                        'PositiveIntegerField', 'ForeignKey', 'DecimalField', 'FloatField'
+                    }
+                    if field_type in important_types:
+                        watch_fields.append(field_name)
+
+        # If no fields detected, watch all non-system fields
+        if not watch_fields:
+            for field in self.model_class._meta.get_fields():
+                if hasattr(field, 'name') and not field.name.startswith('_'):
+                    if field.name not in {'id', 'pk'}:
+                        watch_fields.append(field.name)
+
+        return watch_fields[:10]  # Limit to prevent too many triggers

django_cfg/apps/knowbase/mixins/generators/metadata_generator.py

@@ -0,0 +1,124 @@
+"""
+Metadata and tags generation for ExternalData.
+
+Handles automatic generation of descriptions, tags, and metadata from model instances.
+"""
+
+from typing import List
+
+
+class ExternalDataMetadataGenerator:
+    """
+    Generate metadata, tags, and descriptions for model instances.
+
+    Provides smart auto-generation based on model fields and relationships.
+    """
+
+    def __init__(self, instance):
+        """
+        Initialize metadata generator for a model instance.
+
+        Args:
+            instance: Django model instance to generate metadata for
+        """
+        self.instance = instance
+        self.model_class = instance.__class__
+
+    def generate_description(self) -> str:
+        """
+        Auto-generate description based on model fields.
+
+        Tries common description fields first, then builds description
+        from key fields (name, status, dates).
+
+        Returns:
+            Generated description string
+        """
+        model_name = self.model_class._meta.verbose_name or self.model_class.__name__
+
+        # Try common description fields
+        desc_fields = ['description', 'summary', 'about', 'details', 'info']
+        for field_name in desc_fields:
+            if hasattr(self.instance, field_name):
+                value = getattr(self.instance, field_name, None)
+                if value and str(value).strip():
+                    return f"{model_name} information: {value}"
+
+        # Build description from key fields
+        key_info = []
+
+        # Add primary identifier
+        if hasattr(self.instance, 'name') and self.instance.name:
+            key_info.append(f"Name: {self.instance.name}")
+        elif hasattr(self.instance, 'title') and self.instance.title:
+            key_info.append(f"Title: {self.instance.title}")
+
+        # Add status if available
+        if hasattr(self.instance, 'is_active'):
+            status = "Active" if self.instance.is_active else "Inactive"
+            key_info.append(f"Status: {status}")
+
+        # Add creation date if available
+        if hasattr(self.instance, 'created_at') and self.instance.created_at:
+            created_str = self.instance.created_at.strftime('%Y-%m-%d')
+            key_info.append(f"Created: {created_str}")
+
+        if key_info:
+            return (f"Comprehensive information about this {model_name.lower()}. "
+                    f"{', '.join(key_info)}.")
+
+        return f"Auto-generated information from {model_name} model."
+
+    def generate_tags(self) -> List[str]:
+        """
+        Auto-generate tags based on model fields and metadata.
+
+        Generates tags from:
+        - Model name and verbose name
+        - App label
+        - Field values (category, type, status, etc.)
+        - Boolean field values
+
+        Returns:
+            List of tags (max 10), cleaned and deduplicated
+        """
+        tags = []
+
+        # Add model-based tags
+        tags.append(self.model_class.__name__.lower())
+        if self.model_class._meta.verbose_name:
+            tags.append(self.model_class._meta.verbose_name.lower().replace(' ', '_'))
+
+        # Add app label
+        tags.append(self.model_class._meta.app_label)
+
+        # Add field-based tags
+        tag_fields = ['category', 'type', 'kind', 'status', 'brand', 'model']
+        for field_name in tag_fields:
+            if hasattr(self.instance, field_name):
+                value = getattr(self.instance, field_name, None)
+                if value:
+                    # Handle foreign key relationships
+                    if hasattr(value, 'name'):
+                        tags.append(str(value.name).lower())
+                    elif hasattr(value, 'code'):
+                        tags.append(str(value.code).lower())
+                    else:
+                        tags.append(str(value).lower())
+
+        # Add boolean field tags
+        bool_fields = ['is_active', 'is_public', 'is_featured', 'is_published']
+        for field_name in bool_fields:
+            if hasattr(self.instance, field_name):
+                value = getattr(self.instance, field_name, None)
+                if value is True:
+                    tags.append(field_name.replace('is_', ''))
+
+        # Clean and deduplicate tags
+        clean_tags = []
+        for tag in tags:
+            clean_tag = str(tag).lower().strip().replace(' ', '_')
+            if clean_tag and clean_tag not in clean_tags:
+                clean_tags.append(clean_tag)
+
+        return clean_tags[:10]  # Limit to 10 tags

django_cfg/apps/knowbase/mixins/service.py

@@ -18,7 +18,7 @@ from ..models.external_data import ExternalData, ExternalDataChunk, ExternalData
 from ..services.base import BaseService
 from ..services.embedding import process_external_data_chunks_optimized
 from .creator import ExternalDataCreator
-from .config import ExternalDataConfig
+from .config import ExternalDataMetaConfig
 
 logger = logging.getLogger(__name__)
 
@@ -62,7 +62,7 @@ class ExternalDataService(BaseService):
         """
         try:
             # Create configuration
-            config = ExternalDataConfig(
+            config = ExternalDataMetaConfig(
                 title=title,
                 description=description,
                 source_type=source_type,

django_cfg/apps/knowbase/services/archive/__init__.py

@@ -9,6 +9,7 @@ from .archive_service import *
 from .extraction_service import *
 from .chunking_service import *
 from .vectorization_service import *
+from .context import ChunkContextBuilder, ChunkData, ChunkContextMetadata
 
 __all__ = [
     # Main archive service

django_cfg/apps/knowbase/services/archive/analyzers/__init__.py

@@ -0,0 +1,17 @@
+"""
+Code analysis utilities.
+
+Complexity calculation, quality assessment, purpose detection, and tag generation.
+"""
+
+from .complexity_analyzer import ComplexityAnalyzer
+from .quality_analyzer import QualityAnalyzer
+from .purpose_detector import PurposeDetector
+from .tag_generator import TagGenerator
+
+__all__ = [
+    'ComplexityAnalyzer',
+    'QualityAnalyzer',
+    'PurposeDetector',
+    'TagGenerator',
+]

django_cfg/apps/knowbase/services/archive/analyzers/complexity_analyzer.py

@@ -0,0 +1,33 @@
+"""
+Code complexity analyzer.
+
+Calculates complexity score for code chunks.
+"""
+
+
+class ComplexityAnalyzer:
+    """Analyze code complexity."""
+
+    @staticmethod
+    def calculate_code_complexity(content: str) -> float:
+        """
+        Calculate code complexity score.
+
+        Simple complexity metric based on lines and control structures.
+
+        Args:
+            content: Code content to analyze
+
+        Returns:
+            Complexity score between 0.0 and 1.0
+        """
+        # Simple complexity based on lines and control structures
+        lines = content.split('\n')
+        complexity = len(lines) / 100.0  # Base complexity
+
+        # Add complexity for control structures
+        control_keywords = ['if', 'for', 'while', 'try', 'except', 'with']
+        for keyword in control_keywords:
+            complexity += content.count(keyword) * 0.1
+
+        return min(1.0, complexity)

django_cfg/apps/knowbase/services/archive/analyzers/purpose_detector.py

@@ -0,0 +1,36 @@
+"""
+Code purpose detector.
+
+Detects the purpose of code elements based on naming and content.
+"""
+
+
+class PurposeDetector:
+    """Detect purpose of code elements."""
+
+    @staticmethod
+    def detect_code_purpose(element_name: str, content: str) -> str:
+        """
+        Detect purpose of code element.
+
+        Args:
+            element_name: Name of the code element
+            content: Element content
+
+        Returns:
+            Purpose string (e.g., 'test', 'initialization', 'configuration')
+        """
+        name_lower = element_name.lower()
+
+        if name_lower.startswith('test_'):
+            return 'test'
+        elif name_lower.startswith('_'):
+            return 'private_method'
+        elif 'config' in name_lower:
+            return 'configuration'
+        elif 'init' in name_lower:
+            return 'initialization'
+        elif 'main' in name_lower:
+            return 'main_function'
+        else:
+            return 'implementation'

django_cfg/apps/knowbase/services/archive/analyzers/quality_analyzer.py

@@ -0,0 +1,39 @@
+"""
+Code quality analyzer.
+
+Assesses code quality based on documentation and formatting.
+"""
+
+
+class QualityAnalyzer:
+    """Assess code quality."""
+
+    @staticmethod
+    def assess_code_quality(content: str) -> float:
+        """
+        Assess code quality score.
+
+        Simple quality assessment based on documentation and formatting.
+
+        Args:
+            content: Code content to analyze
+
+        Returns:
+            Quality score between 0.0 and 1.0
+        """
+        # Simple quality assessment
+        quality = 0.5  # Base quality
+
+        # Boost for docstrings
+        if '"""' in content or "'''" in content:
+            quality += 0.2
+
+        # Boost for comments
+        comment_lines = len([line for line in content.split('\n') if line.strip().startswith('#')])
+        quality += min(0.2, comment_lines / 10.0)
+
+        # Penalty for very long lines
+        long_lines = len([line for line in content.split('\n') if len(line) > 100])
+        quality -= min(0.2, long_lines / 10.0)
+
+        return max(0.0, min(1.0, quality))