droidrun 0.3.9__py3-none-any.whl → 0.3.10.dev3__py3-none-any.whl

droidrun/macro/cli.py

@@ -3,15 +3,17 @@ Command-line interface for DroidRun macro replay.
 """
 
 import asyncio
-import click
 import logging
 import os
 from typing import Optional
+
+import click
+from adbutils import adb
 from rich.console import Console
 from rich.table import Table
-from droidrun.macro.replay import MacroPlayer, replay_macro_file, replay_macro_folder
+
 from droidrun.agent.utils.trajectory import Trajectory
-from adbutils import adb
+from droidrun.macro.replay import MacroPlayer
 
 console = Console()
 
@@ -20,21 +22,21 @@ def configure_logging(debug: bool = False):
     """Configure logging for the macro CLI."""
     logger = logging.getLogger("droidrun-macro")
     logger.handlers = []
-    
+
     handler = logging.StreamHandler()
-    
+
     if debug:
         level = logging.DEBUG
         formatter = logging.Formatter("%(levelname)s %(name)s %(message)s", "%H:%M:%S")
     else:
         level = logging.INFO
         formatter = logging.Formatter("%(message)s", "%H:%M:%S")
-    
+
     handler.setFormatter(formatter)
     logger.addHandler(handler)
     logger.setLevel(level)
     logger.propagate = False
-    
+
     return logger
 
 
@@ -55,12 +57,12 @@ def macro_cli():
 def replay(path: str, device: Optional[str], delay: float, start_from: int, max_steps: Optional[int], debug: bool, dry_run: bool):
     """Replay a macro from a file or trajectory folder."""
     logger = configure_logging(debug)
-    
+
     logger.info("🎬 DroidRun Macro Replay")
-    
+
     # Convert start_from from 1-based to 0-based
     start_from_zero = max(0, start_from - 1)
-    
+
     if device is None:
         logger.info("🔍 Finding connected device...")
         devices = adb.list()
@@ -70,7 +72,7 @@ def replay(path: str, device: Optional[str], delay: float, start_from: int, max_
         logger.info(f"📱 Using device: {device}")
     else:
         logger.info(f"📱 Using device: {device}")
-    
+
     asyncio.run(_replay_async(path, device, delay, start_from_zero, max_steps, dry_run, logger))
 
 
@@ -88,40 +90,40 @@ async def _replay_async(path: str, device: str, delay: float, start_from: int, m
         else:
             logger.error(f"❌ Invalid path: {path}")
             return
-        
+
         if not macro_data:
             logger.error("❌ Failed to load macro data")
             return
-        
+
         # Show macro information
         description = macro_data.get("description", "No description")
         total_actions = macro_data.get("total_actions", 0)
         version = macro_data.get("version", "unknown")
-        
+
         logger.info("📋 Macro Information:")
         logger.info(f"   Description: {description}")
         logger.info(f"   Version: {version}")
         logger.info(f"   Total actions: {total_actions}")
         logger.info(f"   Device: {device}")
         logger.info(f"   Delay between actions: {delay}s")
-        
+
         if start_from > 0:
             logger.info(f"   Starting from step: {start_from + 1}")
         if max_steps:
             logger.info(f"   Maximum steps: {max_steps}")
-        
+
         if dry_run:
             logger.info("🔍 DRY RUN MODE - Actions will be shown but not executed")
             await _show_dry_run(macro_data, start_from, max_steps, logger)
         else:
             logger.info("▶️  Starting macro replay...")
             success = await player.replay_macro(macro_data, start_from_step=start_from, max_steps=max_steps)
-            
+
             if success:
                 logger.info("🎉 Macro replay completed successfully!")
             else:
                 logger.error("💥 Macro replay completed with errors")
-    
+
     except Exception as e:
         logger.error(f"💥 Error: {e}")
         if logger.isEnabledFor(logging.DEBUG):
@@ -132,25 +134,25 @@ async def _replay_async(path: str, device: str, delay: float, start_from: int, m
 async def _show_dry_run(macro_data: dict, start_from: int, max_steps: Optional[int], logger: logging.Logger):
     """Show what actions would be executed in dry run mode."""
     actions = macro_data.get("actions", [])
-    
+
     # Apply filters
     if start_from > 0:
         actions = actions[start_from:]
     if max_steps:
         actions = actions[:max_steps]
-    
+
     logger.info(f"📋 Found {len(actions)} actions to execute:")
-    
+
     table = Table(title="Actions to Execute")
     table.add_column("Step", style="cyan")
     table.add_column("Type", style="green")
     table.add_column("Details", style="white")
     table.add_column("Description", style="yellow")
-    
+
     for i, action in enumerate(actions, start=start_from + 1):
         action_type = action.get("action_type", action.get("type", "unknown"))
         details = ""
-        
+
         if action_type == "tap":
             x, y = action.get("x", 0), action.get("y", 0)
             element_text = action.get("element_text", "")
@@ -165,10 +167,10 @@ async def _show_dry_run(macro_data: dict, start_from: int, max_steps: Optional[i
         elif action_type == "key_press":
             key_name = action.get("key_name", "UNKNOWN")
             details = f"{key_name}"
-        
+
         description = action.get("description", "")
         table.add_row(str(i), action_type, details, description[:50] + "..." if len(description) > 50 else description)
-    
+
     # Still use console for table display as it's structured data
     console.print(table)
 
@@ -179,9 +181,9 @@ async def _show_dry_run(macro_data: dict, start_from: int, max_steps: Optional[i
 def list(directory: str, debug: bool):
     """List available trajectory folders in a directory."""
     logger = configure_logging(debug)
-    
+
     logger.info(f"📁 Scanning directory: {directory}")
-    
+
     try:
         folders = []
         for item in os.listdir(directory):
@@ -198,25 +200,25 @@ def list(directory: str, debug: bool):
                     except Exception as e:
                         logger.debug(f"Error loading macro from {item}: {e}")
                         folders.append((item, "Error loading", 0))
-        
+
         if not folders:
             logger.info("📭 No trajectory folders found")
             return
-        
+
         logger.info(f"🎯 Found {len(folders)} trajectory(s):")
-        
+
         table = Table(title=f"Available Trajectories in {directory}")
         table.add_column("Folder", style="cyan")
         table.add_column("Description", style="white")
         table.add_column("Actions", style="green")
-        
+
         for folder, description, actions in sorted(folders):
             table.add_row(folder, description[:80] + "..." if len(description) > 80 else description, str(actions))
-        
+
         # Still use console for table display as it's structured data
         console.print(table)
         logger.info(f"💡 Use 'droidrun macro replay {directory}/<folder>' to replay a trajectory")
-    
+
     except Exception as e:
         logger.error(f"💥 Error: {e}")
         if logger.isEnabledFor(logging.DEBUG):
@@ -225,4 +227,4 @@ def list(directory: str, debug: bool):
 
 
 if __name__ == "__main__":
-    macro_cli() 
+    macro_cli()

droidrun/macro/replay.py

@@ -5,14 +5,12 @@ This module provides functionality to load and replay macro JSON files
 that were generated during DroidAgent trajectory recording.
 """
 
