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

django_cfg/apps/knowbase/mixins/config/defaults.py

@@ -0,0 +1,75 @@
+"""
+Smart defaults for ExternalData configuration.
+
+Provides sensible defaults for ExternalData configuration when not explicitly specified.
+"""
+
+from typing import List
+
+from ...models.external_data import ExternalDataType
+from ..generators import ExternalDataFieldAnalyzer
+
+
+class ExternalDataDefaults:
+    """
+    Provide smart defaults for ExternalData configuration.
+
+    Offers utilities to get sensible defaults when ExternalDataMeta
+    is not provided or incomplete.
+    """
+
+    @staticmethod
+    def get_default_watch_fields(model_class) -> List[str]:
+        """
+        Get default watch fields for a model class.
+
+        Uses field analyzer to detect important fields.
+
+        Args:
+            model_class: Django model class
+
+        Returns:
+            List of field names to watch
+        """
+        analyzer = ExternalDataFieldAnalyzer(model_class)
+        return analyzer.auto_detect_watch_fields()
+
+    @staticmethod
+    def get_default_source_type() -> ExternalDataType:
+        """
+        Get default source type.
+
+        Returns:
+            ExternalDataType.MODEL as default
+        """
+        return ExternalDataType.MODEL
+
+    @staticmethod
+    def get_default_similarity_threshold() -> float:
+        """
+        Get default similarity threshold.
+
+        Returns:
+            0.5 as balanced default threshold
+        """
+        return 0.5
+
+    @staticmethod
+    def get_default_auto_sync() -> bool:
+        """
+        Get default auto_sync setting.
+
+        Returns:
+            True (enabled by default)
+        """
+        return True
+
+    @staticmethod
+    def get_default_is_public() -> bool:
+        """
+        Get default is_public setting.
+
+        Returns:
+            False (private by default for security)
+        """
+        return False

django_cfg/apps/knowbase/mixins/config/meta_config.py

@@ -0,0 +1,120 @@
+"""
+ExternalDataMeta configuration parser.
+
+Handles parsing and processing of ExternalDataMeta configuration from model classes.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Any
+
+from ...models.external_data import ExternalDataType
+from ..generators import ExternalDataFieldAnalyzer
+
+
+@dataclass
+class ExternalDataMetaConfig:
+    """
+    Configuration from ExternalDataMeta class.
+
+    Attributes:
+        watch_fields: List of field names to watch for changes
+        similarity_threshold: Threshold for similarity search (0.0-1.0)
+        source_type: Type of external data source
+        auto_sync: Whether to automatically sync on changes
+        is_public: Whether data is public
+        title: Title for the external data (for create_from_config)
+        description: Description for the external data
+        content: Content for the external data
+        source_identifier: Source identifier
+        is_active: Whether the data is active
+        metadata: Additional metadata
+        tags: List of tags
+        source_config: Source configuration dict
+    """
+    # Core configuration fields
+    watch_fields: List[str] = field(default_factory=list)
+    similarity_threshold: float = 0.5
+    source_type: ExternalDataType = ExternalDataType.MODEL
+    auto_sync: bool = True
+    is_public: bool = False
+
+    # ExternalData creation fields (used by ExternalDataCreator)
+    title: str = ""
+    description: str = ""
+    content: str = ""
+    source_identifier: str = ""
+    is_active: bool = True
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    tags: List[str] = field(default_factory=list)
+    source_config: Dict[str, Any] = field(default_factory=dict)
+
+
+class ExternalDataMetaParser:
+    """
+    Parse ExternalDataMeta from model class.
+
+    Extracts configuration from model's ExternalDataMeta inner class
+    and applies smart defaults where needed.
+    """
+
+    @staticmethod
+    def parse(model_class) -> Dict[str, Any]:
+        """
+        Parse ExternalDataMeta configuration from model class.
+
+        Args:
+            model_class: Django model class with optional ExternalDataMeta
+
+        Returns:
+            Dictionary with parsed configuration and smart defaults
+        """
+        config = {}
+
+        # If ExternalDataMeta exists, use it
+        if hasattr(model_class, 'ExternalDataMeta'):
+            meta_class = model_class.ExternalDataMeta
+            # Extract configuration from ExternalDataMeta
+            for attr in dir(meta_class):
+                if not attr.startswith('_'):
+                    value = getattr(meta_class, attr)
+                    if not callable(value):  # Only properties, not methods
+                        config[attr] = value
+
+        # Smart defaults based on model analysis
+        if 'watch_fields' not in config:
+            analyzer = ExternalDataFieldAnalyzer(model_class)
+            config['watch_fields'] = analyzer.auto_detect_watch_fields()
+
+        if 'similarity_threshold' not in config:
+            config['similarity_threshold'] = 0.5  # Balanced default
+
+        if 'source_type' not in config:
+            config['source_type'] = ExternalDataType.MODEL  # Smart default
+
+        if 'auto_sync' not in config:
+            config['auto_sync'] = True  # Enable by default
+
+        if 'is_public' not in config:
+            config['is_public'] = False  # Private by default for security
+
+        return config
+
+    @staticmethod
+    def to_dataclass(model_class) -> ExternalDataMetaConfig:
+        """
+        Parse configuration and return as dataclass.
+
+        Args:
+            model_class: Django model class
+
+        Returns:
+            ExternalDataMetaConfig dataclass instance
+        """
+        config_dict = ExternalDataMetaParser.parse(model_class)
+        return ExternalDataMetaConfig(
+            watch_fields=config_dict.get('watch_fields', []),
+            similarity_threshold=config_dict.get('similarity_threshold', 0.5),
+            source_type=config_dict.get('source_type', ExternalDataType.MODEL),
+            auto_sync=config_dict.get('auto_sync', True),
+            is_public=config_dict.get('is_public', False),
+        )

django_cfg/apps/knowbase/mixins/creator.py

@@ -8,7 +8,7 @@ from django.contrib.auth import get_user_model
 from django.db import transaction
 from django.utils import timezone
 
-from .config import ExternalDataConfig
+from .config import ExternalDataMetaConfig
 from ..models.external_data import ExternalData, ExternalDataStatus
 
 logger = logging.getLogger(__name__)
@@ -25,12 +25,12 @@ class ExternalDataCreator:
         else:
             self.user = user
     
-    def create_from_config(self, config: ExternalDataConfig) -> Dict[str, Any]:
+    def create_from_config(self, config: ExternalDataMetaConfig) -> Dict[str, Any]:
         """
         Create an ExternalData object from a Pydantic configuration.
         
         Args:
