orgo 0.0.12__tar.gz → 0.0.14__tar.gz

{orgo-0.0.12 → orgo-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orgo
-Version: 0.0.12
+Version: 0.0.14
 Summary: Computers for AI agents
 Author: Orgo Team
 License: MIT
@@ -35,6 +35,9 @@ computer.type("Hello world")
 computer.key("Enter")
 computer.screenshot()  # Returns PIL Image
 
+# Execute Python code
+computer.exec("import pyautogui; pyautogui.click(512, 384)")
+
 # Cleanup
 computer.shutdown()
 ```

{orgo-0.0.12 → orgo-0.0.14}/README.md

@@ -22,6 +22,9 @@ computer.type("Hello world")
 computer.key("Enter")
 computer.screenshot()  # Returns PIL Image
 
+# Execute Python code
+computer.exec("import pyautogui; pyautogui.click(512, 384)")
+
 # Cleanup
 computer.shutdown()
 ```

{orgo-0.0.12 → orgo-0.0.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orgo"
-version = "0.0.12"
+version = "0.0.14"
 description = "Computers for AI agents"
 authors = [{name = "Orgo Team"}]
 license = {text = "MIT"}

{orgo-0.0.12 → orgo-0.0.14}/src/orgo/__init__.py

@@ -1,3 +1,4 @@
+# src/orgo/__init__.py
 """Orgo SDK: Desktop infrastructure for AI agents"""
 
 from .computer import Computer

{orgo-0.0.12 → orgo-0.0.14}/src/orgo/api/__init__.py

@@ -1,3 +1,4 @@
+# src/orgo/api/__init__.py
 """API package for Orgo SDK"""
 
 from .client import ApiClient

{orgo-0.0.12 → orgo-0.0.14}/src/orgo/api/client.py

@@ -1,5 +1,5 @@
-"""API client for Orgo service"""
 # src/orgo/api/client.py
+"""API client for Orgo service"""
 
 import requests
 from typing import Dict, Any, Optional
@@ -96,6 +96,13 @@ class ApiClient:
             "command": command
         })
     
