PraisonAI 3.0.0__py3-none-any.whl

praisonai/deploy/doctor.py

@@ -0,0 +1,367 @@
+"""
+Deploy doctor - connectivity and readiness checks.
+"""
+import subprocess
+import socket
+import sys
+from typing import Optional, List
+from dataclasses import dataclass
+from .schema import validate_agents_yaml
+
+
+@dataclass
+class DoctorCheckResult:
+    """Result of a single doctor check."""
+    name: str
+    passed: bool
+    message: str
+    fix_suggestion: Optional[str] = None
+
+
+@dataclass
+class DoctorReport:
+    """Aggregated report of all doctor checks."""
+    checks: List[DoctorCheckResult]
+    
+    @property
+    def total_checks(self) -> int:
+        return len(self.checks)
+    
+    @property
+    def passed_checks(self) -> int:
+        return sum(1 for c in self.checks if c.passed)
+    
+    @property
+    def failed_checks(self) -> int:
+        return sum(1 for c in self.checks if not c.passed)
+    
+    @property
+    def all_passed(self) -> bool:
+        return all(c.passed for c in self.checks)
+
+
+def check_python_version() -> DoctorCheckResult:
+    """Check Python version is 3.9+."""
+    try:
+        version = sys.version_info
+        version_str = f"{version.major}.{version.minor}.{version.micro}"
+        
+        if version.major >= 3 and version.minor >= 9:
+            return DoctorCheckResult(
+                name="Python Version",
+                passed=True,
+                message=f"Python {version_str} (>= 3.9 required)"
+            )
+        else:
+            return DoctorCheckResult(
+                name="Python Version",
+                passed=False,
+                message=f"Python {version_str} found, but 3.9+ required",
+                fix_suggestion="Upgrade Python to version 3.9 or higher"
+            )
+    except Exception as e:
+        return DoctorCheckResult(
+            name="Python Version",
+            passed=False,
+            message=f"Failed to check Python version: {e}",
+            fix_suggestion="Ensure Python is properly installed"
+        )
+
+
+def check_docker_available() -> DoctorCheckResult:
+    """Check if Docker is installed and running."""
+    try:
+        result = subprocess.run(
+            ['docker', '--version'],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        
+        if result.returncode == 0:
+            version = result.stdout.strip()
+            return DoctorCheckResult(
+                name="Docker",
+                passed=True,
+                message=f"Docker available: {version}"
+            )
+        else:
+            return DoctorCheckResult(
+                name="Docker",
+                passed=False,
+                message="Docker command failed",
+                fix_suggestion="Install Docker: https://docs.docker.com/get-docker/"
+            )
+    except FileNotFoundError:
+        return DoctorCheckResult(
+            name="Docker",
+            passed=False,
+            message="Docker not found",
+            fix_suggestion="Install Docker: https://docs.docker.com/get-docker/"
+        )
+    except Exception as e:
+        return DoctorCheckResult(
+            name="Docker",
+            passed=False,
+            message=f"Docker check failed: {e}",
+            fix_suggestion="Ensure Docker is installed and running"
+        )
+
+
+def check_port_available(port: int) -> DoctorCheckResult:
+    """Check if a port is available."""
+    try:
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            result = s.connect_ex(('127.0.0.1', port))
+            
+            if result != 0:
+                return DoctorCheckResult(
+                    name=f"Port {port}",
+                    passed=True,
+                    message=f"Port {port} is available"
+                )
+            else:
+                return DoctorCheckResult(
+                    name=f"Port {port}",
+                    passed=False,
+                    message=f"Port {port} is already in use",
+                    fix_suggestion=f"Stop the service using port {port} or choose a different port"
+                )
+    except Exception as e:
+        return DoctorCheckResult(
+            name=f"Port {port}",
+            passed=False,
+            message=f"Failed to check port {port}: {e}",
+            fix_suggestion="Check network configuration"
+        )
+
+
+def check_aws_cli() -> DoctorCheckResult:
+    """Check AWS CLI configuration."""
+    try:
+        result = subprocess.run(
+            ['aws', 'sts', 'get-caller-identity', '--output', 'json'],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode == 0:
+            import json
+            identity = json.loads(result.stdout)
+            account = identity.get('Account', 'unknown')
+            user_id = identity.get('UserId', 'unknown')
+            
+            return DoctorCheckResult(
+                name="AWS CLI",
+                passed=True,
+                message=f"AWS CLI configured (Account: {account[:4]}...{account[-4:]})"
+            )
+        else:
+            return DoctorCheckResult(
+                name="AWS CLI",
+                passed=False,
+                message="AWS CLI not configured or credentials invalid",
+                fix_suggestion="Run: aws configure"
+            )
+    except FileNotFoundError:
+        return DoctorCheckResult(
+            name="AWS CLI",
+            passed=False,
+            message="AWS CLI not installed",
+            fix_suggestion="Install AWS CLI: https://aws.amazon.com/cli/"
+        )
+    except Exception as e:
+        return DoctorCheckResult(
+            name="AWS CLI",
+            passed=False,
+            message=f"AWS CLI check failed: {e}",
+            fix_suggestion="Run: aws configure"
+        )
+
+
+def check_azure_cli() -> DoctorCheckResult:
+    """Check Azure CLI configuration."""
+    try:
+        result = subprocess.run(
+            ['az', 'account', 'show', '--output', 'json'],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode == 0:
+            import json
+            account = json.loads(result.stdout)
+            sub_id = account.get('id', 'unknown')
+            name = account.get('name', 'unknown')
+            
+            return DoctorCheckResult(
+                name="Azure CLI",
+                passed=True,
+                message=f"Azure CLI logged in (Subscription: {sub_id[:8]}...)"
+            )
+        else:
+            return DoctorCheckResult(
+                name="Azure CLI",
+                passed=False,
+                message="Azure CLI not logged in",
+                fix_suggestion="Run: az login"
+            )
+    except FileNotFoundError:
+        return DoctorCheckResult(
+            name="Azure CLI",
+            passed=False,
+            message="Azure CLI not installed",
+            fix_suggestion="Install Azure CLI: https://docs.microsoft.com/en-us/cli/azure/install-azure-cli"
+        )
+    except Exception as e:
+        return DoctorCheckResult(
+            name="Azure CLI",
+            passed=False,
+            message=f"Azure CLI check failed: {e}",
+            fix_suggestion="Run: az login"
+        )
+
+
+def check_gcp_cli() -> DoctorCheckResult:
+    """Check GCP CLI configuration."""
+    try:
+        result = subprocess.run(
+            ['gcloud', 'config', 'get-value', 'project'],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode == 0 and result.stdout.strip():
+            project_id = result.stdout.strip()
+            
+            return DoctorCheckResult(
+                name="GCP CLI",
+                passed=True,
+                message=f"GCP CLI configured (Project: {project_id})"
+            )
+        else:
+            return DoctorCheckResult(
+                name="GCP CLI",
+                passed=False,
+                message="GCP CLI not configured or no project set",
+                fix_suggestion="Run: gcloud init"
+            )
+    except FileNotFoundError:
+        return DoctorCheckResult(
+            name="GCP CLI",
+            passed=False,
+            message="GCP CLI not installed",
+            fix_suggestion="Install gcloud CLI: https://cloud.google.com/sdk/docs/install"
+        )
+    except Exception as e:
+        return DoctorCheckResult(
+            name="GCP CLI",
+            passed=False,
+            message=f"GCP CLI check failed: {e}",
+            fix_suggestion="Run: gcloud init"
+        )
+
+
+def check_agents_yaml(file_path: str) -> DoctorCheckResult:
+    """Check if agents.yaml exists and has valid deploy config."""
+    try:
+        config = validate_agents_yaml(file_path)
+        
+        if config:
+            return DoctorCheckResult(
+                name="agents.yaml",
+                passed=True,
+                message=f"Valid deploy configuration found (type: {config.type.value})"
+            )
+        else:
+            return DoctorCheckResult(
+                name="agents.yaml",
+                passed=False,
+                message="No deploy section found in agents.yaml",
+                fix_suggestion="Add deploy configuration to agents.yaml or run: praisonai deploy init"
+            )
+    except FileNotFoundError:
+        return DoctorCheckResult(
+            name="agents.yaml",
+            passed=False,
+            message=f"File not found: {file_path}",
+            fix_suggestion="Create agents.yaml or run: praisonai deploy init"
+        )
+    except ValueError as e:
+        return DoctorCheckResult(
+            name="agents.yaml",
+            passed=False,
+            message=f"Invalid deploy configuration: {e}",
+            fix_suggestion="Fix deploy configuration in agents.yaml or run: praisonai deploy validate"
+        )
+    except Exception as e:
+        return DoctorCheckResult(
+            name="agents.yaml",
+            passed=False,
+            message=f"Failed to validate agents.yaml: {e}",
+            fix_suggestion="Check agents.yaml syntax"
+        )
+
+
+def run_local_checks(port: int = 8005, agents_file: Optional[str] = None) -> DoctorReport:
+    """Run local environment checks."""
+    checks = [
+        check_python_version(),
+        check_port_available(port),
+    ]
+    
+    if agents_file:
+        checks.append(check_agents_yaml(agents_file))
+    
+    return DoctorReport(checks=checks)
+
+
+def run_aws_checks() -> DoctorReport:
+    """Run AWS-specific checks."""
+    checks = [
+        check_aws_cli(),
+    ]
+    return DoctorReport(checks=checks)
+
+
+def run_azure_checks() -> DoctorReport:
+    """Run Azure-specific checks."""
+    checks = [
+        check_azure_cli(),
+    ]
+    return DoctorReport(checks=checks)
+
+
+def run_gcp_checks() -> DoctorReport:
+    """Run GCP-specific checks."""
+    checks = [
+        check_gcp_cli(),
+    ]
+    return DoctorReport(checks=checks)
+
+
+def run_all_checks(agents_file: Optional[str] = None) -> DoctorReport:
+    """Run all available checks."""
+    checks = []
+    
+    # Local checks
+    local_report = run_local_checks(agents_file=agents_file)
+    checks.extend(local_report.checks)
+    
+    # Docker check
+    checks.append(check_docker_available())
+    
+    # Cloud provider checks
+    aws_report = run_aws_checks()
+    checks.extend(aws_report.checks)
+    
+    azure_report = run_azure_checks()
+    checks.extend(azure_report.checks)
+    
+    gcp_report = run_gcp_checks()
+    checks.extend(gcp_report.checks)
+    
+    return DoctorReport(checks=checks)

praisonai/deploy/main.py

@@ -0,0 +1,327 @@
+"""
+Main Deploy class for unified deployment interface.
+"""
+from typing import Dict, Any
+from .models import DeployConfig, DeployResult, DeployType, DeployStatus, DestroyResult, ServiceState
+from .schema import validate_agents_yaml
+from .api import start_api_server, generate_api_server_code
+from .docker import (
+    build_docker_image, run_docker_container, push_docker_image, save_dockerfile,
+    get_docker_container_status, remove_docker_container
+)
+from .providers import get_provider
+
+
+class Deploy:
+    """
+    Unified deployment interface for PraisonAI agents.
+    
+    Supports:
+    - API server deployment (local/production)
+    - Docker containerization
+    - Cloud deployment (AWS, Azure, GCP)
+    
+    Examples:
+        # From YAML
+        deploy = Deploy.from_yaml("agents.yaml")
+        result = deploy.deploy()
+        
+        # Programmatic
+        from praisonai.deploy import Deploy, DeployConfig, DeployType
+        
+        config = DeployConfig(type=DeployType.API)
+        deploy = Deploy(config, agents_file="agents.yaml")
+        result = deploy.deploy()
+    """
+    
+    def __init__(self, config: DeployConfig, agents_file: str = "agents.yaml"):
+        """
+        Initialize Deploy with configuration.
+        
+        Args:
+            config: Deployment configuration
+            agents_file: Path to agents.yaml file
+        """
+        self.config = config
+        self.agents_file = agents_file
+    
+    @classmethod
+    def from_yaml(cls, agents_file: str = "agents.yaml") -> 'Deploy':
+        """
+        Create Deploy instance from agents.yaml file.
+        
+        Args:
+            agents_file: Path to agents.yaml file
+            
+        Returns:
+            Deploy instance
+            
+        Raises:
+            ValueError: If no deploy configuration found in YAML
+        """
+        config = validate_agents_yaml(agents_file)
+        
+        if config is None:
+            raise ValueError(f"No deploy configuration found in {agents_file}")
+        
+        return cls(config, agents_file)
+    
+    def deploy(self, background: bool = False) -> DeployResult:
+        """
+        Execute deployment based on configuration.
+        
+        Args:
+            background: Run in background mode (for API deployments)
+            
+        Returns:
+            DeployResult with deployment information
+        """
+        if self.config.type == DeployType.API:
+            return self._deploy_api(background)
+        elif self.config.type == DeployType.DOCKER:
+            return self._deploy_docker()
+        elif self.config.type == DeployType.CLOUD:
+            return self._deploy_cloud()
+        else:
+            return DeployResult(
+                success=False,
+                message=f"Unsupported deployment type: {self.config.type}",
+                error="Invalid deployment type"
+            )
+    
+    def _deploy_api(self, background: bool = False) -> DeployResult:
+        """Deploy as API server."""
+        return start_api_server(
+            self.agents_file,
+            self.config.api,
+            background=background
+        )
+    
+    def _deploy_docker(self) -> DeployResult:
+        """Deploy as Docker container."""
+        # Generate and save Dockerfile
+        save_dockerfile(self.agents_file, self.config.docker)
+        
+        # Generate API server code
+        api_code = generate_api_server_code(self.agents_file, None)
+        with open("api_server.py", 'w') as f:
+            f.write(api_code)
+        
+        # Build image
+        build_result = build_docker_image(self.config.docker)
+        
+        if not build_result.success:
+            return build_result
+        
+        # Push if configured
+        if self.config.docker.push and self.config.docker.registry:
+            push_result = push_docker_image(self.config.docker)
+            if not push_result.success:
+                return push_result
+        
+        # Run container
+        return run_docker_container(self.config.docker)
+    
+    def _deploy_cloud(self) -> DeployResult:
+        """Deploy to cloud provider."""
+        provider = get_provider(self.config.cloud)
+        return provider.deploy()
+    
+    def plan(self) -> Dict[str, Any]:
+        """
+        Generate deployment plan without executing.
+        
+        Returns:
+            Dictionary with planned deployment configuration
+        """
+        if self.config.type == DeployType.API:
+            return {
+                "type": "api",
+                "host": self.config.api.host,
+                "port": self.config.api.port,
+                "workers": self.config.api.workers,
+                "agents_file": self.agents_file
+            }
+        elif self.config.type == DeployType.DOCKER:
+            return {
+                "type": "docker",
+                "image": f"{self.config.docker.image_name}:{self.config.docker.tag}",
+                "registry": self.config.docker.registry,
+                "push": self.config.docker.push,
+                "ports": self.config.docker.expose
+            }
+        elif self.config.type == DeployType.CLOUD:
+            provider = get_provider(self.config.cloud)
+            return provider.plan()
+        else:
+            return {"error": "Invalid deployment type"}
+    
+    def doctor(self):
+        """
+        Run health checks for deployment.
+        
+        Returns:
+            DoctorReport with check results
+        """
+        from .doctor import run_local_checks, run_all_checks, DoctorReport
+        
+        if self.config.type == DeployType.API:
+            return run_local_checks(
+                port=self.config.api.port,
+                agents_file=self.agents_file
+            )
+        elif self.config.type == DeployType.DOCKER:
+            from .doctor import check_docker_available, DoctorReport
+            checks = run_local_checks(agents_file=self.agents_file).checks
+            checks.append(check_docker_available())
+            return DoctorReport(checks=checks)
+        elif self.config.type == DeployType.CLOUD:
+            provider = get_provider(self.config.cloud)
+            return provider.doctor()
+        else:
+            return run_all_checks(self.agents_file)
+    
+    def status(self) -> DeployStatus:
+        """
+        Get current deployment status.
+        
+        Returns:
+            DeployStatus with current state and information
+        """
+        if self.config.type == DeployType.API:
+            return self._status_api()
+        elif self.config.type == DeployType.DOCKER:
+            return self._status_docker()
+        elif self.config.type == DeployType.CLOUD:
+            return self._status_cloud()
+        else:
+            return DeployStatus(
+                state=ServiceState.UNKNOWN,
+                message=f"Unsupported deployment type: {self.config.type}"
+            )
+    
+    def _status_api(self) -> DeployStatus:
+        """Get status of local API server."""
+        import socket
+        port = self.config.api.port if self.config.api else 8005
+        
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            result = sock.connect_ex(('127.0.0.1', port))
+            sock.close()
+            
+            if result == 0:
+                return DeployStatus(
+                    state=ServiceState.RUNNING,
+                    url=f"http://127.0.0.1:{port}",
+                    message=f"API server running on port {port}",
+                    service_name="praisonai-api",
+                    provider="api",
+                    healthy=True,
+                    instances_running=1,
+                    instances_desired=1
+                )
+            else:
+                return DeployStatus(
+                    state=ServiceState.STOPPED,
+                    message=f"No service running on port {port}",
+                    service_name="praisonai-api",
+                    provider="api",
+                    healthy=False,
+                    instances_running=0,
+                    instances_desired=1
+                )
+        except Exception as e:
+            return DeployStatus(
+                state=ServiceState.UNKNOWN,
+                message=f"Failed to check status: {e}",
+                service_name="praisonai-api",
+                provider="api"
+            )
+    
+    def _status_docker(self) -> DeployStatus:
+        """Get status of Docker container."""
+        return get_docker_container_status(self.config.docker)
+    
+    def _status_cloud(self) -> DeployStatus:
+        """Get status of cloud deployment."""
+        provider = get_provider(self.config.cloud)
+        return provider.status()
+    
+    def destroy(self, force: bool = False) -> DestroyResult:
+        """
+        Destroy/delete the deployment.
+        
+        Args:
+            force: Force deletion without confirmation
+            
+        Returns:
+            DestroyResult with deletion information
+        """
+        if self.config.type == DeployType.API:
+            return self._destroy_api()
+        elif self.config.type == DeployType.DOCKER:
+            return self._destroy_docker(force)
+        elif self.config.type == DeployType.CLOUD:
+            return self._destroy_cloud(force)
+        else:
+            return DestroyResult(
+                success=False,
+                message=f"Unsupported deployment type: {self.config.type}",
+                error="Invalid deployment type"
+            )
+    
+    def _destroy_api(self) -> DestroyResult:
+        """Stop local API server."""
+        import subprocess
+        import signal
+        import os
+        
+        port = self.config.api.port if self.config.api else 8005
+        
+        try:
+            # Find process using the port
+            result = subprocess.run(
+                ['lsof', '-ti', f':{port}'],
+                capture_output=True,
+                text=True,
+                timeout=5
+            )
+            
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split('\n')
+                deleted_resources = []
+                
+                for pid in pids:
+                    try:
+                        os.kill(int(pid), signal.SIGTERM)
+                        deleted_resources.append(f"process:{pid}")
+                    except (ProcessLookupError, ValueError):
+                        pass
+                
+                return DestroyResult(
+                    success=True,
+                    message=f"Stopped API server on port {port}",
+                    resources_deleted=deleted_resources
+                )
+            else:
+                return DestroyResult(
+                    success=True,
+                    message=f"No API server running on port {port}",
+                    resources_deleted=[]
+                )
+        except Exception as e:
+            return DestroyResult(
+                success=False,
+                message="Failed to stop API server",
+                error=str(e)
+            )
+    
+    def _destroy_docker(self, force: bool = False) -> DestroyResult:
+        """Remove Docker container."""
+        return remove_docker_container(self.config.docker, force)
+    
+    def _destroy_cloud(self, force: bool = False) -> DestroyResult:
+        """Destroy cloud deployment."""
+        provider = get_provider(self.config.cloud)
+        return provider.destroy(force)