-import json
 import asyncio
 import logging
-import time
-import os
-from typing import Dict, List, Any, Optional
-from droidrun.tools.adb import AdbTools
+from typing import Any, Dict, Optional
+
 from droidrun.agent.utils.trajectory import Trajectory
+from droidrun.tools.adb import AdbTools
 
 logger = logging.getLogger("droidrun-macro")
 
@@ -145,7 +143,7 @@ class MacroPlayer:
                 return True
 
             elif action_type == "back":
-                logger.info(f"⬅️  Pressing back button")
+                logger.info("⬅️  Pressing back button")
                 result = tools.back()
                 logger.debug(f"   Result: {result}")
                 return True
@@ -211,10 +209,10 @@ class MacroPlayer:
 
             if success:
                 success_count += 1
-                logger.info(f"   ✅ Action completed successfully")
+                logger.info("   ✅ Action completed successfully")
             else:
                 failed_count += 1
-                logger.error(f"   ❌ Action failed")
+                logger.error("   ❌ Action failed")
 
             # Wait between actions (except for the last one)
             if i < len(actions):
@@ -227,7 +225,7 @@ class MacroPlayer:
             (success_count / total_executed * 100) if total_executed > 0 else 0
         )
 
-        logger.info(f"\n🎉 Macro replay completed!")
+        logger.info("\n🎉 Macro replay completed!")
         logger.info(
             f"📊 Success: {success_count}/{total_executed} ({success_rate:.1f}%)"
         )

droidrun/portal.py

