cua-agent 0.1.2__tar.gz → 0.1.4__tar.gz

cua_agent-0.1.4/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.1
+Name: cua-agent
+Version: 0.1.4
+Summary: CUA (Computer Use) Agent for AI-driven computer interaction
+Author-Email: TryCua <gh@trycua.com>
+Requires-Python: <3.13,>=3.10
+Requires-Dist: httpx<0.29.0,>=0.27.0
+Requires-Dist: aiohttp<4.0.0,>=3.9.3
+Requires-Dist: asyncio
+Requires-Dist: anyio<5.0.0,>=4.4.1
+Requires-Dist: typing-extensions<5.0.0,>=4.12.2
+Requires-Dist: pydantic<3.0.0,>=2.6.4
+Requires-Dist: rich<14.0.0,>=13.7.1
+Requires-Dist: python-dotenv<2.0.0,>=1.0.1
+Requires-Dist: cua-computer<0.2.0,>=0.1.0
+Requires-Dist: cua-core<0.2.0,>=0.1.0
+Requires-Dist: certifi>=2024.2.2
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.49.0; extra == "anthropic"
+Requires-Dist: boto3<2.0.0,>=1.35.81; extra == "anthropic"
+Provides-Extra: som
+Requires-Dist: torch>=2.2.1; extra == "som"
+Requires-Dist: torchvision>=0.17.1; extra == "som"
+Requires-Dist: ultralytics>=8.0.0; extra == "som"
+Requires-Dist: transformers>=4.38.2; extra == "som"
+Requires-Dist: cua-som<0.2.0,>=0.1.0; extra == "som"
+Requires-Dist: anthropic<0.47.0,>=0.46.0; extra == "som"
+Requires-Dist: boto3<2.0.0,>=1.35.81; extra == "som"
+Requires-Dist: openai<2.0.0,>=1.14.0; extra == "som"
+Requires-Dist: groq<0.5.0,>=0.4.0; extra == "som"
+Requires-Dist: dashscope<2.0.0,>=1.13.0; extra == "som"
+Requires-Dist: requests<3.0.0,>=2.31.0; extra == "som"
+Provides-Extra: all
+Requires-Dist: torch>=2.2.1; extra == "all"
+Requires-Dist: torchvision>=0.17.1; extra == "all"
+Requires-Dist: ultralytics>=8.0.0; extra == "all"
+Requires-Dist: transformers>=4.38.2; extra == "all"
+Requires-Dist: cua-som<0.2.0,>=0.1.0; extra == "all"
+Requires-Dist: anthropic<0.47.0,>=0.46.0; extra == "all"
+Requires-Dist: boto3<2.0.0,>=1.35.81; extra == "all"
+Requires-Dist: openai<2.0.0,>=1.14.0; extra == "all"
+Requires-Dist: groq<0.5.0,>=0.4.0; extra == "all"
+Requires-Dist: dashscope<2.0.0,>=1.13.0; extra == "all"
+Requires-Dist: requests<3.0.0,>=2.31.0; extra == "all"
+Description-Content-Type: text/markdown
+
+<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>
+
+**Agent** is a Computer Use (CUA) framework for running multi-app agentic workflows targeting macOS and Linux sandbox, supporting local (Ollama) and cloud model providers (OpenAI, Anthropic, Groq, DeepSeek, Qwen). The framework integrates with Microsoft's OmniParser for enhanced UI understanding and interaction.
+
+### Get started with Agent
+
+```python
+from agent import ComputerAgent, AgentLoop, LLMProvider
+from computer import Computer
+
+computer = Computer(verbosity=logging.INFO)
+
+agent = ComputerAgent(
+    computer=computer,
+    loop=AgentLoop.ANTHROPIC,
+    # loop=AgentLoop.OMNI,
+    model=LLM(provider=LLMProvider.ANTHROPIC, name="claude-3-7-sonnet-20250219"),
+    # model=LLM(provider=LLMProvider.OPENAI, name="gpt-4.5-preview"),
+    save_trajectory=True,
+    trajectory_dir=str(Path("trajectories")),
+    only_n_most_recent_images=3,
+    verbosity=logging.INFO,
+)
+
+tasks = [
+"""
+Please help me with the following task:
+1. Open Safari browser
+2. Go to Wikipedia.org
+3. Search for "Claude AI" 
+4. Summarize the main points you find about Claude AI
+"""
+]
+
+async with agent:
+    for i, task in enumerate(tasks, 1):
+        print(f"\nExecuting task {i}/{len(tasks)}: {task}")
+        async for result in agent.run(task):
+            print(result)
+        print(f"Task {i} completed")
+```
+
+## Install
+
+### cua-agent
+
+```bash
+pip install "cua-agent[all]"
+
+# or install specific loop providers
+pip install "cua-agent[anthropic]"
+pip install "cua-agent[omni]"
+```
+
+## Run
+
+Refer to these notebooks for step-by-step guides on how to use the Computer-Use Agent (CUA):
+
+- [Agent Notebook](../../notebooks/agent_nb.ipynb) - Complete examples and workflows

