cua-computer 0.1.29__py3-none-any.whl → 0.2.0__py3-none-any.whl

computer/providers/base.py

@@ -0,0 +1,105 @@
+"""Base provider interface for VM backends."""
+
+import abc
+from enum import Enum
+from typing import Dict, List, Optional, Any, AsyncContextManager
+
+
+class VMProviderType(str, Enum):
+    """Enum of supported VM provider types."""
+    LUME = "lume"
+    LUMIER = "lumier"
+    CLOUD = "cloud"
+    UNKNOWN = "unknown"
+
+
+class BaseVMProvider(AsyncContextManager):
+    """Base interface for VM providers.
+    
+    All VM provider implementations must implement this interface.
+    """
+    
+    @property
+    @abc.abstractmethod
+    def provider_type(self) -> VMProviderType:
+        """Get the provider type."""
+        pass
+        
+    @abc.abstractmethod
+    async def get_vm(self, name: str, storage: Optional[str] = None) -> Dict[str, Any]:
+        """Get VM information by name.
+        
+        Args:
+            name: Name of the VM to get information for
+            storage: Optional storage path override. If provided, this will be used
+                    instead of the provider's default storage path.
+        
+        Returns:
+            Dictionary with VM information including status, IP address, etc.
+        """
+        pass
+        
+    @abc.abstractmethod
+    async def list_vms(self) -> List[Dict[str, Any]]:
+        """List all available VMs."""
+        pass
+        
+    @abc.abstractmethod
+    async def run_vm(self, image: str, name: str, run_opts: Dict[str, Any], storage: Optional[str] = None) -> Dict[str, Any]:
+        """Run a VM by name with the given options.
+        
+        Args:
+            image: Name/tag of the image to use
+            name: Name of the VM to run
+            run_opts: Dictionary of run options (memory, cpu, etc.)
+            storage: Optional storage path override. If provided, this will be used
+                    instead of the provider's default storage path.
+        
+        Returns:
+            Dictionary with VM run status and information
+        """
+        pass
+        
+    @abc.abstractmethod
+    async def stop_vm(self, name: str, storage: Optional[str] = None) -> Dict[str, Any]:
+        """Stop a VM by name.
+        
+        Args:
+            name: Name of the VM to stop
+            storage: Optional storage path override. If provided, this will be used
+                    instead of the provider's default storage path.
+        
+        Returns:
+            Dictionary with VM stop status and information
+        """
+        pass
+        
+    @abc.abstractmethod
+    async def update_vm(self, name: str, update_opts: Dict[str, Any], storage: Optional[str] = None) -> Dict[str, Any]:
+        """Update VM configuration.
+        
+        Args:
+            name: Name of the VM to update
+            update_opts: Dictionary of update options (memory, cpu, etc.)
+            storage: Optional storage path override. If provided, this will be used
+                    instead of the provider's default storage path.
+        
+        Returns:
+            Dictionary with VM update status and information
+        """
+        pass
+        
+    @abc.abstractmethod
+    async def get_ip(self, name: str, storage: Optional[str] = None, retry_delay: int = 2) -> str:
+        """Get the IP address of a VM, waiting indefinitely until it's available.
+        
+        Args:
+            name: Name of the VM to get the IP for
+            storage: Optional storage path override. If provided, this will be used
+                    instead of the provider's default storage path.
+            retry_delay: Delay between retries in seconds (default: 2)
+            
+        Returns:
+            IP address of the VM when it becomes available
+        """
+        pass

computer/providers/cloud/__init__.py

@@ -0,0 +1,5 @@
+"""CloudProvider module for interacting with cloud-based virtual machines."""
+
+from .provider import CloudProvider
+
+__all__ = ["CloudProvider"]

computer/providers/cloud/provider.py

