django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

django_cfg/apps/business/agents/patterns/content_agents.py

@@ -0,0 +1,235 @@
+"""
+Pre-built content processing agents.
+"""
+
+from typing import Any, Dict, List
+
+from pydantic import BaseModel, Field
+
+from ..core.django_agent import DjangoAgent
+from ..core.dependencies import ContentDeps, RunContext
+from ..core.models import ValidationResult
+
+
+class ContentAnalysisResult(BaseModel):
+    """Result from content analysis."""
+    sentiment: str = Field(..., description="Sentiment: positive, negative, neutral")
+    confidence: float = Field(..., ge=0.0, le=1.0, description="Confidence score")
+    topics: List[str] = Field(default_factory=list, description="Extracted topics")
+    keywords: List[str] = Field(default_factory=list, description="Key terms")
+    summary: str = Field(default="", description="Content summary")
+    readability_score: float = Field(default=0.0, ge=0.0, le=100.0)
+    word_count: int = Field(default=0, ge=0)
+    language: str = Field(default="unknown", description="Detected language")
+
+
+class ContentGenerationResult(BaseModel):
+    """Result from content generation."""
+    generated_content: str = Field(..., description="Generated content")
+    content_type: str = Field(..., description="Type of generated content")
+    word_count: int = Field(..., ge=0, description="Word count")
+    quality_score: float = Field(default=0.0, ge=0.0, le=1.0, description="Quality assessment")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+def ContentAnalyzerAgent() -> DjangoAgent[ContentDeps, ContentAnalysisResult]:
+    """
+    Create content analyzer agent.
+    
+    Analyzes content for:
+    - Sentiment analysis
+    - Topic extraction
+    - Keyword identification
+    - Readability assessment
+    - Language detection
+    """
+    agent = DjangoAgent[ContentDeps, ContentAnalysisResult](
+        name="content_analyzer",
+        deps_type=ContentDeps,
+        output_type=ContentAnalysisResult,
+        instructions="""
+        You are a content analysis expert. Analyze the provided content and extract:
+        
+        1. Sentiment (positive, negative, neutral) with confidence score
+        2. Main topics and themes
+        3. Important keywords and phrases
+        4. Content summary (2-3 sentences)
+        5. Readability assessment (0-100 scale)
+        6. Language detection
+        
+        Be thorough but concise in your analysis.
+        """
+    )
+
+    @agent.tool
+    async def analyze_text_structure(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
+        """Analyze text structure and formatting."""
+        # This would integrate with actual text analysis libraries
+        return {
+            "paragraphs": 0,
+            "sentences": 0,
+            "avg_sentence_length": 0.0,
+            "complexity_score": 0.0
+        }
+
+    @agent.tool
+    async def extract_entities(ctx: RunContext[ContentDeps]) -> List[Dict[str, str]]:
+        """Extract named entities from content."""
+        # This would integrate with NER libraries
+        return [
+            {"text": "example", "label": "PERSON", "confidence": 0.95}
+        ]
+
+    @agent.tool
+    async def get_content_metadata(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
+        """Get content metadata from dependencies."""
+        return {
+            "content_id": ctx.deps.content_id,
+            "content_type": ctx.deps.content_type,
+            "target_audience": ctx.deps.target_audience,
+            "user_id": ctx.deps.user.id
+        }
+
+    return agent
+
+
+def ContentGeneratorAgent() -> DjangoAgent[ContentDeps, ContentGenerationResult]:
+    """
+    Create content generator agent.
+    
+    Generates content based on:
+    - Content type requirements
+    - Target audience
+    - Style guidelines
+    - Length specifications
+    """
+    agent = DjangoAgent[ContentDeps, ContentGenerationResult](
+        name="content_generator",
+        deps_type=ContentDeps,
+        output_type=ContentGenerationResult,
+        instructions="""
+        You are a professional content writer. Generate high-quality content based on:
+        
+        1. Content type (article, blog post, social media, etc.)
+        2. Target audience preferences
+        3. Specified tone and style
+        4. Length requirements
+        5. SEO considerations if applicable
+        
+        Ensure the content is:
+        - Engaging and well-structured
+        - Appropriate for the target audience
+        - Original and creative
+        - Grammatically correct
+        - Optimized for readability
+        """
+    )
+
+    @agent.tool
+    async def get_style_guidelines(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
+        """Get style guidelines for content generation."""
+        return {
+            "tone": "professional",
+            "style": "informative",
+            "max_words": 1000,
+            "include_headers": True,
+            "target_audience": ctx.deps.target_audience
+        }
+
+    @agent.tool
+    async def check_content_requirements(ctx: RunContext[ContentDeps]) -> Dict[str, Any]:
+        """Check content requirements and constraints."""
+        return {
+            "content_type": ctx.deps.content_type,
+            "min_length": 300,
+            "max_length": 2000,
+            "required_keywords": [],
+            "forbidden_topics": []
+        }
+
+    @agent.tool
+    async def validate_generated_content(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
+        """Validate generated content quality."""
+        word_count = len(content.split())
+
+        return {
+            "word_count": word_count,
+            "quality_score": 0.85,  # This would be calculated by quality metrics
+            "passes_validation": word_count >= 100,
+            "suggestions": []
+        }
+
+    return agent
+
+
+def ContentValidatorAgent() -> DjangoAgent[ContentDeps, ValidationResult]:
+    """
+    Create content validator agent.
+    
+    Validates content for:
+    - Grammar and spelling
+    - Style consistency
+    - Factual accuracy
+    - Compliance with guidelines
+    - Plagiarism detection
+    """
+    agent = DjangoAgent[ContentDeps, ValidationResult](
+        name="content_validator",
+        deps_type=ContentDeps,
+        output_type=ValidationResult,
+        instructions="""
+        You are a content quality assurance expert. Validate content for:
+        
+        1. Grammar, spelling, and punctuation errors
+        2. Style consistency and readability
+        3. Factual accuracy and logical flow
+        4. Compliance with content guidelines
+        5. Potential plagiarism or copyright issues
+        
+        Provide specific feedback and suggestions for improvement.
+        Mark content as valid only if it meets all quality standards.
+        """
+    )
+
+    @agent.tool
+    async def check_grammar_spelling(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
+        """Check grammar and spelling."""
+        # This would integrate with grammar checking libraries
+        return {
+            "grammar_errors": [],
+            "spelling_errors": [],
+            "grammar_score": 0.95,
+            "suggestions": []
+        }
+
+    @agent.tool
+    async def check_style_consistency(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
+        """Check style consistency."""
+        return {
+            "style_score": 0.90,
+            "inconsistencies": [],
+            "tone_analysis": "consistent",
+            "readability_grade": 8.5
+        }
+
+    @agent.tool
+    async def check_content_guidelines(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
+        """Check compliance with content guidelines."""
+        return {
+            "guideline_compliance": True,
+            "violations": [],
+            "compliance_score": 0.98,
+            "recommendations": []
+        }
+
+    @agent.tool
+    async def check_factual_accuracy(ctx: RunContext[ContentDeps], content: str) -> Dict[str, Any]:
+        """Check factual accuracy of content."""
+        return {
+            "accuracy_score": 0.92,
+            "questionable_claims": [],
+            "fact_check_results": [],
+            "verification_needed": []
+        }
+
+    return agent

django_cfg/apps/business/knowbase/__init__.py

@@ -0,0 +1,27 @@
+"""
+Django SaaS Knowledge Assistant
+
+Enterprise-grade RAG (Retrieval-Augmented Generation) application built on Django 5.2
+with pgvector semantic search, ReArq background processing, and comprehensive
+API endpoints for document management and AI-powered chat.
+
+Key Features:
+- Document ingestion with automatic chunking and embedding generation
+- Semantic search using pgvector cosine similarity
+- RAG-powered chat with context retrieval
+- Multi-tenant user isolation
+- Background processing with ReArq
+- Cost tracking for LLM usage monitoring
+- Comprehensive admin interface with Unfold styling
+- Type-safe APIs with Pydantic v2 validation
+- Full test coverage
+
+Architecture:
+- Models: Document, DocumentChunk, ChatSession, ChatMessage
+- Services: DocumentService, ChatService, SearchService
+- Tasks: Async document processing, maintenance, optimization
+- APIs: REST endpoints with DRF and OpenAPI documentation
+- Admin: Unfold-optimized interfaces with statistics
+"""
+
+default_app_config = 'django_cfg.apps.business.knowbase.apps.KnowbaseConfig'

django_cfg/apps/business/knowbase/apps.py

@@ -0,0 +1,75 @@
+"""
+Knowledge Base App Configuration
+"""
+
+from django.apps import AppConfig
+from django.db.models.signals import post_migrate
+
+
+class KnowbaseConfig(AppConfig):
+    """Knowledge Base application configuration."""
+
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_cfg.apps.business.knowbase'
+    label = 'django_cfg_knowbase'
+    verbose_name = 'Django CFG Knowledge Base'
+
+    def ready(self):
+        """Initialize app when Django starts."""
+        # Import signals to register them
+
+        # Connect post-migrate signal for database setup
+        post_migrate.connect(self.create_pgvector_extension, sender=self)
+
+        # Note: Task system initialization removed - tasks are handled by Django-RQ
+        # Background tasks can be scheduled using django_rq.enqueue()
+
+    def create_pgvector_extension(self, sender, **kwargs):
+        """Create pgvector extension and indexes if they don't exist."""
+        import logging
+
+        from django.db import connection
+        logger = logging.getLogger(__name__)
+
+        try:
+            with connection.cursor() as cursor:
+                # Create extensions
+                cursor.execute("CREATE EXTENSION IF NOT EXISTS vector;")
+                cursor.execute("CREATE EXTENSION IF NOT EXISTS pg_trgm;")  # For text search
+                logger.info("✅ pgvector extensions created/verified")
+
+                # Create vector index for cosine similarity if table exists
+                cursor.execute("""
+                    SELECT EXISTS (
+                        SELECT FROM information_schema.tables 
+                        WHERE table_name = 'django_cfg_knowbase_document_chunks'
+                    );
+                """)
+                table_exists = cursor.fetchone()[0]
+
+                if table_exists:
+                    # Check if index already exists
+                    cursor.execute("""
+                        SELECT EXISTS (
+                            SELECT FROM pg_indexes 
+                            WHERE indexname = 'embedding_cosine_idx'
+                        );
+                    """)
+                    index_exists = cursor.fetchone()[0]
+
+                    if not index_exists:
+                        cursor.execute("""
+                            CREATE INDEX CONCURRENTLY IF NOT EXISTS embedding_cosine_idx 
+                            ON django_cfg_knowbase_document_chunks 
+                            USING ivfflat (embedding vector_cosine_ops) 
+                            WITH (lists = 100);
+                        """)
+                        logger.info("✅ Created embedding_cosine_idx index")
+                    else:
+                        logger.debug("✅ embedding_cosine_idx index already exists")
+                else:
+                    logger.debug("⏳ django_cfg_knowbase_document_chunks table not yet created, skipping index creation")
+
+        except Exception as e:
+            # Log warning but don't fail - extension/index might already exist
+            logger.warning(f"Could not create pgvector extension/indexes: {e}")

django_cfg/apps/business/knowbase/examples/__init__.py

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

django_cfg/apps/business/knowbase/examples/external_data_usage.py

@@ -0,0 +1,194 @@
+"""
+Примеры использования нового ExternalDataManager.
+
+Этот файл показывает, как легко интегрировать внешние данные в knowbase
+после рефакторинга.
+"""
+
+from django.contrib.auth import get_user_model
+
+from django_cfg.apps.business.knowbase.utils.external_data_manager import (
+    ExternalDataManager,
+    quick_search,
+)
+
+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()