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

django_cfg/apps/agents/patterns/content_agents.py

@@ -1,235 +0,0 @@
-"""
-Pre-built content processing agents.
-"""
-
-from typing import Any, Dict, List
-
-from pydantic import BaseModel, Field
-
-from ..core.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/ipc/README.md

@@ -1,346 +0,0 @@
-# Django-CFG RPC Client 📡
-
-Lightweight synchronous RPC client for Django applications to communicate with **django-ipc** WebSocket servers via Redis.
-
-**NEW**: ✨ Built-in RPC Dashboard for real-time monitoring! See [Dashboard README](./dashboard/README.md)
-
-## 🎯 Key Features
-
-- ✅ **100% Synchronous** - No async/await in Django, works with WSGI
-- ✅ **Type-Safe** - Full Pydantic 2 support when django-ipc installed
-- ✅ **Optional Dependency** - Works without django-ipc (dict-based fallback)
-- ✅ **Redis IPC** - Reliable communication via Streams + Lists
-- ✅ **Connection Pooling** - Automatic Redis connection management
-- ✅ **Singleton Pattern** - Single client instance across Django app
-
----
-
-## 📦 Installation
-
-### Option 1: With django-ipc (Recommended)
-
-```bash
-pip install django-cfg django-ipc
-```
-
-### Option 2: Standalone (Basic)
-
-```bash
-pip install django-cfg redis
-```
-
----
-
-## ⚙️ Configuration
-
-### Django Settings (via django-cfg)
-
-```python
-# config.py
-from django_cfg import DjangoConfig
-from django_cfg.modules.django_ipc_client.config import DjangoCfgRPCConfig
-
-class MyProjectConfig(DjangoConfig):
-    project_name = "My Project"
-
-    # RPC Client Configuration
-    django_ipc = DjangoCfgRPCConfig(
-        enabled=True,
-        redis_url="redis://localhost:6379/2",
-        rpc_timeout=30,
-    )
-
-config = MyProjectConfig()
-
-# settings.py
-from config import config
-
-# Settings are automatically generated by django-cfg orchestrator
-# DJANGO_CFG_RPC settings will be available in Django settings
-globals().update(config.get_all_settings())
-```
-
-**✨ Automatic Integration:**
-- ✅ `DJANGO_CFG_RPC` settings are auto-generated
-- ✅ Dashboard app auto-added to `INSTALLED_APPS`
-- ✅ Dashboard URLs auto-registered at `/admin/rpc/`
-- ✅ RPC tracked in `DJANGO_CFG_INTEGRATIONS` list
-
-### Environment Variables
-
-```bash
-DJANGO_CFG_RPC__ENABLED=true
-DJANGO_CFG_RPC__REDIS_URL=redis://localhost:6379/2
-DJANGO_CFG_RPC__RPC_TIMEOUT=30
-```
-
----
-
-## 🚀 Usage
-
-### With django-ipc Models (Type-Safe)
-
-```python
-# views.py
-from django_cfg.modules.django_ipc_client import get_rpc_client
-from django_ipc.models import NotificationRequest, NotificationResponse
-
-rpc = get_rpc_client()
-
-def notify_user(request, user_id):
-    """Send notification to user via WebSocket."""
-
-    result: NotificationResponse = rpc.call(
-        method="send_notification",
-        params=NotificationRequest(
-            user_id=user_id,
-            type="order_update",
-            title="Order Confirmed",
-            message="Your order #12345 has been confirmed",
-            priority="high",
-        ),
-        result_model=NotificationResponse,
-        timeout=10,
-    )
-
-    return JsonResponse({
-        "delivered": result.delivered,
-        "connections": result.connections,
-    })
-```
-
-### Without django-ipc (Dict-Based)
-
-```python
-from django_cfg.modules.django_ipc_client import get_rpc_client
-
-rpc = get_rpc_client()
-
-def notify_user(request, user_id):
-    """Send notification using dict params."""
-
-    result = rpc.call_dict(
-        method="send_notification",
-        params={
-            "user_id": user_id,
-            "type": "order_update",
-            "title": "Order Confirmed",
-            "message": "Your order #12345 has been confirmed",
-        },
-        timeout=10,
-    )
-
-    return JsonResponse({
-        "delivered": result.get("delivered", False),
-    })
-```
-
-### Fire-and-Forget (No Response Wait)
-
-```python
-# For operations where you don't need the result
-rpc.fire_and_forget(
-    method="log_event",
-    params={"event": "user_login", "user_id": "123"}
-)
-```
-
----
-
-## 🔧 API Reference
-
-### `get_rpc_client(force_new=False)`
-
-Get singleton RPC client instance.
-
-**Args:**
-- `force_new` (bool): Force create new instance (for testing)
-
-**Returns:**
-- `DjangoCfgRPCClient` instance
-
----
-
-### `DjangoCfgRPCClient.call(method, params, result_model=None, timeout=None)`
-
-Make synchronous RPC call.
-
-**Args:**
-- `method` (str): RPC method name
-- `params` (BaseModel | dict): Parameters (Pydantic model or dict)
-- `result_model` (Type[BaseModel], optional): Expected result model class
-- `timeout` (int, optional): Timeout override in seconds
-
-**Returns:**
-- Pydantic model instance (if `result_model` provided) or dict
-
-**Raises:**
-- `RPCTimeoutError`: If timeout exceeded
-- `RPCRemoteError`: If remote execution failed
-
----
-
-### `DjangoCfgRPCClient.call_dict(method, params, timeout=None)`
-
-Make RPC call with dict params (no Pydantic).
-
-**Args:**
-- `method` (str): RPC method name
-- `params` (dict): Dictionary with parameters
-- `timeout` (int, optional): Timeout override in seconds
-
-**Returns:**
-- Dictionary with result
-
----
-
-### `DjangoCfgRPCClient.fire_and_forget(method, params)`
-
-Send RPC request without waiting for response.
-
-**Args:**
-- `method` (str): RPC method name
-- `params` (BaseModel | dict): Parameters
-
-**Returns:**
-- str: Message ID from Redis Stream
-
----
-
-### `DjangoCfgRPCClient.health_check(timeout=5)`
-
-Check if RPC system is healthy.
-
-**Args:**
-- `timeout` (int): Health check timeout in seconds
-
-**Returns:**
-- bool: True if healthy, False otherwise
-
----
-
-## ⚠️ Error Handling
-
-### Timeout Handling
-
-```python
-from django_cfg.modules.django_ipc_client import get_rpc_client, RPCTimeoutError
-
-rpc = get_rpc_client()
-
-try:
-    result = rpc.call(method="slow_operation", params={...}, timeout=5)
-except RPCTimeoutError as e:
-    logger.warning(f"RPC timeout: {e.method} after {e.timeout_seconds}s")
-    # Handle timeout (retry, fallback, etc.)
-```
-
-### Remote Error Handling
-
-```python
-from django_cfg.modules.django_ipc_client import RPCRemoteError
-
-try:
-    result = rpc.call(method="...", params={...})
-except RPCRemoteError as e:
-    logger.error(f"Remote error [{e.error.code}]: {e.error.message}")
-
-    if e.is_retryable:
-        # Retry after delay
-        import time
-        time.sleep(e.retry_after or 5)
-        result = rpc.call(...)  # Retry
-    else:
-        # Non-retryable error
-        raise
-```
-
----
-
-## 🏗️ Architecture
-
-```
-┌─────────────────────────────────────────────┐
-│       Django Application (WSGI/Sync)        │
-│  ┌───────────────────────────────────────┐  │
-│  │  django_ipc_client                │  │
-│  │  - DjangoCfgRPCClient (sync)          │  │
-│  │  - Redis Streams (requests)           │  │
-│  │  - Redis Lists (responses)            │  │
-│  └───────────────────────────────────────┘  │
-└───────────────┬─────────────────────────────┘
-                │
-                │ Redis IPC
-                │ (stream:requests → list:response:{cid})
-                ▼
-┌─────────────────────────────────────────────┐
-│     django-ipc Server (Async)           │
-│  - WebSocket Server                         │
-│  - Connection Manager                       │
-│  - RPC Handlers                             │
-│  - Pydantic 2 Models                        │
-└─────────────────────────────────────────────┘
-```
-
----
-
-## 🔗 Related
-
-- **django-ipc** - WebSocket RPC server package
-- **Old Module** - `django_rpc_old` (deprecated, kept for reference)
-
----
-
-## 📝 Migration from django_rpc_old
-
-```python
-# Old (deprecated)
-from django_cfg.modules.django_rpc import get_rpc_client
-
-# New (current)
-from django_cfg.modules.django_ipc_client import get_rpc_client
-```
-
-API remains mostly compatible. Main changes:
-- Configuration key: `WEBSOCKET_RPC` → `DJANGO_CFG_RPC`
-- Models now live in `django-ipc` package (optional dependency)
-- Better error handling with specific exception types
-
----
-
-**Status:** ✅ Production Ready
-**Django-CFG Version:** 2.0+
-**Python Version:** 3.10+
-
-
----
-
-## 📊 RPC Dashboard (NEW!)
-
-### Quick Start
-
-Add dashboard to your Django URLs:
-
-```python
-# urls.py
-from django.urls import path, include
-
-urlpatterns = [
-    # ... other URLs
-    path('admin/rpc/', include('django_cfg.modules.django_ipc_client.dashboard.urls')),
-]
-```
-
-Access at: **http://localhost:8000/admin/rpc/** (requires staff login)
-
-### Features
-
-- ✅ **Real-time monitoring** - Updates every 5 seconds
-- ✅ **Request tracking** - View recent RPC calls
-- ✅ **Notification stats** - Track sent notifications  
-- ✅ **Method analytics** - See which methods are called
-- ✅ **Health checks** - Monitor Redis and streams
-- ✅ **Beautiful UI** - Tailwind CSS dark mode
-
-See [Dashboard README](./dashboard/README.md) for full documentation.
-

