django-cfg 1.4.21__py3-none-any.whl → 1.4.24__py3-none-any.whl

django_cfg/apps/knowbase/mixins/__init__.py

@@ -2,15 +2,15 @@
 Mixins for knowbase integration.
 """
 
-from .external_data_mixin import ExternalDataMixin
-from .config import ExternalDataMetaConfig, ExternalDataMetaParser, ExternalDataDefaults
+from .config import ExternalDataDefaults, ExternalDataMetaConfig, ExternalDataMetaParser
 from .creator import ExternalDataCreator
-from .service import ExternalDataService
+from .external_data_mixin import ExternalDataMixin
 from .generators import (
     ExternalDataContentGenerator,
-    ExternalDataMetadataGenerator,
     ExternalDataFieldAnalyzer,
+    ExternalDataMetadataGenerator,
 )
+from .service import ExternalDataService
 
 __all__ = [
     # Core mixin

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

@@ -4,8 +4,8 @@ Configuration utilities for ExternalData.
 Parsing and defaults for ExternalDataMeta configuration.
 """
 
-from .meta_config import ExternalDataMetaConfig, ExternalDataMetaParser
 from .defaults import ExternalDataDefaults
+from .meta_config import ExternalDataMetaConfig, ExternalDataMetaParser
 
 __all__ = [
     'ExternalDataMetaConfig',

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

@@ -5,7 +5,7 @@ Handles parsing and processing of ExternalDataMeta configuration from model clas
 """
 
 from dataclasses import dataclass, field
-from typing import List, Dict, Any
+from typing import Any, Dict, List
 
 from ...models.external_data import ExternalDataType
 from ..generators import ExternalDataFieldAnalyzer

django_cfg/apps/knowbase/mixins/config.py

@@ -2,22 +2,23 @@
 Configuration classes for ExternalDataMixin.
 """
 
-from typing import Optional, Dict, Any, List
-from pydantic import BaseModel, Field, field_validator, ConfigDict
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 from ..models.external_data import ExternalDataType
 
 
 class ExternalDataConfig(BaseModel):
     """Configuration for ExternalData creation with Pydantic2 validation."""
-    
+
     model_config = ConfigDict(
         validate_assignment=True,
         extra="forbid",
         str_strip_whitespace=True,
         validate_default=True
     )
-    
+
     # Basic information
     title: str = Field(
         ...,
@@ -25,32 +26,32 @@ class ExternalDataConfig(BaseModel):
         max_length=512,
         description="Human-readable title for the external data source"
     )
-    
+
     description: Optional[str] = Field(
         default="",
         max_length=2000,
         description="Description of what this external data contains"
     )
-    
+
     # Source configuration
     source_type: ExternalDataType = Field(
         default=ExternalDataType.MODEL,
         description="Type of external data source"
     )
-    
+
     source_identifier: str = Field(
         ...,
         min_length=1,
         max_length=255,
         description="Unique identifier for the data source"
     )
-    
+
     # Content
     content: str = Field(
         default="",
         description="Extracted text content for vectorization"
     )
-    
+
     # Search and processing settings
     similarity_threshold: float = Field(
         default=0.5,
@@ -58,47 +59,47 @@ class ExternalDataConfig(BaseModel):
         le=1.0,
         description="Similarity threshold for search (0.0-1.0)"
     )
-    
+
     # Visibility settings
     is_active: bool = Field(
         default=True,
         description="Whether this data source is active for search"
     )
-    
+
     is_public: bool = Field(
         default=False,
         description="Whether this data is publicly searchable"
     )
-    
+
     # Additional data
     metadata: Dict[str, Any] = Field(
         default_factory=dict,
         description="Additional metadata from the source"
     )
-    
+
     source_config: Dict[str, Any] = Field(
         default_factory=dict,
         description="Configuration for data extraction"
     )
-    
+
     tags: List[str] = Field(
         default_factory=list,
         description="Tags for categorization and filtering"
     )
-    
+
     @field_validator('tags')
     @classmethod
     def validate_tags(cls, v):
         """Validate tags are non-empty strings."""
         if not isinstance(v, list):
             raise ValueError('Tags must be a list of strings')
-        
+
         for tag in v:
             if not isinstance(tag, str) or not tag.strip():
                 raise ValueError('Each tag must be a non-empty string')
-        
+
         return [tag.strip() for tag in v]
-    
+
     @field_validator('metadata', 'source_config')
     @classmethod
     def validate_json_fields(cls, v):

django_cfg/apps/knowbase/mixins/creator.py

@@ -3,13 +3,13 @@ ExternalData creator for the mixin.
 """
 
 import logging
-from typing import Optional, Dict, Any
+from typing import Any, Dict
+
 from django.contrib.auth import get_user_model
 from django.db import transaction
-from django.utils import timezone
 
-from .config import ExternalDataMetaConfig
 from ..models.external_data import ExternalData, ExternalDataStatus
+from .config import ExternalDataMetaConfig
 
 logger = logging.getLogger(__name__)
 
@@ -18,13 +18,13 @@ class ExternalDataCreator:
     """
     Creator class for ExternalData objects with validation.
     """
-    
+
     def __init__(self, user=None):
         if user is None:
             self.user = self._get_default_user()
         else:
             self.user = user
-    
+
     def create_from_config(self, config: ExternalDataMetaConfig) -> Dict[str, Any]:
         """
         Create an ExternalData object from a Pydantic configuration.
@@ -54,7 +54,7 @@ class ExternalDataCreator:
                     processed_at=None,
                     processing_error="",
                 )
