orgo 0.0.37__tar.gz → 0.0.38__tar.gz

{orgo-0.0.37 → orgo-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orgo
-Version: 0.0.37
+Version: 0.0.38
 Summary: Computers for AI agents
 Author: Orgo Team
 License: MIT

{orgo-0.0.37 → orgo-0.0.38}/pyproject.toml

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

{orgo-0.0.37 → orgo-0.0.38}/src/orgo/computer.py

@@ -4,7 +4,7 @@ Orgo Computer - Control virtual computers with AI.
 Usage:
     from orgo import Computer
     
-    computer = Computer(computer_id="your-computer-id")
+    computer = Computer(project="your-project")
     computer.prompt("Open Firefox and search for AI news")
 """
 
@@ -13,6 +13,7 @@ import base64
 import logging
 import uuid
 import io
+import random
 from typing import Dict, List, Any, Optional, Callable, Literal, Union
 from PIL import Image
 import requests
@@ -24,16 +25,39 @@ from .prompt import get_provider
 logger = logging.getLogger(__name__)
 
 
+def _generate_computer_name() -> str:
+    """Generate a random computer name like 'computer-1568'"""
+    return f"computer-{random.randint(1000, 9999)}"
+
+
+def _print_success(message: str):
+    """Print a success message with nice formatting"""
+    print(f"✓ {message}")
+
+
+def _print_error(message: str):
+    """Print an error message with nice formatting"""
+    print(f"✗ {message}")
+
+
+def _print_info(message: str):
+    """Print an info message with nice formatting"""
+    print(f"→ {message}")
+
+
 class Computer:
     """
     Control an Orgo virtual computer.
     
     Examples:
-        # Connect to existing computer
-        computer = Computer(computer_id="abc123")
+        # Create computer in new/existing project
+        computer = Computer(project="my-project")
         
-        # Create new computer in project
-        computer = Computer(project="my-project", ram=4, cpu=2)
+        # Create with specific name
+        computer = Computer(project="my-project", name="dev-machine")
+        
+        # Connect to existing computer by ID
+        computer = Computer(computer_id="abc123")
         
         # AI control (uses Orgo by default)
         computer.prompt("Open Firefox")
@@ -53,14 +77,15 @@ class Computer:
                  cpu: Optional[Literal[1, 2, 4, 8, 16]] = None,
                  os: Optional[Literal["linux", "windows"]] = None,
                  gpu: Optional[Literal["none", "a10", "l40s", "a100-40gb", "a100-80gb"]] = None,
-                 image: Optional[Union[str, Any]] = None):
+                 image: Optional[Union[str, Any]] = None,
+                 verbose: bool = True):
         """
         Initialize an Orgo virtual computer.
         
         Args:
-            computer_id: Connect to existing computer by ID
-            project: Project name or Project instance
+            project: Project name or Project instance (creates if doesn't exist)
             name: Computer name (auto-generated if not provided)
+            computer_id: Connect to existing computer by ID
             api_key: Orgo API key (defaults to ORGO_API_KEY env var)
             base_api_url: Custom API URL
             ram/memory: RAM in GB (1, 2, 4, 8, 16, 32, 64)
@@ -68,10 +93,12 @@ class Computer:
             os: "linux" or "windows"
             gpu: "none", "a10", "l40s", "a100-40gb", "a100-80gb"
             image: Custom image reference or Forge object
+            verbose: Show console output (default: True)
         """
         self.api_key = api_key or operating_system.environ.get("ORGO_API_KEY")
         self.base_api_url = base_api_url
         self.api = ApiClient(self.api_key, self.base_api_url)
+        self.verbose = verbose
         
         if ram is None and memory is not None:
             ram = memory
@@ -83,7 +110,8 @@ class Computer:
         self.image = image
         
         if hasattr(self.image, 'build') and callable(self.image.build):
-            logger.info("Building image from Forge object...")
+            if self.verbose:
+                _print_info("Building image from Forge object...")
             self.image = self.image.build()
         
         if computer_id:
@@ -91,7 +119,8 @@ class Computer:
             self.name = name
             self.project_id = None
             self.project_name = None
-            logger.info(f"Connected to computer: {self.computer_id}")
+            if self.verbose:
+                _print_success(f"Connected to computer: {self.computer_id}")
         elif project:
             if isinstance(project, str):
                 self.project_name = project
@@ -112,60 +141,69 @@ class Computer:
     # =========================================================================
     
     def _initialize_with_project_name(self, project_name: str, computer_name: Optional[str]):
+        """Initialize computer with project name (create project if needed)"""
         try:
+            # Try to get existing project
             project = self.api.get_project_by_name(project_name)
             self.project_id = project.get("id")
-            computers = self.api.list_computers(self.project_id)
             
-            if computer_name:
-                existing = next((c for c in computers if c.get("name") == computer_name), None)
-                if existing:
-                    self._connect_to_existing_computer(existing)
-                else:
-                    self._create_computer(self.project_id, computer_name)
-            elif computers:
-                self._connect_to_existing_computer(computers[0])
-            else:
-                self._create_computer(self.project_id, computer_name)
+            # If no computer name specified, generate one
+            if not computer_name:
+                computer_name = _generate_computer_name()
+            
+            # Create the computer in this project
+            self._create_computer(self.project_id, computer_name, project_name)
+            
         except Exception:
-            logger.info(f"Creating new project: {project_name}")
+            # Project doesn't exist, create it
+            if self.verbose:
+                _print_info(f"Creating project: {project_name}")
             project = self.api.create_project(project_name)
             self.project_id = project.get("id")
