hud-python 0.3.5__py3-none-any.whl → 0.4.0__py3-none-any.whl

hud/adapters/common/types.py

@@ -1,446 +0,0 @@
-from __future__ import annotations
-
-from typing import Annotated, Any, Literal, TypeAlias
-
-from pydantic import BaseModel, Field
-
-LogType = str | dict[str, Any] | list[str | dict[str, Any]] | None
-
-
-# Helper function to format logs for display
-def _format_logs_for_display(
-    logs: LogType | None = None,
-    reasoning: str | None = None,
-    max_log_len: int = 277,
-) -> str:
-    log_repr = repr(logs)
-    truncated_log = log_repr[:max_log_len] + "..." if len(log_repr) > max_log_len else log_repr
-    return f" │ Reasoning: {reasoning} │ Logs: {truncated_log}"
-
-
-# Base class for all actions
-class CLAAction(BaseModel):
-    type: str
-    reasoning: str | None = None
-    logs: LogType | None = None
-
-    def __str__(self) -> str:
-        # Basic representation for actions that don't have a specific override
-        # This base __str__ will NOT include logs by default, subclasses should handle it.
-        attributes = ", ".join(
-            f"{k}='{v}'" if isinstance(v, str) else f"{k}={v}"
-            for k, v in self.model_dump().items()
-            if k != "type" and v is not None and k != "logs" and k != "reasoning"
-        )
-        action_str = f"{self.type.capitalize()}Action ({attributes})"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# Basic Point model for coordinates
-class Point(BaseModel):
-    x: int
-    y: int
-
-
-# CLICK ACTION
-class ClickAction(CLAAction):
-    type: Literal["click"] = "click"
-    point: Point | None = None
-    button: CLAButton = "left"
-    pattern: list[int] | None = None
-    hold_keys: list[CLAKey] | None = None
-
-    def __str__(self) -> str:
-        parts = ["💥 Click"]
-        if self.point:
-            parts.append(f"at ({self.point.x}, {self.point.y})")
-        if self.button != "left":
-            parts.append(f"with {self.button} button")
-        if self.hold_keys:
-            parts.append(f"holding {self.hold_keys}")
-        action_str = " ".join(parts)
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# PRESS ACTION for key presses/hotkeys
-class PressAction(CLAAction):
-    type: Literal["press"] = "press"
-    keys: list[CLAKey]
-
-    def __str__(self) -> str:
-        action_str = f"🎹 Press keys: {'+'.join(self.keys)}"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# KEYDOWN ACTION for key presses/hotkeys
-class KeyDownAction(CLAAction):
-    type: Literal["keydown"] = "keydown"
-    keys: list[CLAKey]
-
-    def __str__(self) -> str:
-        action_str = f"👇 KeyDown: {'+'.join(self.keys)}"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# KEYUP ACTION for key presses/hotkeys
-class KeyUpAction(CLAAction):
-    type: Literal["keyup"] = "keyup"
-    keys: list[CLAKey]
-
-    def __str__(self) -> str:
-        action_str = f"👆 KeyUp: {'+'.join(self.keys)}"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# TYPE ACTION for text typing
-class TypeAction(CLAAction):
-    type: Literal["type"] = "type"
-    text: str
-    enter_after: bool | None = False
-
-    def __str__(self) -> str:
-        action_str = f'✍️ Type: "{self.text}"'
-        if self.enter_after:
-            action_str += " (and press Enter)"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# SCROLL ACTION
-class ScrollAction(CLAAction):
-    type: Literal["scroll"] = "scroll"
-    point: Point | None = None
-    scroll: Point | None = None
-    hold_keys: list[CLAKey] | None = None
-
-    def __str__(self) -> str:
-        parts = ["📄 Scroll"]
-        if self.point:
-            parts.append(f"at ({self.point.x}, {self.point.y})")
-        if self.scroll:
-            parts.append(f"by ({self.scroll.x}, {self.scroll.y})")
-        if self.hold_keys:  # Added hold_keys for scroll
-            parts.append(f"holding {self.hold_keys}")
-        action_str = " ".join(parts)
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# MOVE ACTION for mouse movement
-class MoveAction(CLAAction):
-    type: Literal["move"] = "move"
-    point: Point | None = None
-    offset: Point | None = None
-
-    def __str__(self) -> str:
-        parts = ["✨ Move"]
-        if self.point:
-            parts.append(f"to ({self.point.x},{self.point.y})")
-        if self.offset:
-            parts.append(f"by ({self.offset.x},{self.offset.y})")
-        action_str = " ".join(parts)
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# WAIT ACTION
-class WaitAction(CLAAction):
-    type: Literal["wait"] = "wait"
-    time: int
-
-    def __str__(self) -> str:
-        action_str = f"💤 Wait for {self.time}ms"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# DRAG ACTION
-class DragAction(CLAAction):
-    type: Literal["drag"] = "drag"
-    path: list[Point]
-    pattern: list[int] | None = None  # [delay_1, delay_2, ...]
-    hold_keys: list[CLAKey] | None = None
-
-    def __str__(self) -> str:
-        parts = ["🤏 Drag"]
-        if self.path and len(self.path) > 0:
-            if len(self.path) == 1:
-                parts.append(f"at ({self.path[0].x},{self.path[0].y})")
-            else:
-                parts.append(
-                    f"from ({self.path[0].x}, {self.path[0].y}) to "
-                    f"({self.path[-1].x}, {self.path[-1].y})"
-                )
-        if self.hold_keys:  # Added hold_keys for drag
-            parts.append(f"holding {self.hold_keys}")
-        action_str = " ".join(parts)
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# RESPONSE ACTION from agent
-class ResponseAction(CLAAction):
-    type: Literal["response"] = "response"
-    text: str  # The final textual response from the agent
-
-    def __str__(self) -> str:
-        displayed_text = self.text if len(self.text) < 50 else self.text[:47] + "..."
-        action_str = f'💬 Response: "{displayed_text}"'
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# SCREENSHOT ACTION
-class ScreenshotFetch(CLAAction):
-    type: Literal["screenshot"] = "screenshot"
-
-    def __str__(self) -> str:
-        action_str = "📸 Screenshot"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-class PositionFetch(CLAAction):
-    type: Literal["position"] = "position"
-
-    def __str__(self) -> str:
-        action_str = "📍 Position"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-class CustomAction(CLAAction):
-    type: Literal["custom"] = "custom"
-    action: str
-    args: dict[str, Any] | None = None
-
-    def __str__(self) -> str:
-        action_str = f"⚙️ Custom: {self.action} {self.args}"
-        action_str += _format_logs_for_display(self.logs, self.reasoning)
-        return action_str
-
-
-# Union of all possible actions
-CLA = Annotated[
-    ClickAction
-    | PressAction
-    | KeyDownAction
-    | KeyUpAction
-    | TypeAction
-    | ResponseAction
-    | ScrollAction
-    | MoveAction
-    | WaitAction
-    | DragAction
-    | CustomAction
-    | ScreenshotFetch
-    | PositionFetch,
-    Field(discriminator="type"),
-]
-
-
-CLAKey: TypeAlias = Literal[
-    # Control keys
-    "backspace",
-    "tab",
-    "enter",
-    "shift",
-    "shiftleft",
-    "shiftright",
-    "ctrl",
-    "ctrlleft",
-    "ctrlright",
-    "alt",
-    "altleft",
-    "altright",
-    "pause",
-    "capslock",
-    "esc",
-    "escape",
-    "space",
-    "pageup",
-    "pagedown",
-    "end",
-    "home",
-    "left",
-    "up",
-    "right",
-    "down",
-    "select",
-    "print",
-    "execute",
-    "printscreen",
-    "prtsc",
-    "insert",
-    "delete",
-    "help",
-    "sleep",
-    # Special keys
-    "numlock",
-    "scrolllock",
-    "clear",
-    "separator",
-    "modechange",
-    "apps",
-    "browserback",
-    "browserfavorites",
-    "browserforward",
-    "browserhome",
-    "browserrefresh",
-    "browsersearch",
-    "browserstop",
-    "launchapp1",
-    "launchapp2",
-    "launchmail",
-    "launchmediaselect",
-    "playpause",
-    "start",
-    "stop",
-    "prevtrack",
-    "nexttrack",
-    "volumemute",
-    "volumeup",
-    "volumedown",
-    "zoom",
-    # Modifier keys
-    "win",
-    "winleft",
-    "winright",
-    "command",
-    "option",
-    "optionleft",
-    "optionright",
-    "fn",
-    # Numpad keys
-    "num0",
-    "num1",
-    "num2",
-    "num3",
-    "num4",
-    "num5",
-    "num6",
-    "num7",
-    "num8",
-    "num9",
-    "multiply",
-    "add",
-    "subtract",
-    "decimal",
-    "divide",
-    # Function keys
-    "f1",
-    "f2",
-    "f3",
-    "f4",
-    "f5",
-    "f6",
-    "f7",
-    "f8",
-    "f9",
-    "f10",
-    "f11",
-    "f12",
-    "f13",
-    "f14",
-    "f15",
-    "f16",
-    "f17",
-    "f18",
-    "f19",
-    "f20",
-    "f21",
-    "f22",
-    "f23",
-    "f24",
-    # Language-specific keys
-    "hanguel",
-    "hangul",
-    "hanja",
-    "kana",
-    "kanji",
-    "junja",
-    "convert",
-    "nonconvert",
-    "yen",
-    # Characters
-    "\t",
-    "\n",
-    "\r",
-    " ",
-    "!",
-    '"',
-    "#",
-    "$",
-    "%",
-    "&",
-    "'",
-    "(",
-    ")",
-    "*",
-    "+",
-    ",",
-    "-",
-    ".",
-    "/",
-    "0",
-    "1",
-    "2",
-    "3",
-    "4",
-    "5",
-    "6",
-    "7",
-    "8",
-    "9",
-    ":",
-    ";",
-    "<",
-    "=",
-    ">",
-    "?",
-    "@",
-    "[",
-    "\\",
-    "]",
-    "^",
-    "_",
-    "`",
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "{",
-    "|",
-    "}",
-    "~",
-]
-
-
-CLAButton: TypeAlias = Literal["left", "right", "middle", "back", "forward"]