@@ -0,0 +1,100 @@
+"""Cloud VM provider implementation.
+
+This module contains a stub implementation for a future cloud VM provider.
+"""
+
+import logging
+from typing import Dict, List, Optional, Any
+
+from ..base import BaseVMProvider, VMProviderType
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+class CloudProvider(BaseVMProvider):
+    """Cloud VM Provider stub implementation.
+    
+    This is a placeholder for a future cloud VM provider implementation.
+    """
+    
+    def __init__(
+        self, 
+        host: str = "localhost",
+        port: int = 7777,
+        storage: Optional[str] = None,
+        verbose: bool = False,
+    ):
+        """Initialize the Cloud provider.
+        
+        Args:
+            host: Host to use for API connections (default: localhost)
+            port: Port for the API server (default: 7777)
+            storage: Path to store VM data
+            verbose: Enable verbose logging
+        """
+        self.host = host
+        self.port = port
+        self.storage = storage
+        self.verbose = verbose
+        
+        logger.warning("CloudProvider is not yet implemented")
+        
+    @property
+    def provider_type(self) -> VMProviderType:
+        """Get the provider type."""
+        return VMProviderType.CLOUD
+        
+    async def __aenter__(self):
+        """Enter async context manager."""
+        logger.debug("Entering CloudProvider context")
+        return self
+        
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit async context manager."""
+        logger.debug("Exiting CloudProvider context")
+        
+    async def get_vm(self, name: str, storage: Optional[str] = None) -> Dict[str, Any]:
+        """Get VM information by name."""
+        logger.warning("CloudProvider.get_vm is not implemented")
+        return {
+            "name": name,
+            "status": "unavailable",
+            "message": "CloudProvider is not implemented"
+        }
+        
+    async def list_vms(self) -> List[Dict[str, Any]]:
+        """List all available VMs."""
+        logger.warning("CloudProvider.list_vms is not implemented")
+        return []
+        
+    async def run_vm(self, image: str, name: str, run_opts: Dict[str, Any], storage: Optional[str] = None) -> Dict[str, Any]:
+        """Run a VM with the given options."""
+        logger.warning("CloudProvider.run_vm is not implemented")
+        return {
+            "name": name,
+            "status": "unavailable",
+            "message": "CloudProvider is not implemented"
+        }
+        
+    async def stop_vm(self, name: str, storage: Optional[str] = None) -> Dict[str, Any]:
+        """Stop a running VM."""
+        logger.warning("CloudProvider.stop_vm is not implemented")
+        return {
+            "name": name,
+            "status": "stopped",
+            "message": "CloudProvider is not implemented"
+        }
+        
+    async def update_vm(self, name: str, update_opts: Dict[str, Any], storage: Optional[str] = None) -> Dict[str, Any]:
+        """Update VM configuration."""
+        logger.warning("CloudProvider.update_vm is not implemented")
+        return {
+            "name": name,
+            "status": "unchanged",
+            "message": "CloudProvider is not implemented"
+        }
+        
+    async def get_ip(self, name: str, storage: Optional[str] = None, retry_delay: int = 2) -> str:
+        """Get the IP address of a VM."""
+        logger.warning("CloudProvider.get_ip is not implemented")
+        raise NotImplementedError("CloudProvider.get_ip is not implemented")

computer/providers/factory.py

@@ -0,0 +1,118 @@
+"""Factory for creating VM providers."""
+
+import logging
+from typing import Dict, Optional, Any, Type, Union
+
+from .base import BaseVMProvider, VMProviderType
+
+logger = logging.getLogger(__name__)
+
+
+class VMProviderFactory:
+    """Factory for creating VM providers based on provider type."""
+
+    @staticmethod
+    def create_provider(
+        provider_type: Union[str, VMProviderType],
+        port: int = 7777,
+        host: str = "localhost",
+        bin_path: Optional[str] = None,
+        storage: Optional[str] = None,
+        shared_path: Optional[str] = None,
+        image: Optional[str] = None,
+        verbose: bool = False,
+        ephemeral: bool = False,
+        noVNC_port: Optional[int] = None
+    ) -> BaseVMProvider:
+        """Create a VM provider of the specified type.
+        
+        Args:
+            provider_type: Type of VM provider to create
+            port: Port for the API server
+            host: Hostname for the API server
+            bin_path: Path to provider binary if needed
+            storage: Path for persistent VM storage
+            shared_path: Path for shared folder between host and VM
+            image: VM image to use (for Lumier provider)
+            verbose: Enable verbose logging
+            ephemeral: Use ephemeral (temporary) storage
+            noVNC_port: Specific port for noVNC interface (for Lumier provider)
+            
+        Returns:
+            An instance of the requested VM provider
+            
+        Raises:
+            ImportError: If the required dependencies for the provider are not installed
+            ValueError: If the provider type is not supported
+        """
+        # Convert string to enum if needed
+        if isinstance(provider_type, str):
+            try:
+                provider_type = VMProviderType(provider_type.lower())
+            except ValueError:
+                provider_type = VMProviderType.UNKNOWN
+        
+        if provider_type == VMProviderType.LUME:
+            try:
+                from .lume import LumeProvider, HAS_LUME
+                if not HAS_LUME:
+                    raise ImportError(
+                        "The pylume package is required for LumeProvider. "
+                        "Please install it with 'pip install cua-computer[lume]'"
+                    )
+                return LumeProvider(
+                    port=port,
+                    host=host,
+                    storage=storage,
+                    verbose=verbose,
+                    ephemeral=ephemeral
+                )
+            except ImportError as e:
+                logger.error(f"Failed to import LumeProvider: {e}")
+                raise ImportError(
+                    "The pylume package is required for LumeProvider. "
+                    "Please install it with 'pip install cua-computer[lume]'"
+                ) from e
+        elif provider_type == VMProviderType.LUMIER:
+            try:
+                from .lumier import LumierProvider, HAS_LUMIER
+                if not HAS_LUMIER:
+                    raise ImportError(
+                        "Docker is required for LumierProvider. "
+                        "Please install Docker for Apple Silicon and Lume CLI before using this provider."
+                    )
+                return LumierProvider(
+                    port=port,
+                    host=host,
+                    storage=storage,
+                    shared_path=shared_path,
+                    image=image or "macos-sequoia-cua:latest",
+                    verbose=verbose,
+                    ephemeral=ephemeral,
+                    noVNC_port=noVNC_port
+                )
+            except ImportError as e:
+                logger.error(f"Failed to import LumierProvider: {e}")
+                raise ImportError(
+                    "Docker and Lume CLI are required for LumierProvider. "
+                    "Please install Docker for Apple Silicon and run the Lume installer script."
+                ) from e
+
+        elif provider_type == VMProviderType.CLOUD:
+            try:
+                from .cloud import CloudProvider
+                # Return the stub implementation of CloudProvider
+                return CloudProvider(
+                    host=host,
+                    port=port,
+                    storage=storage,
+                    verbose=verbose
+                )
+            except ImportError as e:
+                logger.error(f"Failed to import CloudProvider: {e}")
+                raise ImportError(
+                    "The CloudProvider is not fully implemented yet. "
+                    "Please use LUME or LUMIER provider instead."
+                ) from e
+        else:
+            raise ValueError(f"Unsupported provider type: {provider_type}")

computer/providers/lume/__init__.py

@@ -0,0 +1,9 @@
+"""Lume VM provider implementation."""
+
+try:
+    from .provider import LumeProvider
+    HAS_LUME = True
+    __all__ = ["LumeProvider"]
+except ImportError:
+    HAS_LUME = False
+    __all__ = []