ai-computer-client 0.1.0__tar.gz

ai_computer_client-0.1.0/.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Distribution
+dist/
+build/
+*.egg-info/
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/
+.tox/
+
+# Misc
+.DS_Store 

ai_computer_client-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 AI Computer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

ai_computer_client-0.1.0/PKG-INFO

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: ai-computer-client
+Version: 0.1.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
+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:
+        # Execute some code
+        code = """
+        print('Hello from AI Computer!')
+        result = 42
+        print(f'The answer is {result}')
+        """
+        
+        # Stream execution
+        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())
+```
+
+## Features
+
+- Asynchronous API
+- Streaming execution 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.
+
+#### Methods
+
+- `setup()`: Initialize the client and create a sandbox
+- `execute_code(code: str, timeout: int = 30)`: Execute code and return combined output
+- `execute_code_stream(code: str, timeout: int = 30)`: Execute code and stream output
+- `cleanup()`: Delete the sandbox
+- `wait_for_ready()`: Wait for sandbox to be ready
+
+## Development
+
+### Running Tests
+
+```bash
+pip install -e ".[dev]"
+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.1.0/README.md

@@ -0,0 +1,97 @@
+# 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:
+        # Execute some code
+        code = """
+        print('Hello from AI Computer!')
+        result = 42
+        print(f'The answer is {result}')
+        """
+        
+        # Stream execution
+        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())
+```
+
+## Features
+
+- Asynchronous API
+- Streaming execution 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.
+
+#### Methods
+
+- `setup()`: Initialize the client and create a sandbox
+- `execute_code(code: str, timeout: int = 30)`: Execute code and return combined output
+- `execute_code_stream(code: str, timeout: int = 30)`: Execute code and stream output
+- `cleanup()`: Delete the sandbox
+- `wait_for_ready()`: Wait for sandbox to be ready
+
+## Development
+
+### Running Tests
+
+```bash
+pip install -e ".[dev]"
+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.1.0/ai_computer/__init__.py

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

ai_computer_client-0.1.0/ai_computer/client.py

