ai-computer-client 0.1.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

ai_computer/__init__.py

@@ -1,4 +1,4 @@
-from .client import SandboxClient, SandboxResponse, StreamEvent
+from .client import SandboxClient, SandboxResponse, StreamEvent, FileOperationResponse
 
-__version__ = "0.1.0"
-__all__ = ["SandboxClient", "SandboxResponse", "StreamEvent"] 
+__version__ = "0.3.0"
+__all__ = ["SandboxClient", "SandboxResponse", "StreamEvent", "FileOperationResponse"] 

ai_computer/client.py

@@ -1,8 +1,11 @@
 import aiohttp
 import json
 import asyncio
-from typing import Optional, Dict, AsyncGenerator, Union
+from typing import Optional, Dict, AsyncGenerator, Union, List, BinaryIO
 from dataclasses import dataclass
+import os
+import mimetypes
+from pathlib import Path
 
 @dataclass
 class SandboxResponse:
@@ -28,6 +31,25 @@ class StreamEvent:
     type: str
     data: str
 
+@dataclass
+class FileOperationResponse:
+    """Response from file operations.
+    
+    Attributes:
+        success: Whether the operation was successful
+        filename: Name of the file
+        size: Size of the file in bytes
+        path: Path where the file was saved
+        message: Optional status message
+        error: Optional error message if operation failed
+    """
+    success: bool
+    filename: Optional[str] = None
+    size: Optional[int] = None
+    path: Optional[str] = None
+    message: Optional[str] = None
+    error: Optional[str] = None
+
 class SandboxClient:
     """Client for interacting with the AI Sandbox service.
     
@@ -241,6 +263,59 @@ class SandboxClient:
         except Exception as e:
             yield StreamEvent(type="error", data=f"Connection error: {str(e)}")
     
+    async def execute_shell(
+        self,
+        command: str,
+        args: Optional[List[str]] = None,
+        timeout: int = 30
+    ) -> SandboxResponse:
+        """Execute a shell command in the sandbox.
+        
+        Args:
+            command: The shell command to execute
+            args: Optional list of arguments for the command
+            timeout: Maximum execution time in seconds
+            
+        Returns:
+            SandboxResponse containing execution results
+        """
+        if not self.token or not self.sandbox_id:
+            return SandboxResponse(success=False, error="Client not properly initialized. Call setup() first")
+            
+        # Ensure sandbox is ready
+        ready = await self.wait_for_ready()
+        if not ready.success:
+            return ready
+            
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "command": command,
+            "args": args or [],
+            "timeout": timeout
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/execute/shell",
+                    headers=headers,
+                    json=data
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return SandboxResponse(success=False, error=error_text)
+                    
+                    # Parse the response
+                    result = await response.json()
+                    return SandboxResponse(success=True, data=result)
+                    
+        except Exception as e:
+            return SandboxResponse(success=False, error=f"Connection error: {str(e)}")
+    
     async def cleanup(self) -> SandboxResponse:
         """Delete the sandbox.
         
@@ -262,4 +337,417 @@ class SandboxClient:
                     return SandboxResponse(success=True, data=data)
                 else:
                     text = await response.text()
