ai-computer-client 0.3.1__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.3.dist-info/METADATA

@@ -0,0 +1,222 @@
+Metadata-Version: 2.4
+Name: ai-computer-client
+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
+Author: AI Computer
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: typing-extensions>=4.0.0
+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'
+Description-Content-Type: text/markdown
+
+# AI Computer Python Client
+
+A Python client for interacting with the AI Computer service. This client provides a simple interface for executing Python code in an isolated sandbox environment.
+
+## Installation
+
+```bash
+pip install ai-computer-client
+```
+
+## Quick Start
+
+```python
+import asyncio
+from ai_computer import SandboxClient
+
+async def main():
+    # Initialize the client
+    client = SandboxClient()
+    
+    # Setup the client (gets token and creates sandbox)
+    setup_response = await client.setup()
+    if not setup_response.success:
+        print(f"Setup failed: {setup_response.error}")
+        return
+    
+    try:
+        # Example 1: Simple code execution
+        code = """x = 10
+y = 20
+result = x + y
+print(f"The sum is: {result}")"""
+        
+        print("\nExample 1: Simple execution")
+        print("-" * 50)
+        response = await client.execute_code(code)
+        if response.success:
+            print("Execution result:", response.data)
+        else:
+            print("Execution failed:", response.error)
+
+        # Example 2: Streaming execution
+        code = """import time
+
+for i in range(5):
+    print(f"Processing step {i + 1}")
+    time.sleep(1)  # Simulate work
+    
+result = "Calculation complete!"
+print(result)"""
+        
+        print("\nExample 2: Streaming execution")
+        print("-" * 50)
+        async for event in client.execute_code_stream(code):
+            if event.type == 'stdout':
+                print(f"Output: {event.data}")
+            elif event.type == 'stderr':
+                print(f"Error: {event.data}")
+            elif event.type == 'error':
+                print(f"Execution error: {event.data}")
+                break
+            elif event.type == 'completed':
+                print("Execution completed")
+                break
+    
+    finally:
+        # Clean up
+        await client.cleanup()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+Example output:
+```
+Example 1: Simple execution
+--------------------------------------------------
+Execution result: {'output': 'The sum is: 30\n', 'sandbox_id': '06a30496-b535-47b0-9fe7-34f7ec483cd7'}
+
+Example 2: Streaming execution
+--------------------------------------------------
+Output: Processing step 1
+Output: Processing step 2
+Output: Processing step 3
+Output: Processing step 4
+Output: Processing step 5
+Output: Calculation complete!
+Execution completed
+```
+
+## Features
+
+- Asynchronous API for efficient execution
+- Real-time streaming of code output
+- Automatic sandbox management
+- Error handling and timeouts
+- Type hints for better IDE support
+
+## API Reference
+
+### SandboxClient
+
+The main client class for interacting with the AI Computer service.
+
+```python
+client = SandboxClient(base_url="http://api.aicomputer.dev")
+```
+
+#### Methods
+
+##### `async setup() -> SandboxResponse`
+Initialize the client and create a sandbox. This must be called before executing any code.
+
+```python
+response = await client.setup()
+if response.success:
+    print("Sandbox ready")
+```
+
+##### `async execute_code(code: str, timeout: int = 30) -> SandboxResponse`
+Execute Python code and return the combined output.
+
+```python
+code = """
+x = 10
+y = 20
+result = x + y
+print(f"The sum is: {result}")
+"""
+
+response = await client.execute_code(code)
+if response.success:
+    print("Output:", response.data['output'])
+```
+
+##### `async execute_code_stream(code: str, timeout: int = 30) -> AsyncGenerator[StreamEvent, None]`
+Execute Python code and stream the output in real-time.
+
+```python
+async for event in client.execute_code_stream(code):
+    if event.type == 'stdout':
+        print("Output:", event.data)
+    elif event.type == 'stderr':
+        print("Error:", event.data)
+```
+
+##### `async cleanup() -> SandboxResponse`
+Delete the sandbox and clean up resources.
+
+```python
+await client.cleanup()
+```
+
+### Response Types
+
+#### SandboxResponse
+```python
+@dataclass
+class SandboxResponse:
+    success: bool
+    data: Optional[Dict] = None
+    error: Optional[str] = None
+```
+
+#### StreamEvent
+```python
+@dataclass
+class StreamEvent:
+    type: str  # 'stdout', 'stderr', 'error', 'completed'
+    data: str
+```
+
+## Development
+
+### Running Tests
+
+```bash
+# Install development dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+### Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+MIT License 

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,,