django-cfg 1.1.82__py3-none-any.whl → 1.2.0__py3-none-any.whl

django_cfg/apps/agents/patterns/content_agents.py

@@ -0,0 +1,234 @@
+"""
+Pre-built content processing agents.
+"""
+
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any
+
+from ..core.agent import DjangoAgent
+from ..core.dependencies import ContentDeps, RunContext
+from ..core.models import AnalysisResult, ProcessResult, 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/agents/toolsets/__init__.py

@@ -0,0 +1,15 @@
+"""
+Django-specific toolsets for agent orchestration.
+"""
+
+from .django_toolset import DjangoToolset
+from .orm_toolset import ORMToolset
+from .cache_toolset import CacheToolset
+from .file_toolset import FileToolset
+
+__all__ = [
+    "DjangoToolset",
+    "ORMToolset", 
+    "CacheToolset",
+    "FileToolset",
+]

django_cfg/apps/agents/toolsets/cache_toolset.py

@@ -0,0 +1,285 @@
+"""
+Django cache toolset for caching operations.
+"""
+
+import logging
+from typing import Any, Optional, Dict, List
+from pydantic_ai.toolsets import AbstractToolset
+from pydantic_ai import RunContext
+from django.core.cache import cache, caches
+
+from ..core.dependencies import DjangoDeps
+
+logger = logging.getLogger(__name__)
+
+
+class CacheToolset(AbstractToolset[DjangoDeps]):
+    """
+    Django cache toolset for caching operations.
+    
+    Provides tools for:
+    - Cache get/set operations
+    - Cache key management
+    - Cache statistics
+    - Multi-cache support
+    """
+    
+    def __init__(self, cache_alias: str = 'default', key_prefix: str = 'orchestrator'):
+        """
+        Initialize cache toolset.
+        
+        Args:
+            cache_alias: Django cache alias to use
+            key_prefix: Prefix for all cache keys
+        """
+        self.cache_alias = cache_alias
+        self.key_prefix = key_prefix
+    
+    @property
+    def id(self) -> str:
+        return f"django_cache_{self.cache_alias}"
+    
+    def _get_cache(self):
+        """Get cache instance."""
+        if self.cache_alias == 'default':
+            return cache
+        else:
+            return caches[self.cache_alias]
+    
+    def _make_key(self, key: str, user_id: Optional[int] = None) -> str:
+        """Create cache key with prefix and optional user scope."""
+        parts = [self.key_prefix]
+        
+        if user_id:
+            parts.append(f"user_{user_id}")
+        
+        parts.append(key)
+        
+        return ':'.join(parts)
+    
+    async def get_cached_value(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        key: str,
+        user_scoped: bool = False
+    ) -> Any:
+        """Get value from cache."""
+        cache_instance = self._get_cache()
+        
+        user_id = ctx.deps.user.id if user_scoped else None
+        cache_key = self._make_key(key, user_id)
+        
+        try:
+            value = cache_instance.get(cache_key)
+            logger.debug(f"Cache get: {cache_key} -> {'HIT' if value is not None else 'MISS'}")
+            return value
+        except Exception as e:
+            logger.error(f"Cache get failed for key '{cache_key}': {e}")
+            return None
+    
+    async def set_cached_value(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        key: str,
+        value: Any,
+        timeout: Optional[int] = None,
+        user_scoped: bool = False
+    ) -> bool:
+        """Set value in cache."""
+        cache_instance = self._get_cache()
+        
+        user_id = ctx.deps.user.id if user_scoped else None
+        cache_key = self._make_key(key, user_id)
+        
+        try:
+            cache_instance.set(cache_key, value, timeout)
+            logger.debug(f"Cache set: {cache_key} (timeout: {timeout})")
+            return True
+        except Exception as e:
+            logger.error(f"Cache set failed for key '{cache_key}': {e}")
+            return False
+    
+    async def delete_cached_value(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        key: str,
+        user_scoped: bool = False
+    ) -> bool:
+        """Delete value from cache."""
+        cache_instance = self._get_cache()
+        
+        user_id = ctx.deps.user.id if user_scoped else None
+        cache_key = self._make_key(key, user_id)
+        
+        try:
+            result = cache_instance.delete(cache_key)
+            logger.debug(f"Cache delete: {cache_key} -> {result}")
+            return bool(result)
+        except Exception as e:
+            logger.error(f"Cache delete failed for key '{cache_key}': {e}")
+            return False
+    
+    async def get_or_set_cached_value(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        key: str,
+        default_value: Any,
+        timeout: Optional[int] = None,
+        user_scoped: bool = False
+    ) -> Any:
+        """Get value from cache or set default if not exists."""
+        cache_instance = self._get_cache()
+        
+        user_id = ctx.deps.user.id if user_scoped else None
+        cache_key = self._make_key(key, user_id)
+        
+        try:
+            value = cache_instance.get_or_set(cache_key, default_value, timeout)
+            logger.debug(f"Cache get_or_set: {cache_key}")
+            return value
+        except Exception as e:
+            logger.error(f"Cache get_or_set failed for key '{cache_key}': {e}")
+            return default_value
+    
+    async def increment_cached_value(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        key: str,
+        delta: int = 1,
+        user_scoped: bool = False
+    ) -> Optional[int]:
+        """Increment numeric value in cache."""
+        cache_instance = self._get_cache()
+        
+        user_id = ctx.deps.user.id if user_scoped else None
+        cache_key = self._make_key(key, user_id)
+        
+        try:
+            # Check if cache backend supports increment
+            if hasattr(cache_instance, 'incr'):
+                try:
+                    value = cache_instance.incr(cache_key, delta)
+                    logger.debug(f"Cache increment: {cache_key} += {delta} -> {value}")
+                    return value
+                except ValueError:
+                    # Key doesn't exist, set initial value
+                    cache_instance.set(cache_key, delta)
+                    return delta
+            else:
+                # Fallback for backends without increment support
+                current = cache_instance.get(cache_key, 0)
+                new_value = current + delta
+                cache_instance.set(cache_key, new_value)
+                return new_value
+        except Exception as e:
+            logger.error(f"Cache increment failed for key '{cache_key}': {e}")
+            return None
+    
+    async def get_cache_keys(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        pattern: Optional[str] = None,
+        user_scoped: bool = False
+    ) -> List[str]:
+        """Get cache keys matching pattern."""
+        cache_instance = self._get_cache()
+        
+        # This is backend-dependent and may not work with all cache backends
+        try:
+            if hasattr(cache_instance, 'keys'):
+                if pattern:
+                    user_id = ctx.deps.user.id if user_scoped else None
+                    search_pattern = self._make_key(pattern, user_id)
+                    keys = cache_instance.keys(search_pattern)
+                else:
+                    keys = cache_instance.keys(f"{self.key_prefix}:*")
+                
+                return list(keys)
+            else:
+                logger.warning("Cache backend does not support key listing")
+                return []
+        except Exception as e:
+            logger.error(f"Failed to get cache keys: {e}")
+            return []
+    
+    async def clear_user_cache(self, ctx: RunContext[DjangoDeps]) -> bool:
+        """Clear all cache entries for current user."""
+        user_id = ctx.deps.user.id
+        pattern = f"{self.key_prefix}:user_{user_id}:*"
+        
+        try:
+            keys = await self.get_cache_keys(ctx, pattern="*", user_scoped=True)
+            
+            if keys:
+                cache_instance = self._get_cache()
+                cache_instance.delete_many(keys)
+                logger.info(f"Cleared {len(keys)} cache entries for user {user_id}")
+            
+            return True
+        except Exception as e:
+            logger.error(f"Failed to clear user cache for user {user_id}: {e}")
+            return False
+    
+    async def get_cache_stats(self, ctx: RunContext[DjangoDeps]) -> Dict[str, Any]:
+        """Get cache statistics (if supported by backend)."""
+        cache_instance = self._get_cache()
+        
+        stats = {
+            'cache_alias': self.cache_alias,
+            'key_prefix': self.key_prefix,
+            'backend': cache_instance.__class__.__name__,
+        }
+        
+        try:
+            # Try to get backend-specific stats
+            if hasattr(cache_instance, '_cache') and hasattr(cache_instance._cache, 'get_stats'):
+                # Memcached backend
+                backend_stats = cache_instance._cache.get_stats()
+                stats['backend_stats'] = backend_stats
+            elif hasattr(cache_instance, 'info'):
+                # Redis backend
+                info = cache_instance.info()
+                stats['backend_stats'] = {
+                    'used_memory': info.get('used_memory_human'),
+                    'connected_clients': info.get('connected_clients'),
+                    'total_commands_processed': info.get('total_commands_processed'),
+                }
+            
+            # Get key count if possible
+            keys = await self.get_cache_keys(ctx)
+            stats['total_keys'] = len(keys)
+            
+        except Exception as e:
+            logger.warning(f"Could not get cache stats: {e}")
+            stats['error'] = str(e)
+        
+        return stats
+    
+    async def touch_cached_value(
+        self, 
+        ctx: RunContext[DjangoDeps], 
+        key: str,
+        timeout: Optional[int] = None,
+        user_scoped: bool = False
+    ) -> bool:
+        """Update cache key timeout without changing value."""
+        cache_instance = self._get_cache()
+        
+        user_id = ctx.deps.user.id if user_scoped else None
+        cache_key = self._make_key(key, user_id)
+        
+        try:
+            if hasattr(cache_instance, 'touch'):
+                result = cache_instance.touch(cache_key, timeout)
+                logger.debug(f"Cache touch: {cache_key} -> {result}")
+                return result
+            else:
+                # Fallback: get and set with new timeout
+                value = cache_instance.get(cache_key)
+                if value is not None:
+                    cache_instance.set(cache_key, value, timeout)
+                    return True
+                return False
+        except Exception as e:
+            logger.error(f"Cache touch failed for key '{cache_key}': {e}")
+            return False