+    def execute_python(self, project_id: str, code: str, timeout: int = 10) -> Dict[str, Any]:
+        """Execute Python code on the computer"""
+        return self._request("POST", f"computers/{project_id}/exec", {
+            "code": code,
+            "timeout": timeout
+        })
+    
     def wait(self, project_id: str, seconds: float) -> Dict[str, Any]:
         return self._request("POST", f"computers/{project_id}/wait", {
             "seconds": seconds

{orgo-0.0.12 → orgo-0.0.14}/src/orgo/computer.py

@@ -1,15 +1,18 @@
-"""Computer class for interacting with Orgo virtual environments"""
 # src/orgo/computer.py
-
+"""Computer class for interacting with Orgo virtual environments"""
 import os
 import io
 import base64
+import logging
 from typing import Dict, List, Any, Optional, Callable, Union
 from PIL import Image
+from requests.exceptions import RequestException
 
 from .api.client import ApiClient
 from .prompt import get_provider
+from .project import ProjectManager
 
+logger = logging.getLogger(__name__)
 
 class Computer:
     def __init__(self, project_id=None, api_key=None, config=None, base_api_url=None):
@@ -26,16 +29,31 @@ class Computer:
         self.base_api_url = base_api_url
         self.api = ApiClient(self.api_key, self.base_api_url)
         
+        # Look for a saved project ID if none was provided
+        if project_id is None:
+            project_id = ProjectManager.load_project_id()
+        
         if project_id:
-            self.project_id = project_id
-            self._info = self.api.connect_computer(project_id)
+            try:
+                self.project_id = project_id
+                self._info = self.api.connect_computer(project_id)
+            except (RequestException, ValueError) as e:
+                logger.warning(f"Could not connect to saved project {project_id}: {e}")
+                self._create_new_computer(config)
         else:
-            response = self.api.create_computer(config)
-            self.project_id = response.get("name")
-            self._info = response
+            self._create_new_computer(config)
             
+    def _create_new_computer(self, config=None):
+        """Create a new computer instance and save its ID"""
+        response = self.api.create_computer(config)
+        self.project_id = response.get("name")
+        self._info = response
+        
         if not self.project_id:
             raise ValueError("Failed to initialize computer: No project ID returned")
+            
+        # Save the project ID for future use
+        ProjectManager.save_project_id(self.project_id)
     
     def status(self) -> Dict[str, Any]:
         """Get current computer status"""
@@ -93,6 +111,37 @@ class Computer:
         response = self.api.execute_bash(self.project_id, command)
         return response.get("output", "")
     
+    def exec(self, code: str, timeout: int = 10) -> Dict[str, Any]:
+        """
+        Execute Python code on the remote computer.
+        
+        Args:
+            code: Python code to execute
+            timeout: Maximum execution time in seconds (default: 10, max: 300)
+            
+        Returns:
+            Dict with keys:
+            - success: bool indicating if execution completed without errors
+            - output: str containing stdout output
+            - error: str containing error message if any
+            - error_type: str with exception type name if error occurred
+            - timeout: bool indicating if execution timed out
+            
+        Example:
+            result = computer.exec('''
+import os
+print(f"Current directory: {os.getcwd()}")
+print(f"Files: {os.listdir('.')}")
+            ''')
+            
+            if result['success']:
+                print(result['output'])
+            else:
+                print(f"Error: {result['error']}")
+        """
+        response = self.api.execute_python(self.project_id, code, timeout)
+        return response
+    
     def wait(self, seconds: float) -> Dict[str, Any]:
         """Wait for specified number of seconds"""
         return self.api.wait(self.project_id, seconds)
@@ -130,28 +179,6 @@ class Computer:
             
         Returns:
             List of messages from the conversation
-            
-        Examples:
-            # Simple usage with environment variables
-            computer.prompt("Open Firefox and search for Python tutorials")
-            
-            # With explicit API key
-            computer.prompt("Open Terminal and list files", api_key="your-anthropic-key")
-            
-            # With callback for progress updates
-            computer.prompt("Create a new text file", callback=my_callback_function)
-            
-            # With thinking enabled (Claude 3.7 Sonnet)
-            computer.prompt(
-                "Analyze a complex webpage", 
-                thinking_enabled=True
-            )
-            
-            # With custom screenshot management
-            computer.prompt(
-                "Perform a complex multi-step task",
-                max_saved_screenshots=10  # Keep more screenshots for complex tasks
-            )
         """
         # Get the provider instance
         provider_instance = get_provider(provider)

orgo-0.0.14/src/orgo/project.py

@@ -0,0 +1,51 @@
+# src/orgo/project.py
+"""Project management for Orgo virtual environments"""
+import os
+import json
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+class ProjectManager:
+    """Manages project persistence for Orgo computers"""
+    
+    @staticmethod
+    def load_project_id() -> Optional[str]:
+        """Load project ID from local config file"""
+        config_path = ProjectManager._get_config_path()
+        
+        if not os.path.exists(config_path):
+            return None
+            
+        try:
+            with open(config_path, 'r') as f:
+                data = json.load(f)
+                return data.get('project_id')
+        except (json.JSONDecodeError, IOError, OSError) as e:
+            logger.warning(f"Error loading project config: {str(e)}")
+            return None
+    
+    @staticmethod
+    def save_project_id(project_id: str) -> None:
+        """Save project ID to local config file"""
+        config_dir = ProjectManager._get_project_dir()
+        config_path = ProjectManager._get_config_path()
+        
+        try:
+            os.makedirs(config_dir, exist_ok=True)
+            with open(config_path, 'w') as f:
+                json.dump({'project_id': project_id}, f, indent=2)
+        except (IOError, OSError) as e:
+            logger.error(f"Failed to save project ID: {str(e)}")
+            raise RuntimeError(f"Failed to save project configuration: {str(e)}") from e
+    
+    @staticmethod
+    def _get_project_dir() -> str:
+        """Get the project directory path"""
+        return os.path.join(os.getcwd(), ".orgo")
+    
+    @staticmethod
+    def _get_config_path() -> str:
+        """Get the full path to the config file"""
+        return os.path.join(ProjectManager._get_project_dir(), "project.json")

{orgo-0.0.12 → orgo-0.0.14}/src/orgo/prompt.py

@@ -1,3 +1,4 @@
+# src/orgo/prompt.py
 """
 Prompt module for interacting with virtual computers using AI models.
 """

{orgo-0.0.12 → orgo-0.0.14}/src/orgo/utils/__init__.py

@@ -1,3 +1,4 @@
+# src/orgo/utils/__init__.py
 """Utility functions for Orgo SDK"""
 
 from .auth import get_api_key

{orgo-0.0.12 → orgo-0.0.14}/src/orgo/utils/auth.py

@@ -1,3 +1,4 @@
+# src/orgo/utils/auth.py
 """Authentication utilities for Orgo SDK"""
 
 import os

{orgo-0.0.12 → orgo-0.0.14}/src/orgo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orgo
-Version: 0.0.12
+Version: 0.0.14
 Summary: Computers for AI agents
 Author: Orgo Team
 License: MIT
@@ -35,6 +35,9 @@ computer.type("Hello world")
 computer.key("Enter")
 computer.screenshot()  # Returns PIL Image
 
+# Execute Python code
+computer.exec("import pyautogui; pyautogui.click(512, 384)")
+
 # Cleanup
 computer.shutdown()
 ```

{orgo-0.0.12 → orgo-0.0.14}/src/orgo.egg-info/SOURCES.txt

@@ -2,16 +2,13 @@ README.md
 pyproject.toml
 src/orgo/__init__.py
 src/orgo/computer.py
+src/orgo/project.py
 src/orgo/prompt.py
 src/orgo.egg-info/PKG-INFO
 src/orgo.egg-info/SOURCES.txt
 src/orgo.egg-info/dependency_links.txt
 src/orgo.egg-info/requires.txt
 src/orgo.egg-info/top_level.txt
-src/orgo/adapters/__init__.py
-src/orgo/adapters/anthropic.py
-src/orgo/adapters/base.py
-src/orgo/adapters/openai.py
 src/orgo/api/__init__.py
 src/orgo/api/client.py
 src/orgo/utils/__init__.py

orgo-0.0.12/src/orgo/adapters/__init__.py

@@ -1,7 +0,0 @@
-"""Adapters for integrating Orgo with AI models"""
-
-from .base import BaseAdapter
-from .anthropic import AnthropicAdapter
-from .openai import OpenAIAdapter
-
-__all__ = ["BaseAdapter", "AnthropicAdapter", "OpenAIAdapter"]

orgo-0.0.12/src/orgo/adapters/anthropic.py

@@ -1,64 +0,0 @@
-"""Adapter for Anthropic's Claude"""
-
-from typing import Dict, Any, Optional
-from .base import BaseAdapter
-
-class AnthropicAdapter(BaseAdapter):
-    def get_tool_definition(self) -> Dict[str, Any]:
-        return {
-            "name": "computer",
-            "description": "Controls a virtual computer to automate tasks",
-            "type": "function",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "action": {
-                        "type": "string",
-                        "enum": ["left_click", "right_click", "double_click", "type", "key", "scroll", "screenshot"],
-                        "description": "The action to perform on the computer"
-                    },
-                    "coordinate": {
-                        "type": "array",
-                        "items": {"type": "number"},
-                        "description": "The x,y coordinates for click actions",
-                        "minItems": 2,
-                        "maxItems": 2
-                    },
-                    "text": {
-                        "type": "string",
-                        "description": "The text to type or key to press"
-                    },
-                    "direction": {
-                        "type": "string",
-                        "enum": ["up", "down", "left", "right"],
-                        "description": "The direction to scroll"
-                    },
-                    "amount": {
-                        "type": "number",
-                        "description": "The amount to scroll"
-                    }
-                },
-                "required": ["action"],
-                "additionalProperties": False
-            }
-        }
-    
-    def format_result(self, tool_id: str, output: Optional[str] = None, error: Optional[str] = None) -> Dict[str, Any]:
-        screenshot = self.computer.get_base64()
-        result = {
-            "type": "tool_result",
-            "id": tool_id,
-            "content": {
-                "type": "image",
-                "source": {
-                    "type": "base64",
-                    "media_type": "image/png",
-                    "data": screenshot
-                }
-            }
-        }
-        
-        if error:
-            result["error"] = error
-            
-        return result

