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

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.0"
+__version__ = "1.4.4"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/apps/agents/examples/__init__.py

@@ -0,0 +1,3 @@
+"""
+Examples for Django Orchestrator.
+"""

django_cfg/apps/agents/examples/simple_example.py

@@ -0,0 +1,161 @@
+"""
+Simple example demonstrating Django Orchestrator usage.
+"""
+
+import asyncio
+from dataclasses import dataclass
+from pydantic import BaseModel
+from django.contrib.auth.models import User
+
+from django_cfg.modules.django_orchestrator import DjangoAgent, SimpleOrchestrator, DjangoDeps, RunContext
+
+
+# Define output model
+class GreetingResult(BaseModel):
+    """Result from greeting agent."""
+    greeting: str
+    personalized: bool
+    user_info: str
+
+
+# Create agent
+greeting_agent = DjangoAgent[DjangoDeps, GreetingResult](
+    name="greeting_agent",
+    deps_type=DjangoDeps,
+    output_type=GreetingResult,
+    instructions="Generate personalized greetings for users"
+)
+
+
+# Add tools to agent
+@greeting_agent.tool
+async def get_user_info(ctx: RunContext[DjangoDeps]) -> str:
+    """Get user information for personalization."""
+    user = ctx.deps.user
+    return f"User: {user.username}, Email: {user.email}, Joined: {user.date_joined}"
+
+
+@greeting_agent.tool
+async def get_time_of_day(ctx: RunContext[DjangoDeps]) -> str:
+    """Get current time of day for greeting."""
+    from datetime import datetime
+    hour = datetime.now().hour
+    
+    if hour < 12:
+        return "morning"
+    elif hour < 17:
+        return "afternoon"
+    else:
+        return "evening"
+
+
+async def simple_example():
+    """Run simple orchestrator example."""
+    print("🤖 Django Orchestrator Simple Example")
+    print("=" * 50)
+    
+    # Create test user (in real app, get from request)
+    try:
+        user = await User.objects.aget(username='testuser')
+    except User.DoesNotExist:
+        user = await User.objects.acreate_user(
+            username='testuser',
+            email='test@example.com',
+            first_name='Test',
+            last_name='User'
+        )
+    
+    # Create dependencies
+    deps = DjangoDeps(user=user)
+    
+    # Create orchestrator
+    orchestrator = SimpleOrchestrator()
+    orchestrator.register_agent(greeting_agent)
+    
+    # Execute single agent
+    print("\n1. Single Agent Execution:")
+    results = await orchestrator.execute(
+        pattern="sequential",
+        agents=["greeting_agent"],
+        prompt="Create a personalized greeting",
+        deps=deps
+    )
+    
+    result = results[0]
+    print(f"✅ Agent: {result.agent_name}")
+    print(f"✅ Output: {result.output}")
+    print(f"✅ Execution Time: {result.execution_time:.2f}s")
+    print(f"✅ Tokens Used: {result.tokens_used}")
+    
+    # Get metrics
+    print("\n2. Agent Metrics:")
+    metrics = greeting_agent.get_metrics()
+    for key, value in metrics.items():
+        print(f"📊 {key}: {value}")
+    
+    # Get orchestrator metrics
+    print("\n3. Orchestrator Metrics:")
+    orch_metrics = orchestrator.get_metrics()
+    for key, value in orch_metrics.items():
+        print(f"📈 {key}: {value}")
+
+
+async def multi_agent_example():
+    """Run multi-agent orchestrator example."""
+    print("\n🤖 Multi-Agent Example")
+    print("=" * 30)
+    
+    # Create additional agents
+    analyzer_agent = DjangoAgent[DjangoDeps, BaseModel](
+        name="content_analyzer",
+        deps_type=DjangoDeps,
+        output_type=BaseModel,
+        instructions="Analyze content sentiment and topics"
+    )
+    
+    formatter_agent = DjangoAgent[DjangoDeps, BaseModel](
+        name="content_formatter",
+        deps_type=DjangoDeps,
+        output_type=BaseModel,
+        instructions="Format content for display"
+    )
+    
+    # Create orchestrator
+    orchestrator = SimpleOrchestrator()
+    orchestrator.register_agent(analyzer_agent)
+    orchestrator.register_agent(formatter_agent)
+    
+    # Get user
+    user = await User.objects.aget(username='testuser')
+    deps = DjangoDeps(user=user)
+    
+    # Execute sequential workflow
+    print("\n1. Sequential Workflow:")
+    results = await orchestrator.execute(
+        pattern="sequential",
+        agents=["content_analyzer", "content_formatter"],
+        prompt="Analyze and format this content: Hello world!",
+        deps=deps
+    )
+    
+    for i, result in enumerate(results, 1):
+        print(f"Step {i} - {result.agent_name}: {result.success}")
+    
+    # Execute parallel workflow
+    print("\n2. Parallel Workflow:")
+    results = await orchestrator.execute(
+        pattern="parallel",
+        agents=["content_analyzer", "content_formatter"],
+        prompt="Process content in parallel",
+        deps=deps,
+        max_concurrent=2
+    )
+    
+    successful = sum(1 for r in results if r.success)
+    print(f"✅ {successful}/{len(results)} agents completed successfully")
+
+
+if __name__ == "__main__":
+    # Run examples
+    asyncio.run(simple_example())
+    asyncio.run(multi_agent_example())