-                
+
                 logger.info(f"Created ExternalData: {external_data.title} (ID: {external_data.id})")
                 return {
                     'success': True,
@@ -68,7 +68,7 @@ class ExternalDataCreator:
                 'error': f"Failed to create ExternalData: {e}",
                 'external_data': None
             }
-    
+
     def _get_default_user(self):
         """Get default user for ExternalData ownership."""
         User = get_user_model()

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

@@ -5,6 +5,7 @@ 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
 
@@ -16,7 +17,7 @@ class VehicleModelWithMixin(ExternalDataMixin, models.Model):
     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)
@@ -27,26 +28,26 @@ class VehicleModelWithMixin(ExternalDataMixin, models.Model):
     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."""
@@ -57,20 +58,20 @@ class VehicleModelWithMixin(ExternalDataMixin, models.Model):
             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)
@@ -80,7 +81,7 @@ class VehicleModelWithMixin(ExternalDataMixin, models.Model):
                     "## 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)
@@ -88,33 +89,33 @@ class VehicleModelWithMixin(ExternalDataMixin, models.Model):
                         min_price = min(prices)
                         max_price = max(prices)
                         content_parts.append(f"- **Price Range**: ${min_price:,} - ${max_price:,}")
-        
+
         content_parts.extend([
             "",
-            f"## Model History",
+            "## 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."""
@@ -132,7 +133,7 @@ class VehicleModelWithMixin(ExternalDataMixin, models.Model):
             'updated_at': self.updated_at.isoformat(),
             'integration_type': 'vehicle_model_mixin_auto'
         }
-    
+
     # Optional: tags
     def get_external_tags(self):
         """Generate tags for ExternalData."""
@@ -144,20 +145,20 @@ class VehicleModelWithMixin(ExternalDataMixin, models.Model):
             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
 

django_cfg/apps/knowbase/mixins/external_data_mixin.py

@@ -56,15 +56,16 @@ Usage:
             return ['my_model', self.name.lower()]
 """
 
-import logging
 import hashlib
-from typing import Optional, List, Dict, Any
+import logging
+from typing import Any, Dict, List, Optional
+
 from django.db import models
-from django.db.models.signals import post_save, post_delete
+from django.db.models.signals import post_delete, post_save
 
-from ..models.external_data import ExternalData, ExternalDataType, ExternalDataStatus
-from .creator import ExternalDataCreator
+from ..models.external_data import ExternalData, ExternalDataStatus, ExternalDataType
 from .config import ExternalDataMetaConfig, ExternalDataMetaParser
+from .creator import ExternalDataCreator
 from .generators import (
     ExternalDataContentGenerator,
     ExternalDataMetadataGenerator,

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

@@ -6,8 +6,8 @@ of ExternalData from Django model instances.
 """
 
 from .content_generator import ExternalDataContentGenerator
-from .metadata_generator import ExternalDataMetadataGenerator
 from .field_analyzer import ExternalDataFieldAnalyzer
+from .metadata_generator import ExternalDataMetadataGenerator
 
 __all__ = [
     'ExternalDataContentGenerator',

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

@@ -4,7 +4,7 @@ Content and title generation for ExternalData.
 Handles automatic generation of titles and markdown content from model instances.
 """
 
-from typing import List, Dict, Any, Tuple
+from typing import Any, Dict, List, Tuple
 
 
 class ExternalDataContentGenerator:
@@ -104,7 +104,7 @@ class ExternalDataContentGenerator:
             f"This data is automatically synchronized from the {self.model_class.__name__} "
             f"model using ExternalDataMixin."
         )
-        content_parts.append(f"")
+        content_parts.append("")
         content_parts.append(f"**Model**: {self.model_class._meta.label}")
         content_parts.append(f"**ID**: {self.instance.pk}")