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

ai_computer/submodules/filesystem.py

@@ -0,0 +1,438 @@
+import aiohttp
+import asyncio
+import os
+import mimetypes
+from pathlib import Path
+from typing import Optional, Union, BinaryIO, Dict, Any
+from urllib.parse import quote
+
+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[str] = None,
+        timeout: int = 300
+    ) -> FileOperationResponse:
+        """Download a file from the sandbox to the local filesystem.
+        
+        Args:
+            remote_path: Path to the file in the sandbox
+            local_path: Local path to save the file (defaults to basename of 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
+            )
+            
+        # 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}"
+        }
+        
+        # Store original path for error messages
+        original_path = remote_path
+        
+        # Ensure path is absolute
+        if not remote_path.startswith('/'):
+            remote_path = f"/{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:
+                # Use the new API endpoint with query parameters
+                url = f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files"
+                params = {"path": quote(remote_path)}
+                
+                async with session.get(
+                    url,
+                    headers=headers,
+                    params=params
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Failed to download file '{original_path}': {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: Optional[str] = 'utf-8') -> SandboxResponse:
+        """Read a file from the sandbox.
+        
+        Args:
+            path: Path to the file in the sandbox
+            encoding: Text encoding to use (None for binary)
+            
+        Returns:
+            SandboxResponse with the file content
+        """
+        ready = await self._ensure_ready()
+        if not ready.success:
+            return ready
+            
+        # Ensure path is absolute
+        if not path.startswith('/'):
+            path = f"/{path}"
+            
+        headers = {
+            "Authorization": f"Bearer {self.token}"
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                # Use the new API endpoint with query parameters
+                url = f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files"
+                params = {"path": quote(path)}
+                
+                async with session.get(
+                    url,
+                    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)
+                
+    async def download_bytes(self, path: str, timeout: int = 300) -> SandboxResponse:
+        """Download a file from the sandbox into memory.
+        
+        Args:
+            path: Path to the file in the sandbox
+            timeout: Maximum download time in seconds
+            
+        Returns:
+            SandboxResponse with the file content as bytes in the data field
+        """
+        ready = await self._ensure_ready()
+        if not ready.success:
+            return ready
+            
+        # Ensure path is absolute
+        if not path.startswith('/'):
+            path = f"/{path}"
+            
+        headers = {
+            "Authorization": f"Bearer {self.token}"
+        }
+        
+        timeout_settings = aiohttp.ClientTimeout(
+            total=timeout,
+            connect=30,
+            sock_connect=30,
+            sock_read=timeout
+        )
+        
+        try:
+            async with aiohttp.ClientSession(timeout=timeout_settings) as session:
+                # Use the new API endpoint with query parameters
+                url = f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/files"
+                params = {"path": quote(path)}
+                
+                async with session.get(
+                    url,
+                    headers=headers,
+                    params=params
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return SandboxResponse(
+                            success=False,
+                            error=f"Download failed: {error_text}"
+                        )
+                    
+                    # Read the content
+                    content = await response.read()
+                    size = len(content)
+                    
+                    return SandboxResponse(
+                        success=True,
+                        data={
+                            'content': content,
+                            'size': size
+                        }
+                    )
+                    
+        except Exception as e:
+            return SandboxResponse(
+                success=False,
+                error=f"Failed to download file: {str(e)}"
+            )
+

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.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-computer-client
-Version: 0.3.2
+Version: 0.3.4
 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
@@ -23,6 +23,9 @@ Provides-Extra: dev
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
 Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Provides-Extra: integration
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'integration'
+Requires-Dist: pytest>=7.0.0; extra == 'integration'
 Description-Content-Type: text/markdown
 
 # AI Computer Python Client
@@ -201,14 +204,34 @@ class StreamEvent:
 
 ### Running Tests
 
-```bash
-# Install development dependencies
-pip install -e ".[dev]"
+To run the unit tests:
 
-# Run tests
+```bash
 pytest
 ```
 
+### Running Integration Tests
+
+We have a comprehensive suite of integration tests that validate the client against the live API. These tests are automatically run as part of our CI/CD pipeline before each release.
+
+To run the integration tests locally:
+
+1. Set the required environment variables:
+
+```bash
+export AI_COMPUTER_API_KEY="your_api_key_here"
+# Optional: Use a specific sandbox ID (if not provided, a new one will be created)
+export AI_COMPUTER_SANDBOX_ID="optional_sandbox_id"
+```
+
+2. Run the tests:
+
+```bash
+python -m integration_tests.test_integration
+```
+
+For more details, see the [Integration Tests README](integration_tests/README.md).
+
 ### Contributing
 
 1. Fork the repository

ai_computer_client-0.3.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+ai_computer/__init__.py,sha256=0L4QSM3q4zWzYqNwisOqF_8ObcMdacmlXHbn55RX9YU,364
+ai_computer/client.py,sha256=U-xm04Koy429TbiMwJTURLeRH3NWy3lJFX5i7rvvacs,15090
+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=8GNpgL-6aVpD1UNtq-nvtvnMQy72dWKe247YA4cLsOs,11201
+ai_computer/submodules/filesystem.py,sha256=7x3g6Cr8PDKIuc9ogETuVjcOAlFKoHXhUcuntgRJv3s,15831
+ai_computer/submodules/shell.py,sha256=lcy4CpgoJWN6tsGi-IUb6PQpywLSNOD3_lt_yvSU6Y8,1632
+ai_computer_client-0.3.4.dist-info/METADATA,sha256=vVUG7UlP2FxGwugFbRm4gdL_JzLW1vt-S_kOH1W6Ugk,6407
+ai_computer_client-0.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_computer_client-0.3.4.dist-info/licenses/LICENSE,sha256=N_0S5G1Wik2LWVDViJMAM0Z-6vTBX1bvDjb8vouBA-c,1068
+ai_computer_client-0.3.4.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,,