@@ -144,7 +144,7 @@ def ping_portal_content(device: AdbDevice, debug: bool = False):
 
 def ping_portal_tcp(device: AdbDevice, debug: bool = False):
     try:
-        tools = AdbTools(serial=device.serial, use_tcp=True)
+        AdbTools(serial=device.serial, use_tcp=True)
     except Exception as e:
         raise Exception("Failed to setup TCP forwarding") from e
 

droidrun/telemetry/__init__.py

@@ -1,4 +1,4 @@
+from .events import DroidAgentFinalizeEvent, DroidAgentInitEvent
 from .tracker import capture, flush, print_telemetry_message
-from .events import DroidAgentInitEvent, DroidAgentFinalizeEvent
 
-__all__ = ["capture", "flush", "DroidAgentInitEvent", "DroidAgentFinalizeEvent", "print_telemetry_message"]
+__all__ = ["capture", "flush", "DroidAgentInitEvent", "DroidAgentFinalizeEvent", "print_telemetry_message"]

droidrun/telemetry/events.py

@@ -1,7 +1,7 @@
-from typing import List
-from droidrun.agent.context import Task
+
 from pydantic import BaseModel
 
+
 class TelemetryEvent(BaseModel):
     pass
 
@@ -14,10 +14,9 @@ class DroidAgentInitEvent(TelemetryEvent):
     timeout: int
     vision: bool
     reasoning: bool
-    reflection: bool
     enable_tracing: bool
     debug: bool
-    save_trajectories: str = "none",  
+    save_trajectories: str = "none",
 
 
 class DroidAgentFinalizeEvent(TelemetryEvent):

droidrun/telemetry/phoenix.py

