PraisonAI 3.0.0__py3-none-any.whl

praisonai/jobs/server.py

@@ -0,0 +1,186 @@
+"""
+Server for PraisonAI Async Jobs API.
+
+Provides FastAPI application setup and server startup.
+"""
+
+import logging
+import os
+from typing import Optional
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .store import InMemoryJobStore, JobStore
+from .executor import JobExecutor
+from .router import create_router
+
+logger = logging.getLogger(__name__)
+
+# Global instances (for single-process deployment)
+_store: Optional[JobStore] = None
+_executor: Optional[JobExecutor] = None
+
+
+def get_store() -> JobStore:
+    """Get or create the job store."""
+    global _store
+    if _store is None:
+        _store = InMemoryJobStore(max_jobs=1000)
+    return _store
+
+
+def get_executor() -> JobExecutor:
+    """Get or create the job executor."""
+    global _executor
+    if _executor is None:
+        _executor = JobExecutor(
+            store=get_store(),
+            max_concurrent=int(os.environ.get("PRAISONAI_MAX_CONCURRENT_JOBS", "10")),
+            default_timeout=int(os.environ.get("PRAISONAI_JOB_TIMEOUT", "3600"))
+        )
+    return _executor
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan manager."""
+    executor = get_executor()
+    await executor.start()
+    logger.info("Jobs API server started")
+    
+    yield
+    
+    await executor.stop()
+    logger.info("Jobs API server stopped")
+
+
+def create_app(
+    store: Optional[JobStore] = None,
+    executor: Optional[JobExecutor] = None,
+    cors_origins: Optional[list] = None
+) -> FastAPI:
+    """
+    Create the FastAPI application.
+    
+    Args:
+        store: Optional custom job store
+        executor: Optional custom executor
+        cors_origins: Optional list of allowed CORS origins
+        
+    Returns:
+        FastAPI application
+    """
+    global _store, _executor
+    
+    if store:
+        _store = store
+    if executor:
+        _executor = executor
+    
+    app = FastAPI(
+        title="PraisonAI Jobs API",
+        description="Async Jobs API for long-running agent tasks",
+        version="1.0.0",
+        lifespan=lifespan
+    )
+    
+    # Add CORS middleware
+    origins = cors_origins or ["*"]
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    
+    # Add jobs router
+    jobs_router = create_router(get_store(), get_executor())
+    app.include_router(jobs_router)
+    
+    # Health check endpoint
+    @app.get("/health")
+    async def health_check():
+        """Health check endpoint."""
+        return {
+            "status": "healthy",
+            "store": get_store().__class__.__name__,
+            "executor_stats": get_executor().get_stats()
+        }
+    
+    # Stats endpoint
+    @app.get("/stats")
+    async def get_stats():
+        """Get server statistics."""
+        store = get_store()
+        executor = get_executor()
+        
+        stats = {
+            "executor": executor.get_stats()
+        }
+        
+        if hasattr(store, "get_stats"):
+            stats["store"] = store.get_stats()
+        
+        return stats
+    
+    return app
+
+
+def start_server(
+    host: str = "127.0.0.1",
+    port: int = 8005,
+    reload: bool = False,
+    workers: int = 1,
+    log_level: str = "info"
+):
+    """
+    Start the jobs API server.
+    
+    Args:
+        host: Host to bind to
+        port: Port to bind to
+        reload: Enable auto-reload for development
+        workers: Number of worker processes
+        log_level: Logging level
+    """
+    try:
+        import uvicorn
+    except ImportError:
+        raise RuntimeError("uvicorn is required. Install with: pip install uvicorn")
+    
+    logger.info(f"Starting PraisonAI Jobs API on {host}:{port}")
+    
+    uvicorn.run(
+        "praisonai.jobs.server:create_app",
+        host=host,
+        port=port,
+        reload=reload,
+        workers=workers,
+        log_level=log_level,
+        factory=True
+    )
+
+
+# For direct module execution
+if __name__ == "__main__":
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="PraisonAI Jobs API Server")
+    parser.add_argument("--host", default="127.0.0.1", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=8005, help="Port to bind to")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload")
+    parser.add_argument("--workers", type=int, default=1, help="Number of workers")
+    parser.add_argument("--log-level", default="info", help="Log level")
+    
+    args = parser.parse_args()
+    
+    start_server(
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        workers=args.workers,
+        log_level=args.log_level
+    )

praisonai/jobs/store.py

@@ -0,0 +1,203 @@
+"""
+Job Store for PraisonAI Async Jobs API.
+
+Provides storage backends for job state persistence.
+"""
+
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from typing import Optional, List, Dict, Any
+from datetime import datetime, timedelta
+
+from .models import Job, JobStatus
+
+logger = logging.getLogger(__name__)
+
+
+class JobStore(ABC):
+    """Abstract base class for job storage backends."""
+    
+    @abstractmethod
+    async def save(self, job: Job) -> None:
+        """Save or update a job."""
+        pass
+    
+    @abstractmethod
+    async def get(self, job_id: str) -> Optional[Job]:
+        """Get a job by ID."""
+        pass
+    
+    @abstractmethod
+    async def get_by_idempotency_key(self, key: str) -> Optional[Job]:
+        """Get a job by idempotency key."""
+        pass
+    
+    @abstractmethod
+    async def list_jobs(
+        self,
+        status: Optional[JobStatus] = None,
+        session_id: Optional[str] = None,
+        limit: int = 20,
+        offset: int = 0
+    ) -> List[Job]:
+        """List jobs with optional filters."""
+        pass
+    
+    @abstractmethod
+    async def count(
+        self,
+        status: Optional[JobStatus] = None,
+        session_id: Optional[str] = None
+    ) -> int:
+        """Count jobs matching filters."""
+        pass
+    
+    @abstractmethod
+    async def delete(self, job_id: str) -> bool:
+        """Delete a job by ID."""
+        pass
+    
+    @abstractmethod
+    async def cleanup_old_jobs(self, max_age_seconds: int = 86400) -> int:
+        """Remove jobs older than max_age_seconds. Returns count deleted."""
+        pass
+
+
+class InMemoryJobStore(JobStore):
+    """
+    In-memory job store.
+    
+    Suitable for development and single-process deployments.
+    Jobs are lost on restart.
+    """
+    
+    def __init__(self, max_jobs: int = 1000):
+        self._jobs: Dict[str, Job] = {}
+        self._idempotency_keys: Dict[str, str] = {}  # key -> job_id
+        self._max_jobs = max_jobs
+        self._lock = asyncio.Lock()
+    
+    async def save(self, job: Job) -> None:
+        """Save or update a job."""
+        async with self._lock:
+            self._jobs[job.id] = job
+            
+            # Track idempotency key
+            if job.idempotency_key:
+                self._idempotency_keys[job.idempotency_key] = job.id
+            
+            # Enforce max jobs limit by removing oldest completed
+            if len(self._jobs) > self._max_jobs:
+                await self._evict_oldest_completed()
+    
+    async def _evict_oldest_completed(self) -> None:
+        """Remove oldest completed jobs to stay under limit."""
+        completed = [
+            (job_id, job) for job_id, job in self._jobs.items()
+            if job.is_terminal
+        ]
+        
+        if not completed:
+            return
+        
+        # Sort by completed_at, oldest first
+        completed.sort(key=lambda x: x[1].completed_at or datetime.min)
+        
+        # Remove oldest 10%
+        to_remove = max(1, len(completed) // 10)
+        for job_id, job in completed[:to_remove]:
+            del self._jobs[job_id]
+            if job.idempotency_key:
+                self._idempotency_keys.pop(job.idempotency_key, None)
+    
+    async def get(self, job_id: str) -> Optional[Job]:
+        """Get a job by ID."""
+        return self._jobs.get(job_id)
+    
+    async def get_by_idempotency_key(self, key: str) -> Optional[Job]:
+        """Get a job by idempotency key."""
+        job_id = self._idempotency_keys.get(key)
+        if job_id:
+            return self._jobs.get(job_id)
+        return None
+    
+    async def list_jobs(
+        self,
+        status: Optional[JobStatus] = None,
+        session_id: Optional[str] = None,
+        limit: int = 20,
+        offset: int = 0
+    ) -> List[Job]:
+        """List jobs with optional filters."""
+        jobs = list(self._jobs.values())
+        
+        # Apply filters
+        if status:
+            jobs = [j for j in jobs if j.status == status]
+        if session_id:
+            jobs = [j for j in jobs if j.session_id == session_id]
+        
+        # Sort by created_at descending (newest first)
+        jobs.sort(key=lambda j: j.created_at, reverse=True)
+        
+        # Apply pagination
+        return jobs[offset:offset + limit]
+    
+    async def count(
+        self,
+        status: Optional[JobStatus] = None,
+        session_id: Optional[str] = None
+    ) -> int:
+        """Count jobs matching filters."""
+        jobs = list(self._jobs.values())
+        
+        if status:
+            jobs = [j for j in jobs if j.status == status]
+        if session_id:
+            jobs = [j for j in jobs if j.session_id == session_id]
+        
+        return len(jobs)
+    
+    async def delete(self, job_id: str) -> bool:
+        """Delete a job by ID."""
+        async with self._lock:
+            job = self._jobs.pop(job_id, None)
+            if job:
+                if job.idempotency_key:
+                    self._idempotency_keys.pop(job.idempotency_key, None)
+                return True
+            return False
+    
+    async def cleanup_old_jobs(self, max_age_seconds: int = 86400) -> int:
+        """Remove jobs older than max_age_seconds."""
+        async with self._lock:
+            cutoff = datetime.utcnow() - timedelta(seconds=max_age_seconds)
+            to_remove = []
+            
+            for job_id, job in self._jobs.items():
+                if job.is_terminal and job.completed_at and job.completed_at < cutoff:
+                    to_remove.append(job_id)
+            
+            for job_id in to_remove:
+                job = self._jobs.pop(job_id)
+                if job.idempotency_key:
+                    self._idempotency_keys.pop(job.idempotency_key, None)
+            
+            if to_remove:
+                logger.info(f"Cleaned up {len(to_remove)} old jobs")
+            
+            return len(to_remove)
+    
+    def get_stats(self) -> Dict[str, Any]:
+        """Get store statistics."""
+        status_counts = {}
+        for job in self._jobs.values():
+            status_counts[job.status.value] = status_counts.get(job.status.value, 0) + 1
+        
+        return {
+            "total_jobs": len(self._jobs),
+            "idempotency_keys": len(self._idempotency_keys),
+            "max_jobs": self._max_jobs,
+            "status_counts": status_counts
+        }

praisonai/llm/__init__.py

@@ -0,0 +1,66 @@
+"""
+LLM Module for PraisonAI CLI Wrapper.
+
+This module provides LLM provider registry and utilities for the CLI wrapper.
+The core LLM functionality is in praisonaiagents.llm.
+"""
+
+# Lazy loading for performance
+_lazy_cache = {}
+
+
+def __getattr__(name):
+    """Lazy load LLM registry classes."""
+    if name in _lazy_cache:
+        return _lazy_cache[name]
+    
+    if name == "LLMProviderRegistry":
+        from .registry import LLMProviderRegistry
+        _lazy_cache[name] = LLMProviderRegistry
+        return LLMProviderRegistry
+    elif name == "get_default_llm_registry":
+        from .registry import get_default_llm_registry
+        _lazy_cache[name] = get_default_llm_registry
+        return get_default_llm_registry
+    elif name == "register_llm_provider":
+        from .registry import register_llm_provider
+        _lazy_cache[name] = register_llm_provider
+        return register_llm_provider
+    elif name == "unregister_llm_provider":
+        from .registry import unregister_llm_provider
+        _lazy_cache[name] = unregister_llm_provider
+        return unregister_llm_provider
+    elif name == "has_llm_provider":
+        from .registry import has_llm_provider
+        _lazy_cache[name] = has_llm_provider
+        return has_llm_provider
+    elif name == "list_llm_providers":
+        from .registry import list_llm_providers
+        _lazy_cache[name] = list_llm_providers
+        return list_llm_providers
+    elif name == "create_llm_provider":
+        from .registry import create_llm_provider
+        _lazy_cache[name] = create_llm_provider
+        return create_llm_provider
+    elif name == "parse_model_string":
+        from .registry import parse_model_string
+        _lazy_cache[name] = parse_model_string
+        return parse_model_string
+    elif name == "_reset_default_registry":
+        from .registry import _reset_default_registry
+        _lazy_cache[name] = _reset_default_registry
+        return _reset_default_registry
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    "LLMProviderRegistry",
+    "get_default_llm_registry",
+    "register_llm_provider",
+    "unregister_llm_provider",
+    "has_llm_provider",
+    "list_llm_providers",
+    "create_llm_provider",
+    "parse_model_string",
+]