-                    return SandboxResponse(success=False, error=text) 
+                    return SandboxResponse(success=False, error=text)
+
+    async def upload_file(
+        self,
+        file_path: Union[str, Path],
+        destination: str = "/workspace",
+        chunk_size: int = 1024 * 1024,  # 1MB chunks
+        timeout: int = 300  # 5 minutes
+    ) -> FileOperationResponse:
+        """Upload a file to the sandbox environment.
+        
+        Args:
+            file_path: Path to the file to upload
+            destination: Destination path in the sandbox (default: /workspace)
+            chunk_size: Size of chunks for reading large files
+            timeout: Maximum upload time in seconds
+            
+        Returns:
+            FileOperationResponse containing upload results
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                success=False,
+                error="Client not properly initialized. Call setup() first"
+            )
+
+        # Ensure sandbox is ready
+        ready = await self.wait_for_ready()
+        if not ready.success:
+            return FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+
+        # Convert to Path object and validate file
+        file_path = Path(file_path)
+        if not file_path.exists():
+            return FileOperationResponse(
+                success=False,
+                error=f"File not found: {file_path}"
+            )
+        
+        if not file_path.is_file():
+            return FileOperationResponse(
+                success=False,
+                error=f"Not a file: {file_path}"
+            )
+
+        # Get file size and validate
+        file_size = file_path.stat().st_size
+        if file_size > 100 * 1024 * 1024:  # 100MB limit
+            return FileOperationResponse(
+                success=False,
+                error="File too large. Maximum size is 100MB"
+            )
+
+        try:
+            # Prepare the upload
+            headers = {
+                "Authorization": f"Bearer {self.token}"
+            }
+
+            # Guess content type
+            content_type = mimetypes.guess_type(file_path)[0] or 'application/octet-stream'
+            
+            # Prepare multipart form data
+            data = aiohttp.FormData()
+            data.add_field('file',
+                         open(file_path, 'rb'),
+                         filename=file_path.name,
+                         content_type=content_type)
+            data.add_field('path', destination)
+
+            timeout_settings = aiohttp.ClientTimeout(
+                total=timeout,
+                connect=30,
+                sock_connect=30,
+                sock_read=timeout
+            )
+
+            async with aiohttp.ClientSession(timeout=timeout_settings) as session:
+                async with session.post(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files/upload",
+                    headers=headers,
+                    data=data
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Upload failed: {error_text}"
+                        )
+
+                    result = await response.json()
+                    return FileOperationResponse(
+                        success=True,
+                        filename=result.get("filename"),
+                        size=result.get("size"),
+                        path=result.get("path"),
+                        message=result.get("message")
+                    )
+
+        except asyncio.TimeoutError:
+            return FileOperationResponse(
+                success=False,
+                error=f"Upload timed out after {timeout} seconds"
+            )
+        except Exception as e:
+            return FileOperationResponse(
+                success=False,
+                error=f"Upload failed: {str(e)}"
+            )
+
+    async def download_file(
+        self,
+        sandbox_path: str,
+        local_path: Optional[Union[str, Path]] = None,
+        chunk_size: int = 8192,  # 8KB chunks for download
+        timeout: int = 300  # 5 minutes
+    ) -> FileOperationResponse:
+        """Download a file from the sandbox environment.
+        
+        Args:
+            sandbox_path: Path to the file in the sandbox
+            local_path: Local path to save the file (default: current directory with original filename)
+            chunk_size: Size of chunks for downloading large files
+            timeout: Maximum download time in seconds
+            
+        Returns:
+            FileOperationResponse containing download results
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                success=False,
+                error="Client not properly initialized. Call setup() first"
+            )
+
+        # Ensure sandbox is ready
+        ready = await self.wait_for_ready()
+        if not ready.success:
+            return FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+
+        # Normalize sandbox path
+        sandbox_path = sandbox_path.lstrip('/')
+        
+        # Determine local path
+        if local_path is None:
+            local_path = Path(os.path.basename(sandbox_path))
+        else:
+            local_path = Path(local_path)
+
+        # Create parent directories if they don't exist
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            timeout_settings = aiohttp.ClientTimeout(
+                total=timeout,
+                connect=30,
+                sock_connect=30,
+                sock_read=timeout
+            )
+
+            headers = {
+                "Authorization": f"Bearer {self.token}"
+            }
+
+            async with aiohttp.ClientSession(timeout=timeout_settings) as session:
+                async with session.get(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files/download/{sandbox_path}",
+                    headers=headers
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Download failed: {error_text}"
+                        )
+
+                    # Get content length if available
+                    total_size = int(response.headers.get('content-length', 0))
+
+                    # Download the file in chunks
+                    downloaded_size = 0
+                    try:
+                        with open(local_path, 'wb') as f:
+                            async for chunk in response.content.iter_chunked(chunk_size):
+                                f.write(chunk)
+                                downloaded_size += len(chunk)
+
+                        return FileOperationResponse(
+                            success=True,
+                            filename=local_path.name,
+                            size=downloaded_size or total_size,
+                            path=str(local_path.absolute()),
+                            message="File downloaded successfully"
+                        )
+                    except Exception as e:
+                        # Clean up partial download
+                        if local_path.exists():
+                            local_path.unlink()
+                        raise e
+
+        except asyncio.TimeoutError:
+            # Clean up partial download
+            if local_path.exists():
+                local_path.unlink()
+            return FileOperationResponse(
+                success=False,
+                error=f"Download timed out after {timeout} seconds"
+            )
+        except Exception as e:
+            # Clean up partial download
+            if local_path.exists():
+                local_path.unlink()
+            return FileOperationResponse(
+                success=False,
+                error=f"Download failed: {str(e)}"
+            )
+
+    async def upload_bytes(
+        self,
+        content: Union[bytes, BinaryIO],
+        filename: str,
+        destination: str = "/workspace",
+        content_type: Optional[str] = None,
+        timeout: int = 300  # 5 minutes
+    ) -> FileOperationResponse:
+        """Upload bytes or a file-like object to the sandbox environment.
+        
+        Args:
+            content: Bytes or file-like object to upload
+            filename: Name to give the file in the sandbox
+            destination: Destination path in the sandbox (default: /workspace)
+            content_type: Optional MIME type (will be guessed from filename if not provided)
+            timeout: Maximum upload time in seconds
+            
+        Returns:
+            FileOperationResponse containing upload results
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                success=False,
+                error="Client not properly initialized. Call setup() first"
+            )
+
+        # Ensure sandbox is ready
+        ready = await self.wait_for_ready()
+        if not ready.success:
+            return FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+
+        try:
+            # Handle both bytes and file-like objects
+            if isinstance(content, bytes):
+                file_obj = content
+                content_length = len(content)
+            else:
+                # Ensure we're at the start of the file
+                if hasattr(content, 'seek'):
+                    content.seek(0)
+                file_obj = content
+                # Try to get content length if possible
+                content_length = None
+                if hasattr(content, 'seek') and hasattr(content, 'tell'):
+                    try:
+                        current_pos = content.tell()
+                        content.seek(0, os.SEEK_END)
+                        content_length = content.tell()
+                        content.seek(current_pos)
+                    except (OSError, IOError):
+                        pass
+
+            # Validate size if we can determine it
+            if content_length and content_length > 100 * 1024 * 1024:  # 100MB limit
+                return FileOperationResponse(
+                    success=False,
+                    error="Content too large. Maximum size is 100MB"
+                )
+
+            # Prepare the upload
+            headers = {
+                "Authorization": f"Bearer {self.token}"
+            }
+
+            # Guess content type if not provided
+            if not content_type:
+                content_type = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+            
+            # Prepare multipart form data
+            data = aiohttp.FormData()
+            data.add_field('file',
+                         file_obj,
+                         filename=filename,
+                         content_type=content_type)
+            data.add_field('path', destination)
+
+            timeout_settings = aiohttp.ClientTimeout(
+                total=timeout,
+                connect=30,
+                sock_connect=30,
+                sock_read=timeout
+            )
+
+            async with aiohttp.ClientSession(timeout=timeout_settings) as session:
+                async with session.post(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files/upload",
+                    headers=headers,
+                    data=data
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Upload failed: {error_text}"
+                        )
+
+                    result = await response.json()
+                    return FileOperationResponse(
+                        success=True,
+                        filename=result.get("filename"),
+                        size=result.get("size"),
+                        path=result.get("path"),
+                        message=result.get("message")
+                    )
+
+        except asyncio.TimeoutError:
+            return FileOperationResponse(
+                success=False,
+                error=f"Upload timed out after {timeout} seconds"
+            )
+        except Exception as e:
+            return FileOperationResponse(
+                success=False,
+                error=f"Upload failed: {str(e)}"
+            )
+
+    async def download_bytes(
+        self,
+        sandbox_path: str,
+        chunk_size: int = 8192,  # 8KB chunks for download
+        timeout: int = 300  # 5 minutes
+    ) -> Union[bytes, FileOperationResponse]:
+        """Download a file from the sandbox environment into memory.
+        
+        Args:
+            sandbox_path: Path to the file in the sandbox
+            chunk_size: Size of chunks for downloading large files
+            timeout: Maximum download time in seconds
+            
+        Returns:
+            On success: The file contents as bytes
+            On failure: FileOperationResponse with error details
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                success=False,
+                error="Client not properly initialized. Call setup() first"
+            )
+
+        # Ensure sandbox is ready
+        ready = await self.wait_for_ready()
+        if not ready.success:
+            return FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+
+        # Normalize sandbox path
+        sandbox_path = sandbox_path.lstrip('/')
+
+        try:
+            timeout_settings = aiohttp.ClientTimeout(
+                total=timeout,
+                connect=30,
+                sock_connect=30,
+                sock_read=timeout
+            )
+
+            headers = {
+                "Authorization": f"Bearer {self.token}"
+            }
+
+            async with aiohttp.ClientSession(timeout=timeout_settings) as session:
+                async with session.get(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files/download/{sandbox_path}",
+                    headers=headers
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Download failed: {error_text}"
+                        )
+
+                    # Read the entire response into memory
+                    content = await response.read()
+                    
+                    return content
+
+        except asyncio.TimeoutError:
+            return FileOperationResponse(
+                success=False,
+                error=f"Download timed out after {timeout} seconds"
+            )
+        except Exception as e:
+            return FileOperationResponse(
+                success=False,
+                error=f"Download failed: {str(e)}"
+            ) 