django_cfg/apps/knowbase/examples/__init__.py

@@ -0,0 +1,3 @@
+"""
+Examples for using the External Data system in django_cfg.apps.knowbase.
+"""

django_cfg/apps/knowbase/examples/external_data_usage.py

@@ -0,0 +1,191 @@
+"""
+Примеры использования нового ExternalDataManager.
+
+Этот файл показывает, как легко интегрировать внешние данные в knowbase
+после рефакторинга.
+"""
+
+from django.contrib.auth import get_user_model
+from django_cfg.apps.knowbase.utils.external_data_manager import ExternalDataManager, quick_add_model, quick_search
+from django_cfg.apps.knowbase.models.external_data import ExternalDataType
+
+User = get_user_model()
+
+
+def example_add_django_model():
+    """Пример добавления Django модели как внешнего источника данных."""
+    
+    # Получаем пользователя
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    # Создаем менеджер
+    manager = ExternalDataManager(user)
+    
+    # Добавляем модель Vehicle (если она существует)
+    try:
+        from apps.vehicles_data.models import Vehicle
+        
+        external_data = manager.add_django_model(
+            model_class=Vehicle,
+            title="Vehicle Database",
+            fields=['brand__name', 'model', 'year', 'description'],
+            description="All vehicles from the database",
+            search_fields=['brand__name', 'model'],
+            chunk_size=800,
+            overlap_size=150,
+            auto_vectorize=True
+        )
+        
+        print(f"✅ Added Vehicle model as external data: {external_data.id}")
+        print(f"   Status: {external_data.status}")
+        print(f"   Total chunks: {external_data.total_chunks}")
+        
+    except ImportError:
+        print("⚠️ Vehicle model not found, using example data instead")
+        
+        # Добавляем произвольные данные
+        external_data = manager.add_custom_data(
+            title="Sample Car Data",
+            identifier="sample_cars",
+            content="""
+            Toyota Camry 2023: Reliable sedan with excellent fuel economy
+            Honda Civic 2023: Compact car perfect for city driving
+            BMW X5 2023: Luxury SUV with advanced features
+            Tesla Model 3 2023: Electric vehicle with autopilot
+            """,
+            description="Sample car data for testing",
+            tags=['cars', 'vehicles', 'sample']
+        )
+        
+        print(f"✅ Added sample car data: {external_data.id}")
+
+
+def example_search_external_data():
+    """Пример поиска по внешним данным."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    manager = ExternalDataManager(user)
+    
+    # Поиск по запросу
+    results = manager.search(
+        query="reliable car with good fuel economy",
+        limit=3,
+        threshold=0.6
+    )
+    
+    print(f"🔍 Search results ({len(results)} found):")
+    for i, result in enumerate(results, 1):
+        print(f"  {i}. {result['source_title']} (similarity: {result['similarity']:.3f})")
+        print(f"     Content: {result['content'][:100]}...")
+        print()
+
+
+def example_get_statistics():
+    """Пример получения статистики."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    manager = ExternalDataManager(user)
+    stats = manager.get_statistics()
+    
+    print("📊 External Data Statistics:")
+    print(f"   Total sources: {stats.total_sources}")
+    print(f"   Active sources: {stats.active_sources}")
+    print(f"   Processed sources: {stats.processed_sources}")
+    print(f"   Failed sources: {stats.failed_sources}")
+    print(f"   Total chunks: {stats.total_chunks}")
+    print(f"   Total tokens: {stats.total_tokens}")
+    print(f"   Total cost: ${stats.total_cost:.4f}")
+    print(f"   Source types: {stats.source_type_counts}")
+
+
+def example_health_check():
+    """Пример проверки здоровья системы."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    manager = ExternalDataManager(user)
+    health = manager.health_check()
+    
+    print("🏥 System Health Check:")
+    print(f"   Status: {health.status}")
+    print(f"   Healthy: {'✅' if health.healthy else '❌'}")
+    print(f"   Database: {'✅' if health.database_healthy else '❌'}")
+    print(f"   Embedding Service: {'✅' if health.embedding_service_healthy else '❌'}")
+    print(f"   Processing: {'✅' if health.processing_healthy else '❌'}")
+    print(f"   Response time: {health.response_time_ms:.2f}ms")
+    print(f"   Active sources: {health.active_sources}")
+    print(f"   Pending processing: {health.pending_processing}")
+    print(f"   Failed processing: {health.failed_processing}")
+    
+    if health.issues:
+        print(f"   Issues: {health.issues}")
+    if health.warnings:
+        print(f"   Warnings: {health.warnings}")
+
+
+def example_quick_functions():
+    """Пример использования быстрых функций."""
+    
+    user = User.objects.first()
+    if not user:
+        print("❌ No users found")
+        return
+    
+    # Быстрый поиск
+    results = quick_search(
+        user=user,
+        query="electric vehicle",
+        limit=2
+    )
+    
+    print(f"⚡ Quick search results: {len(results)} found")
+    for result in results:
+        print(f"   - {result['source_title']}: {result['similarity']:.3f}")
+
+
+def run_all_examples():
+    """Запустить все примеры."""
+    
+    print("🚀 Running External Data Manager Examples")
+    print("=" * 50)
+    
+    try:
+        print("\n1. Adding Django Model:")
+        example_add_django_model()
+        
+        print("\n2. Searching External Data:")
+        example_search_external_data()
+        
+        print("\n3. Getting Statistics:")
+        example_get_statistics()
+        
+        print("\n4. Health Check:")
+        example_health_check()
+        
+        print("\n5. Quick Functions:")
+        example_quick_functions()
+        
+        print("\n✅ All examples completed successfully!")
+        
+    except Exception as e:
+        print(f"\n❌ Error running examples: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    run_all_examples()

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
+"""