-            self._create_computer(self.project_id, computer_name)
+            
+            # Generate name if not specified
+            if not computer_name:
+                computer_name = _generate_computer_name()
+            
+            self._create_computer(self.project_id, computer_name, project_name)
     
     def _initialize_with_project_instance(self, project: 'Project', computer_name: Optional[str]):
-        computers = project.list_computers()
+        """Initialize computer with Project instance"""
+        # Generate name if not specified
+        if not computer_name:
+            computer_name = _generate_computer_name()
         
-        if computer_name:
-            existing = next((c for c in computers if c.get("name") == computer_name), None)
-            if existing:
-                self._connect_to_existing_computer(existing)
-            else:
-                self._create_computer(project.id, computer_name)
-        elif computers:
-            self._connect_to_existing_computer(computers[0])
-        else:
-            self._create_computer(project.id, computer_name)
+        self._create_computer(project.id, computer_name, project.name)
     
     def _create_new_project_and_computer(self, computer_name: Optional[str]):
+        """Create a new project and computer when no project specified"""
         project_name = f"project-{uuid.uuid4().hex[:8]}"
+        
+        if self.verbose:
+            _print_info(f"Creating project: {project_name}")
+        
         project = self.api.create_project(project_name)
         self.project_id = project.get("id")
         self.project_name = project_name
-        self._create_computer(self.project_id, computer_name)
+        
+        # Generate name if not specified
+        if not computer_name:
+            computer_name = _generate_computer_name()
+        
+        self._create_computer(self.project_id, computer_name, project_name)
     
     def _connect_to_existing_computer(self, computer_info: Dict[str, Any]):
+        """Connect to an existing computer"""
         self.computer_id = computer_info.get("id")
         self.name = computer_info.get("name")
-        logger.info(f"Connected to: {self.name} ({self.computer_id})")
+        if self.verbose:
+            _print_success(f"Connected to: {self.name} ({self.computer_id})")
     
-    def _create_computer(self, project_id: str, computer_name: Optional[str]):
-        if not computer_name:
-            computer_name = f"desktop-{uuid.uuid4().hex[:8]}"
-        
+    def _create_computer(self, project_id: str, computer_name: str, project_name: str):
+        """Create a new computer with beautiful console output"""
         self.name = computer_name
         
-        # Validate
+        # Validate parameters
         if self.ram not in [1, 2, 4, 8, 16, 32, 64]:
             raise ValueError("ram must be: 1, 2, 4, 8, 16, 32, or 64 GB")
         if self.cpu not in [1, 2, 4, 8, 16]:
@@ -175,7 +213,7 @@ class Computer:
         if self.gpu not in ["none", "a10", "l40s", "a100-40gb", "a100-80gb"]:
             raise ValueError("gpu must be: 'none', 'a10', 'l40s', 'a100-40gb', or 'a100-80gb'")
         
-        # Resolve image
+        # Resolve image if needed
         image_ref = self.image
         if image_ref and isinstance(image_ref, str) and not image_ref.startswith("registry.fly.io"):
             try:
@@ -187,19 +225,34 @@ class Computer:
                     if resolved:
                         image_ref = resolved
             except Exception as e:
-                logger.warning(f"Failed to resolve image: {e}")
+                if self.verbose:
+                    logger.warning(f"Failed to resolve image: {e}")
         
-        computer = self.api.create_computer(
-            project_id=project_id,
-            computer_name=computer_name,
-            os=self.os,
-            ram=self.ram,
-            cpu=self.cpu,
-            gpu=self.gpu,
-            image=image_ref
-        )
-        self.computer_id = computer.get("id")
-        logger.info(f"Created: {self.name} ({self.computer_id})")
+        # Create the computer
+        try:
+            computer = self.api.create_computer(
+                project_id=project_id,
+                computer_name=computer_name,
+                os=self.os,
+                ram=self.ram,
+                cpu=self.cpu,
+                gpu=self.gpu,
+                image=image_ref
+            )
+            self.computer_id = computer.get("id")
+            
+            # Beautiful success message
+            if self.verbose:
+                _print_success(
+                    f"Computer [{self.name}] successfully created under workspace [{project_name}]"
+                )
+                _print_info(f"ID: {self.computer_id}")
+                _print_info(f"View at: https://orgo.ai/workspaces/{self.computer_id}")
+        
+        except Exception as e:
+            if self.verbose:
+                _print_error(f"Failed to create computer: {str(e)}")
+            raise
     
     # =========================================================================
     # Computer Management
@@ -211,11 +264,21 @@ class Computer:
     
     def restart(self) -> Dict[str, Any]:
         """Restart the computer."""
-        return self.api.restart_computer(self.computer_id)
+        if self.verbose:
+            _print_info(f"Restarting computer: {self.name}")
+        result = self.api.restart_computer(self.computer_id)
+        if self.verbose:
+            _print_success("Computer restarted")
+        return result
     
     def destroy(self) -> Dict[str, Any]:
         """Delete the computer."""
-        return self.api.delete_computer(self.computer_id)
+        if self.verbose:
+            _print_info(f"Deleting computer: {self.name}")
+        result = self.api.delete_computer(self.computer_id)
+        if self.verbose:
+            _print_success("Computer deleted")
+        return result
     
     # =========================================================================
     # Mouse Actions

{orgo-0.0.37 → orgo-0.0.38}/src/orgo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orgo
-Version: 0.0.37
+Version: 0.0.38
 Summary: Computers for AI agents
 Author: Orgo Team
 License: MIT