hud-python 0.4.52__py3-none-any.whl → 0.4.53__py3-none-any.whl

hud/cli/utils/tests/test_package_runner.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest import mock
+
+import pytest
+
+from hud.cli.utils.package_runner import run_package_as_mcp
+
+
+@pytest.mark.asyncio
+@mock.patch("hud.cli.utils.package_runner.FastMCP")
+async def test_run_package_as_external_command(MockFastMCP):
+    proxy = mock.AsyncMock()
+    MockFastMCP.as_proxy.return_value = proxy
+    await run_package_as_mcp(["python", "-m", "server"], transport="http", port=9999)
+    assert proxy.run_async.awaited
+
+
+@pytest.mark.asyncio
+@mock.patch("hud.cli.utils.package_runner.importlib.import_module")
+async def test_run_package_import_module(mock_import):
+    server = SimpleNamespace(name="test", run_async=mock.AsyncMock())
+    mod = SimpleNamespace(mcp=server)
+    mock_import.return_value = mod
+    await run_package_as_mcp("module_name", transport="stdio")
+    assert server.run_async.awaited
+
+
+@pytest.mark.asyncio
+@mock.patch("hud.cli.utils.package_runner.importlib.import_module")
+async def test_run_package_import_missing_attr(mock_import):
+    mock_import.return_value = SimpleNamespace()
+    with pytest.raises(SystemExit):
+        await run_package_as_mcp("module_name", transport="stdio")

hud/cli/utils/tests/test_registry_utils.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hud.cli.utils.registry import (
+    extract_digest_from_image,
+    extract_name_and_tag,
+    list_registry_entries,
+    load_from_registry,
+    save_to_registry,
+)
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_extract_digest_from_image_variants():
+    assert extract_digest_from_image("repo/name@sha256:abcdef1234567890") == "abcdef123456"
+    assert extract_digest_from_image("sha256:deadbeefcafebabe") == "deadbeefcafe"
+    assert extract_digest_from_image("org/name:tag") == "tag"
+    assert extract_digest_from_image("org/name") == "latest"
+
+
+def test_extract_name_and_tag():
+    assert extract_name_and_tag("docker.io/hudpython/test_init:latest@sha256:abc") == (
+        "hudpython/test_init",
+        "latest",
+    )
+    assert extract_name_and_tag("myorg/myenv:v1.0") == ("myorg/myenv", "v1.0")
+    assert extract_name_and_tag("myorg/myenv") == ("myorg/myenv", "latest")
+
+
+def test_save_load_list_registry(tmp_path: Path, monkeypatch):
+    # Redirect registry dir to temp
+    from hud.cli.utils import registry as mod
+
+    monkeypatch.setattr(mod, "get_registry_dir", lambda: tmp_path)
+
+    data = {"image": "org/name:tag", "build": {"version": "0.1.0"}}
+    saved = save_to_registry(data, "org/name:tag@sha256:abcdef0123456789", verbose=True)
+    assert saved is not None and saved.exists()
+
+    # Digest directory was created
+    entries = list_registry_entries()
+    assert len(entries) == 1
+
+    digest, _ = entries[0]
+    loaded = load_from_registry(digest)
+    assert loaded and loaded.get("image") == "org/name:tag"

hud/cli/utils/tests/test_remote_runner.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+import pytest
+
+from hud.cli.utils.remote_runner import run_remote_server
+
+
+def test_run_remote_server_requires_api_key(monkeypatch):
+    # Ensure settings.api_key is None and no api_key provided
+    from hud.cli.utils import remote_runner as mod
+
+    monkeypatch.setattr(mod.settings, "api_key", None, raising=True)
+
+    with pytest.raises(SystemExit) as exc:
+        run_remote_server(
+            image="img:latest",
+            docker_args=[],
+            transport="stdio",
+            port=8765,
+            url="https://api.example.com/mcp",
+            api_key=None,
+            run_id=None,
+            verbose=False,
+        )
+    assert exc.value.code == 1