django_cfg/apps/urls.py

@@ -57,7 +57,7 @@ def get_django_cfg_urlpatterns() -> List[URLPattern]:
 
         # RPC Dashboard - WebSocket & RPC activity monitoring
         if base_module.is_rpc_enabled():
-            patterns.append(path('admin/rpc/', include('django_cfg.modules.django_cfg_rpc_client.dashboard.urls_admin')))
+            patterns.append(path('admin/rpc/', include('django_cfg.modules.django_ipc_client.dashboard.urls_admin')))
 
     except Exception:
         # Fallback: include all URLs if config is not available

django_cfg/core/base/config_model.py

@@ -30,7 +30,7 @@ from ...models import (
 from ...models.tasks import TaskConfig
 from ...models.payments import PaymentsConfig
 from ...models.ngrok import NgrokConfig
-from ...modules.django_cfg_rpc_client.config import DjangoCfgRPCConfig
+from ...modules.django_ipc_client.config import DjangoCfgRPCConfig
 
 
 class DjangoConfig(BaseModel):
@@ -305,7 +305,7 @@ class DjangoConfig(BaseModel):
     )
 
     # === RPC Client Configuration ===
-    django_cfg_rpc: Optional[DjangoCfgRPCConfig] = Field(
+    django_ipc: Optional[DjangoCfgRPCConfig] = Field(
         default=None,
         description="Django-CFG RPC Client configuration (WebSocket RPC communication)",
     )

django_cfg/core/builders/apps_builder.py

@@ -133,8 +133,8 @@ class InstalledAppsBuilder:
         if self.config.payments and self.config.payments.enabled:
             apps.append("django_cfg.apps.payments")
 
-        if self.config.django_cfg_rpc and self.config.django_cfg_rpc.enabled:
-            apps.append("django_cfg.modules.django_cfg_rpc_client.dashboard")
+        if self.config.django_ipc and self.config.django_ipc.enabled:
+            apps.append("django_cfg.modules.django_ipc_client.dashboard")
 
         return apps
 

django_cfg/core/generation/integration_generators/third_party.py

@@ -123,11 +123,11 @@ class ThirdPartyIntegrationsGenerator:
         Returns:
             Dictionary with RPC configuration
         """
-        if not hasattr(self.config, "django_cfg_rpc") or not self.config.django_cfg_rpc:
+        if not hasattr(self.config, "django_ipc") or not self.config.django_ipc:
             return {}
 
-        rpc_settings = self.config.django_cfg_rpc.to_django_settings()
-        self.integrations.append("django_cfg_rpc")
+        rpc_settings = self.config.django_ipc.to_django_settings()
+        self.integrations.append("django_ipc")
 
         return rpc_settings
 

django_cfg/modules/base.py

@@ -197,7 +197,7 @@ class BaseCfgModule(ABC):
         Returns:
             True if RPC Client is enabled, False otherwise
         """
-        rpc_config = self._get_config_key('django_cfg_rpc', None)
+        rpc_config = self._get_config_key('django_ipc', None)
 
         # Only handle DjangoCfgRPCConfig model
         if rpc_config and hasattr(rpc_config, 'enabled'):

django_cfg/modules/django_currency/examples/__init__.py

@@ -0,0 +1,3 @@
+"""
+Examples for currency module usage.
+"""