ai-computer-client 0.1.0__tar.gz → 0.2.0__tar.gz

{ai_computer_client-0.1.0 → ai_computer_client-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-computer-client
-Version: 0.1.0
+Version: 0.2.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
@@ -50,16 +50,34 @@ async def main():
     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}')
-        """
+        # Example 1: Simple code execution
+        code = """x = 10
+y = 20
+result = x + y
+print(f"The sum is: {result}")"""
         
-        # Stream execution
+        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}")
@@ -80,10 +98,27 @@ 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
-- Streaming execution output
+- Asynchronous API for efficient execution
+- Real-time streaming of code output
 - Automatic sandbox management
 - Error handling and timeouts
 - Type hints for better IDE support
@@ -94,20 +129,83 @@ if __name__ == "__main__":
 
 The main client class for interacting with the AI Computer service.
 
+```python
+client = SandboxClient(base_url="http://aicomputer.dev")
+```
+
 #### 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
+##### `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
 ```
 

ai_computer_client-0.2.0/README.md

@@ -0,0 +1,195 @@
+# 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://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.1.0 → ai_computer_client-0.2.0}/ai_computer/client.py

@@ -1,7 +1,7 @@
 import aiohttp
 import json
 import asyncio
-from typing import Optional, Dict, AsyncGenerator, Union
+from typing import Optional, Dict, AsyncGenerator, Union, List
 from dataclasses import dataclass
 
 @dataclass
@@ -241,6 +241,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.
         

{ai_computer_client-0.1.0 → ai_computer_client-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ai-computer-client"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python client for interacting with the AI Computer service"
 readme = "README.md"
 requires-python = ">=3.7"

ai_computer_client-0.1.0/README.md

@@ -1,97 +0,0 @@
-# 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