hud/cli/utils/tests/test_runner_modules.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from unittest import mock
+
+import pytest
+
+from hud.cli.utils.remote_runner import build_remote_headers, parse_env_vars, parse_headers
+from hud.cli.utils.runner import run_mcp_server
+
+
+def test_parse_headers_and_env_vars():
+    assert parse_headers(["A:B", "C=D"]) == {"A": "B", "C": "D"}
+    assert parse_env_vars(["API_KEY=xxx"]) == {"Env-Api-Key": "xxx"}
+
+
+def test_build_remote_headers_combines():
+    headers = build_remote_headers(
+        image="img:latest", env_args=["X=1"], header_args=["H:V"], api_key="k", run_id="r"
+    )
+    assert headers["Mcp-Image"] == "img:latest"
+    assert headers["Authorization"].startswith("Bearer ")
+    assert headers["Run-Id"] == "r"
+    assert headers["Env-X"] == "1"
+    assert headers["H"] == "V"
+
+
+@mock.patch("hud.cli.utils.runner.run_stdio_server")
+def test_run_mcp_server_stdio(mock_stdio):
+    run_mcp_server("img", [], "stdio", 8765, verbose=False, interactive=False)
+    assert mock_stdio.called
+
+
+def test_run_mcp_server_stdio_interactive_fails():
+    with pytest.raises(SystemExit):
+        run_mcp_server("img", [], "stdio", 8765, verbose=False, interactive=True)
+
+
+@mock.patch("hud.cli.utils.runner.run_http_server")
+def test_run_mcp_server_http(mock_http):
+    run_mcp_server("img", [], "http", 8765, verbose=True, interactive=False)
+    assert mock_http.called
+
+
+@mock.patch("hud.cli.utils.runner.run_http_server_interactive")
+def test_run_mcp_server_http_interactive(mock_http_int):
+    run_mcp_server("img", [], "http", 8765, verbose=False, interactive=True)
+    assert mock_http_int.called
+
+
+def test_run_mcp_server_unknown():
+    with pytest.raises(SystemExit):
+        run_mcp_server("img", [], "bad", 8765, verbose=False)

hud/cli/utils/tests/test_source_hash.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from hud.cli.utils.source_hash import compute_source_hash, list_source_files
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+def test_source_hash_changes_with_content(tmp_path: Path):
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "pyproject.toml").write_text("[tool.hud]\n")
+    (env / "server").mkdir()
+    (env / "server" / "main.py").write_text("print('hi')\n")
+
+    h1 = compute_source_hash(env)
+    # Change file content
+    (env / "server" / "main.py").write_text("print('bye')\n")
+    h2 = compute_source_hash(env)
+    assert h1 != h2
+
+
+def test_list_source_files_sorted(tmp_path: Path):
+    env = tmp_path / "env"
+    env.mkdir()
+    (env / "Dockerfile").write_text("FROM python:3.11")
+    (env / "environment").mkdir()
+    (env / "environment" / "a.py").write_text("a")
+    (env / "environment" / "b.py").write_text("b")
+
+    files = list_source_files(env)
+    rels = [str(p.resolve().relative_to(env)).replace("\\", "/") for p in files]
+    assert rels == ["Dockerfile", "environment/a.py", "environment/b.py"]

hud/cli/utils/tests/test_tasks.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from hud.cli.utils.tasks import find_tasks_file
+
+
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_with_arg(mock_cwd):
+    """Test that when a tasks file is provided, it's returned as-is."""
+    assert find_tasks_file("some/path.json") == "some/path.json"
+    mock_cwd.assert_not_called()
+
+
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_no_files(mock_cwd):
+    """Test that FileNotFoundError is raised when no task files exist."""
+    mock_path = MagicMock(spec=Path)
+    mock_path.glob.return_value = []
+    mock_cwd.return_value = mock_path
+
+    with pytest.raises(FileNotFoundError, match="No task JSON or JSONL files found"):
+        find_tasks_file(None)
+
+
+@patch("hud.cli.utils.tasks.hud_console")
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_single_file(mock_cwd, mock_console):
+    """Test that when only one file exists, it's returned without prompting."""
+    mock_path = MagicMock(spec=Path)
+    mock_file = MagicMock(spec=Path)
+    mock_file.__str__.return_value = "test.json"
+
+    def glob_side_effect(pattern):
+        if pattern == "*.json":
+            return [mock_file]
+        return []
+
+    mock_path.glob.side_effect = glob_side_effect
+    mock_path.__str__.return_value = str(Path.cwd())
+    mock_cwd.return_value = mock_path
+
+    result = find_tasks_file(None)
+    assert result == "test.json"
+    mock_console.select.assert_not_called()
+
+
+@patch("hud.cli.utils.tasks.hud_console")
+@patch("pathlib.Path.cwd")
+def test_find_tasks_file_multiple_files(mock_cwd, mock_console):
+    """Test that when multiple files exist, user is prompted to select one."""
+    mock_path = MagicMock(spec=Path)
+    mock_file1 = MagicMock(spec=Path)
+    mock_file1.__str__.return_value = "test1.json"
+    mock_file2 = MagicMock(spec=Path)
+    mock_file2.__str__.return_value = "test2.jsonl"
+
+    def glob_side_effect(pattern):
+        if pattern == "*.json":
+            return [mock_file1]
+        if pattern == "*.jsonl":
+            return [mock_file2]
+        return []
+
+    mock_path.glob.side_effect = glob_side_effect
+    mock_path.__str__.return_value = str(Path.cwd())
+    mock_cwd.return_value = mock_path
+    mock_console.select.return_value = "test2.jsonl"
+
+    result = find_tasks_file(None)
+
+    assert result == "test2.jsonl"
+    mock_console.select.assert_called_once()
+    call_args = mock_console.select.call_args
+    assert call_args[0][0] == "Select a tasks file"
+    assert "test1.json" in call_args[1]["choices"]
+    assert "test2.jsonl" in call_args[1]["choices"]

