ai-computer-client 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

ai_computer/__init__.py

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

ai_computer/client.py

@@ -1,8 +1,11 @@
 import aiohttp
 import json
 import asyncio
-from typing import Optional, Dict, AsyncGenerator, Union, List
+from typing import Optional, Dict, AsyncGenerator, Union, List, BinaryIO
 from dataclasses import dataclass
+import os
+import mimetypes
+from pathlib import Path
 
 @dataclass
 class SandboxResponse:
@@ -28,6 +31,25 @@ class StreamEvent:
     type: str
     data: str
 
+@dataclass
+class FileOperationResponse:
+    """Response from file operations.
+    
+    Attributes:
+        success: Whether the operation was successful
+        filename: Name of the file
+        size: Size of the file in bytes
+        path: Path where the file was saved
+        message: Optional status message
+        error: Optional error message if operation failed
+    """
+    success: bool
+    filename: Optional[str] = None
+    size: Optional[int] = None
+    path: Optional[str] = None
+    message: Optional[str] = None
+    error: Optional[str] = None
+
 class SandboxClient:
     """Client for interacting with the AI Sandbox service.
     
@@ -315,4 +337,425 @@ class SandboxClient:
                     return SandboxResponse(success=True, data=data)
                 else:
                     text = await response.text()
-                    return SandboxResponse(success=False, error=text) 
+                    return SandboxResponse(success=False, error=text)
+
+    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
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                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 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').read(),
+                         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,
+        sandbox_path: str,
+        local_path: Optional[Union[str, Path]] = None,
+        chunk_size: int = 8192,  # 8KB chunks for download
+        timeout: int = 300  # 5 minutes
+    ) -> FileOperationResponse:
+        """Download a file from the sandbox environment.
+        
+        Args:
+            sandbox_path: Path to the file in the sandbox (must be an absolute path starting with /).
+                        Any double slashes in the path will be normalized.
+            local_path: Local path to save the file (default: current directory with original filename)
+            chunk_size: Size of chunks for downloading large files
+            timeout: Maximum download time in seconds
+            
+        Returns:
+            FileOperationResponse containing download results
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                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 FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+
+        # Ensure path is absolute and normalize any double slashes
+        if not sandbox_path.startswith('/'):
+            sandbox_path = f"/{sandbox_path}"
+        clean_path = '/'.join(part for part in sandbox_path.split('/') if part)
+        clean_path = f"/{clean_path}"
+        
+        # Determine local path
+        if local_path is None:
+            local_path = Path(os.path.basename(sandbox_path))
+        else:
+            local_path = Path(local_path)
+
+        # Create parent directories if they don't exist
+        local_path.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            timeout_settings = aiohttp.ClientTimeout(
+                total=timeout,
+                connect=30,
+                sock_connect=30,
+                sock_read=timeout
+            )
+
+            headers = {
+                "Authorization": f"Bearer {self.token}"
+            }
+
+            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{clean_path}",
+                    headers=headers
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Download failed: {error_text}"
+                        )
+
+                    # Get content length if available
+                    total_size = int(response.headers.get('content-length', 0))
+
+                    # Download the file in chunks
+                    downloaded_size = 0
+                    try:
+                        with open(local_path, 'wb') as f:
+                            async for chunk in response.content.iter_chunked(chunk_size):
+                                f.write(chunk)
+                                downloaded_size += len(chunk)
+
+                        return FileOperationResponse(
+                            success=True,
+                            filename=local_path.name,
+                            size=downloaded_size or total_size,
+                            path=str(local_path.absolute()),
+                            message="File downloaded successfully"
+                        )
+                    except Exception as e:
+                        # Clean up partial download
+                        if local_path.exists():
+                            local_path.unlink()
+                        raise e
+
+        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 upload_bytes(
+        self,
+        content: Union[bytes, BinaryIO],
+        filename: str,
+        destination: str = "/workspace",
+        content_type: Optional[str] = None,
+        timeout: int = 300  # 5 minutes
+    ) -> FileOperationResponse:
+        """Upload bytes or a file-like object to the sandbox environment.
+        
+        Args:
+            content: Bytes or file-like object to upload
+            filename: Name to give the file in the sandbox
+            destination: Destination path in the sandbox (absolute path starting with /)
+            content_type: Optional MIME type (will be guessed from filename if not provided)
+            timeout: Maximum upload time in seconds
+            
+        Returns:
+            FileOperationResponse containing upload results
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                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 FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+
+        try:
+            # Handle both bytes and file-like objects
+            if isinstance(content, bytes):
+                file_obj = content
+                content_length = len(content)
+            else:
+                # Ensure we're at the start of the file
+                if hasattr(content, 'seek'):
+                    content.seek(0)
+                file_obj = content
+                # Try to get content length if possible
+                content_length = None
+                if hasattr(content, 'seek') and hasattr(content, 'tell'):
+                    try:
+                        current_pos = content.tell()
+                        content.seek(0, os.SEEK_END)
+                        content_length = content.tell()
+                        content.seek(current_pos)
+                    except (OSError, IOError):
+                        pass
+
+            # Validate size if we can determine it
+            if content_length and content_length > 100 * 1024 * 1024:  # 100MB limit
+                return FileOperationResponse(
+                    success=False,
+                    error="Content too large. Maximum size is 100MB"
+                )
+
+            # Prepare the upload
+            headers = {
+                "Authorization": f"Bearer {self.token}"
+            }
+
+            # Guess content type if not provided
+            if not content_type:
+                content_type = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+            
+            # Prepare multipart form data
+            data = aiohttp.FormData()
+            data.add_field('file',
+                         file_obj,
+                         filename=filename,
+                         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_bytes(
+        self,
+        sandbox_path: str,
+        chunk_size: int = 8192,  # 8KB chunks for download
+        timeout: int = 300  # 5 minutes
+    ) -> Union[bytes, FileOperationResponse]:
+        """Download a file from the sandbox environment into memory.
+        
+        Args:
+            sandbox_path: Path to the file in the sandbox (must be an absolute path starting with /).
+                        Any double slashes in the path will be normalized.
+            chunk_size: Size of chunks for downloading large files
+            timeout: Maximum download time in seconds
+            
+        Returns:
+            On success: The file contents as bytes
+            On failure: FileOperationResponse with error details
+        """
+        if not self.token or not self.sandbox_id:
+            return FileOperationResponse(
+                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 FileOperationResponse(
+                success=False,
+                error=ready.error or "Sandbox not ready"
+            )
+
+        # Ensure path is absolute and normalize any double slashes
+        if not sandbox_path.startswith('/'):
+            sandbox_path = f"/{sandbox_path}"
+        clean_path = '/'.join(part for part in sandbox_path.split('/') if part)
+        clean_path = f"/{clean_path}"
+
+        try:
+            timeout_settings = aiohttp.ClientTimeout(
+                total=timeout,
+                connect=30,
+                sock_connect=30,
+                sock_read=timeout
+            )
+
+            headers = {
+                "Authorization": f"Bearer {self.token}"
+            }
+
+            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{clean_path}",
+                    headers=headers
+                ) as response:
+                    if response.status != 200:
+                        error_text = await response.text()
+                        return FileOperationResponse(
+                            success=False,
+                            error=f"Download failed: {error_text}"
+                        )
+
+                    # Read the entire response into memory
+                    content = await response.read()
+                    
+                    return content
+
+        except asyncio.TimeoutError:
+            return FileOperationResponse(
+                success=False,
+                error=f"Download timed out after {timeout} seconds"
+            )
+        except Exception as e:
+            return FileOperationResponse(
+                success=False,
+                error=f"Download failed: {str(e)}"
+            ) 

ai_computer_client-0.3.1.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: ai-computer-client
+Version: 0.3.1
+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
+
+Python client library for interacting with the AI Computer Sandbox service.
+
+## Installation
+
+```bash
+pip install ai-computer-client
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+from ai_computer import SandboxClient
+
+async def main():
+    # Initialize client
+    client = SandboxClient()
+    
+    # Setup sandbox environment
+    await client.setup()
+    
+    try:
+        # Execute code
+        result = await client.execute_code("print('Hello, World!')")
+        print(result.data["output"])
+        
+        # Upload a file
+        response = await client.upload_file("local/path/to/file.txt")
+        if response.success:
+            print(f"File uploaded to {response.path}")
+        
+        # Download a file
+        response = await client.download_file(
+            "/workspace/file.txt",
+            "local/download/path.txt"
+        )
+        if response.success:
+            print(f"File downloaded to {response.path}")
+            
+        # Work with bytes directly
+        content = b"Hello, World!"
+        response = await client.upload_bytes(
+            content=content,
+            filename="hello.txt"
+        )
+        
+        # Download as bytes
+        content = await client.download_bytes("/workspace/hello.txt")
+        if isinstance(content, bytes):
+            print(content.decode())
+            
+    finally:
+        # Cleanup
+        await client.cleanup()
+
+# Run with asyncio
+import asyncio
+asyncio.run(main())
+```
+
+### Advanced Usage
+
+```python
+# Stream code execution
+async for event in client.execute_code_stream("print('Hello')\nprint('World')"):
+    if event.type == "stdout":
+        print(f"Output: {event.data}")
+    elif event.type == "stderr":
+        print(f"Error: {event.data}")
+    elif event.type == "completed":
+        print("Execution completed")
+
+# Upload with custom settings
+response = await client.upload_file(
+    "file.txt",
+    destination="/workspace/custom/path",
+    chunk_size=2*1024*1024,  # 2MB chunks
+    timeout=600  # 10 minutes
+)
+
+# Work with file-like objects
+from io import BytesIO
+
+buffer = BytesIO(b"Hello from buffer!")
+response = await client.upload_bytes(
+    content=buffer,
+    filename="buffer.txt",
+    content_type="text/plain"
+)
+```
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/ai-computer/ai-computer-client-python
+cd ai-computer-client-python
+
+# Create and activate virtual environment
+python -m venv venv
+source venv/bin/activate  # or `venv\Scripts\activate` on Windows
+
+# Install development dependencies
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest tests/
+```
+
+## License
+
+MIT License 

ai_computer_client-0.3.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+ai_computer/__init__.py,sha256=9slbwvU5DHW6aOeLy7qIFe7TQkXF3-kOMI2x82VqiAk,197
+ai_computer/client.py,sha256=TwVsAmNjaj5MDytKZtoHefFJAwYyL2OndtVbY2YxJlM,28729
+ai_computer_client-0.3.1.dist-info/METADATA,sha256=YDRTkYudV6X0SRLW0OECdduJgCc3dYITjTr99eat0ls,3754
+ai_computer_client-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ai_computer_client-0.3.1.dist-info/licenses/LICENSE,sha256=N_0S5G1Wik2LWVDViJMAM0Z-6vTBX1bvDjb8vouBA-c,1068
+ai_computer_client-0.3.1.dist-info/RECORD,,

ai_computer_client-0.2.0.dist-info/METADATA

@@ -1,222 +0,0 @@
-Metadata-Version: 2.4
-Name: ai-computer-client
-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
-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://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.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-ai_computer/__init__.py,sha256=g2yDiDT6i24MV3Y2JNfk2ZFkYvxvrN6NXywjZPslXDY,149
-ai_computer/client.py,sha256=8LgOSO0AD3R8lljblzktIwPLwoAdmX4n-JG58ebd5xY,12119
-ai_computer_client-0.2.0.dist-info/METADATA,sha256=3XRPWBjdJTIiErS_Kqnoc7iIOOO8LC2QIzc4k3AVHAc,5654
-ai_computer_client-0.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ai_computer_client-0.2.0.dist-info/licenses/LICENSE,sha256=N_0S5G1Wik2LWVDViJMAM0Z-6vTBX1bvDjb8vouBA-c,1068
-ai_computer_client-0.2.0.dist-info/RECORD,,