orgo-0.0.12/src/orgo/adapters/base.py

@@ -1,14 +0,0 @@
-"""Base adapter for AI model integration"""
-
-from typing import Dict, Any, Optional
-from ..computer import Computer
-
-class BaseAdapter:
-    def __init__(self, computer: Computer):
-        self.computer = computer
-    
-    def get_tool_definition(self) -> Dict[str, Any]:
-        raise NotImplementedError("Subclasses must implement get_tool_definition()")
-    
-    def format_result(self, tool_id: str, output: Optional[str] = None, error: Optional[str] = None) -> Dict[str, Any]:
-        raise NotImplementedError("Subclasses must implement format_result()")

orgo-0.0.12/src/orgo/adapters/openai.py

@@ -1,69 +0,0 @@
-"""Adapter for OpenAI models"""
-
-from typing import Dict, Any, Optional
-from .base import BaseAdapter
-
-class OpenAIAdapter(BaseAdapter):
-    def get_tool_definition(self) -> Dict[str, Any]:
-        return {
-            "type": "function",
-            "function": {
-                "name": "computer",
-                "description": "Controls a virtual computer to automate tasks",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "action": {
-                            "type": "string",
-                            "enum": ["click", "right_click", "double_click", "type", "key", "scroll", "screenshot"],
-                            "description": "The action to perform on the computer"
-                        },
-                        "x": {
-                            "type": "number",
-                            "description": "The x coordinate for click actions"
-                        },
-                        "y": {
-                            "type": "number",
-                            "description": "The y coordinate for click actions"
-                        },
-                        "text": {
-                            "type": "string",
-                            "description": "The text to type or key to press"
-                        },
-                        "direction": {
-                            "type": "string",
-                            "enum": ["up", "down", "left", "right"],
-                            "description": "The direction to scroll"
-                        },
-                        "amount": {
-                            "type": "number",
-                            "description": "The amount to scroll"
-                        }
-                    },
-                    "required": ["action"],
-                    "additionalProperties": False
-                }
-            }
-        }
-    
-    def format_result(self, tool_id: str, output: Optional[str] = None, error: Optional[str] = None) -> Dict[str, Any]:
-        screenshot = self.computer.get_base64()
-        result = {
-            "tool_call_id": tool_id,
-            "content": [
-                {
-                    "type": "image_url",
-                    "image_url": {
-                        "url": f"data:image/png;base64,{screenshot}"
-                    }
-                }
-            ]
-        }
-        
-        if error:
-            result["content"].insert(0, {
-                "type": "text",
-                "text": f"Error: {error}"
-            })
-            
-        return result