hud/cli/utils/version_check.py

@@ -171,11 +171,11 @@ def check_for_updates() -> VersionInfo | None:
 
     # Try to load from cache
     cached_info = _load_cache()
-    
+
     # If cache exists but current version has changed (user upgraded), invalidate cache
     if cached_info and cached_info.current != current:
         cached_info = None  # Force fresh check
-    
+
     if cached_info:
         # Update the current version in the cached info to reflect reality
         # but keep the cached latest version and timestamp

hud/datasets/tests/test_runner.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from hud.datasets.runner import _flush_telemetry
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry():
+    """Test _flush_telemetry function."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        from opentelemetry.sdk.trace import TracerProvider
+
+        mock_provider = MagicMock(spec=TracerProvider)
+        mock_provider.force_flush.return_value = True
+        mock_get_provider.return_value = mock_provider
+
+        mock_wait.return_value = 5
+
+        await _flush_telemetry()
+
+        mock_wait.assert_called_once()
+        mock_provider.force_flush.assert_called_once_with(timeout_millis=20000)
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_no_telemetry():
+    """Test _flush_telemetry when telemetry is not configured."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=False),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider"),
+    ):
+        mock_wait.return_value = 0
+
+        await _flush_telemetry()
+
+        mock_wait.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_exception():
+    """Test _flush_telemetry handles exceptions gracefully."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        from opentelemetry.sdk.trace import TracerProvider
+
+        mock_provider = MagicMock(spec=TracerProvider)
+        mock_provider.force_flush.side_effect = Exception("Flush failed")
+        mock_get_provider.return_value = mock_provider
+
+        mock_wait.return_value = 3
+
+        # Should not raise
+        await _flush_telemetry()
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_no_completed_tasks():
+    """Test _flush_telemetry when no tasks were completed."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        from opentelemetry.sdk.trace import TracerProvider
+
+        mock_provider = MagicMock(spec=TracerProvider)
+        mock_get_provider.return_value = mock_provider
+
+        mock_wait.return_value = 0
+
+        await _flush_telemetry()
+
+        mock_provider.force_flush.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_flush_telemetry_non_sdk_provider():
+    """Test _flush_telemetry with non-SDK TracerProvider."""
+    with (
+        patch("hud.otel.config.is_telemetry_configured", return_value=True),
+        patch("hud.utils.hud_console.hud_console"),
+        patch("hud.utils.task_tracking.wait_all_tasks", new_callable=AsyncMock) as mock_wait,
+        patch("opentelemetry.trace.get_tracer_provider") as mock_get_provider,
+    ):
+        # Return a non-TracerProvider object
+        mock_get_provider.return_value = MagicMock(spec=object)
+
+        mock_wait.return_value = 2
+
+        # Should not raise
+        await _flush_telemetry()

