agentscope-runtime 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

agentscope_runtime/engine/deployers/utils/service_utils/fastapi_templates.py

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+"""FastAPI templates management and rendering."""
+
+import os
+from typing import Dict, Any, Optional
+from jinja2 import Template, Environment, FileSystemLoader
+from ..deployment_modes import DeploymentMode
+
+
+class FastAPITemplateManager:
+    """Manager for FastAPI deployment templates."""
+
+    def __init__(self):
+        """Initialize template manager."""
+        self.template_dir = os.path.join(
+            os.path.dirname(__file__),
+        )
+        self.env = Environment(
+            loader=FileSystemLoader(self.template_dir),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def render_standalone_template(
+        self,
+        agent_name: str,
+        endpoint_path: str = "/process",
+        deployment_mode: str = DeploymentMode.STANDALONE,
+        protocol_adapters: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        """Render the standalone deployment template.
+
+        Args:
+            agent_name: Name of the agent variable
+            endpoint_path: API endpoint path
+            deployment_mode: Deployment mode (standalone or detached_process)
+            protocol_adapters: Protocol adapters code string
+            **kwargs: Additional template variables
+
+        Returns:
+            Rendered template content
+        """
+        template = self.env.get_template("standalone_main.py.j2")
+        return template.render(
+            agent_name=agent_name,
+            endpoint_path=endpoint_path,
+            deployment_mode=deployment_mode,
+            protocol_adapters=protocol_adapters,
+            **kwargs,
+        )
+
+    def render_detached_script_template(
+        self,
+        endpoint_path: str = "/process",
+        host: str = "127.0.0.1",
+        port: int = 8000,
+        stream_enabled: bool = True,
+        response_type: str = "sse",
+        runner_code: str = "",
+        func_code: str = "",
+        services_config: str = "",
+        protocol_adapters: Optional[str] = None,
+        **kwargs,
+    ) -> str:
+        """Render the detached process script template.
+
+        Args:
+            endpoint_path: API endpoint path
+            host: Host to bind to
+            port: Port to bind to
+            stream_enabled: Enable streaming responses
+            response_type: Response type
+            runner_code: Code to setup runner
+            func_code: Code to setup custom function
+            services_config: Services configuration code
+            protocol_adapters: Protocol adapters code string
+            **kwargs: Additional template variables
+
+        Returns:
+            Rendered template content
+        """
+        template = self.env.get_template("detached_script.py.j2")
+        return template.render(
+            endpoint_path=endpoint_path,
+            host=host,
+            port=port,
+            stream_enabled=str(stream_enabled).lower(),
+            response_type=response_type,
+            runner_code=runner_code,
+            func_code=func_code,
+            services_config=services_config,
+            protocol_adapters=protocol_adapters,
+            **kwargs,
+        )
+
+    def render_template_from_string(
+        self,
+        template_string: str,
+        **variables,
+    ) -> str:
+        """Render a template from string.
+
+        Args:
+            template_string: Template content as string
+            **variables: Template variables
+
+        Returns:
+            Rendered template content
+        """
+        template = Template(template_string)
+        return template.render(**variables)
+
+    def get_template_list(self) -> list:
+        """Get list of available templates.
+
+        Returns:
+            List of template filenames
+        """
+        if not os.path.exists(self.template_dir):
+            return []
+
+        templates = []
+        for filename in os.listdir(self.template_dir):
+            if filename.endswith(".j2"):
+                templates.append(filename)
+
+        return templates
+
+    def validate_template_variables(
+        self,
+        template_name: str,
+        variables: Dict[str, Any],
+    ) -> Dict[str, list]:
+        """Validate template variables.
+
+        Args:
+            template_name: Name of the template
+            variables: Variables to validate
+
+        Returns:
+            Dictionary with 'missing' and 'extra' keys containing lists
+        """
+        # This is a basic implementation
+        # In practice, you might want to parse the template to find
+        # required variables
+        required_vars = {
+            "standalone_main.py.j2": ["agent_name", "endpoint_path"],
+        }
+
+        required = required_vars.get(template_name, [])
+        provided = list(variables.keys())
+
+        missing = [var for var in required if var not in provided]
+        extra = [var for var in provided if var not in required]
+
+        return {"missing": missing, "extra": extra}

agentscope_runtime/engine/deployers/utils/service_utils/process_manager.py

@@ -0,0 +1,268 @@
+# -*- coding: utf-8 -*-
+# pylint:disable=consider-using-with
+
+import asyncio
+import os
+import subprocess
+from typing import Optional
+
+import psutil
+
+
+class ProcessManager:
+    """Manager for detached process lifecycle."""
+
+    def __init__(self, shutdown_timeout: int = 30):
+        """Initialize process manager.
+
+        Args:
+            shutdown_timeout: Timeout in seconds for graceful shutdown
+        """
+        self.shutdown_timeout = shutdown_timeout
+
+    async def start_detached_process(
+        self,
+        script_path: str,
+        host: str = "127.0.0.1",
+        port: int = 8000,
+        env: Optional[dict] = None,
+    ) -> int:
+        """Start a detached process running the given script.
+
+        Args:
+            script_path: Path to the Python script to run
+            host: Host to bind to
+            port: Port to bind to
+            env: Additional environment variables
+
+        Returns:
+            Process PID
+
+        Raises:
+            RuntimeError: If process creation fails
+        """
+        try:
+            # Prepare environment
+            process_env = os.environ.copy()
+            if env:
+                process_env.update(env)
+
+            # Start detached process
+            process = subprocess.Popen(
+                [
+                    "python",
+                    script_path,
+                    "--host",
+                    host,
+                    "--port",
+                    str(port),
+                ],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+                start_new_session=True,  # Create new process group
+                env=process_env,
+                cwd=os.path.dirname(script_path),
+            )
+
+            # Verify process started successfully
+            await asyncio.sleep(0.1)  # Give process time to start
+            if process.poll() is not None:
+                raise RuntimeError("Process failed to start")
+
+            return process.pid
+
+        except Exception as e:
+            raise RuntimeError(f"Failed to start detached process: {e}") from e
+
+    async def stop_process_gracefully(
+        self,
+        pid: int,
+        timeout: Optional[int] = None,
+    ) -> bool:
+        """Stop a process gracefully.
+
+        Args:
+            pid: Process ID to stop
+            timeout: Timeout for graceful shutdown (uses default if None)
+
+        Returns:
+            True if process was stopped successfully
+
+        Raises:
+            RuntimeError: If process termination fails
+        """
+        if timeout is None:
+            timeout = self.shutdown_timeout
+
+        try:
+            # Check if process exists
+            if not psutil.pid_exists(pid):
+                return True  # Already terminated
+
+            process = psutil.Process(pid)
+
+            # Send SIGTERM for graceful shutdown
+            process.terminate()
+
+            # Wait for process to terminate
+            try:
+                process.wait(timeout=timeout)
+                return True
+            except psutil.TimeoutExpired:
+                # Force kill if graceful shutdown failed
+                process.kill()
+                process.wait(timeout=5)  # Wait for kill to complete
+                return True
+
+        except psutil.NoSuchProcess:
+            return True  # Process already terminated
+        except psutil.AccessDenied as e:
+            raise RuntimeError(
+                f"Access denied when terminating process {pid}: {e}",
+            ) from e
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to terminate process {pid}: {e}",
+            ) from e
+
+    def is_process_running(self, pid: int) -> bool:
+        """Check if a process is running.
+
+        Args:
+            pid: Process ID to check
+
+        Returns:
+            True if process is running
+        """
+        try:
+            return psutil.pid_exists(pid)
+        except Exception:
+            return False
+
+    def create_pid_file(self, pid: int, file_path: str):
+        """Create a PID file.
+
+        Args:
+            pid: Process ID
+            file_path: Path to PID file
+
+        Raises:
+            OSError: If file creation fails
+        """
+        try:
+            # Ensure directory exists
+            os.makedirs(os.path.dirname(file_path), exist_ok=True)
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                f.write(str(pid))
+        except Exception as e:
+            raise OSError(f"Failed to create PID file {file_path}: {e}") from e
+
+    def read_pid_file(self, file_path: str) -> Optional[int]:
+        """Read PID from file.
+
+        Args:
+            file_path: Path to PID file
+
+        Returns:
+            Process ID or None if file doesn't exist or is invalid
+        """
+        try:
+            if not os.path.exists(file_path):
+                return None
+
+            with open(file_path, "r", encoding="utf-8") as f:
+                return int(f.read().strip())
+        except (ValueError, OSError):
+            return None
+
+    def cleanup_pid_file(self, file_path: str):
+        """Remove PID file.
+
+        Args:
+            file_path: Path to PID file
+        """
+        try:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+        except OSError:
+            pass  # Ignore cleanup errors
+
+    async def find_process_by_port(self, port: int) -> Optional[int]:
+        """Find process listening on a specific port.
+
+        Args:
+            port: Port number
+
+        Returns:
+            Process ID or None if not found
+        """
+        try:
+            for conn in psutil.net_connections(kind="inet"):
+                if conn.laddr.port == port and conn.status == "LISTEN":
+                    if conn.pid:
+                        return conn.pid
+            return None
+        except Exception:
+            return None
+
+    def get_process_info(self, pid: int) -> Optional[dict]:
+        """Get information about a process.
+
+        Args:
+            pid: Process ID
+
+        Returns:
+            Dictionary with process information or None if process not found
+        """
+        try:
+            if not psutil.pid_exists(pid):
+                return None
+
+            process = psutil.Process(pid)
+            return {
+                "pid": pid,
+                "name": process.name(),
+                "status": process.status(),
+                "cpu_percent": process.cpu_percent(),
+                "memory_percent": process.memory_percent(),
+                "create_time": process.create_time(),
+                "cmdline": process.cmdline(),
+            }
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            return None
+
+    async def wait_for_port(
+        self,
+        host: str,
+        port: int,
+        timeout: int = 30,
+    ) -> bool:
+        """Wait for a service to become available on a port.
+
+        Args:
+            host: Host to check
+            port: Port to check
+            timeout: Maximum time to wait
+
+        Returns:
+            True if service becomes available, False if timeout
+        """
+        import socket
+
+        end_time = asyncio.get_event_loop().time() + timeout
+
+        while asyncio.get_event_loop().time() < end_time:
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                    sock.settimeout(1)
+                    result = sock.connect_ex((host, port))
+                    if result == 0:
+                        return True
+            except Exception:
+                pass
+
+            await asyncio.sleep(0.5)
+
+        return False

agentscope_runtime/engine/deployers/utils/service_utils/service_config.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""Service configuration models for dynamic service loading."""
+
+from enum import Enum
+from typing import Dict, Any, Optional
+
+from pydantic import BaseModel
+
+
+class ServiceType(str, Enum):
+    """Types of services that can be configured."""
+
+    MEMORY = "memory"
+    SESSION_HISTORY = "session_history"
+    SANDBOX = "sandbox"
+    RAG = "rag"
+
+
+class ServiceProvider(str, Enum):
+    """Service implementation providers."""
+
+    IN_MEMORY = "in_memory"
+    REDIS = "redis"
+    # Extensible for other providers
+
+
+class ServiceConfig(BaseModel):
+    """Configuration for a single service."""
+
+    provider: ServiceProvider
+    config: Optional[Dict[str, Any]] = {}
+
+
+class ServicesConfig(BaseModel):
+    """Configuration for all services."""
+
+    memory: ServiceConfig = ServiceConfig(provider=ServiceProvider.IN_MEMORY)
+    session_history: ServiceConfig = ServiceConfig(
+        provider=ServiceProvider.IN_MEMORY,
+    )
+    sandbox: Optional[ServiceConfig] = None
+    rag: Optional[ServiceConfig] = None
+
+
+# Default configuration
+DEFAULT_SERVICES_CONFIG = ServicesConfig()
+
+
+def create_redis_services_config(
+    host: str = "localhost",
+    port: int = 6379,
+    memory_db: int = 0,
+    session_db: int = 1,
+) -> ServicesConfig:
+    """Create a ServicesConfig with Redis providers.
+
+    Args:
+        host: Redis host
+        port: Redis port
+        memory_db: Redis database for memory service
+        session_db: Redis database for session history service
+
+    Returns:
+        ServicesConfig: Configuration with Redis services
+    """
+    return ServicesConfig(
+        memory=ServiceConfig(
+            provider=ServiceProvider.REDIS,
+            config={"host": host, "port": port, "db": memory_db},
+        ),
+        session_history=ServiceConfig(
+            provider=ServiceProvider.REDIS,
+            config={"host": host, "port": port, "db": session_db},
+        ),
+    )