cua-computer 0.4.3__tar.gz → 0.4.5__tar.gz

{cua_computer-0.4.3 → cua_computer-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cua-computer
-Version: 0.4.3
+Version: 0.4.5
 Summary: Computer-Use Interface (CUI) framework powering Cua
 Author-Email: TryCua <gh@trycua.com>
 Requires-Python: >=3.11
@@ -26,8 +26,8 @@ Description-Content-Type: text/markdown
 <h1>
   <div class="image-wrapper" style="display: inline-block;">
     <picture>
-      <source media="(prefers-color-scheme: dark)" alt="logo" height="150" srcset="../../img/logo_white.png" style="display: block; margin: auto;">
-      <source media="(prefers-color-scheme: light)" alt="logo" height="150" srcset="../../img/logo_black.png" style="display: block; margin: auto;">
+      <source media="(prefers-color-scheme: dark)" alt="logo" height="150" srcset="https://raw.githubusercontent.com/trycua/cua/main/img/logo_white.png" style="display: block; margin: auto;">
+      <source media="(prefers-color-scheme: light)" alt="logo" height="150" srcset="https://raw.githubusercontent.com/trycua/cua/main/img/logo_black.png" style="display: block; margin: auto;">
       <img alt="Shows my svg">
     </picture>
   </div>
@@ -44,7 +44,7 @@ Description-Content-Type: text/markdown
 ### Get started with Computer
 
 <div align="center">
-    <img src="../../img/computer.png"/>
+    <img src="https://raw.githubusercontent.com/trycua/cua/main/img/computer.png"/>
 </div>
 
 ```python
@@ -87,82 +87,11 @@ The `cua-computer` PyPi package pulls automatically the latest executable versio
 
 Refer to this notebook for a step-by-step guide on how to use the Computer-Use Interface (CUI):
 
-- [Computer-Use Interface (CUI)](../../notebooks/computer_nb.ipynb)
+- [Computer-Use Interface (CUI)](https://github.com/trycua/cua/blob/main/notebooks/computer_nb.ipynb)
 
-## Using the Gradio Computer UI
-
-The computer module includes a Gradio UI for creating and sharing demonstration data. We make it easy for people to build community datasets for better computer use models with an upload to Huggingface feature.
-
-```bash
-# Install with UI support
-pip install "cua-computer[ui]"
-```
-
-> **Note:** For precise control of the computer, we recommend using VNC or Screen Sharing instead of the Computer Gradio UI.
-
-### Building and Sharing Demonstrations with Huggingface
-
-Follow these steps to contribute your own demonstrations:
-
-#### 1. Set up Huggingface Access
-
-Set your HF_TOKEN in a .env file or in your environment variables:
-
-```bash
-# In .env file
-HF_TOKEN=your_huggingface_token
-```
-
-#### 2. Launch the Computer UI
-
-```python
-# launch_ui.py
-from computer.ui.gradio.app import create_gradio_ui
-from dotenv import load_dotenv
-load_dotenv('.env')
-
-app = create_gradio_ui()
-app.launch(share=False)
-```
-
-For examples, see [Computer UI Examples](../../examples/computer_ui_examples.py)
-
-#### 3. Record Your Tasks
-
-<details open>
-<summary>View demonstration video</summary>
-<video src="https://github.com/user-attachments/assets/de3c3477-62fe-413c-998d-4063e48de176" controls width="600"></video>
-</details>
-
-Record yourself performing various computer tasks using the UI.
-
-#### 4. Save Your Demonstrations
-
-<details open>
-<summary>View demonstration video</summary>
-<video src="https://github.com/user-attachments/assets/5ad1df37-026a-457f-8b49-922ae805faef" controls width="600"></video>
-</details>
-
-Save each task by picking a descriptive name and adding relevant tags (e.g., "office", "web-browsing", "coding").
-
-#### 5. Record Additional Demonstrations
-
-Repeat steps 3 and 4 until you have a good amount of demonstrations covering different tasks and scenarios.
-
-#### 6. Upload to Huggingface
-
-<details open>
-<summary>View demonstration video</summary>
-<video src="https://github.com/user-attachments/assets/c586d460-3877-4b5f-a736-3248886d2134" controls width="600"></video>
-</details>
-
-Upload your dataset to Huggingface by:
-- Naming it as `{your_username}/{dataset_name}`
-- Choosing public or private visibility
-- Optionally selecting specific tags to upload only tasks with certain tags
-
-#### Examples and Resources
-
-- Example Dataset: [ddupont/test-dataset](https://huggingface.co/datasets/ddupont/test-dataset)
-- Find Community Datasets: 🔍 [Browse CUA Datasets on Huggingface](https://huggingface.co/datasets?other=cua)
+## Docs
 
+- [Computers](https://trycua.com/docs/computer-sdk/computers)
+- [Commands](https://trycua.com/docs/computer-sdk/commands)
+- [Computer UI](https://trycua.com/docs/computer-sdk/computer-ui)
+- [Sandboxed Python](https://trycua.com/docs/computer-sdk/sandboxed-python)

cua_computer-0.4.5/README.md

@@ -0,0 +1,73 @@
+<div align="center">
+<h1>
+  <div class="image-wrapper" style="display: inline-block;">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" alt="logo" height="150" srcset="https://raw.githubusercontent.com/trycua/cua/main/img/logo_white.png" style="display: block; margin: auto;">
+      <source media="(prefers-color-scheme: light)" alt="logo" height="150" srcset="https://raw.githubusercontent.com/trycua/cua/main/img/logo_black.png" style="display: block; margin: auto;">
+      <img alt="Shows my svg">
+    </picture>
+  </div>
+
+  [![Python](https://img.shields.io/badge/Python-333333?logo=python&logoColor=white&labelColor=333333)](#)
+  [![macOS](https://img.shields.io/badge/macOS-000000?logo=apple&logoColor=F0F0F0)](#)
+  [![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?&logo=discord&logoColor=white)](https://discord.com/invite/mVnXXpdE85)
+  [![PyPI](https://img.shields.io/pypi/v/cua-computer?color=333333)](https://pypi.org/project/cua-computer/)
+</h1>
+</div>
+
+**cua-computer** is a Computer-Use Interface (CUI) framework powering Cua for interacting with local macOS and Linux sandboxes, PyAutoGUI-compatible, and pluggable with any AI agent systems (Cua, Langchain, CrewAI, AutoGen). Computer relies on [Lume](https://github.com/trycua/lume) for creating and managing sandbox environments.
+
+### Get started with Computer
+
+<div align="center">
+    <img src="https://raw.githubusercontent.com/trycua/cua/main/img/computer.png"/>
+</div>
+
+```python
+from computer import Computer
+
+computer = Computer(os_type="macos", display="1024x768", memory="8GB", cpu="4")
+try:
+    await computer.run()
+    
+    screenshot = await computer.interface.screenshot()
+    with open("screenshot.png", "wb") as f:
+        f.write(screenshot)
+    
+    await computer.interface.move_cursor(100, 100)
+    await computer.interface.left_click()
+    await computer.interface.right_click(300, 300)
+    await computer.interface.double_click(400, 400)
+
+    await computer.interface.type("Hello, World!")
+    await computer.interface.press_key("enter")
+
+    await computer.interface.set_clipboard("Test clipboard")
+    content = await computer.interface.copy_to_clipboard()
+    print(f"Clipboard content: {content}")
+finally:
+    await computer.stop()
+```
+
+## Install
+
+To install the Computer-Use Interface (CUI):
+
+```bash
+pip install "cua-computer[all]"
+```
+
+The `cua-computer` PyPi package pulls automatically the latest executable version of Lume through [pylume](https://github.com/trycua/pylume).
+
+## Run
+
+Refer to this notebook for a step-by-step guide on how to use the Computer-Use Interface (CUI):
+
+- [Computer-Use Interface (CUI)](https://github.com/trycua/cua/blob/main/notebooks/computer_nb.ipynb)
+
+## Docs
+
+- [Computers](https://trycua.com/docs/computer-sdk/computers)
+- [Commands](https://trycua.com/docs/computer-sdk/commands)
+- [Computer UI](https://trycua.com/docs/computer-sdk/computer-ui)
+- [Sandboxed Python](https://trycua.com/docs/computer-sdk/sandboxed-python)

{cua_computer-0.4.3 → cua_computer-0.4.5}/computer/__init__.py

@@ -12,7 +12,6 @@ logger = logging.getLogger("computer")
 try:
     # Import from core telemetry
     from core.telemetry import (
-        flush,
         is_telemetry_enabled,
         record_event,
     )
@@ -30,9 +29,6 @@ try:
                 "python_version": sys.version,
             },
         )
-
-        # Flush events to ensure they're sent
-        flush()
     else:
         logger.info("Telemetry is disabled")
 except ImportError as e:

{cua_computer-0.4.3 → cua_computer-0.4.5}/computer/computer.py

@@ -9,10 +9,18 @@ import re
 from .logger import Logger, LogLevel
 import json
 import logging
-from .telemetry import record_computer_initialization
+from core.telemetry import is_telemetry_enabled, record_event
 import os
 from . import helpers
 
+import platform
+
+SYSTEM_INFO = {
+    "os": platform.system().lower(),
+    "os_version": platform.release(),
+    "python_version": platform.python_version(),
+}
+
 # Import provider related modules
 from .providers.base import VMProviderType
 from .providers.factory import VMProviderFactory
@@ -152,6 +160,8 @@ class Computer:
             if not name:
                 # Normalize the name to be used for the VM
                 name = image.replace(":", "_")
+                # Remove any forward slashes
+                name = name.replace("/", "_")
 
             # Convert display parameter to Display object
             if isinstance(display, str):
@@ -190,8 +200,8 @@ class Computer:
         self.use_host_computer_server = use_host_computer_server
 
         # Record initialization in telemetry (if enabled)
-        if telemetry_enabled:
-            record_computer_initialization()
+        if telemetry_enabled and is_telemetry_enabled():
+            record_event("computer_initialized", SYSTEM_INFO)
         else:
             self.logger.debug("Telemetry disabled - skipping initialization tracking")
 

cua_computer-0.4.5/computer/diorama_computer.py

@@ -0,0 +1,243 @@
+import asyncio
+from .interface.models import KeyType, Key
+
+class DioramaComputer:
+    """
+    A Computer-compatible proxy for Diorama that sends commands over the ComputerInterface.
+    """
+    def __init__(self, computer, apps):
+        """
+        Initialize the DioramaComputer with a computer instance and list of apps.
+        
+        Args:
+            computer: The computer instance to proxy commands through
+            apps: List of applications available in the diorama environment
+        """
+        self.computer = computer
+        self.apps = apps
+        self.interface = DioramaComputerInterface(computer, apps)
+        self._initialized = False
+
+    async def __aenter__(self):
+        """
+        Async context manager entry point.
+        
+        Returns:
+            self: The DioramaComputer instance
+        """
+        self._initialized = True
+        return self
+
+    async def run(self):
+        """
+        Initialize and run the DioramaComputer if not already initialized.
+        
+        Returns:
+            self: The DioramaComputer instance
+        """
+        if not self._initialized:
+            await self.__aenter__()
+        return self
+
+class DioramaComputerInterface:
+    """
+    Diorama Interface proxy that sends diorama_cmds via the Computer's interface.
+    """
+    def __init__(self, computer, apps):
+        """
+        Initialize the DioramaComputerInterface.
+        
+        Args:
+            computer: The computer instance to send commands through
+            apps: List of applications available in the diorama environment
+        """
+        self.computer = computer
+        self.apps = apps
+        self._scene_size = None
+
+    async def _send_cmd(self, action, arguments=None):
+        """
+        Send a command to the diorama interface through the computer.
+        
+        Args:
+            action (str): The action/command to execute
+            arguments (dict, optional): Additional arguments for the command
+            
+        Returns:
+            The result from the diorama command execution
+            
+        Raises:
+            RuntimeError: If the computer interface is not initialized or command fails
+        """
+        arguments = arguments or {}
+        arguments = {"app_list": self.apps, **arguments}
+        # Use the computer's interface (must be initialized)
+        iface = getattr(self.computer, "_interface", None)
+        if iface is None:
+            raise RuntimeError("Computer interface not initialized. Call run() first.")
+        result = await iface.diorama_cmd(action, arguments)
+        if not result.get("success"):
+            raise RuntimeError(f"Diorama command failed: {result.get('error')}\n{result.get('trace')}")
+        return result.get("result")
+
+    async def screenshot(self, as_bytes=True):
+        """
+        Take a screenshot of the diorama scene.
+        
+        Args:
+            as_bytes (bool): If True, return image as bytes; if False, return PIL Image object
+            
+        Returns:
+            bytes or PIL.Image: Screenshot data in the requested format
+        """
+        from PIL import Image
+        import base64
+        result = await self._send_cmd("screenshot")
+        # assume result is a b64 string of an image
+        img_bytes = base64.b64decode(result)
+        import io
+        img = Image.open(io.BytesIO(img_bytes))
+        self._scene_size = img.size
+        return img_bytes if as_bytes else img
+
+    async def get_screen_size(self):
+        """
+        Get the dimensions of the diorama scene.
+        
+        Returns:
+            dict: Dictionary containing 'width' and 'height' keys with pixel dimensions
+        """
+        if not self._scene_size:
+            await self.screenshot(as_bytes=False)
+        return {"width": self._scene_size[0], "height": self._scene_size[1]}
+
+    async def move_cursor(self, x, y):
+        """
+        Move the cursor to the specified coordinates.
+        
+        Args:
+            x (int): X coordinate to move cursor to
+            y (int): Y coordinate to move cursor to
+        """
+        await self._send_cmd("move_cursor", {"x": x, "y": y})
+
+    async def left_click(self, x=None, y=None):
+        """
+        Perform a left mouse click at the specified coordinates or current cursor position.
+        
+        Args:
+            x (int, optional): X coordinate to click at. If None, clicks at current cursor position
+            y (int, optional): Y coordinate to click at. If None, clicks at current cursor position
+        """
+        await self._send_cmd("left_click", {"x": x, "y": y})
+
+    async def right_click(self, x=None, y=None):
+        """
+        Perform a right mouse click at the specified coordinates or current cursor position.
+        
+        Args:
+            x (int, optional): X coordinate to click at. If None, clicks at current cursor position
+            y (int, optional): Y coordinate to click at. If None, clicks at current cursor position
+        """
+        await self._send_cmd("right_click", {"x": x, "y": y})
+
+    async def double_click(self, x=None, y=None):
+        """
+        Perform a double mouse click at the specified coordinates or current cursor position.
+        
+        Args:
+            x (int, optional): X coordinate to double-click at. If None, clicks at current cursor position
+            y (int, optional): Y coordinate to double-click at. If None, clicks at current cursor position
+        """
+        await self._send_cmd("double_click", {"x": x, "y": y})
+
+    async def scroll_up(self, clicks=1):
+        """
+        Scroll up by the specified number of clicks.
+        
+        Args:
+            clicks (int): Number of scroll clicks to perform upward. Defaults to 1
+        """
+        await self._send_cmd("scroll_up", {"clicks": clicks})
+
+    async def scroll_down(self, clicks=1):
+        """
+        Scroll down by the specified number of clicks.
+        
+        Args:
+            clicks (int): Number of scroll clicks to perform downward. Defaults to 1
+        """
+        await self._send_cmd("scroll_down", {"clicks": clicks})
+
+    async def drag_to(self, x, y, duration=0.5):
+        """
+        Drag from the current cursor position to the specified coordinates.
+        
+        Args:
+            x (int): X coordinate to drag to
+            y (int): Y coordinate to drag to
+            duration (float): Duration of the drag operation in seconds. Defaults to 0.5
+        """
+        await self._send_cmd("drag_to", {"x": x, "y": y, "duration": duration})
+
+    async def get_cursor_position(self):
+        """
+        Get the current cursor position.
+        
+        Returns:
+            dict: Dictionary containing the current cursor coordinates
+        """
+        return await self._send_cmd("get_cursor_position")
+
+    async def type_text(self, text):
+        """
+        Type the specified text at the current cursor position.
+        
+        Args:
+            text (str): The text to type
+        """
+        await self._send_cmd("type_text", {"text": text})
+
+    async def press_key(self, key):
+        """
+        Press a single key.
+        
+        Args:
+            key: The key to press
+        """
+        await self._send_cmd("press_key", {"key": key})
+
+    async def hotkey(self, *keys):
+        """
+        Press multiple keys simultaneously as a hotkey combination.
+        
+        Args:
+            *keys: Variable number of keys to press together. Can be Key enum instances or strings
+            
+        Raises:
+            ValueError: If any key is not a Key enum or string type
+        """
+        actual_keys = []
+        for key in keys:
+            if isinstance(key, Key):
+                actual_keys.append(key.value)
+            elif isinstance(key, str):
+                # Try to convert to enum if it matches a known key
+                key_or_enum = Key.from_string(key)
+                actual_keys.append(key_or_enum.value if isinstance(key_or_enum, Key) else key_or_enum)
+            else:
+                raise ValueError(f"Invalid key type: {type(key)}. Must be Key enum or string.")
+        await self._send_cmd("hotkey", {"keys": actual_keys})
+
+    async def to_screen_coordinates(self, x, y):
+        """
+        Convert coordinates to screen coordinates.
+        
+        Args:
+            x (int): X coordinate to convert
+            y (int): Y coordinate to convert
+            
+        Returns:
+            dict: Dictionary containing the converted screen coordinates
+        """
+        return await self._send_cmd("to_screen_coordinates", {"x": x, "y": y})

{cua_computer-0.4.3 → cua_computer-0.4.5}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "cua-computer"
-version = "0.4.3"
+version = "0.4.5"
 description = "Computer-Use Interface (CUI) framework powering Cua"
 readme = "README.md"
 authors = [
@@ -57,7 +57,7 @@ target-version = [
 
 [tool.ruff]
 line-length = 100
-target-version = "0.4.3"
+target-version = "0.4.5"
 select = [
     "E",
     "F",
@@ -71,7 +71,7 @@ docstring-code-format = true
 
 [tool.mypy]
 strict = true
-python_version = "0.4.3"
+python_version = "0.4.5"
 ignore_missing_imports = true
 disallow_untyped_defs = true
 check_untyped_defs = true

cua_computer-0.4.3/README.md

@@ -1,144 +0,0 @@
-<div align="center">
-<h1>
-  <div class="image-wrapper" style="display: inline-block;">
-    <picture>
-      <source media="(prefers-color-scheme: dark)" alt="logo" height="150" srcset="../../img/logo_white.png" style="display: block; margin: auto;">
-      <source media="(prefers-color-scheme: light)" alt="logo" height="150" srcset="../../img/logo_black.png" style="display: block; margin: auto;">
-      <img alt="Shows my svg">
-    </picture>
-  </div>
-
-  [![Python](https://img.shields.io/badge/Python-333333?logo=python&logoColor=white&labelColor=333333)](#)
-  [![macOS](https://img.shields.io/badge/macOS-000000?logo=apple&logoColor=F0F0F0)](#)
-  [![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?&logo=discord&logoColor=white)](https://discord.com/invite/mVnXXpdE85)
-  [![PyPI](https://img.shields.io/pypi/v/cua-computer?color=333333)](https://pypi.org/project/cua-computer/)
-</h1>
-</div>
-
-**cua-computer** is a Computer-Use Interface (CUI) framework powering Cua for interacting with local macOS and Linux sandboxes, PyAutoGUI-compatible, and pluggable with any AI agent systems (Cua, Langchain, CrewAI, AutoGen). Computer relies on [Lume](https://github.com/trycua/lume) for creating and managing sandbox environments.
-
-### Get started with Computer
-
-<div align="center">
-    <img src="../../img/computer.png"/>
-</div>
-
-```python
-from computer import Computer
-
-computer = Computer(os_type="macos", display="1024x768", memory="8GB", cpu="4")
-try:
-    await computer.run()
-    
-    screenshot = await computer.interface.screenshot()
-    with open("screenshot.png", "wb") as f:
-        f.write(screenshot)
-    
-    await computer.interface.move_cursor(100, 100)
-    await computer.interface.left_click()
-    await computer.interface.right_click(300, 300)
-    await computer.interface.double_click(400, 400)
-
-    await computer.interface.type("Hello, World!")
-    await computer.interface.press_key("enter")
-
-    await computer.interface.set_clipboard("Test clipboard")
-    content = await computer.interface.copy_to_clipboard()
-    print(f"Clipboard content: {content}")
-finally:
-    await computer.stop()
-```
-
-## Install
-
-To install the Computer-Use Interface (CUI):
-
-```bash
-pip install "cua-computer[all]"
-```
-
-The `cua-computer` PyPi package pulls automatically the latest executable version of Lume through [pylume](https://github.com/trycua/pylume).
-
-## Run
-
-Refer to this notebook for a step-by-step guide on how to use the Computer-Use Interface (CUI):
-
-- [Computer-Use Interface (CUI)](../../notebooks/computer_nb.ipynb)
-
-## Using the Gradio Computer UI
-
-The computer module includes a Gradio UI for creating and sharing demonstration data. We make it easy for people to build community datasets for better computer use models with an upload to Huggingface feature.
-
-```bash
-# Install with UI support
-pip install "cua-computer[ui]"
-```
-
-> **Note:** For precise control of the computer, we recommend using VNC or Screen Sharing instead of the Computer Gradio UI.
-
-### Building and Sharing Demonstrations with Huggingface
-
-Follow these steps to contribute your own demonstrations:
-
-#### 1. Set up Huggingface Access
-
-Set your HF_TOKEN in a .env file or in your environment variables:
-
-```bash
-# In .env file
-HF_TOKEN=your_huggingface_token
-```
-
-#### 2. Launch the Computer UI
-
-```python
-# launch_ui.py
-from computer.ui.gradio.app import create_gradio_ui
-from dotenv import load_dotenv
-load_dotenv('.env')
-
-app = create_gradio_ui()
-app.launch(share=False)
-```
-
-For examples, see [Computer UI Examples](../../examples/computer_ui_examples.py)
-
-#### 3. Record Your Tasks
-
-<details open>
-<summary>View demonstration video</summary>
-<video src="https://github.com/user-attachments/assets/de3c3477-62fe-413c-998d-4063e48de176" controls width="600"></video>
-</details>
-
-Record yourself performing various computer tasks using the UI.
-
-#### 4. Save Your Demonstrations
-
-<details open>
-<summary>View demonstration video</summary>
-<video src="https://github.com/user-attachments/assets/5ad1df37-026a-457f-8b49-922ae805faef" controls width="600"></video>
-</details>
-
-Save each task by picking a descriptive name and adding relevant tags (e.g., "office", "web-browsing", "coding").
-
-#### 5. Record Additional Demonstrations
-
-Repeat steps 3 and 4 until you have a good amount of demonstrations covering different tasks and scenarios.
-
-#### 6. Upload to Huggingface
-
-<details open>
-<summary>View demonstration video</summary>
-<video src="https://github.com/user-attachments/assets/c586d460-3877-4b5f-a736-3248886d2134" controls width="600"></video>
-</details>
-
-Upload your dataset to Huggingface by:
-- Naming it as `{your_username}/{dataset_name}`
-- Choosing public or private visibility
-- Optionally selecting specific tags to upload only tasks with certain tags
-
-#### Examples and Resources
-
-- Example Dataset: [ddupont/test-dataset](https://huggingface.co/datasets/ddupont/test-dataset)
-- Find Community Datasets: 🔍 [Browse CUA Datasets on Huggingface](https://huggingface.co/datasets?other=cua)
-

cua_computer-0.4.3/computer/diorama_computer.py

@@ -1,104 +0,0 @@
-import asyncio
-from .interface.models import KeyType, Key
-
-class DioramaComputer:
-    """
-    A Computer-compatible proxy for Diorama that sends commands over the ComputerInterface.
-    """
-    def __init__(self, computer, apps):
-        self.computer = computer
-        self.apps = apps
-        self.interface = DioramaComputerInterface(computer, apps)
-        self._initialized = False
-
-    async def __aenter__(self):
-        self._initialized = True
-        return self
-
-    async def run(self):
-        if not self._initialized:
-            await self.__aenter__()
-        return self
-
-class DioramaComputerInterface:
-    """
-    Diorama Interface proxy that sends diorama_cmds via the Computer's interface.
-    """
-    def __init__(self, computer, apps):
-        self.computer = computer
-        self.apps = apps
-        self._scene_size = None
-
-    async def _send_cmd(self, action, arguments=None):
-        arguments = arguments or {}
-        arguments = {"app_list": self.apps, **arguments}
-        # Use the computer's interface (must be initialized)
-        iface = getattr(self.computer, "_interface", None)
-        if iface is None:
-            raise RuntimeError("Computer interface not initialized. Call run() first.")
-        result = await iface.diorama_cmd(action, arguments)
-        if not result.get("success"):
-            raise RuntimeError(f"Diorama command failed: {result.get('error')}\n{result.get('trace')}")
-        return result.get("result")
-
-    async def screenshot(self, as_bytes=True):
-        from PIL import Image
-        import base64
-        result = await self._send_cmd("screenshot")
-        # assume result is a b64 string of an image
-        img_bytes = base64.b64decode(result)
-        import io
-        img = Image.open(io.BytesIO(img_bytes))
-        self._scene_size = img.size
-        return img_bytes if as_bytes else img
-
-    async def get_screen_size(self):
-        if not self._scene_size:
-            await self.screenshot(as_bytes=False)
-        return {"width": self._scene_size[0], "height": self._scene_size[1]}
-
-    async def move_cursor(self, x, y):
-        await self._send_cmd("move_cursor", {"x": x, "y": y})
-
-    async def left_click(self, x=None, y=None):
-        await self._send_cmd("left_click", {"x": x, "y": y})
-
-    async def right_click(self, x=None, y=None):
-        await self._send_cmd("right_click", {"x": x, "y": y})
-
-    async def double_click(self, x=None, y=None):
-        await self._send_cmd("double_click", {"x": x, "y": y})
-
-    async def scroll_up(self, clicks=1):
-        await self._send_cmd("scroll_up", {"clicks": clicks})
-
-    async def scroll_down(self, clicks=1):
-        await self._send_cmd("scroll_down", {"clicks": clicks})
-
-    async def drag_to(self, x, y, duration=0.5):
-        await self._send_cmd("drag_to", {"x": x, "y": y, "duration": duration})
-
-    async def get_cursor_position(self):
-        return await self._send_cmd("get_cursor_position")
-
-    async def type_text(self, text):
-        await self._send_cmd("type_text", {"text": text})
-
-    async def press_key(self, key):
-        await self._send_cmd("press_key", {"key": key})
-
-    async def hotkey(self, *keys):
-        actual_keys = []
-        for key in keys:
-            if isinstance(key, Key):
-                actual_keys.append(key.value)
-            elif isinstance(key, str):
-                # Try to convert to enum if it matches a known key
-                key_or_enum = Key.from_string(key)
-                actual_keys.append(key_or_enum.value if isinstance(key_or_enum, Key) else key_or_enum)
-            else:
-                raise ValueError(f"Invalid key type: {type(key)}. Must be Key enum or string.")
-        await self._send_cmd("hotkey", {"keys": actual_keys})
-
-    async def to_screen_coordinates(self, x, y):
-        return await self._send_cmd("to_screen_coordinates", {"x": x, "y": y})

cua_computer-0.4.3/computer/telemetry.py

@@ -1,116 +0,0 @@
-"""Computer telemetry for tracking anonymous usage and feature usage."""
-
-import logging
-import platform
-from typing import Any
-
-# Import the core telemetry module
-TELEMETRY_AVAILABLE = False
-
-try:
-    from core.telemetry import (
-        increment,
-        is_telemetry_enabled,
-        is_telemetry_globally_disabled,
-        record_event,
-    )
-
-    def increment_counter(counter_name: str, value: int = 1) -> None:
-        """Wrapper for increment to maintain backward compatibility."""
-        if is_telemetry_enabled():
-            increment(counter_name, value)
-
-    def set_dimension(name: str, value: Any) -> None:
-        """Set a dimension that will be attached to all events."""
-        logger = logging.getLogger("computer.telemetry")
-        logger.debug(f"Setting dimension {name}={value}")
-
-    TELEMETRY_AVAILABLE = True
-    logger = logging.getLogger("computer.telemetry")
-    logger.info("Successfully imported telemetry")
-except ImportError as e:
-    logger = logging.getLogger("computer.telemetry")
-    logger.warning(f"Could not import telemetry: {e}")
-    TELEMETRY_AVAILABLE = False
-
-
-# Local fallbacks in case core telemetry isn't available
-def _noop(*args: Any, **kwargs: Any) -> None:
-    """No-op function for when telemetry is not available."""
-    pass
-
-
-logger = logging.getLogger("computer.telemetry")
-
-# If telemetry isn't available, use no-op functions
-if not TELEMETRY_AVAILABLE:
-    logger.debug("Telemetry not available, using no-op functions")
-    record_event = _noop  # type: ignore
-    increment_counter = _noop  # type: ignore
-    set_dimension = _noop  # type: ignore
-    get_telemetry_client = lambda: None  # type: ignore
-    flush = _noop  # type: ignore
-    is_telemetry_enabled = lambda: False  # type: ignore
-    is_telemetry_globally_disabled = lambda: True  # type: ignore
-
-# Get system info once to use in telemetry
-SYSTEM_INFO = {
-    "os": platform.system().lower(),
-    "os_version": platform.release(),
-    "python_version": platform.python_version(),
-}
-
-
-def enable_telemetry() -> bool:
-    """Enable telemetry if available.
-
-    Returns:
-        bool: True if telemetry was successfully enabled, False otherwise
-    """
-    global TELEMETRY_AVAILABLE
-
-    # Check if globally disabled using core function
-    if TELEMETRY_AVAILABLE and is_telemetry_globally_disabled():
-        logger.info("Telemetry is globally disabled via environment variable - cannot enable")
-        return False
-
-    # Already enabled
-    if TELEMETRY_AVAILABLE:
-        return True
-
-    # Try to import and enable
-    try:
-        # Verify we can import core telemetry
-        from core.telemetry import record_event  # type: ignore
-
-        TELEMETRY_AVAILABLE = True
-        logger.info("Telemetry successfully enabled")
-        return True
-    except ImportError as e:
-        logger.warning(f"Could not enable telemetry: {e}")
-        return False
-
-
-def is_telemetry_enabled() -> bool:
-    """Check if telemetry is enabled.
-
-    Returns:
-        bool: True if telemetry is enabled, False otherwise
-    """
-    # Use the core function if available, otherwise use our local flag
-    if TELEMETRY_AVAILABLE:
-        from core.telemetry import is_telemetry_enabled as core_is_enabled
-
-        return core_is_enabled()
-    return False
-
-
-def record_computer_initialization() -> None:
-    """Record when a computer instance is initialized."""
-    if TELEMETRY_AVAILABLE and is_telemetry_enabled():
-        record_event("computer_initialized", SYSTEM_INFO)
-
-        # Set dimensions that will be attached to all events
-        set_dimension("os", SYSTEM_INFO["os"])
-        set_dimension("os_version", SYSTEM_INFO["os_version"])
-        set_dimension("python_version", SYSTEM_INFO["python_version"])