hud/adapters/operator/__init__.py

@@ -1,5 +0,0 @@
-from __future__ import annotations
-
-from .adapter import OperatorAdapter
-
-__all__ = ["OperatorAdapter"]

hud/adapters/operator/adapter.py

@@ -1,108 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, ClassVar
-
-from hud.adapters.common import CLA, Adapter
-from hud.adapters.common.types import (
-    CLAButton,
-    CLAKey,
-    ClickAction,
-    CustomAction,
-    DragAction,
-    MoveAction,
-    Point,
-    PressAction,
-    ResponseAction,
-    ScreenshotFetch,
-    ScrollAction,
-    TypeAction,
-    WaitAction,
-)
-
-
-class OperatorAdapter(Adapter):
-    KEY_MAP: ClassVar[dict[str, CLAKey]] = {
-        "return": "enter",
-        "arrowup": "up",
-        "arrowdown": "down",
-        "arrowleft": "left",
-        "arrowright": "right",
-        "cmd": "ctrl",
-        "super": "win",
-    }
-
-    BUTTON_MAP: ClassVar[dict[str, CLAButton]] = {"wheel": "middle"}
-
-    def __init__(self) -> None:
-        super().__init__()
-        # OpenAI Computer Use default dimensions
-        self.agent_width = 1024
-        self.agent_height = 768
-
-    def _map_key(self, key: str) -> CLAKey:
-        """Map a key to its standardized form."""
-        return self.KEY_MAP.get(key.lower(), key.lower())  # type: ignore
-
-    def convert(self, data: Any) -> CLA:
-        """Convert a Computer Use action to a HUD action"""
-        try:
-            action_type = data.get("type")
-
-            if action_type == "click":
-                x, y = data.get("x", 0), data.get("y", 0)
-                button = data.get("button", "left")
-                button = self.BUTTON_MAP.get(button, button)
-                if button is None:
-                    button = "left"
-                converted_action = ClickAction(point=Point(x=x, y=y), button=button)
-
-            elif action_type == "double_click":
-                x, y = data.get("x", 0), data.get("y", 0)
-                converted_action = ClickAction(point=Point(x=x, y=y), button="left", pattern=[100])
-
-            elif action_type == "scroll":
-                x, y = int(data.get("x", 0)), int(data.get("y", 0))
-                scroll_x = int(data.get("scroll_x", 0))
-                scroll_y = int(data.get("scroll_y", 0))
-                converted_action = ScrollAction(
-                    point=Point(x=x, y=y), scroll=Point(x=scroll_x, y=scroll_y)
-                )
-
-            elif action_type == "type":
-                text = data.get("text", "")
-                converted_action = TypeAction(text=text, enter_after=False)
-
-            elif action_type == "wait":
-                ms = data.get("ms", 1000)
-                converted_action = WaitAction(time=ms)
-
-            elif action_type == "move":
-                x, y = data.get("x", 0), data.get("y", 0)
-                converted_action = MoveAction(point=Point(x=x, y=y))
-
-            elif action_type == "keypress":
-                keys = data.get("keys", [])
-                converted_action = PressAction(keys=[self._map_key(k) for k in keys])
-
-            elif action_type == "drag":
-                path = data.get("path", [])
-                points = [Point(x=p.get("x", 0), y=p.get("y", 0)) for p in path]
-                converted_action = DragAction(path=points)
-
-            elif action_type == "screenshot":
-                converted_action = ScreenshotFetch()
-
-            elif action_type == "response":
-                converted_action = ResponseAction(text=data.get("text", ""))
-            elif action_type == "custom":
-                converted_action = CustomAction(action=data.get("action", ""))
-            else:
-                raise ValueError(f"Unsupported action type: {action_type}")
-
-            converted_action.reasoning = data.get("reasoning", "")
-            converted_action.logs = data.get("logs", "")
-
-            return converted_action
-
-        except Exception as e:
-            raise ValueError(f"Invalid action: {data}. Error: {e!s}") from e

hud/adapters/operator/tests/__init__.py

@@ -1 +0,0 @@
-# Tests for hud.adapters.operator module