{cua_agent-0.1.2 → cua_agent-0.1.4}/README.md

@@ -60,67 +60,15 @@ async with agent:
 ### cua-agent
 
 ```bash
-
-pip install cua-agent[all]
+pip install "cua-agent[all]"
 
 # or install specific loop providers
-pip install cua-agent[anthropic]
-pip install cua-agent[omni]
-
-
+pip install "cua-agent[anthropic]"
+pip install "cua-agent[omni]"
 ```
 
-## Features
-
-### OmniParser Integration
-- Enhanced UI understanding with element detection
-- Automatic bounding box detection for UI elements
-- Improved accuracy for complex UI interactions
-- Support for icon and text element recognition
-
-### Basic Computer Control
-- Direct keyboard and mouse control
-- Window and application management
-- Screenshot capabilities
-- Basic UI element detection
-
-### Provider Support
-- OpenAI (GPT-4V) - Recommended for OmniParser integration
-- Anthropic (Claude) - Strong general performance
-- Groq - Fast inference with Llama models
-- DeepSeek - Alternative model provider
-- Qwen - Alibaba's multimodal model
-
 ## Run
 
 Refer to these notebooks for step-by-step guides on how to use the Computer-Use Agent (CUA):
 
-- [Agent Notebook](../../notebooks/agent_nb.ipynb) - Complete examples and workflows
-
-## Components
-
-The library consists of several components:
-
-- **Core**
-  - `ComputerAgent`: Unified agent class supporting multiple loop types
-  - `BaseComputerAgent`: Abstract base class for computer agents
-  
-- **Providers**
-  - `Anthropic`: Implementation for Anthropic Claude models
-  - `Omni`: Implementation for multiple providers (OpenAI, Groq, etc.)
-
-- **Loops**
-  - `AnthropicLoop`: Loop implementation for Anthropic
-  - `OmniLoop`: Generic loop supporting multiple providers
-
-## Configuration
-
-The agent can be configured with various parameters:
-
-- **loop_type**: The type of loop to use (ANTHROPIC or OMNI)
-- **provider**: AI provider to use with the loop
-- **model**: The AI model to use
-- **save_trajectory**: Whether to save screenshots and logs
-- **only_n_most_recent_images**: Only keep a specific number of recent images
-
-See the [Core README](./agent/core/README.md) for more details on the unified agent.
+- [Agent Notebook](../../notebooks/agent_nb.ipynb) - Complete examples and workflows

cua_agent-0.1.4/agent/__init__.py

@@ -0,0 +1,56 @@
+"""CUA (Computer Use) Agent for AI-driven computer interaction."""
+
+import sys
+import logging
+
+__version__ = "0.1.0"
+
+# Initialize logging
+logger = logging.getLogger("cua.agent")
+
+# Initialize telemetry when the package is imported
+try:
+    # Import from core telemetry for basic functions
+    from core.telemetry import (
+        is_telemetry_enabled,
+        flush,
+        record_event,
+    )
+
+    # Import set_dimension from our own telemetry module
+    from .core.telemetry import set_dimension
+
+    # Check if telemetry is enabled
+    if is_telemetry_enabled():
+        logger.info("Telemetry is enabled")
+
+        # Record package initialization
+        record_event(
+            "module_init",
+            {
+                "module": "agent",
+                "version": __version__,
+                "python_version": sys.version,
+            },
+        )
+
+        # Set the package version as a dimension
+        set_dimension("agent_version", __version__)
+
+        # Flush events to ensure they're sent
+        flush()
+    else:
+        logger.info("Telemetry is disabled")
+except ImportError as e:
+    # Telemetry not available
+    logger.warning(f"Telemetry not available: {e}")
+except Exception as e:
+    # Other issues with telemetry
+    logger.warning(f"Error initializing telemetry: {e}")
+
+from .core.factory import AgentFactory
+from .core.agent import ComputerAgent
+from .providers.omni.types import LLMProvider, LLM
+from .types.base import Provider, AgentLoop
+
+__all__ = ["AgentFactory", "Provider", "ComputerAgent", "AgentLoop", "LLMProvider", "LLM"]