{ai_computer_client-0.1.1.dist-info → ai_computer_client-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-computer-client
-Version: 0.1.1
+Version: 0.3.0
 Summary: Python client for interacting with the AI Computer service
 Project-URL: Homepage, https://github.com/ColeMurray/ai-computer-client-python
 Project-URL: Documentation, https://github.com/ColeMurray/ai-computer-client-python#readme

ai_computer_client-0.3.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+ai_computer/__init__.py,sha256=41ibex5hg-OZ28VsmhU2RqxzzV6YEUD6vLbuNSddRsk,197
+ai_computer/client.py,sha256=--gmDUzABePoV7XWvo-zMH69Jg3JQR1vbotwEoAHtSg,28080
+ai_computer_client-0.3.0.dist-info/METADATA,sha256=rhUG0es12ZwHZApMsT8CBna_BB_2VJSrpMVr9Kc3wcs,5654
+ai_computer_client-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_computer_client-0.3.0.dist-info/licenses/LICENSE,sha256=N_0S5G1Wik2LWVDViJMAM0Z-6vTBX1bvDjb8vouBA-c,1068
+ai_computer_client-0.3.0.dist-info/RECORD,,

ai_computer_client-0.1.1.dist-info/RECORD

@@ -1,6 +0,0 @@
-ai_computer/__init__.py,sha256=g2yDiDT6i24MV3Y2JNfk2ZFkYvxvrN6NXywjZPslXDY,149
-ai_computer/client.py,sha256=PaBRmSFzgOXNxxQAd3zSCaqzZ8rcvUOhsnFulu40uhc,10214
-ai_computer_client-0.1.1.dist-info/METADATA,sha256=DZpD89o215WIDWe213XGNFOhEMUQ61P5kUzzLSr0eaE,5654
-ai_computer_client-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ai_computer_client-0.1.1.dist-info/licenses/LICENSE,sha256=N_0S5G1Wik2LWVDViJMAM0Z-6vTBX1bvDjb8vouBA-c,1068
-ai_computer_client-0.1.1.dist-info/RECORD,,