ai-computer-client 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

ai_computer/submodules/filesystem.py

@@ -0,0 +1,373 @@
+import aiohttp
+import asyncio
+import os
+import mimetypes
+from pathlib import Path
+from typing import Optional, Union, BinaryIO, Dict, Any
+
+from .base import BaseSubmodule
+from ..models import FileOperationResponse, SandboxResponse
+
+class FileSystemModule(BaseSubmodule):
+    """File system operations for the sandbox environment.
+    
+    This module provides methods for file operations such as uploading,
+    downloading, reading, and writing files in the sandbox.
+    """
+    
+    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 (absolute path starting with /)
+            chunk_size: Size of chunks for reading large files
+            timeout: Maximum upload time in seconds
+            
+        Returns:
+            FileOperationResponse containing upload results
+        """
+        ready = await self._ensure_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'),  # Pass file object directly for streaming
+                         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,
+        remote_path: str,
+        local_path: Optional[Union[str, Path]] = None,
+        timeout: int = 300  # 5 minutes
+    ) -> FileOperationResponse:
+        """Download a file from the sandbox.
+        
+        Args:
+            remote_path: Path to the file in the sandbox
+            local_path: Local path to save the file (if None, uses the filename from remote_path)
+            timeout: Maximum download time in seconds
+            
+        Returns:
+            FileOperationResponse containing download results
+        """
+        ready = await self._ensure_ready()
+        if not ready.success:
+            return FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+            
+        # Ensure path is absolute and normalize any double slashes
+        if not remote_path.startswith('/'):
+            remote_path = f"/{remote_path}"
+        clean_path = '/'.join(part for part in remote_path.split('/') if part)
+        clean_path = f"/{clean_path}"
+            
+        # Determine local path if not provided
+        if local_path is None:
+            local_path = os.path.basename(remote_path)
+        local_path = Path(local_path)
+        
+        # Create parent directories if they don't exist
+        os.makedirs(local_path.parent, exist_ok=True)
+        
+        headers = {
+            "Authorization": f"Bearer {self.token}"
+        }
+        
+        params = {
+            "path": remote_path
+        }
+        
+        timeout_settings = aiohttp.ClientTimeout(
+            total=timeout,
+            connect=30,
+            sock_connect=30,
+            sock_read=timeout
+        )
+        
+        try:
+            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",
+                    headers=headers,
+                    params=params
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Download failed: {error_text}"
+                        )
+                    
+                    # Get content disposition header to extract filename
+                    content_disposition = response.headers.get('Content-Disposition', '')
+                    filename = os.path.basename(remote_path)  # Default to basename of remote path
+                    
+                    # Extract filename from content disposition if available
+                    if 'filename=' in content_disposition:
+                        filename = content_disposition.split('filename=')[1].strip('"\'')
+                    
+                    # Save the file
+                    with open(local_path, 'wb') as f:
+                        size = 0
+                        async for chunk in response.content.iter_chunked(1024 * 1024):  # 1MB chunks
+                            f.write(chunk)
+                            size += len(chunk)
+                    
+                    return FileOperationResponse(
+                        success=True,
+                        filename=filename,
+                        size=size,
+                        path=str(local_path),
+                        message=f"File downloaded successfully to {local_path}"
+                    )
+                    
+        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 read_file(self, path: str, encoding: str = 'utf-8') -> SandboxResponse:
+        """Read a file from the sandbox and return its contents.
+        
+        Args:
+            path: Path to the file in the sandbox
+            encoding: Text encoding to use (set to None for binary files)
+            
+        Returns:
+            SandboxResponse with the file contents in the data field
+        """
+        ready = await self._ensure_ready()
+        if not ready.success:
+            return ready
+        
+        # Ensure path is absolute and normalize any double slashes
+        if not path.startswith('/'):
+            path = f"/{path}"
+        clean_path = '/'.join(part for part in path.split('/') if part)
+        clean_path = f"/{clean_path}"
+        
+        headers = {
+            "Authorization": f"Bearer {self.token}"
+        }
+        
+        params = {
+            "path": clean_path
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files/download",
+                    headers=headers,
+                    params=params
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return SandboxResponse(
+                            success=False,
+                            error=f"Failed to read file: {error_text}"
+                        )
+                    
+                    # Read the content
+                    content = await response.read()
+                    size = len(content)
+                    
+                    # Decode if needed
+                    if encoding is not None:
+                        try:
+                            content = content.decode(encoding)
+                        except UnicodeDecodeError:
+                            return SandboxResponse(
+                                success=False,
+                                error=f"Failed to decode file with encoding {encoding}"
+                            )
+                    
+                    return SandboxResponse(
+                        success=True,
+                        data={
+                            'content': content,
+                            'size': size
+                        }
+                    )
+                    
+        except Exception as e:
+            return SandboxResponse(
+                success=False,
+                error=f"Failed to read file: {str(e)}"
+            )
+    
+    async def write_file(
+        self, 
+        path: str, 
+        content: Union[str, bytes],
+        encoding: str = 'utf-8'
+    ) -> SandboxResponse:
+        """Write content to a file in the sandbox.
+        
+        Args:
+            path: Path to the file in the sandbox
+            content: Content to write (string or bytes)
+            encoding: Text encoding to use (ignored for bytes content)
+            
+        Returns:
+            SandboxResponse indicating success or failure
+        """
+        ready = await self._ensure_ready()
+        if not ready.success:
+            return ready
+        
+        # Convert string to bytes if needed
+        if isinstance(content, str):
+            try:
+                content = content.encode(encoding)
+            except UnicodeEncodeError:
+                return SandboxResponse(
+                    success=False,
+                    error=f"Failed to encode content with encoding {encoding}"
+                )
+        
+        # Ensure path is absolute and normalize any double slashes
+        if not path.startswith('/'):
+            path = f"/{path}"
+        clean_path = '/'.join(part for part in path.split('/') if part)
+        clean_path = f"/{clean_path}"
+        
+        # Extract the filename and destination directory
+        filename = os.path.basename(path)
+        destination = os.path.dirname(path)
+        
+        # Create a temporary file with the content
+        import tempfile
+        temp_file = tempfile.NamedTemporaryFile(delete=False)
+        try:
+            temp_file.write(content)
+            temp_file.close()
+            
+            # Upload the temporary file
+            result = await self.upload_file(
+                file_path=temp_file.name,
+                destination=destination
+            )
+            
+            if result.success:
+                return SandboxResponse(
+                    success=True,
+                    data={
+                        'path': result.path,
+                        'size': result.size
+                    }
+                )
+            else:
+                return SandboxResponse(
+                    success=False,
+                    error=f"Failed to write file: {result.error}"
+                )
+        except Exception as e:
+            return SandboxResponse(
+                success=False,
+                error=f"Failed to write file: {str(e)}"
+            )
+        finally:
+            # Clean up the temporary file
+            if os.path.exists(temp_file.name):
+                os.unlink(temp_file.name)
+

ai_computer/submodules/shell.py

@@ -0,0 +1,52 @@
+import aiohttp
+import asyncio
+from typing import Optional, List, Dict, Any
+
+from .base import BaseSubmodule
+from ..models import SandboxResponse, StreamEvent
+
+class ShellModule(BaseSubmodule):
+    """Shell command execution for the sandbox environment.
+    
+    This module provides methods for executing shell commands in the sandbox.
+    """
+    
+    async def execute(
+        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
+        """
+        ready = await self._ensure_ready()
+        if not ready.success:
+            return ready
+            
+        headers = self._get_headers()
+        
+        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:
+                    return await self._handle_response(response)
+                    
+        except Exception as e:
+            return SandboxResponse(success=False, error=f"Connection error: {str(e)}")