cua_agent-0.1.4/agent/core/agent.py

@@ -0,0 +1,252 @@
+"""Unified computer agent implementation that supports multiple loops."""
+
+import os
+import logging
+import asyncio
+import time
+import uuid
+from typing import Any, AsyncGenerator, Dict, List, Optional, TYPE_CHECKING, Union, cast
+from datetime import datetime
+from enum import Enum
+
+from computer import Computer
+
+from ..types.base import Provider, AgentLoop
+from .base_agent import BaseComputerAgent
+from ..core.telemetry import record_agent_initialization
+
+# Only import types for type checking to avoid circular imports
+if TYPE_CHECKING:
+    from ..providers.anthropic.loop import AnthropicLoop
+    from ..providers.omni.loop import OmniLoop
+    from ..providers.omni.parser import OmniParser
+
+# Import the provider types
+from ..providers.omni.types import LLMProvider, LLM, Model, LLMModel
+
+logger = logging.getLogger(__name__)
+
+# Default models for different providers
+DEFAULT_MODELS = {
+    LLMProvider.OPENAI: "gpt-4o",
+    LLMProvider.ANTHROPIC: "claude-3-7-sonnet-20250219",
+}
+
+# Map providers to their environment variable names
+ENV_VARS = {
+    LLMProvider.OPENAI: "OPENAI_API_KEY",
+    LLMProvider.ANTHROPIC: "ANTHROPIC_API_KEY",
+}
+
+
+class ComputerAgent(BaseComputerAgent):
+    """Unified implementation of the computer agent supporting multiple loop types.
+
+    This class consolidates the previous AnthropicComputerAgent and OmniComputerAgent
+    into a single implementation with configurable loop type.
+    """
+
+    def __init__(
+        self,
+        computer: Computer,
+        loop: AgentLoop = AgentLoop.OMNI,
+        model: Optional[Union[LLM, Dict[str, str], str]] = None,
+        api_key: Optional[str] = None,
+        save_trajectory: bool = True,
+        trajectory_dir: Optional[str] = "trajectories",
+        only_n_most_recent_images: Optional[int] = None,
+        max_retries: int = 3,
+        verbosity: int = logging.INFO,
+        telemetry_enabled: bool = True,
+        **kwargs,
+    ):
+        """Initialize a ComputerAgent instance.
+
+        Args:
+            computer: The Computer instance to control
+            loop: The agent loop to use: ANTHROPIC or OMNI
+            model: The model to use. Can be a string, dict or LLM object.
+                  Defaults to LLM for the loop type.
+            api_key: The API key to use. If None, will use environment variables.
+            save_trajectory: Whether to save the trajectory.
+            trajectory_dir: The directory to save trajectories to.
+            only_n_most_recent_images: Only keep this many most recent images.
+            max_retries: Maximum number of retries for failed requests.
+            verbosity: Logging level (standard Python logging levels).
+            telemetry_enabled: Whether to enable telemetry tracking. Defaults to True.
+            **kwargs: Additional keyword arguments to pass to the loop.
+        """
+        super().__init__(computer)
+        self._configure_logging(verbosity)
+        logger.info(f"Initializing ComputerAgent with {loop} loop")
+
+        # Store telemetry preference
+        self.telemetry_enabled = telemetry_enabled
+
+        # Process the model configuration
+        self.model = self._process_model_config(model, loop)
+        self.loop_type = loop
+        self.api_key = api_key
+
+        # Store computer
+        self.computer = computer
+
+        # Save trajectory settings
+        self.save_trajectory = save_trajectory
+        self.trajectory_dir = trajectory_dir
+        self.only_n_most_recent_images = only_n_most_recent_images
+
+        # Store the max retries setting
+        self.max_retries = max_retries
+
+        # Initialize message history
+        self.messages = []
+
+        # Extra kwargs for the loop
+        self.loop_kwargs = kwargs
+
+        # Initialize the actual loop implementation
+        self.loop = self._init_loop()
+
+        # Record initialization in telemetry if enabled
+        if telemetry_enabled:
+            record_agent_initialization()
+
+    def _process_model_config(
+        self, model_input: Optional[Union[LLM, Dict[str, str], str]], loop: AgentLoop
+    ) -> LLM:
+        """Process and normalize model configuration.
+
+        Args:
+            model_input: Input model configuration (LLM, dict, string, or None)
+            loop: The loop type being used
+
+        Returns:
+            Normalized LLM instance
+        """
+        # Handle case where model_input is None
+        if model_input is None:
+            # Use Anthropic for Anthropic loop, OpenAI for Omni loop
+            default_provider = (
+                LLMProvider.ANTHROPIC if loop == AgentLoop.ANTHROPIC else LLMProvider.OPENAI
+            )
+            return LLM(provider=default_provider)
+
+        # Handle case where model_input is already a LLM or one of its aliases
+        if isinstance(model_input, (LLM, Model, LLMModel)):
+            return model_input
+
+        # Handle case where model_input is a dict
+        if isinstance(model_input, dict):
+            provider = model_input.get("provider", LLMProvider.OPENAI)
+            if isinstance(provider, str):
+                provider = LLMProvider(provider)
+            return LLM(provider=provider, name=model_input.get("name"))
+
+        # Handle case where model_input is a string (model name)
+        if isinstance(model_input, str):
+            default_provider = (
+                LLMProvider.ANTHROPIC if loop == AgentLoop.ANTHROPIC else LLMProvider.OPENAI
+            )
+            return LLM(provider=default_provider, name=model_input)
+
+        raise ValueError(f"Unsupported model configuration: {model_input}")
+
+    def _configure_logging(self, verbosity: int):
+        """Configure logging based on verbosity level."""
+        # Use the logging level directly without mapping
+        logger.setLevel(verbosity)
+        logging.getLogger("agent").setLevel(verbosity)
+
+        # Log the verbosity level that was set
+        if verbosity <= logging.DEBUG:
+            logger.info("Agent logging set to DEBUG level (full debug information)")
+        elif verbosity <= logging.INFO:
+            logger.info("Agent logging set to INFO level (standard output)")
+        elif verbosity <= logging.WARNING:
+            logger.warning("Agent logging set to WARNING level (warnings and errors only)")
+        elif verbosity <= logging.ERROR:
+            logger.warning("Agent logging set to ERROR level (errors only)")
+        elif verbosity <= logging.CRITICAL:
+            logger.warning("Agent logging set to CRITICAL level (critical errors only)")
+
+    def _init_loop(self) -> Any:
+        """Initialize the loop based on the loop_type.
+
+        Returns:
+            Initialized loop instance
+        """
+        # Lazy import OmniLoop and OmniParser to avoid circular imports
+        from ..providers.omni.loop import OmniLoop
+        from ..providers.omni.parser import OmniParser
+
+        if self.loop_type == AgentLoop.ANTHROPIC:
+            from ..providers.anthropic.loop import AnthropicLoop
+
+            # Ensure we always have a valid model name
+            model_name = self.model.name or DEFAULT_MODELS[LLMProvider.ANTHROPIC]
+
+            return AnthropicLoop(
+                api_key=self.api_key,
+                model=model_name,
+                computer=self.computer,
+                save_trajectory=self.save_trajectory,
+                base_dir=self.trajectory_dir,
+                only_n_most_recent_images=self.only_n_most_recent_images,
+                **self.loop_kwargs,
+            )
+
+        # Initialize parser for OmniLoop with appropriate device
+        if "parser" not in self.loop_kwargs:
+            self.loop_kwargs["parser"] = OmniParser()
+
+        # Ensure we always have a valid model name
+        model_name = self.model.name or DEFAULT_MODELS[self.model.provider]
+
+        return OmniLoop(
+            provider=self.model.provider,
+            api_key=self.api_key,
+            model=model_name,
+            computer=self.computer,
+            save_trajectory=self.save_trajectory,
+            base_dir=self.trajectory_dir,
+            only_n_most_recent_images=self.only_n_most_recent_images,
+            **self.loop_kwargs,
+        )
+
+    async def _execute_task(self, task: str) -> AsyncGenerator[Dict[str, Any], None]:
+        """Execute a task using the appropriate agent loop.
+
+        Args:
+            task: The task to execute
+
+        Returns:
+            AsyncGenerator yielding task outputs
+        """
+        logger.info(f"Executing task: {task}")
+
+        try:
+            # Create a message from the task
+            task_message = {"role": "user", "content": task}
+            messages_with_task = self.messages + [task_message]
+
+            # Use the run method of the loop
+            async for output in self.loop.run(messages_with_task):
+                yield output
+        except Exception as e:
+            logger.error(f"Error executing task: {e}")
+            raise
+        finally:
+            pass
+
+    async def _execute_action(self, action_type: str, **action_params) -> Any:
+        """Execute an action with telemetry tracking."""
+        try:
+            # Execute the action
+            result = await super()._execute_action(action_type, **action_params)
+            return result
+        except Exception as e:
+            logger.exception(f"Error executing action {action_type}: {e}")
+            raise
+        finally:
+            pass

