orgo 0.0.1__tar.gz → 0.0.3__tar.gz

orgo-0.0.3/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.2
+Name: orgo
+Version: 0.0.3
+Summary: Desktop infrastructure for AI agents
+Author: Orgo Team
+License: MIT
+Project-URL: Homepage, https://www.orgo.ai
+Project-URL: Documentation, https://docs.orgo.ai
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pillow>=8.0.0
+
+# Orgo SDK
+
+Desktop infrastructure for AI agents.
+
+## Install
+
+```bash
+pip install orgo
+```
+
+## Usage
+
+```python
+from orgo import Computer
+
+# Create computer
+computer = Computer()
+
+# Control
+computer.left_click(100, 200)
+computer.type("Hello world")
+computer.key("Enter")
+computer.screenshot()  # Returns PIL Image
+
+# Cleanup
+computer.shutdown()
+```
+
+Full documentation: [docs.orgo.ai](https://docs.orgo.ai)

orgo-0.0.3/README.md

@@ -0,0 +1,29 @@
+# Orgo SDK
+
+Desktop infrastructure for AI agents.
+
+## Install
+
+```bash
+pip install orgo
+```
+
+## Usage
+
+```python
+from orgo import Computer
+
+# Create computer
+computer = Computer()
+
+# Control
+computer.left_click(100, 200)
+computer.type("Hello world")
+computer.key("Enter")
+computer.screenshot()  # Returns PIL Image
+
+# Cleanup
+computer.shutdown()
+```
+
+Full documentation: [docs.orgo.ai](https://docs.orgo.ai)

orgo-0.0.3/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "orgo"
+version = "0.0.3"
+description = "Desktop infrastructure for AI agents"
+authors = [{name = "Orgo Team"}]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.7"
+dependencies = [
+    "requests>=2.25.0",
+    "pillow>=8.0.0",
+]
+
+[project.urls]
+"Homepage" = "https://www.orgo.ai"
+"Documentation" = "https://docs.orgo.ai"
+
+[tool.setuptools]
+package-dir = {"" = "src"}

orgo-0.0.3/src/orgo/__init__.py

@@ -0,0 +1,5 @@
+"""Orgo SDK: Desktop infrastructure for AI agents"""
+
+from .computer import Computer
+
+__all__ = ["Computer"]

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

@@ -0,0 +1,7 @@
+"""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.3/src/orgo/adapters/anthropic.py

@@ -0,0 +1,64 @@
+"""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.3/src/orgo/adapters/base.py

@@ -0,0 +1,14 @@
+"""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.3/src/orgo/adapters/openai.py

@@ -0,0 +1,69 @@
+"""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

orgo-0.0.3/src/orgo/api/__init__.py

@@ -0,0 +1,5 @@
+"""API package for Orgo SDK"""
+
+from .client import ApiClient
+
+__all__ = ["ApiClient"]

orgo-0.0.3/src/orgo/api/client.py

@@ -0,0 +1,102 @@
+"""API client for Orgo service"""
+
+import requests
+from typing import Dict, Any, Optional
+
+from orgo.utils.auth import get_api_key
+
+class ApiClient:
+    BASE_URL = "https://www.orgo.ai/api"
+    
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = get_api_key(api_key)
+        self.session = requests.Session()
+        self.session.headers.update({
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        })
+    
+    def _request(self, method: str, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        url = f"{self.BASE_URL}/{endpoint}"
+        
+        try:
+            if method.upper() == "GET":
+                response = self.session.get(url, params=data)
+            else:
+                response = self.session.request(method, url, json=data)
+            
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            if hasattr(e, 'response') and e.response is not None:
+                error_message = f"API error: {e.response.status_code}"
+                try:
+                    error_data = e.response.json()
+                    if 'error' in error_data:
+                        error_message += f" - {error_data['error']}"
+                except ValueError:
+                    pass
+                raise Exception(error_message) from e
+            raise Exception(f"Connection error: {str(e)}") from e
+    
+    # Computer lifecycle methods
+    def create_computer(self, config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Create a new project with desktop instance"""
+        return self._request("POST", "projects", {"config": config} if config else None)
+    
+    def connect_computer(self, project_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{project_id}")
+    
+    def get_status(self, project_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{project_id}/status")
+    
+    def restart_computer(self, project_id: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/restart")
+    
+    def shutdown_computer(self, project_id: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/shutdown")
+    
+    # Computer control methods
+    def left_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/click", {
+            "button": "left", "x": x, "y": y
+        })
+    
+    def right_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/click", {
+            "button": "right", "x": x, "y": y
+        })
+    
+    def double_click(self, project_id: str, x: int, y: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/click", {
+            "button": "left", "x": x, "y": y, "double": True
+        })
+    
+    def scroll(self, project_id: str, direction: str, amount: int) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/scroll", {
+            "direction": direction, "amount": amount
+        })
+    
+    def type_text(self, project_id: str, text: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/type", {
+            "text": text
+        })
+    
+    def key_press(self, project_id: str, key: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/key", {
+            "key": key
+        })
+    
+    def get_screenshot(self, project_id: str) -> Dict[str, Any]:
+        return self._request("GET", f"computers/{project_id}/screenshot")
+    
+    def execute_bash(self, project_id: str, command: str) -> Dict[str, Any]:
+        return self._request("POST", f"computers/{project_id}/bash", {
+            "command": command
+        })
+    
+    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.3/src/orgo/computer.py

@@ -0,0 +1,84 @@
+"""Computer class for interacting with Orgo virtual environments"""
+
+import os
+import io
+import base64
+from typing import Dict, Any
+from PIL import Image
+
+from .api.client import ApiClient
+
+class Computer:
+    def __init__(self, project_id=None, api_key=None, config=None):
+        self.api = ApiClient(api_key or os.environ.get("ORGO_API_KEY"))
+        
+        if project_id:
+            self.project_id = project_id
+            self._info = self.api.connect_computer(project_id)
+        else:
+            response = self.api.create_computer(config)
+            self.project_id = response.get("id")
+            self._info = response
+            
+        if not self.project_id:
+            raise ValueError("Failed to initialize computer: No project ID returned")
+    
+    def status(self) -> Dict[str, Any]:
+        """Get current computer status"""
+        return self.api.get_status(self.project_id)
+    
+    def restart(self) -> Dict[str, Any]:
+        """Restart the computer"""
+        return self.api.restart_computer(self.project_id)
+    
+    def shutdown(self) -> Dict[str, Any]:
+        """Terminate the computer instance"""
+        return self.api.shutdown_computer(self.project_id)
+    
+    # Navigation methods
+    def left_click(self, x: int, y: int) -> Dict[str, Any]:
+        """Perform left mouse click at specified coordinates"""
+        return self.api.left_click(self.project_id, x, y)
+    
+    def right_click(self, x: int, y: int) -> Dict[str, Any]:
+        """Perform right mouse click at specified coordinates"""
+        return self.api.right_click(self.project_id, x, y)
+    
+    def double_click(self, x: int, y: int) -> Dict[str, Any]:
+        """Perform double click at specified coordinates"""
+        return self.api.double_click(self.project_id, x, y)
+    
+    def scroll(self, direction: str = "down", amount: int = 1) -> Dict[str, Any]:
+        """Scroll in specified direction and amount"""
+        return self.api.scroll(self.project_id, direction, amount)
+    
+    # Input methods
+    def type(self, text: str) -> Dict[str, Any]:
+        """Type the specified text"""
+        return self.api.type_text(self.project_id, text)
+    
+    def key(self, key: str) -> Dict[str, Any]:
+        """Press a key or key combination (e.g., "Enter", "ctrl+c")"""
+        return self.api.key_press(self.project_id, key)
+    
+    # View methods
+    def screenshot(self) -> Image.Image:
+        """Capture screenshot and return as PIL Image"""
+        response = self.api.get_screenshot(self.project_id)
+        img_data = base64.b64decode(response.get("screenshot", ""))
+        return Image.open(io.BytesIO(img_data))
+    
+    def screenshot_base64(self) -> str:
+        """Capture screenshot and return as base64 string"""
+        response = self.api.get_screenshot(self.project_id)
+        return response.get("screenshot", "")
+    
+    # Execution methods
+    def bash(self, command: str) -> str:
+        """Execute a bash command and return output"""
+        response = self.api.execute_bash(self.project_id, command)
+        return response.get("output", "")
+    
+    def wait(self, seconds: float) -> Dict[str, Any]:
+        """Wait for specified number of seconds"""
+        return self.api.wait(self.project_id, seconds)

orgo-0.0.3/src/orgo/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Utility functions for Orgo SDK"""
+
+from .auth import get_api_key
+
+__all__ = ["get_api_key"]

orgo-0.0.3/src/orgo/utils/auth.py

@@ -0,0 +1,16 @@
+"""Authentication utilities for Orgo SDK"""
+
+import os
+from typing import Optional
+
+def get_api_key(api_key: Optional[str] = None) -> str:
+    """Get the Orgo API key from parameters or environment"""
+    key = api_key or os.environ.get("ORGO_API_KEY")
+    
+    if not key:
+        raise ValueError(
+            "API key required. Set ORGO_API_KEY environment variable or pass api_key parameter. "
+            "Get a key at https://www.orgo.ai/start"
+        )
+        
+    return key

orgo-0.0.3/src/orgo.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.2
+Name: orgo
+Version: 0.0.3
+Summary: Desktop infrastructure for AI agents
+Author: Orgo Team
+License: MIT
+Project-URL: Homepage, https://www.orgo.ai
+Project-URL: Documentation, https://docs.orgo.ai
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Requires-Dist: pillow>=8.0.0
+
+# Orgo SDK
+
+Desktop infrastructure for AI agents.
+
+## Install
+
+```bash
+pip install orgo
+```
+
+## Usage
+
+```python
+from orgo import Computer
+
+# Create computer
+computer = Computer()
+
+# Control
+computer.left_click(100, 200)
+computer.type("Hello world")
+computer.key("Enter")
+computer.screenshot()  # Returns PIL Image
+
+# Cleanup
+computer.shutdown()
+```
+
+Full documentation: [docs.orgo.ai](https://docs.orgo.ai)

orgo-0.0.3/src/orgo.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/orgo/__init__.py
+src/orgo/computer.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
+src/orgo/utils/auth.py

orgo-0.0.3/src/orgo.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.25.0
+pillow>=8.0.0

orgo-0.0.3/src/orgo.egg-info/top_level.txt

@@ -0,0 +1 @@
+orgo

orgo-0.0.1/PKG-INFO

@@ -1,6 +0,0 @@
-Metadata-Version: 2.2
-Name: orgo
-Version: 0.0.1
-Author: Your Name
-License: MIT
-Requires-Python: >=3.6

orgo-0.0.1/orgo.egg-info/PKG-INFO

@@ -1,6 +0,0 @@
-Metadata-Version: 2.2
-Name: orgo
-Version: 0.0.1
-Author: Your Name
-License: MIT
-Requires-Python: >=3.6

orgo-0.0.1/orgo.egg-info/SOURCES.txt

@@ -1,5 +0,0 @@
-pyproject.toml
-orgo.egg-info/PKG-INFO
-orgo.egg-info/SOURCES.txt
-orgo.egg-info/dependency_links.txt
-orgo.egg-info/top_level.txt

orgo-0.0.1/orgo.egg-info/top_level.txt

@@ -1 +0,0 @@
-

orgo-0.0.1/pyproject.toml

@@ -1,11 +0,0 @@
-[build-system]
-requires = ["setuptools", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "orgo"
-version = "0.0.1"
-description = ""
-authors = [{name = "Your Name"}]
-license = {text = "MIT"}
-requires-python = ">=3.6"