agentscope-runtime 0.1.5b2__py3-none-any.whl → 0.1.6__py3-none-any.whl

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

@@ -1,268 +0,0 @@
-# -*- 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

@@ -1,75 +0,0 @@
-# -*- 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},
-        ),
-    )

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

@@ -1,220 +0,0 @@
-# -*- coding: utf-8 -*-
-# pylint:disable=line-too-long
-
-from typing import Dict, Type, Any
-from .service_config import (
-    ServiceType,
-    ServiceProvider,
-    ServiceConfig,
-    ServicesConfig,
-)
-
-
-class ServiceFactory:
-    """Factory for creating service instances based on configuration."""
-
-    # Service registry mapping service types and providers to
-    # implementation classes
-    _service_registry: Dict[str, Dict[str, Type]] = {}
-
-    @classmethod
-    def _populate_registry(cls):
-        """Populate the service registry with available implementations."""
-        if cls._service_registry:
-            return  # Already populated
-
-        try:
-            # Import service implementations
-            from agentscope_runtime.engine.services.memory_service import (
-                InMemoryMemoryService,
-            )
-            from agentscope_runtime.engine.services.session_history_service import (  # noqa E501
-                InMemorySessionHistoryService,
-            )
-
-            # Register memory services
-            cls._service_registry[ServiceType.MEMORY] = {
-                ServiceProvider.IN_MEMORY: InMemoryMemoryService,
-            }
-
-            # Register session history services
-            cls._service_registry[ServiceType.SESSION_HISTORY] = {
-                ServiceProvider.IN_MEMORY: InMemorySessionHistoryService,
-            }
-
-            # Try to register Redis services if available
-
-            from agentscope_runtime.engine.services.redis_memory_service import (  # noqa E501
-                RedisMemoryService,
-            )
-            from agentscope_runtime.engine.services.redis_session_history_service import (  # noqa E501
-                RedisSessionHistoryService,
-            )
-
-            cls._service_registry[ServiceType.MEMORY][
-                ServiceProvider.REDIS
-            ] = RedisMemoryService
-            cls._service_registry[ServiceType.SESSION_HISTORY][
-                ServiceProvider.REDIS
-            ] = RedisSessionHistoryService
-
-            # Try to register other services if available
-            from agentscope_runtime.engine.services.sandbox_service import (
-                SandboxService,
-            )
-
-            # Assuming default implementation
-            cls._service_registry[ServiceType.SANDBOX] = {
-                ServiceProvider.IN_MEMORY: SandboxService,
-            }
-
-            from agentscope_runtime.engine.services.rag_service import (
-                RAGService,
-            )
-
-            # Assuming default implementation
-            cls._service_registry[ServiceType.RAG] = {
-                ServiceProvider.IN_MEMORY: RAGService,
-            }
-
-        except ImportError as e:
-            raise RuntimeError(
-                f"Failed to import required service classes: {e}",
-            ) from e
-
-    @classmethod
-    def create_service(
-        cls,
-        service_type: ServiceType,
-        config: ServiceConfig,
-    ) -> Any:
-        """Create a service instance based on type and configuration.
-
-        Args:
-            service_type: Type of service to create
-            config: Configuration for the service
-
-        Returns:
-            Service instance
-
-        Raises:
-            ValueError: If service type or provider is unknown
-            RuntimeError: If service creation fails
-        """
-        cls._populate_registry()
-
-        if service_type not in cls._service_registry:
-            raise ValueError(f"Unknown service type: {service_type}")
-
-        providers = cls._service_registry[service_type]
-        if config.provider not in providers:
-            available_providers = list(providers.keys())
-            raise ValueError(
-                f"Unknown provider '{config.provider}' for service '"
-                f"{service_type}'. Available providers: {available_providers}",
-            )
-
-        service_class = providers[config.provider]
-
-        try:
-            # Create service instance with configuration parameters
-            return service_class(**config.config)
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to create {service_type} service with provider "
-                f"'{config.provider}': {e}",
-            ) from e
-
-    @classmethod
-    def register_service(
-        cls,
-        service_type: ServiceType,
-        provider: ServiceProvider,
-        service_class: Type,
-    ):
-        """Register a new service implementation.
-
-        Args:
-            service_type: Type of service
-            provider: Service provider
-            service_class: Implementation class
-        """
-        cls._populate_registry()
-
-        if service_type not in cls._service_registry:
-            cls._service_registry[service_type] = {}
-
-        cls._service_registry[service_type][provider] = service_class
-
-    @classmethod
-    def create_services_from_config(
-        cls,
-        config: ServicesConfig,
-    ) -> Dict[str, Any]:
-        """Create all services from a services configuration.
-
-        Args:
-            config: Services configuration
-
-        Returns:
-            Dict mapping service names to service instances
-
-        Raises:
-            RuntimeError: If any required service creation fails
-        """
-        services = {}
-
-        # Create required services
-        try:
-            services["memory"] = cls.create_service(
-                ServiceType.MEMORY,
-                config.memory,
-            )
-            services["session_history"] = cls.create_service(
-                ServiceType.SESSION_HISTORY,
-                config.session_history,
-            )
-        except Exception as e:
-            raise RuntimeError(
-                f"Failed to create required services: {e}",
-            ) from e
-
-        # Create optional services
-        if config.sandbox:
-            try:
-                services["sandbox"] = cls.create_service(
-                    ServiceType.SANDBOX,
-                    config.sandbox,
-                )
-            except Exception as e:
-                # Log warning but don't fail
-                print(f"Warning: Failed to create sandbox service: {e}")
-
-        if config.rag:
-            try:
-                services["rag"] = cls.create_service(
-                    ServiceType.RAG,
-                    config.rag,
-                )
-            except Exception as e:
-                # Log warning but don't fail
-                print(f"Warning: Failed to create RAG service: {e}")
-
-        return services
-
-    @classmethod
-    def get_available_providers(cls, service_type: ServiceType) -> list:
-        """Get list of available providers for a service type.
-
-        Args:
-            service_type: Type of service
-
-        Returns:
-            List of available provider names
-        """
-        cls._populate_registry()
-
-        if service_type not in cls._service_registry:
-            return []
-
-        return list(cls._service_registry[service_type].keys())