{cua_agent-0.1.2 → cua_agent-0.1.4}/agent/core/base_agent.py

@@ -113,7 +113,7 @@ class BaseComputerAgent(ABC):
             # Take a test screenshot to verify the computer is working
             logger.info("Testing computer with a screenshot...")
             try:
-                test_screenshot = await self.computer.screenshot()
+                test_screenshot = await self.computer.interface.screenshot()
                 # Determine the screenshot size based on its type
                 if isinstance(test_screenshot, bytes):
                     size = len(test_screenshot)

{cua_agent-0.1.2 → cua_agent-0.1.4}/agent/core/experiment.py

@@ -8,6 +8,7 @@ from datetime import datetime
 from typing import Any, Dict, List, Optional
 from PIL import Image
 import json
+import re
 
 logger = logging.getLogger(__name__)
 
@@ -106,9 +107,18 @@ class ExperimentManager:
             # Increment screenshot counter
             self.screenshot_count += 1
 
+            # Sanitize action_type to ensure valid filename
+            # Replace characters that are not safe for filenames
+            sanitized_action = ""
+            if action_type:
+                # Replace invalid filename characters with underscores
+                sanitized_action = re.sub(r'[\\/*?:"<>|]', "_", action_type)
+                # Limit the length to avoid excessively long filenames
+                sanitized_action = sanitized_action[:50]
+
             # Create a descriptive filename
             timestamp = int(datetime.now().timestamp() * 1000)