django_cfg/apps/ipc/__init__.py

@@ -1,51 +0,0 @@
-"""
-Django-CFG RPC Client Module.
-
-Lightweight synchronous RPC client for Django applications to communicate
-with django-cfg-rpc WebSocket servers via Redis.
-
-Key Features:
-- ✅ 100% synchronous (no async/await in Django)
-- ✅ Type-safe with Pydantic 2 models from django-cfg-rpc
-- ✅ Automatic connection pooling
-- ✅ Optional dependency on django-cfg-rpc
-- ✅ Graceful fallback if django-cfg-rpc not installed
-
-Example:
-    >>> from django_cfg.modules.django_ipc_client import get_rpc_client
-    >>> from django_ipc.models import NotificationRequest, NotificationResponse
-    >>>
-    >>> rpc = get_rpc_client()
-    >>> result: NotificationResponse = rpc.call(
-    ...     method="send_notification",
-    ...     params=NotificationRequest(
-    ...         user_id="123",
-    ...         type="order_update",
-    ...         title="Order Confirmed",
-    ...         message="Your order has been confirmed"
-    ...     ),
-    ...     result_model=NotificationResponse
-    ... )
-"""
-
-from .services.client.client import DjangoCfgRPCClient, get_rpc_client
-from .services.client.config import DjangoCfgRPCConfig
-from .services.client.exceptions import (
-    RPCConfigurationError,
-    RPCConnectionError,
-    RPCRemoteError,
-    RPCTimeoutError,
-)
-
-__all__ = [
-    # Client
-    "DjangoCfgRPCClient",
-    "get_rpc_client",
-    # Configuration
-    "DjangoCfgRPCConfig",
-    # Exceptions
-    "RPCTimeoutError",
-    "RPCRemoteError",
-    "RPCConnectionError",
-    "RPCConfigurationError",
-]

