hud-python 0.4.28__py3-none-any.whl → 0.4.30__py3-none-any.whl

hud/cli/rl/utils.py

@@ -1,165 +0,0 @@
-"""Shared utilities for RL commands."""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from hud.utils.hud_console import HUDConsole
-
-hud_console = HUDConsole()
-
-logger = logging.getLogger(__name__)
-
-
-def read_lock_file() -> dict[str, Any]:
-    """Read and parse hud.lock.yaml file."""
-    lock_file = Path("hud.lock.yaml")
-    if not lock_file.exists():
-        return {}
-
-    try:
-        with open(lock_file) as f:
-            return yaml.safe_load(f) or {}
-    except Exception as e:
-        hud_console.warning(f"Could not read hud.lock.yaml: {e}")
-        return {}
-
-
-def write_lock_file(data: dict[str, Any]) -> bool:
-    """Write data to hud.lock.yaml file."""
-    lock_file = Path("hud.lock.yaml")
-
-    try:
-        with open(lock_file, "w") as f:
-            yaml.dump(data, f, default_flow_style=False, sort_keys=False)
-        return True
-    except Exception as e:
-        hud_console.warning(f"Could not write hud.lock.yaml: {e}")
-        return False
-
-
-def get_mcp_config_from_lock() -> dict[str, Any] | None:
-    """Get MCP configuration from lock file."""
-    lock_data = read_lock_file()
-
-    # Check if there's an image reference
-    image = lock_data.get("image")
-    if image:
-        return {
-            "hud": {
-                "url": "https://mcp.hud.so/v3/mcp",
-                "headers": {"Authorization": "Bearer $HUD_API_KEY", "Mcp-Image": image},
-            }
-        }
-
-    return None
-
-
-def get_primary_dataset() -> str | None:
-    """Get primary dataset name from lock file."""
-    lock_data = read_lock_file()
-    return lock_data.get("primary_dataset", {}).get("name")
-
-
-def get_image_from_lock() -> str | None:
-    """Get image name from lock file."""
-    lock_data = read_lock_file()
-    return lock_data.get("image")
-
-
-def detect_image_name() -> str | None:
-    """Try to detect image name from various sources."""
-    # First check lock file
-    image = get_image_from_lock()
-    if image:
-        return image
-
-    # Check pyproject.toml
-    pyproject = Path("pyproject.toml")
-    if pyproject.exists():
-        try:
-            import tomllib
-
-            with open(pyproject, "rb") as f:
-                data = tomllib.load(f)
-
-            # Check for hud.image_name
-            image = data.get("tool", {}).get("hud", {}).get("image_name")
-            if image:
-                return image
-
-            # Use project name
-            name = data.get("project", {}).get("name")
-            if name:
-                return f"{name}:latest"
-        except Exception:
-            logger.warning("Failed to load pyproject.toml")
-
-    # Use directory name as last resort
-    return f"{Path.cwd().name}:latest"
-
-
-def validate_dataset_name(name: str) -> bool:
-    """Validate HuggingFace dataset name format."""
-    if not name:
-        return False
-
-    if "/" not in name:
-        hud_console.error(f"Invalid dataset name: {name}")
-        hud_console.info("Dataset name should be in format: org/dataset")
-        return False
-
-    parts = name.split("/")
-    if len(parts) != 2:
-        hud_console.error(f"Invalid dataset name: {name}")
-        return False
-
-    org, dataset = parts
-    if not org or not dataset:
-        hud_console.error(f"Invalid dataset name: {name}")
-        return False
-
-    # Check for valid characters (alphanumeric, dash, underscore)
-    import re
-
-    if not re.match(r"^[a-zA-Z0-9_-]+$", org) or not re.match(r"^[a-zA-Z0-9_-]+$", dataset):
-        hud_console.error(f"Invalid characters in dataset name: {name}")
-        hud_console.info("Use only letters, numbers, dashes, and underscores")
-        return False
-
-    return True
-
-
-def create_tasks_template() -> list[dict[str, Any]]:
-    """Create a template for tasks.json file."""
-    return [
-        {
-            "id": "example-task-001",
-            "prompt": "Complete the first TODO item in the list",
-            "mcp_config": {
-                "# TODO": "Add your MCP configuration here",
-                "# Example for remote": {
-                    "hud": {
-                        "url": "https://mcp.hud.so/v3/mcp",
-                        "headers": {
-                            "Authorization": "Bearer $HUD_API_KEY",
-                            "Mcp-Image": "your-org/your-env:latest",
-                        },
-                    }
-                },
-                "# Example for local": {
-                    "local": {"command": "docker", "args": ["run", "--rm", "-i", "your-env:latest"]}
-                },
-            },
-            "setup_tool": {"name": "setup", "arguments": {"name": "todo_seed", "num_items": 5}},
-            "evaluate_tool": {
-                "name": "evaluate",
-                "arguments": {"name": "todo_completed", "expected_count": 1},
-            },
-            "metadata": {"difficulty": "easy", "category": "task_completion"},
-        }
-    ]