-            action_suffix = f"_{action_type}" if action_type else ""
+            action_suffix = f"_{sanitized_action}" if sanitized_action else ""
             filename = f"screenshot_{self.screenshot_count:03d}{action_suffix}_{timestamp}.png"
 
             # Save directly to the turn directory

{cua_agent-0.1.2 → cua_agent-0.1.4}/agent/core/loop.py

@@ -166,7 +166,7 @@ class BaseLoop(ABC):
         """
         try:
             # Take screenshot
-            screenshot = await self.computer.screenshot()
+            screenshot = await self.computer.interface.screenshot()
 
             # Initialize with default values
             width, height = 1024, 768

cua_agent-0.1.4/agent/core/telemetry.py

@@ -0,0 +1,130 @@
+"""Agent telemetry for tracking anonymous usage and feature usage."""
+
+import logging
+import os
+import platform
+import sys
+from typing import Dict, Any
+
+# Import the core telemetry module
+TELEMETRY_AVAILABLE = False
+
+try:
+    from core.telemetry import (
+        record_event,
+        increment,
+        get_telemetry_client,
+        flush,
+        is_telemetry_enabled,
+        is_telemetry_globally_disabled,
+    )
+
+    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("cua.agent.telemetry")
+        logger.debug(f"Setting dimension {name}={value}")
+
+    TELEMETRY_AVAILABLE = True
+    logger = logging.getLogger("cua.agent.telemetry")
+    logger.info("Successfully imported telemetry")
+except ImportError as e:
+    logger = logging.getLogger("cua.agent.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("cua.agent.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:
+        from core.telemetry import (
+            record_event,
+            increment,
+            get_telemetry_client,
+            flush,
+            is_telemetry_globally_disabled,
+        )
+
+        # Check again after import
+        if is_telemetry_globally_disabled():
+            logger.info("Telemetry is globally disabled via environment variable - cannot enable")
+            return False
+
+        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_agent_initialization() -> None:
+    """Record when an agent instance is initialized."""
+    if TELEMETRY_AVAILABLE and is_telemetry_enabled():
+        record_event("agent_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"])