django_cfg/apps/ipc/apps.py

@@ -1,28 +0,0 @@
-"""
-Django app configuration for IPC/RPC module.
-
-Provides RPC client and monitoring dashboard.
-"""
-
-from django.apps import AppConfig
-
-
-class IPCConfig(AppConfig):
-    """
-    IPC/RPC application configuration.
-
-    Provides:
-    - RPC client for inter-service communication
-    - Monitoring dashboard with real-time stats
-    - DRF API endpoints for dashboard
-    """
-
-    default_auto_field = 'django.db.models.BigAutoField'
-    name = 'django_cfg.apps.ipc'
-    label = 'django_cfg_ipc'
-    verbose_name = 'IPC/RPC System'
-
-    def ready(self):
-        """Initialize app when Django starts."""
-        # Import monitor to ensure Redis connection is initialized
-        from .services import monitor  # noqa: F401

django_cfg/apps/ipc/serializers/__init__.py

@@ -1,19 +0,0 @@
-"""
-Serializers for IPC/RPC module.
-"""
-
-from .serializers import (
-    HealthCheckSerializer,
-    MethodStatsSerializer,
-    NotificationStatsSerializer,
-    OverviewStatsSerializer,
-    RecentRequestsSerializer,
-)
-
-__all__ = [
-    'HealthCheckSerializer',
-    'OverviewStatsSerializer',
-    'RecentRequestsSerializer',
-    'NotificationStatsSerializer',
-    'MethodStatsSerializer',
-]