hud/datasets/tests/test_utils.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock, mock_open, patch
+
+import pytest
+
+from hud.datasets.utils import fetch_system_prompt_from_dataset, save_tasks
+from hud.types import Task
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_success():
+    """Test successful fetch of system prompt."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        mock_download.return_value = "/tmp/system_prompt.txt"
+        with patch("builtins.open", mock_open(read_data="Test system prompt")):
+            result = await fetch_system_prompt_from_dataset("test/dataset")
+            assert result == "Test system prompt"
+            mock_download.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_empty_file():
+    """Test fetch when file is empty."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        mock_download.return_value = "/tmp/system_prompt.txt"
+        with patch("builtins.open", mock_open(read_data="  \n  ")):
+            result = await fetch_system_prompt_from_dataset("test/dataset")
+            assert result is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_file_not_found():
+    """Test fetch when file doesn't exist."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        from huggingface_hub.errors import EntryNotFoundError
+
+        mock_download.side_effect = EntryNotFoundError("File not found")
+        result = await fetch_system_prompt_from_dataset("test/dataset")
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_import_error():
+    """Test fetch when huggingface_hub is not installed."""
+    # Mock the import itself to raise ImportError
+    import sys
+
+    with patch.dict(sys.modules, {"huggingface_hub": None}):
+        result = await fetch_system_prompt_from_dataset("test/dataset")
+        assert result is None
+
+
+@pytest.mark.asyncio
+async def test_fetch_system_prompt_general_exception():
+    """Test fetch with general exception."""
+    with patch("huggingface_hub.hf_hub_download") as mock_download:
+        mock_download.side_effect = Exception("Network error")
+        result = await fetch_system_prompt_from_dataset("test/dataset")
+        assert result is None
+
+
+def test_save_tasks_basic():
+    """Test basic save_tasks functionality."""
+    tasks = [
+        {"id": "1", "prompt": "test", "mcp_config": {"key": "value"}},
+        {"id": "2", "prompt": "test2", "mcp_config": {"key2": "value2"}},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        mock_dataset_class.from_list.assert_called_once()
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert len(call_args) == 2
+        # Check that mcp_config was JSON serialized
+        assert isinstance(call_args[0]["mcp_config"], str)
+        mock_dataset.push_to_hub.assert_called_once_with("test/repo")
+
+
+def test_save_tasks_with_specific_fields():
+    """Test save_tasks with specific fields."""
+    tasks = [
+        {"id": "1", "prompt": "test", "mcp_config": {"key": "value"}, "extra": "data"},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo", fields=["id", "prompt"])
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert "id" in call_args[0]
+        assert "prompt" in call_args[0]
+        assert "extra" not in call_args[0]
+
+
+def test_save_tasks_with_list_field():
+    """Test save_tasks serializes list fields."""
+    tasks = [
+        {"id": "1", "tags": ["tag1", "tag2"], "count": 5},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        # List should be JSON serialized
+        assert isinstance(call_args[0]["tags"], str)
+        assert '"tag1"' in call_args[0]["tags"]
+
+
+def test_save_tasks_with_primitive_types():
+    """Test save_tasks handles various primitive types."""
+    tasks = [
+        {
+            "string": "text",
+            "integer": 42,
+            "float": 3.14,
+            "boolean": True,
+            "none": None,
+        },
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert call_args[0]["string"] == "text"
+        assert call_args[0]["integer"] == 42
+        assert call_args[0]["float"] == 3.14
+        assert call_args[0]["boolean"] is True
+        assert call_args[0]["none"] == ""  # None becomes empty string
+
+
+def test_save_tasks_with_other_type():
+    """Test save_tasks converts other types to string."""
+
+    class CustomObj:
+        def __str__(self):
+            return "custom_value"
+
+    tasks = [
+        {"id": "1", "custom": CustomObj()},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo")
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert call_args[0]["custom"] == "custom_value"
+
+
+def test_save_tasks_rejects_task_objects():
+    """Test save_tasks raises error for Task objects."""
+    task = Task(prompt="test", mcp_config={})
+
+    with pytest.raises(ValueError, match="expects dictionaries, not Task objects"):
+        save_tasks([task], "test/repo")  # type: ignore
+
+
+def test_save_tasks_rejects_task_objects_in_list():
+    """Test save_tasks raises error when Task object is in the list."""
+    tasks = [
+        {"id": "1", "prompt": "test", "mcp_config": {}},
+        Task(prompt="test2", mcp_config={}),  # Task object
+    ]
+
+    with pytest.raises(ValueError, match="Item 1 is a Task object"):
+        save_tasks(tasks, "test/repo")  # type: ignore
+
+
+def test_save_tasks_with_kwargs():
+    """Test save_tasks passes kwargs to push_to_hub."""
+    tasks = [{"id": "1", "prompt": "test"}]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks(tasks, "test/repo", private=True, commit_message="Test commit")
+
+        mock_dataset.push_to_hub.assert_called_once_with(
+            "test/repo", private=True, commit_message="Test commit"
+        )
+
+
+def test_save_tasks_field_not_in_dict():
+    """Test save_tasks handles missing fields gracefully."""
+    tasks = [
+        {"id": "1", "prompt": "test"},
+    ]
+
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        # Request fields that don't exist
+        save_tasks(tasks, "test/repo", fields=["id", "missing_field"])
+
+        call_args = mock_dataset_class.from_list.call_args[0][0]
+        assert "id" in call_args[0]
+        assert "missing_field" not in call_args[0]
+
+
+def test_save_tasks_empty_list():
+    """Test save_tasks with empty list."""
+    with patch("hud.datasets.utils.Dataset") as mock_dataset_class:
+        mock_dataset = MagicMock()
+        mock_dataset_class.from_list.return_value = mock_dataset
+
+        save_tasks([], "test/repo")
+
+        mock_dataset_class.from_list.assert_called_once_with([])
+        mock_dataset.push_to_hub.assert_called_once()

hud/otel/tests/__init__.py

@@ -1 +0,0 @@
-"""Tests for OpenTelemetry integration."""