{ai_computer_client-0.3.2.dist-info → ai_computer_client-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-computer-client
-Version: 0.3.2
+Version: 0.3.3
 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.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+ai_computer/__init__.py,sha256=0L4QSM3q4zWzYqNwisOqF_8ObcMdacmlXHbn55RX9YU,364
+ai_computer/client.py,sha256=ozdVAp_I8l7lGI5zI8cQUN00RfJ_V8XhrkjspwHV5yI,14402
+ai_computer/models.py,sha256=JG3gTKqCVrKlKsr4REAq5tb-WmZttn78LzxlrNiOJsQ,1214
+ai_computer/submodules/__init__.py,sha256=kz4NTuF9r3i_VwTLWsyRHaHKereyq0kFe1HrfKQLtB4,162
+ai_computer/submodules/base.py,sha256=3WoURENRnho26PkdghKM8S9s3-GYr11CwZidXhs-fFM,2530
+ai_computer/submodules/code.py,sha256=U0cLcB7iu90QS3BbFP31oNPJYgpgvYSWzxakhxMa3-A,11216
+ai_computer/submodules/filesystem.py,sha256=79gBefBIMj8qwFwTdVrpktOTqfvAfeZTf_jdTSxtcHs,13610
+ai_computer/submodules/shell.py,sha256=lcy4CpgoJWN6tsGi-IUb6PQpywLSNOD3_lt_yvSU6Y8,1632
+ai_computer_client-0.3.3.dist-info/METADATA,sha256=5kn2XaOh0LeQR7hexOsd1C1pOPrbr-pfWPLhDPUIaWU,5658
+ai_computer_client-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_computer_client-0.3.3.dist-info/licenses/LICENSE,sha256=N_0S5G1Wik2LWVDViJMAM0Z-6vTBX1bvDjb8vouBA-c,1068
+ai_computer_client-0.3.3.dist-info/RECORD,,

ai_computer_client-0.3.2.dist-info/RECORD

@@ -1,6 +0,0 @@
-ai_computer/__init__.py,sha256=GlAloQ10Yg8fIBKNj9HXovNHWAq9PsazLtYCIS1jOig,197
-ai_computer/client.py,sha256=fo0OxmbZPYsSCWeYWkBzEGGDQ7bvx0qqvijDkr8zO8M,28733
-ai_computer_client-0.3.2.dist-info/METADATA,sha256=aFEKdik1aa7F2hBhhWImmdewJgekuXnqDU5QJoPKzpU,5658
-ai_computer_client-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ai_computer_client-0.3.2.dist-info/licenses/LICENSE,sha256=N_0S5G1Wik2LWVDViJMAM0Z-6vTBX1bvDjb8vouBA-c,1068
-ai_computer_client-0.3.2.dist-info/RECORD,,