@@ -0,0 +1,265 @@
+import aiohttp
+import json
+import asyncio
+from typing import Optional, Dict, AsyncGenerator, Union
+from dataclasses import dataclass
+
+@dataclass
+class SandboxResponse:
+    """Response from sandbox operations.
+    
+    Attributes:
+        success: Whether the operation was successful
+        data: Optional response data
+        error: Optional error message if operation failed
+    """
+    success: bool
+    data: Optional[Dict] = None
+    error: Optional[str] = None
+
+@dataclass
+class StreamEvent:
+    """Event from streaming code execution.
+    
+    Attributes:
+        type: Type of event ('stdout', 'stderr', 'info', 'error', 'completed', 'keepalive')
+        data: Event data
+    """
+    type: str
+    data: str
+
+class SandboxClient:
+    """Client for interacting with the AI Sandbox service.
+    
+    This client provides methods to execute Python code in an isolated sandbox environment.
+    It handles authentication, sandbox creation/deletion, and code execution.
+    
+    Args:
+        base_url: The base URL of the sandbox service
+        token: Optional pre-existing authentication token
+    """
+    
+    def __init__(
+        self,
+        base_url: str = "http://aicomputer.dev",
+        token: Optional[str] = None
+    ):
+        self.base_url = base_url.rstrip('/')
+        self.token = token
+        self.sandbox_id = None
+        
+    async def setup(self) -> SandboxResponse:
+        """Initialize the client and create a sandbox.
+        
+        This method:
+        1. Gets a development token (if not provided)
+        2. Creates a new sandbox
+        3. Waits for the sandbox to be ready
+        
+        Returns:
+            SandboxResponse indicating success/failure
+        """
+        async with aiohttp.ClientSession() as session:
+            # Get development token if not provided
+            if not self.token:
+                async with session.post(f"{self.base_url}/dev/token") as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        self.token = data["access_token"]
+                    else:
+                        text = await response.text()
+                        return SandboxResponse(success=False, error=text)
+                
+            # Create sandbox
+            headers = {"Authorization": f"Bearer {self.token}"}
+            async with session.post(f"{self.base_url}/api/v1/sandbox/create", headers=headers) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    self.sandbox_id = data["sandbox_id"]
+                    # Wait for sandbox to be ready
+                    ready = await self.wait_for_ready()
+                    if not ready.success:
+                        return ready
+                    return SandboxResponse(success=True, data=data)
+                else:
+                    text = await response.text()
+                    return SandboxResponse(success=False, error=text)
+    
+    async def wait_for_ready(self, max_retries: int = 30, delay: int = 1) -> SandboxResponse:
+        """Wait for the sandbox to be in Running state.
+        
+        Args:
+            max_retries: Maximum number of status check attempts
+            delay: Delay between retries in seconds
+            
+        Returns:
+            SandboxResponse indicating if sandbox is ready
+        """
+        if not self.token or not self.sandbox_id:
+            return SandboxResponse(success=False, error="Client not properly initialized")
+            
+        headers = {"Authorization": f"Bearer {self.token}"}
+        
+        for _ in range(max_retries):
+            async with aiohttp.ClientSession() as session:
+                async with session.get(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/status",
+                    headers=headers
+                ) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        if data["status"] == "Running":
+                            return SandboxResponse(success=True, data=data)
+                    await asyncio.sleep(delay)
+        
+        return SandboxResponse(success=False, error="Sandbox failed to become ready")
+    
+    async def execute_code(
+        self,
+        code: Union[str, bytes],
+        timeout: int = 30
+    ) -> SandboxResponse:
+        """Execute Python code in the sandbox and return the combined output.
+        
+        This method collects all output from the streaming response and returns it as a single result.
+        It captures both stdout and stderr, and handles any errors during execution.
+        
+        Args:
+            code: Python code to execute
+            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 = {
+            "code": code,
+            "timeout": timeout
+        }
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/execute",
+                    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 execute_code_stream(
+        self,
+        code: Union[str, bytes],
+        timeout: int = 30
+    ) -> AsyncGenerator[StreamEvent, None]:
+        """Execute Python code in the sandbox and stream the output.
+        
+        This method returns an async generator that yields StreamEvent objects containing
+        the type of event and the associated data.
+        
+        Args:
+            code: Python code to execute
+            timeout: Maximum execution time in seconds
+            
+        Yields:
+            StreamEvent objects with execution output/events
+        """
+        if not self.token or not self.sandbox_id:
+            yield StreamEvent(type="error", data="Client not properly initialized. Call setup() first")
+            return
+            
+        # Ensure sandbox is ready
+        ready = await self.wait_for_ready()
+        if not ready.success:
+            yield StreamEvent(type="error", data=ready.error or "Sandbox not ready")
+            return
+            
+        headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "code": code,
+            "timeout": timeout
+        }
+        
+        try:
+            # Create a ClientTimeout object with all timeout settings
+            timeout_settings = aiohttp.ClientTimeout(
+                total=timeout + 30,  # Add buffer for connection overhead
+                connect=30,
+                sock_connect=30,
+                sock_read=timeout + 30
+            )
+            
+            async with aiohttp.ClientSession(timeout=timeout_settings) as session:
+                async with session.post(
+                    f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}/execute/stream",
+                    headers=headers,
+                    json=data
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        yield StreamEvent(type="error", data=error_text)
+                        return
+                        
+                    # Process the streaming response
+                    async for line in response.content:
+                        if line:
+                            try:
+                                event = json.loads(line.decode())
+                                yield StreamEvent(type=event['type'], data=event['data'])
+                                
+                                # Stop if we receive an error or completed event
+                                if event['type'] in ['error', 'completed']:
+                                    break
+                            except json.JSONDecodeError as e:
+                                yield StreamEvent(type="error", data=f"Failed to parse event: {str(e)}")
+                                break
+                                
+        except Exception as e:
+            yield StreamEvent(type="error", data=f"Connection error: {str(e)}")
+    
+    async def cleanup(self) -> SandboxResponse:
+        """Delete the sandbox.
+        
+        Returns:
+            SandboxResponse indicating success/failure of cleanup
+        """
+        if not self.token or not self.sandbox_id:
+            return SandboxResponse(success=True)
+            
+        headers = {"Authorization": f"Bearer {self.token}"}
+        async with aiohttp.ClientSession() as session:
+            async with session.delete(
+                f"{self.base_url}/api/v1/sandbox/{self.sandbox_id}",
+                headers=headers
+            ) as response:
+                if response.status == 200:
+                    data = await response.json()
+                    self.sandbox_id = None
+                    return SandboxResponse(success=True, data=data)
+                else:
+                    text = await response.text()
+                    return SandboxResponse(success=False, error=text) 

ai_computer_client-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ai-computer-client"
+version = "0.1.0"
+description = "Python client for interacting with the AI Computer service"
+readme = "README.md"
+requires-python = ">=3.7"
+license = { text = "MIT" }
+authors = [
+    { name = "AI Computer" },
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "aiohttp>=3.8.0",
+    "typing-extensions>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ColeMurray/ai-computer-client-python"
+Documentation = "https://github.com/ColeMurray/ai-computer-client-python#readme"
+
+[tool.hatch.build.targets.wheel]
+packages = ["ai_computer"]
+
+[tool.hatch.build]
+include = [
+    "ai_computer/**/*.py",
+    "ai_computer/**/*.pyi",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"
+asyncio_default_fixture_loop_scope = "function"