cua-computer 0.2.10__py3-none-any.whl → 0.2.12__py3-none-any.whl

computer/__init__.py

@@ -6,14 +6,14 @@ import sys
 __version__ = "0.1.0"
 
 # Initialize logging
-logger = logging.getLogger("cua.computer")
+logger = logging.getLogger("computer")
 
 # Initialize telemetry when the package is imported
 try:
     # Import from core telemetry
     from core.telemetry import (
-        is_telemetry_enabled,
         flush,
+        is_telemetry_enabled,
         record_event,
     )
 

computer/computer.py

@@ -85,7 +85,7 @@ class Computer:
             experiments: Optional list of experimental features to enable (e.g. ["app-use"])
         """
 
-        self.logger = Logger("cua.computer", verbosity)
+        self.logger = Logger("computer", verbosity)
         self.logger.info("Initializing Computer...")
 
         # Store original parameters
@@ -106,7 +106,15 @@ class Computer:
         # The default is currently to use non-ephemeral storage
         if storage and ephemeral and storage != "ephemeral":
             raise ValueError("Storage path and ephemeral flag cannot be used together")
-        self.storage = "ephemeral" if ephemeral else storage
+        
+        # Windows Sandbox always uses ephemeral storage
+        if self.provider_type == VMProviderType.WINSANDBOX:
+            if not ephemeral and storage != None and storage != "ephemeral":
+                self.logger.warning("Windows Sandbox storage is always ephemeral. Setting ephemeral=True.")
+            self.ephemeral = True
+            self.storage = "ephemeral"
+        else:
+            self.storage = "ephemeral" if ephemeral else storage
         
         # For Lumier provider, store the first shared directory path to use
         # for VM file sharing
@@ -124,11 +132,11 @@ class Computer:
 
         # Configure root logger
         self.verbosity = verbosity
-        self.logger = Logger("cua", verbosity)
+        self.logger = Logger("computer", verbosity)
 
         # Configure component loggers with proper hierarchy
-        self.vm_logger = Logger("cua.vm", verbosity)
-        self.interface_logger = Logger("cua.interface", verbosity)
+        self.vm_logger = Logger("computer.vm", verbosity)
+        self.interface_logger = Logger("computer.interface", verbosity)
 
         if not use_host_computer_server:
             if ":" not in image or len(image.split(":")) != 2:
@@ -285,6 +293,15 @@ class Computer:
                                     api_key=self.api_key,
                                     verbose=verbose,
                                 )
+                            elif self.provider_type == VMProviderType.WINSANDBOX:
+                                self.config.vm_provider = VMProviderFactory.create_provider(
+                                    self.provider_type,
+                                    port=port,
+                                    host=host,
+                                    storage=storage,
+                                    verbose=verbose,
+                                    ephemeral=ephemeral,
+                                )
                             else:
                                 raise ValueError(f"Unsupported provider type: {self.provider_type}")
                             self._provider_context = await self.config.vm_provider.__aenter__()
@@ -383,7 +400,6 @@ class Computer:
                 # Wait for VM to be ready with a valid IP address
                 self.logger.info("Waiting for VM to be ready with a valid IP address...")
                 try:
-                    # Increased values for Lumier provider which needs more time for initial setup
                     if self.provider_type == VMProviderType.LUMIER:
                         max_retries = 60  # Increased for Lumier VM startup which takes longer
                         retry_delay = 3    # 3 seconds between retries for Lumier
@@ -513,7 +529,7 @@ class Computer:
         return
 
     # @property
-    async def get_ip(self, max_retries: int = 15, retry_delay: int = 2) -> str:
+    async def get_ip(self, max_retries: int = 15, retry_delay: int = 3) -> str:
         """Get the IP address of the VM or localhost if using host computer server.
         
         This method delegates to the provider's get_ip method, which waits indefinitely 

computer/helpers.py

@@ -1,6 +1,7 @@
 """
 Helper functions and decorators for the Computer module.
 """
+import logging
 import asyncio
 from functools import wraps
 from typing import Any, Callable, Optional, TypeVar, cast
@@ -8,6 +9,8 @@ from typing import Any, Callable, Optional, TypeVar, cast
 # Global reference to the default computer instance
 _default_computer = None
 
+logger = logging.getLogger(__name__)
+
 def set_default_computer(computer):
     """
     Set the default computer instance to be used by the remote decorator.
@@ -41,7 +44,7 @@ def sandboxed(venv_name: str = "default", computer: str = "default", max_retries
                 try:
                     return await comp.venv_exec(venv_name, func, *args, **kwargs)
                 except Exception as e:
-                    print(f"Attempt {i+1} failed: {e}")
+                    logger.error(f"Attempt {i+1} failed: {e}")
                     await asyncio.sleep(1)
                     if i == max_retries - 1:
                         raise e

computer/interface/factory.py

@@ -8,7 +8,7 @@ class InterfaceFactory:
     
     @staticmethod
     def create_interface_for_os(
-        os: Literal['macos', 'linux'],
+        os: Literal['macos', 'linux', 'windows'],
         ip_address: str,
         api_key: Optional[str] = None,
         vm_name: Optional[str] = None
@@ -16,7 +16,7 @@ class InterfaceFactory:
         """Create an interface for the specified OS.
         
         Args:
-            os: Operating system type ('macos' or 'linux')
+            os: Operating system type ('macos', 'linux', or 'windows')
             ip_address: IP address of the computer to control
             api_key: Optional API key for cloud authentication
             vm_name: Optional VM name for cloud authentication
@@ -30,10 +30,13 @@ class InterfaceFactory:
         # Import implementations here to avoid circular imports
         from .macos import MacOSComputerInterface
         from .linux import LinuxComputerInterface
+        from .windows import WindowsComputerInterface
         
         if os == 'macos':
             return MacOSComputerInterface(ip_address, api_key=api_key, vm_name=vm_name)
         elif os == 'linux':
             return LinuxComputerInterface(ip_address, api_key=api_key, vm_name=vm_name)
+        elif os == 'windows':
+            return WindowsComputerInterface(ip_address, api_key=api_key, vm_name=vm_name)
         else:
-            raise ValueError(f"Unsupported OS type: {os}")
+            raise ValueError(f"Unsupported OS type: {os}")

computer/interface/linux.py

@@ -30,7 +30,7 @@ class LinuxComputerInterface(BaseComputerInterface):
         self._command_lock = asyncio.Lock()  # Lock to ensure only one command at a time
 
         # Set logger name for Linux interface
-        self.logger = Logger("cua.interface.linux", LogLevel.NORMAL)
+        self.logger = Logger("computer.interface.linux", LogLevel.NORMAL)
 
     @property
     def ws_uri(self) -> str:

computer/interface/macos.py

@@ -29,7 +29,7 @@ class MacOSComputerInterface(BaseComputerInterface):
         self._command_lock = asyncio.Lock()  # Lock to ensure only one command at a time
 
         # Set logger name for macOS interface
-        self.logger = Logger("cua.interface.macos", LogLevel.NORMAL)
+        self.logger = Logger("computer.interface.macos", LogLevel.NORMAL)
 
     @property
     def ws_uri(self) -> str: