PraisonAI 3.0.0__py3-none-any.whl

praisonai/deploy/models.py

@@ -0,0 +1,179 @@
+"""
+Deploy configuration models using Pydantic.
+"""
+from enum import Enum
+from typing import Optional, Dict, List, Any
+from pydantic import BaseModel, Field, field_validator
+
+
+class DeployType(str, Enum):
+    """Deployment type enum."""
+    API = "api"
+    DOCKER = "docker"
+    CLOUD = "cloud"
+
+
+class CloudProvider(str, Enum):
+    """Cloud provider enum."""
+    AWS = "aws"
+    AZURE = "azure"
+    GCP = "gcp"
+
+
+class APIConfig(BaseModel):
+    """Configuration for API server deployment."""
+    host: str = Field(default="127.0.0.1", description="Server host")
+    port: int = Field(default=8005, description="Server port")
+    workers: int = Field(default=1, description="Number of worker processes")
+    cors_enabled: bool = Field(default=True, description="Enable CORS")
+    auth_enabled: bool = Field(default=False, description="Enable authentication")
+    auth_token: Optional[str] = Field(default=None, description="Authentication token")
+    reload: bool = Field(default=False, description="Enable auto-reload for development")
+
+
+class DockerConfig(BaseModel):
+    """Configuration for Docker deployment."""
+    image_name: str = Field(default="praisonai-app", description="Docker image name")
+    tag: str = Field(default="latest", description="Docker image tag")
+    base_image: str = Field(default="python:3.11-slim", description="Base Docker image")
+    expose: List[int] = Field(default=[8005], description="Ports to expose")
+    registry: Optional[str] = Field(default=None, description="Docker registry URL")
+    push: bool = Field(default=False, description="Push image to registry after build")
+    build_args: Optional[Dict[str, str]] = Field(default=None, description="Docker build arguments")
+
+
+class CloudConfig(BaseModel):
+    """Configuration for cloud deployment."""
+    provider: CloudProvider = Field(..., description="Cloud provider")
+    region: str = Field(..., description="Deployment region")
+    service_name: str = Field(..., description="Service/application name")
+    
+    # Common cloud config
+    image: Optional[str] = Field(default=None, description="Container image URL")
+    cpu: Optional[str] = Field(default="256", description="CPU allocation")
+    memory: Optional[str] = Field(default="512", description="Memory allocation (MB)")
+    min_instances: int = Field(default=1, description="Minimum instances")
+    max_instances: int = Field(default=10, description="Maximum instances")
+    env_vars: Optional[Dict[str, str]] = Field(default=None, description="Environment variables")
+    
+    # AWS-specific
+    cluster_name: Optional[str] = Field(default=None, description="ECS cluster name (AWS)")
+    task_definition: Optional[str] = Field(default=None, description="Task definition (AWS)")
+    
+    # Azure-specific
+    resource_group: Optional[str] = Field(default=None, description="Resource group (Azure)")
+    subscription_id: Optional[str] = Field(default=None, description="Subscription ID (Azure)")
+    
+    # GCP-specific
+    project_id: Optional[str] = Field(default=None, description="Project ID (GCP)")
+
+
+class AgentConfig(BaseModel):
+    """Configuration for an agent to deploy."""
+    name: str = Field(..., description="Agent name/identifier")
+    entrypoint: str = Field(..., description="Agent entrypoint file (e.g., agents.yaml)")
+    env: Dict[str, str] = Field(default_factory=dict, description="Environment variables")
+    secrets: Dict[str, str] = Field(default_factory=dict, description="Secret references")
+    ports: Optional[List[int]] = Field(default=None, description="Ports to expose")
+    resources: Optional[Dict[str, str]] = Field(default=None, description="Resource requirements")
+
+
+class DeployConfig(BaseModel):
+    """Main deployment configuration."""
+    type: DeployType = Field(..., description="Deployment type")
+    api: Optional[APIConfig] = Field(default=None, description="API server configuration")
+    docker: Optional[DockerConfig] = Field(default=None, description="Docker configuration")
+    cloud: Optional[CloudConfig] = Field(default=None, description="Cloud configuration")
+    agents: Optional[List[AgentConfig]] = Field(default=None, description="Agent configurations")
+    
+    @field_validator('api', 'docker', 'cloud')
+    @classmethod
+    def validate_config_for_type(cls, v, info):
+        """Validate that required config is present for the deployment type."""
+        if info.data.get('type') == DeployType.API and info.field_name == 'api':
+            return v or APIConfig()
+        elif info.data.get('type') == DeployType.DOCKER and info.field_name == 'docker':
+            return v or DockerConfig()
+        elif info.data.get('type') == DeployType.CLOUD and info.field_name == 'cloud':
+            if v is None:
+                raise ValueError("cloud config required for cloud deployment type")
+            return v
+        return v
+    
+    def model_post_init(self, __context):
+        """Post-initialization validation."""
+        if self.type == DeployType.API and self.api is None:
+            self.api = APIConfig()
+        elif self.type == DeployType.DOCKER and self.docker is None:
+            self.docker = DockerConfig()
+        elif self.type == DeployType.CLOUD and self.cloud is None:
+            raise ValueError("cloud config required for cloud deployment type")
+
+
+class DeployResult(BaseModel):
+    """Result of a deployment operation."""
+    success: bool = Field(..., description="Whether deployment succeeded")
+    message: str = Field(..., description="Result message")
+    url: Optional[str] = Field(default=None, description="Deployed service URL")
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")
+
+
+class ServiceState(str, Enum):
+    """Service state enum."""
+    RUNNING = "running"
+    STOPPED = "stopped"
+    PENDING = "pending"
+    FAILED = "failed"
+    NOT_FOUND = "not_found"
+    UNKNOWN = "unknown"
+
+
+class DeployStatus(BaseModel):
+    """Status of a deployed service."""
+    state: ServiceState = Field(..., description="Current service state")
+    url: Optional[str] = Field(default=None, description="Service URL/endpoint")
+    message: str = Field(default="", description="Status message")
+    
+    # Resource identifiers
+    service_name: Optional[str] = Field(default=None, description="Service name")
+    provider: Optional[str] = Field(default=None, description="Provider (api/docker/aws/azure/gcp)")
+    region: Optional[str] = Field(default=None, description="Deployment region")
+    
+    # Health info
+    healthy: bool = Field(default=False, description="Whether service is healthy")
+    instances_running: int = Field(default=0, description="Number of running instances")
+    instances_desired: int = Field(default=0, description="Desired number of instances")
+    
+    # Timestamps
+    created_at: Optional[str] = Field(default=None, description="Creation timestamp")
+    updated_at: Optional[str] = Field(default=None, description="Last update timestamp")
+    
+    # Provider-specific metadata
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Provider-specific metadata")
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON output."""
+        return {
+            "state": self.state.value,
+            "url": self.url,
+            "message": self.message,
+            "service_name": self.service_name,
+            "provider": self.provider,
+            "region": self.region,
+            "healthy": self.healthy,
+            "instances_running": self.instances_running,
+            "instances_desired": self.instances_desired,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "metadata": self.metadata
+        }
+
+
+class DestroyResult(BaseModel):
+    """Result of a destroy operation."""
+    success: bool = Field(..., description="Whether destroy succeeded")
+    message: str = Field(..., description="Result message")
+    resources_deleted: List[str] = Field(default_factory=list, description="List of deleted resources")
+    error: Optional[str] = Field(default=None, description="Error message if failed")
+    metadata: Dict[str, Any] = Field(default_factory=dict, description="Additional metadata")

praisonai/deploy/providers/__init__.py

@@ -0,0 +1,33 @@
+"""
+Cloud provider adapters for deployment.
+"""
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base import BaseProvider
+    from .aws import AWSProvider
+    from .azure import AzureProvider
+    from .gcp import GCPProvider
+
+
+def __getattr__(name):
+    """Lazy load provider modules."""
+    if name == 'BaseProvider':
+        from .base import BaseProvider
+        return BaseProvider
+    elif name == 'AWSProvider':
+        from .aws import AWSProvider
+        return AWSProvider
+    elif name == 'AzureProvider':
+        from .azure import AzureProvider
+        return AzureProvider
+    elif name == 'GCPProvider':
+        from .gcp import GCPProvider
+        return GCPProvider
+    elif name == 'get_provider':
+        from .base import get_provider
+        return get_provider
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ['BaseProvider', 'AWSProvider', 'AzureProvider', 'GCPProvider', 'get_provider']

praisonai/deploy/providers/aws.py

@@ -0,0 +1,331 @@
+"""
+AWS provider for cloud deployment (ECS Fargate).
+"""
+import subprocess
+import json
+from typing import Dict, Any
+from .base import BaseProvider
+from ..models import CloudConfig, DeployResult, DeployStatus, DestroyResult, ServiceState
+from ..doctor import DoctorReport, DoctorCheckResult, check_aws_cli
+
+
+class AWSProvider(BaseProvider):
+    """AWS deployment provider using ECS Fargate."""
+    
+    def doctor(self) -> DoctorReport:
+        """Run AWS-specific health checks."""
+        checks = [check_aws_cli()]
+        
+        # Check if region is configured
+        try:
+            result = subprocess.run(
+                ['aws', 'configure', 'get', 'region'],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            if result.returncode == 0 and result.stdout.strip():
+                checks.append(DoctorCheckResult(
+                    name="AWS Region",
+                    passed=True,
+                    message=f"Region configured: {result.stdout.strip()}"
+                ))
+            else:
+                checks.append(DoctorCheckResult(
+                    name="AWS Region",
+                    passed=False,
+                    message="No default region configured",
+                    fix_suggestion="Run: aws configure set region us-east-1"
+                ))
+        except Exception as e:
+            checks.append(DoctorCheckResult(
+                name="AWS Region",
+                passed=False,
+                message=f"Failed to check region: {e}",
+                fix_suggestion="Run: aws configure"
+            ))
+        
+        return DoctorReport(checks=checks)
+    
+    def plan(self) -> Dict[str, Any]:
+        """Generate AWS deployment plan."""
+        cluster_name = self.config.cluster_name or f"{self.config.service_name}-cluster"
+        
+        plan = {
+            "provider": "aws",
+            "service_name": self.config.service_name,
+            "region": self.config.region,
+            "cluster_name": cluster_name,
+            "launch_type": "FARGATE",
+            "cpu": self.config.cpu,
+            "memory": self.config.memory,
+            "desired_count": self.config.min_instances,
+            "image": self.config.image or f"{self.config.service_name}:latest",
+            "steps": [
+                "1. Create ECS cluster (if not exists)",
+                "2. Create task definition",
+                "3. Create or update ECS service",
+                "4. Wait for service to stabilize"
+            ]
+        }
+        
+        return plan
+    
+    def deploy(self) -> DeployResult:
+        """Deploy to AWS ECS Fargate."""
+        try:
+            cluster_name = self.config.cluster_name or f"{self.config.service_name}-cluster"
+            
+            # Step 1: Create cluster if not exists
+            print(f"📦 Creating ECS cluster: {cluster_name}")
+            try:
+                subprocess.run(
+                    ['aws', 'ecs', 'create-cluster',
+                     '--cluster-name', cluster_name,
+                     '--region', self.config.region],
+                    capture_output=True,
+                    timeout=30
+                )
+            except Exception:
+                pass  # Cluster may already exist
+            
+            # Step 2: Register task definition
+            print(f"📝 Registering task definition")
+            
+            task_def = {
+                "family": self.config.service_name,
+                "networkMode": "awsvpc",
+                "requiresCompatibilities": ["FARGATE"],
+                "cpu": self.config.cpu,
+                "memory": self.config.memory,
+                "containerDefinitions": [
+                    {
+                        "name": self.config.service_name,
+                        "image": self.config.image or f"{self.config.service_name}:latest",
+                        "portMappings": [
+                            {
+                                "containerPort": 8005,
+                                "protocol": "tcp"
+                            }
+                        ],
+                        "environment": [
+                            {"name": k, "value": v}
+                            for k, v in (self.config.env_vars or {}).items()
+                        ]
+                    }
+                ]
+            }
+            
+            result = subprocess.run(
+                ['aws', 'ecs', 'register-task-definition',
+                 '--cli-input-json', json.dumps(task_def),
+                 '--region', self.config.region],
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            if result.returncode != 0:
+                return DeployResult(
+                    success=False,
+                    message="Failed to register task definition",
+                    error=result.stderr
+                )
+            
+            # Step 3: Create or update service
+            print(f"🚀 Deploying service: {self.config.service_name}")
+            
+            # Try to update first, create if doesn't exist
+            update_result = subprocess.run(
+                ['aws', 'ecs', 'update-service',
+                 '--cluster', cluster_name,
+                 '--service', self.config.service_name,
+                 '--task-definition', self.config.service_name,
+                 '--desired-count', str(self.config.min_instances),
+                 '--region', self.config.region],
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+            
+            if update_result.returncode != 0:
+                # Service doesn't exist, create it
+                # Note: This is simplified - production would need VPC/subnet/security group config
+                return DeployResult(
+                    success=False,
+                    message="Service creation requires VPC configuration",
+                    error="Please create the service manually with proper VPC/subnet/security group configuration, then use update"
+                )
+            
+            return DeployResult(
+                success=True,
+                message=f"Service deployed successfully to AWS ECS",
+                url=f"https://console.aws.amazon.com/ecs/home?region={self.config.region}#/clusters/{cluster_name}/services/{self.config.service_name}",
+                metadata={
+                    "cluster": cluster_name,
+                    "service": self.config.service_name,
+                    "region": self.config.region
+                }
+            )
+        
+        except Exception as e:
+            return DeployResult(
+                success=False,
+                message="AWS deployment failed",
+                error=str(e)
+            )
+    
+    def status(self) -> DeployStatus:
+        """Get current AWS ECS service status."""
+        try:
+            cluster_name = self.config.cluster_name or f"{self.config.service_name}-cluster"
+            
+            result = subprocess.run(
+                ['aws', 'ecs', 'describe-services',
+                 '--cluster', cluster_name,
+                 '--services', self.config.service_name,
+                 '--region', self.config.region,
+                 '--output', 'json'],
+                capture_output=True,
+                text=True,
+                timeout=30
+            )
+            
+            if result.returncode != 0:
+                return DeployStatus(
+                    state=ServiceState.NOT_FOUND,
+                    message=f"Service not found or error: {result.stderr}",
+                    service_name=self.config.service_name,
+                    provider="aws",
+                    region=self.config.region
+                )
+            
+            data = json.loads(result.stdout)
+            services = data.get('services', [])
+            
+            if not services:
+                return DeployStatus(
+                    state=ServiceState.NOT_FOUND,
+                    message="Service not found",
+                    service_name=self.config.service_name,
+                    provider="aws",
+                    region=self.config.region
+                )
+            
+            service = services[0]
+            status_str = service.get('status', 'UNKNOWN')
+            running_count = service.get('runningCount', 0)
+            desired_count = service.get('desiredCount', 0)
+            
+            # Map AWS status to ServiceState
+            if status_str == 'ACTIVE' and running_count > 0:
+                state = ServiceState.RUNNING
+            elif status_str == 'ACTIVE' and running_count == 0:
+                state = ServiceState.STOPPED
+            elif status_str == 'DRAINING':
+                state = ServiceState.PENDING
+            elif status_str == 'INACTIVE':
+                state = ServiceState.STOPPED
+            else:
+                state = ServiceState.UNKNOWN
+            
+            return DeployStatus(
+                state=state,
+                url=f"https://console.aws.amazon.com/ecs/home?region={self.config.region}#/clusters/{cluster_name}/services/{self.config.service_name}",
+                message=f"Status: {status_str}",
+                service_name=self.config.service_name,
+                provider="aws",
+                region=self.config.region,
+                healthy=running_count >= desired_count and running_count > 0,
+                instances_running=running_count,
+                instances_desired=desired_count,
+                created_at=service.get('createdAt'),
+                metadata={
+                    "cluster": cluster_name,
+                    "task_definition": service.get('taskDefinition'),
+                    "launch_type": service.get('launchType'),
+                    "deployments": len(service.get('deployments', []))
+                }
+            )
+            
+        except Exception as e:
+            return DeployStatus(
+                state=ServiceState.UNKNOWN,
+                message=f"Failed to get status: {e}",
+                service_name=self.config.service_name,
+                provider="aws",
+                region=self.config.region
+            )
+    
+    def destroy(self, force: bool = False) -> DestroyResult:
+        """Destroy AWS ECS service and related resources."""
+        try:
+            cluster_name = self.config.cluster_name or f"{self.config.service_name}-cluster"
+            deleted_resources = []
+            
+            # Step 1: Update service desired count to 0
+            print(f"🛑 Stopping service: {self.config.service_name}")
+            subprocess.run(
+                ['aws', 'ecs', 'update-service',
+                 '--cluster', cluster_name,
+                 '--service', self.config.service_name,
+                 '--desired-count', '0',
+                 '--region', self.config.region],
+                capture_output=True,
+                timeout=30
+            )
+            
+            # Step 2: Delete the service
+            print(f"🗑️ Deleting service: {self.config.service_name}")
+            result = subprocess.run(
+                ['aws', 'ecs', 'delete-service',
+                 '--cluster', cluster_name,
+                 '--service', self.config.service_name,
+                 '--force' if force else '--no-force',
+                 '--region', self.config.region],
+                capture_output=True,
+                text=True,
+                timeout=60
+            )
+            
+            if result.returncode == 0:
+                deleted_resources.append(f"ecs-service:{self.config.service_name}")
+            else:
+                return DestroyResult(
+                    success=False,
+                    message="Failed to delete service",
+                    error=result.stderr,
+                    resources_deleted=deleted_resources
+                )
+            
+            # Step 3: Optionally delete cluster if empty
+            if force:
+                print(f"🗑️ Deleting cluster: {cluster_name}")
+                cluster_result = subprocess.run(
+                    ['aws', 'ecs', 'delete-cluster',
+                     '--cluster', cluster_name,
+                     '--region', self.config.region],
+                    capture_output=True,
+                    text=True,
+                    timeout=30
+                )
+                if cluster_result.returncode == 0:
+                    deleted_resources.append(f"ecs-cluster:{cluster_name}")
+            
+            return DestroyResult(
+                success=True,
+                message=f"Successfully destroyed AWS ECS service",
+                resources_deleted=deleted_resources,
+                metadata={
+                    "cluster": cluster_name,
+                    "region": self.config.region
+                }
+            )
+            
+        except Exception as e:
+            return DestroyResult(
+                success=False,
+                message="Failed to destroy AWS resources",
+                error=str(e)
+            )