@@ -0,0 +1,173 @@
+import asyncio
+import functools
+import inspect
+import os
+import uuid
+from contextvars import Token, copy_context
+from typing import Any, Callable
+
+from llama_index.core.callbacks.base_handler import BaseCallbackHandler
+from llama_index_instrumentation import get_dispatcher
+from openinference.instrumentation import TraceConfig
+
+dispatcher = get_dispatcher()
+
+def arize_phoenix_callback_handler(**kwargs: Any) -> BaseCallbackHandler:
+    # newer versions of arize, v2.x
+    from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
+    from openinference.semconv.resource import ResourceAttributes
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+        OTLPSpanExporter,
+    )
+    from opentelemetry.sdk import trace as trace_sdk
+    from opentelemetry.sdk.resources import Resource
+    from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+
+    endpoint = kwargs.get("endpoint", os.getenv("phoenix_url", "http://127.0.0.1:6006")) + "/v1/traces"
+
+    resource_attributes = {}
+    phoenix_project_name = os.getenv("phoenix_project_name", "")
+    if phoenix_project_name.strip():
+        resource_attributes[ResourceAttributes.PROJECT_NAME] = phoenix_project_name
+    resource = Resource(attributes=resource_attributes)
+
+    tracer_provider = trace_sdk.TracerProvider(resource=resource)
+    tracer_provider.add_span_processor(
+        SimpleSpanProcessor(OTLPSpanExporter(endpoint))
+    )
+    config = TraceConfig(
+        base64_image_max_length=64000000
+    )
+
+    return LlamaIndexInstrumentor().instrument(
+        tracer_provider=kwargs.get("tracer_provider", tracer_provider),
+        separate_trace_from_runtime_context=kwargs.get(
+            "separate_trace_from_runtime_context"
+        ),
+        config=config
+    )
+
+
+def clean_span(span_name: str):
+    """
+    Create a span with a clean name (without class prefix).
+
+    This function returns a decorator that creates spans with custom names
+    instead of the default class.method format.
+
+    It preserves parent-child relationships by using the same active span
+    context variable as the built-in dispatcher decorator does.
+
+    Args:
+        span_name: The desired name for the span
+
+    Returns:
+        A decorator function
+    """
+    def decorator(func: Callable) -> Callable:
+        # Support both sync and async callables
+        if inspect.iscoroutinefunction(func):
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                # Import here to avoid circular imports
+                from llama_index_instrumentation.dispatcher import active_instrument_tags
+                from llama_index_instrumentation.span import active_span_id
+
+
+                span_id = f"{span_name}-{uuid.uuid4()}"
+                bound_args = inspect.signature(func).bind(*args, **kwargs)
+                # Treat as method only if qualname indicates Class.method
+                is_method = "." in getattr(func, "__qualname__", "")
+                instance = args[0] if (args and is_method) else None
+
+                tags = active_instrument_tags.get()
+                token = active_span_id.set(span_id)
+                parent_id = None if token.old_value is Token.MISSING else token.old_value
+
+                dispatcher.span_enter(
+                    id_=span_id,
+                    bound_args=bound_args,
+                    instance=instance,
+                    parent_id=parent_id,
+                    tags=tags,
+                )
+                try:
+                    result = await func(*args, **kwargs)
+                except Exception as e:
+                    dispatcher.span_drop(id_=span_id, bound_args=bound_args, instance=instance, err=e)
+                    raise
+                else:
+                    dispatcher.span_exit(id_=span_id, bound_args=bound_args, instance=instance, result=result)
+                    return result
+                finally:
+                    active_span_id.reset(token)
+
+            return async_wrapper
+        else:
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                # Import here to avoid circular imports
+                from llama_index_instrumentation.dispatcher import active_instrument_tags
+                from llama_index_instrumentation.span import active_span_id
+
+
+                span_id = f"{span_name}-{uuid.uuid4()}"
+                bound_args = inspect.signature(func).bind(*args, **kwargs)
+                # Treat as method only if qualname indicates Class.method
+                is_method = "." in getattr(func, "__qualname__", "")
+                instance = args[0] if (args and is_method) else None
+
+                tags = active_instrument_tags.get()
+                context = copy_context()
+                token = active_span_id.set(span_id)
+                parent_id = None if token.old_value is Token.MISSING else token.old_value
+
+                dispatcher.span_enter(
+                    id_=span_id,
+                    bound_args=bound_args,
+                    instance=instance,
+                    parent_id=parent_id,
+                    tags=tags,
+                )
+                try:
+                    result = func(*args, **kwargs)
+                    if isinstance(result, asyncio.Future):
+                        new_future = asyncio.ensure_future(result)
+
+                        def _on_done(fut: asyncio.Future) -> None:
+                            try:
+                                fut_result = None if fut.exception() else fut.result()
+                                dispatcher.span_exit(
+                                    id_=span_id,
+                                    bound_args=bound_args,
+                                    instance=instance,
+                                    result=fut_result,
+                                )
+                            except Exception as e2:
+                                dispatcher.span_drop(
+                                    id_=span_id,
+                                    bound_args=bound_args,
+                                    instance=instance,
+                                    err=e2,
+                                )
+                                raise
+                            finally:
+                                try:
+                                    context.run(active_span_id.reset, token)
+                                except ValueError:
+                                    pass
+
+                        new_future.add_done_callback(_on_done)
+                        return new_future
+                except Exception as e:
+                    dispatcher.span_drop(id_=span_id, bound_args=bound_args, instance=instance, err=e)
+                    raise
+                else:
+                    dispatcher.span_exit(id_=span_id, bound_args=bound_args, instance=instance, result=result)
+                    return result
+                finally:
+                    if not isinstance(locals().get("result"), asyncio.Future):
+                        active_span_id.reset(token)
+
+            return wrapper
+    return decorator

droidrun/telemetry/tracker.py

@@ -1,8 +1,10 @@
-from posthog import Posthog
+import logging
+import os
 from pathlib import Path
 from uuid import uuid4
-import os
-import logging
+
+from posthog import Posthog
+
 from .events import TelemetryEvent
 
 logger = logging.getLogger("droidrun-telemetry")
@@ -76,9 +78,9 @@ def capture(event: TelemetryEvent, user_id: str | None = None):
 def flush():
     try:
         if not is_telemetry_enabled():
-            logger.debug(f"Telemetry disabled, skipping flush")
+            logger.debug("Telemetry disabled, skipping flush")
             return
         posthog.flush()
-        logger.debug(f"Flushed telemetry data")
+        logger.debug("Flushed telemetry data")
     except Exception as e:
         logger.error(f"Error flushing telemetry data: {e}")

droidrun/tools/__init__.py

@@ -2,8 +2,8 @@
 DroidRun Tools - Core functionality for Android device control.
 """
 
-from droidrun.tools.tools import Tools, describe_tools
 from droidrun.tools.adb import AdbTools
 from droidrun.tools.ios import IOSTools
+from droidrun.tools.tools import Tools, describe_tools
 
 __all__ = ["Tools", "describe_tools", "AdbTools", "IOSTools"]