hud/datasets/execution/__init__.py

@@ -1,13 +0,0 @@
-"""Dataset execution module."""
-
-from __future__ import annotations
-
-from .parallel import calculate_optimal_workers, run_dataset_parallel, run_dataset_parallel_manual
-from .runner import run_dataset
-
-__all__ = [
-    "calculate_optimal_workers",
-    "run_dataset",
-    "run_dataset_parallel",
-    "run_dataset_parallel_manual",
-]

hud/datasets/task.py

@@ -1,116 +0,0 @@
-"""Task model for HUD datasets."""
-
-from __future__ import annotations
-
-import json
-import logging
-from collections import defaultdict
-from string import Template
-from typing import Any
-
-from pydantic import BaseModel, Field, field_validator
-
-from hud.settings import settings
-from hud.types import MCPToolCall
-
-logger = logging.getLogger(__name__)
-
-
-class Task(BaseModel):
-    """
-    A task configuration that can be used to create a task.
-
-    The mcp_config field supports environment variable substitution using
-    template placeholders in the format ${VAR_NAME} or ${VAR_NAME:default_value}.
-
-    Example:
-        mcp_config: {
-            "hud": {
-                "url": "${HUD_MCP_URL:https://mcp.hud.so/v3/mcp}",
-                "headers": {
-                    "Authorization": "Bearer ${HUD_API_KEY}",
-                    "Mcp-Image": "your-mcp-image"
-                }
-            }
-        }
-    """
-
-    id: str | None = None
-    prompt: str
-    mcp_config: dict[str, Any]
-    setup_tool: MCPToolCall | list[MCPToolCall] | None = None
-    evaluate_tool: MCPToolCall | list[MCPToolCall] | None = None
-    system_prompt: str | None = None
-    metadata: dict[str, Any] = Field(default_factory=dict)
-
-    @field_validator("mcp_config", "metadata", mode="before")
-    @classmethod
-    def parse_json_strings(cls, v: Any) -> Any:
-        """Parse JSON strings into dictionaries."""
-        if isinstance(v, str):
-            try:
-                return json.loads(v)
-            except json.JSONDecodeError as e:
-                from hud.shared.exceptions import HudConfigError
-
-                raise HudConfigError(f"Invalid JSON string: {e}") from e
-        return v
-
-    @field_validator("setup_tool", "evaluate_tool", mode="before")
-    @classmethod
-    def convert_dict_to_tool_call(cls, v: Any) -> Any:
-        """Convert dict to MCPToolCall instance, parsing JSON strings first."""
-        if v is None:
-            return None
-
-        # Parse JSON string if needed
-        if isinstance(v, str):
-            try:
-                v = json.loads(v)
-            except json.JSONDecodeError as e:
-                from hud.shared.exceptions import HudConfigError
-
-                raise HudConfigError(f"Invalid JSON string: {e}") from e
-
-        if isinstance(v, dict):
-            return MCPToolCall(**v)
-        if isinstance(v, list):
-            return [MCPToolCall(**item) if isinstance(item, dict) else item for item in v]
-        return v
-
-    @field_validator("mcp_config", mode="before")
-    @classmethod
-    def resolve_env_vars(cls, v: dict[str, Any]) -> dict[str, Any]:
-        """
-        Automatically resolve environment variables in mcp_config using Template.
-
-        Supports ${VAR_NAME} syntax with variable substitution from
-        System environment variables (including HUD_API_KEY, etc.)
-
-        Missing variables resolve to empty strings.
-        """
-        import os
-
-        # Start with current environment variables
-        mapping = dict(os.environ)
-        mapping.update(settings.model_dump())
-
-        if settings.api_key:
-            mapping["HUD_API_KEY"] = settings.api_key
-        else:
-            logger.error("HUD_API_KEY is not set, tracing and remote training will not work")
-
-        def substitute_in_value(obj: Any) -> Any:
-            """Recursively substitute variables in nested structures."""
-            if isinstance(obj, str):
-                # Use Template's substitute with defaultdict - missing vars become empty strings
-                safe_mapping = defaultdict(str, mapping)
-                return Template(obj).substitute(safe_mapping)
-            elif isinstance(obj, dict):
-                return {k: substitute_in_value(v) for k, v in obj.items()}
-            elif isinstance(obj, list):
-                return [substitute_in_value(item) for item in obj]
-            else:
-                return obj
-
-        return substitute_in_value(v)