-            config: An instance of ExternalDataConfig.
+            config: An instance of ExternalDataMetaConfig.
             
         Returns:
             dict: Result with success status, external_data object, and message/error.
@@ -72,10 +72,10 @@ class ExternalDataCreator:
     def _get_default_user(self):
         """Get default user for ExternalData ownership."""
         User = get_user_model()
-        
-        # Try to find a superuser
-        superuser = User.objects.filter(is_superuser=True).first()
-        if superuser:
-            return superuser
-        
-        raise ValueError("No user provided and no superuser found for ExternalData ownership")
+
+        # Try to find a staff user (staff or superuser)
+        staff_user = User.objects.filter(is_staff=True).first()
+        if staff_user:
+            return staff_user
+
+        raise ValueError("No user provided and no staff user found for ExternalData ownership")

django_cfg/apps/knowbase/mixins/examples/vehicle_model_example.py

@@ -0,0 +1,199 @@
+"""
+Example of using ExternalDataMixin with VehicleModel.
+
+This shows how to integrate VehicleModel with knowbase using the mixin.
+"""
+
+from django.db import models
+from django_cfg.apps.knowbase.mixins import ExternalDataMixin
+from django_cfg.apps.knowbase.models.external_data import ExternalDataType
+
+
+class VehicleModelWithMixin(ExternalDataMixin, models.Model):
+    """
+    Example VehicleModel with ExternalDataMixin integration.
+    
+    This replaces the manual integration we had before with automatic
+    tracking and vectorization.
+    """
+    
+    # Original VehicleModel fields
+    brand = models.ForeignKey('vehicles_data.Brand', on_delete=models.CASCADE)
+    code = models.CharField(max_length=20)
+    name = models.CharField(max_length=100)
+    body_type = models.CharField(max_length=20, blank=True)
+    segment = models.CharField(max_length=50, blank=True)
+    is_active = models.BooleanField(default=True)
+    total_vehicles = models.PositiveIntegerField(default=0)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    
+    class Meta:
+        abstract = True  # This is just an example
+    
+    class ExternalDataMeta:
+        # Fields to watch for changes - only update when these change
+        watch_fields = ['name', 'body_type', 'segment', 'is_active']
+        
+        # Lower threshold for multilingual vehicle data
+        similarity_threshold = 0.4
+        
+        # Vehicle models are model type
+        source_type = ExternalDataType.MODEL
+        
+        # Enable auto-sync
+        auto_sync = True
+        
+        # Make public for search
+        is_public = True
+    
+    # Required: content generation method
+    def get_external_content(self):
+        """Generate content for vectorization."""
+        content_parts = [
+            f"# {self.brand.name} {self.name}",
+            "",
+            "## Basic Information",
+            f"- **Brand**: {self.brand.name} ({self.brand.code})",
+            f"- **Model**: {self.name} ({self.code})",
+        ]
+        
+        if self.body_type:
+            content_parts.append(f"- **Body Type**: {self.body_type}")
+        
+        if self.segment:
+            content_parts.append(f"- **Market Segment**: {self.segment}")
+        
+        content_parts.extend([
+            f"- **Status**: {'Active' if self.is_active else 'Inactive'}",
+            "",
+            "## Market Statistics",
+            f"- **Total Listings**: {self.total_vehicles:,} vehicles available",
+        ])
+        
+        if hasattr(self, 'vehicles') and self.vehicles.exists():
+            # Add some vehicle statistics if available
+            vehicles = self.vehicles.filter(is_active=True)
+            if vehicles.exists():
+                content_parts.extend([
+                    "",
+                    "## Available Vehicles",
+                    f"- **Active Listings**: {vehicles.count():,} vehicles",
+                ])
+                
+                # Add price range if available
+                if hasattr(vehicles.first(), 'price'):
+                    prices = vehicles.exclude(price__isnull=True).values_list('price', flat=True)
+                    if prices:
+                        min_price = min(prices)
+                        max_price = max(prices)
+                        content_parts.append(f"- **Price Range**: ${min_price:,} - ${max_price:,}")
+        
+        content_parts.extend([
+            "",
+            f"## Model History",
+            f"- **First Listed**: {self.created_at.strftime('%Y-%m-%d')}",
+            f"- **Last Updated**: {self.updated_at.strftime('%Y-%m-%d')}",
+        ])
+        
+        return "\n".join(content_parts)
+    
+    # Optional: custom title
+    def get_external_title(self):
+        """Generate title for ExternalData."""
+        return f"Vehicle Model: {self.brand.name} {self.name}"
+    
+    # Optional: custom description
+    def get_external_description(self):
+        """Generate description for ExternalData."""
+        parts = [f"Comprehensive information about {self.brand.name} {self.name}"]
+        
+        if self.body_type:
+            parts.append(f"({self.body_type})")
+        
+        parts.append("including specifications, market data, and vehicle listings.")
+        
+        return " ".join(parts)
+    
+    # Optional: metadata
+    def get_external_metadata(self):
+        """Generate metadata for ExternalData."""
+        return {
+            'vehicle_model_id': str(self.id),
+            'brand_code': self.brand.code,
+            'brand_name': self.brand.name,
+            'model_code': self.code,
+            'model_name': self.name,
+            'body_type': self.body_type,
+            'segment': self.segment,
+            'total_vehicles': self.total_vehicles,
+            'is_active': self.is_active,
+            'created_at': self.created_at.isoformat(),
+            'updated_at': self.updated_at.isoformat(),
+            'integration_type': 'vehicle_model_mixin_auto'
+        }
+    
+    # Optional: tags
+    def get_external_tags(self):
+        """Generate tags for ExternalData."""
+        tags = [
+            'vehicle',
+            'model',
+            self.brand.code.lower(),
+            self.code.lower(),
+            self.brand.name.lower().replace(' ', '_'),
+            self.name.lower().replace(' ', '_'),
+        ]
+        
+        if self.body_type:
+            tags.append(self.body_type.lower().replace(' ', '_'))
+        
+        if self.segment:
+            tags.append(self.segment.lower().replace(' ', '_'))
+        
+        return tags
+    
+    @property
+    def full_name(self):
+        """Get full model name with brand."""
+        return f"{self.brand.name} {self.name}"
+    
+    def __str__(self):
+        return self.full_name
+
+
+# Usage example:
+"""
+# To use this mixin in your existing VehicleModel:
+
+1. Add the mixin to your model:
+   class VehicleModel(ExternalDataMixin, models.Model):
+       # ... your existing fields ...
+       
+       class ExternalDataMeta:
+           watch_fields = ['name', 'body_type', 'segment', 'is_active']
+           similarity_threshold = 0.4
+           source_type = ExternalDataType.MODEL
+           auto_sync = True
+           is_public = True
+       
+       def get_external_content(self):
+           # ... content generation logic ...
+           return content
+
+2. Run migrations to add the mixin fields:
+   python manage.py makemigrations
+   python manage.py migrate
+
+3. That's it! The mixin will automatically:
+   - Create ExternalData when VehicleModel is created
+   - Update ExternalData when watched fields change
+   - Delete ExternalData when VehicleModel is deleted
+   - Handle vectorization and search integration
+   
+4. Manual operations (if needed):
+   vehicle_model.regenerate_external_data()  # Force regeneration
+   vehicle_model.delete_external_data()      # Remove integration
+   vehicle_model.has_external_data          # Check if linked
+   vehicle_model.external_data_status       # Get processing status
+"""