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

hud/utils/deprecation.py

@@ -1,115 +0,0 @@
-"""Deprecation utilities for HUD SDK."""
-
-from __future__ import annotations
-
-import functools
-import logging
-import warnings
-from typing import TYPE_CHECKING, Any, TypeVar, cast
-
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
-T = TypeVar("T")
-
-
-def deprecated(
-    reason: str,
-    *,
-    version: str | None = None,
-    replacement: str | None = None,
-    removal_version: str | None = None,
-) -> Callable[[T], T]:
-    """
-    Decorator to mark functions, methods, or classes as deprecated.
-
-    Args:
-        reason: Explanation of why this is deprecated
-        version: Version when this was deprecated (e.g., "1.0.0")
-        replacement: What to use instead
-        removal_version: Version when this will be removed
-
-    Example:
-        @deprecated(
-            reason="Use TaskConfig instead",
-            replacement="hud.datasets.TaskConfig",
-            version="0.3.0",
-            removal_version="0.4.0"
-        )
-        class OldClass:
-            pass
-    """
-
-    def decorator(obj: T) -> T:
-        message_parts = [f"{obj.__module__}.{obj.__qualname__} is deprecated"]
-
-        if version:
-            message_parts.append(f"(deprecated since v{version})")
-
-        message_parts.append(f": {reason}")
-
-        if replacement:
-            message_parts.append(f". Use {replacement} instead")
-
-        if removal_version:
-            message_parts.append(f". Will be removed in v{removal_version}")
-
-        deprecation_message = " ".join(message_parts) + "."
-
-        if isinstance(obj, type):
-            # Handle class deprecation
-            original_init = obj.__init__
-
-            @functools.wraps(original_init)
-            def new_init(self: Any, *args: Any, **kwargs: Any) -> None:
-                warnings.warn(deprecation_message, DeprecationWarning, stacklevel=2)
-                logger.warning(deprecation_message)
-                original_init(self, *args, **kwargs)
-
-            obj.__init__ = new_init
-
-            # Update docstring
-            if obj.__doc__:
-                obj.__doc__ = f"**DEPRECATED**: {deprecation_message}\n\n{obj.__doc__}"
-            else:
-                obj.__doc__ = f"**DEPRECATED**: {deprecation_message}"
-
-        else:
-            # Handle function/method deprecation
-            func = cast("Callable[..., Any]", obj)
-
-            @functools.wraps(func)
-            def wrapper(*args: Any, **kwargs: Any) -> Any:
-                warnings.warn(deprecation_message, DeprecationWarning, stacklevel=2)
-                logger.warning(deprecation_message)
-                return func(*args, **kwargs)
-
-            # Update docstring
-            if wrapper.__doc__:
-                wrapper.__doc__ = f"**DEPRECATED**: {deprecation_message}\n\n{wrapper.__doc__}"
-            else:
-                wrapper.__doc__ = f"**DEPRECATED**: {deprecation_message}"
-
-            return cast("T", wrapper)
-
-        return obj
-
-    return decorator
-
-
-def emit_deprecation_warning(
-    message: str,
-    category: type[Warning] = DeprecationWarning,
-    stacklevel: int = 2,
-) -> None:
-    """
-    Emit a deprecation warning with both warnings and logging.
-
-    Args:
-        message: The deprecation message
-        category: Warning category (default: DeprecationWarning)
-        stacklevel: Stack level for warning (default: 2)
-    """
-    warnings.warn(message, category, stacklevel=stacklevel)
-    logger.warning(message)

hud/utils/misc.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any
-
-from hud.server import make_request
-from hud.settings import settings
-
-if TYPE_CHECKING:
-    from hud.env.environment import Environment  # Import Environment for type hinting
-
-logger = logging.getLogger(__name__)
-
-
-async def upload_env_telemetry(
-    environment: Environment,
-    results: Any,
-    api_key: str | None = None,
-) -> None:
-    """
-    Sends telemetry data (results from a cloud runner) to the HUD telemetry upload endpoint.
-    """
-    environment_id = environment.client.env_id  # type: ignore
-
-    if not api_key:
-        api_key = settings.api_key
-
-    if not api_key:
-        raise ValueError("API key must be provided either as an argument or set in hud.settings.")
-
-    endpoint_url = f"{settings.base_url}/v2/environments/{environment_id}/telemetry-upload"
-
-    request_payload = {
-        "results": {
-            "steps": results,
-        }
-    }
-
-    logger.debug("Sending telemetry to %s for env_id: %s", endpoint_url, environment_id)
-
-    try:
-        await make_request(
-            method="POST",
-            url=endpoint_url,
-            json=request_payload,
-            api_key=api_key,
-        )
-        logger.info("Successfully uploaded telemetry for environment_id: %s", environment_id)
-    except Exception as e:
-        logger.error(
-            "Failed to upload telemetry for environment_id: %s. Error: %s", environment_id, e
-        )
-        raise

hud/utils/tests/test_common.py

@@ -1,277 +0,0 @@
-from __future__ import annotations
-
-import io
-import tarfile
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import pytest
-
-from hud.utils.common import directory_to_tar_bytes, get_gym_id
-
-if TYPE_CHECKING:
-    import pytest_mock
-
-
-def test_directory_to_tar_bytes(tmpdir_factory: pytest.TempdirFactory):
-    """Test that a directory can be converted to a tar bytes object."""
-    temp_dir = tmpdir_factory.mktemp("test_dir")
-    temp_dir_path = Path(temp_dir)
-
-    (temp_dir_path / "test.txt").write_text("test content")
-
-    nested_dir = temp_dir_path / "nested"
-    nested_dir.mkdir(exist_ok=True)
-    (nested_dir / "file.txt").write_text("nested content")
-
-    tar_bytes = directory_to_tar_bytes(temp_dir_path)
-    assert tar_bytes is not None
-    assert len(tar_bytes) > 0
-
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as tar:
-        members = tar.getmembers()
-        member_names = {m.name for m in members}
-
-        assert "test.txt" in member_names
-        assert "nested/file.txt" in member_names
-
-        test_content = tar.extractfile("test.txt")
-        assert test_content is not None
-        assert test_content.read().decode() == "test content"
-
-        nested_content = tar.extractfile("nested/file.txt")
-        assert nested_content is not None
-        assert nested_content.read().decode() == "nested content"
-
-
-@pytest.mark.asyncio
-async def test_get_gym_id(mocker: pytest_mock.MockerFixture):
-    """Test that the gym ID can be retrieved."""
-    mocker.patch("hud.utils.common.make_request", return_value={"id": "test_gym_id"})
-    gym_id = await get_gym_id("test_gym")
-    assert gym_id == "test_gym_id"
-
-
-def test_function_config_stores_function_name_args_and_optional_id():
-    """FunctionConfig should store function name, args list, and optional id."""
-    from hud.utils.common import FunctionConfig
-
-    # Minimal config
-    minimal = FunctionConfig(function="test_func", args=[])
-    assert minimal.function == "test_func"
-    assert minimal.args == []
-    assert minimal.id is None
-
-    # With args
-    with_args = FunctionConfig(function="navigate", args=["https://example.com", {"wait": True}])
-    assert with_args.function == "navigate"
-    assert len(with_args.args) == 2
-    assert with_args.args[0] == "https://example.com"
-    assert with_args.args[1] == {"wait": True}
-
-    # With id
-    with_id = FunctionConfig(
-        function="complex_operation",
-        args=[42, "test", {"nested": {"key": "value"}}],
-        id="op_123",
-    )
-    assert with_id.function == "complex_operation"
-    assert len(with_id.args) == 3
-    assert with_id.id == "op_123"
-
-
-@pytest.mark.asyncio
-async def test_get_gym_id_fetches_id_from_api_response(
-    mocker: pytest_mock.MockerFixture,
-):
-    """get_gym_id should extract 'id' field from API response."""
-    # Arrange
-    api_response = {"id": "gym-123", "name": "Test Gym", "status": "active"}
-    mocker.patch("hud.utils.common.make_request", return_value=api_response)
-
-    # Act
-    gym_id = await get_gym_id("test_gym")
-
-    # Assert
-    assert gym_id == "gym-123"
-
-
-@pytest.mark.asyncio
-async def test_get_gym_id_propagates_network_errors(mocker: pytest_mock.MockerFixture):
-    """get_gym_id should propagate exceptions from make_request."""
-    # Arrange
-    mocker.patch("hud.utils.common.make_request", side_effect=ConnectionError("API unavailable"))
-
-    # Act & Assert
-    with pytest.raises(ConnectionError, match="API unavailable"):
-        await get_gym_id("test_gym")
-
-
-@pytest.mark.asyncio
-async def test_get_gym_id_raises_key_error_when_id_missing(
-    mocker: pytest_mock.MockerFixture,
-):
-    """get_gym_id should raise KeyError when response lacks 'id' field."""
-    # Arrange
-    incomplete_response = {"name": "Test Gym", "status": "active"}  # Missing 'id'
-    mocker.patch("hud.utils.common.make_request", return_value=incomplete_response)
-
-    # Act & Assert
-    with pytest.raises(KeyError):
-        await get_gym_id("test_gym")
-
-
-def test_directory_to_tar_bytes_creates_valid_tar_archive(
-    tmpdir_factory: pytest.TempdirFactory,
-):
-    """directory_to_tar_bytes should create a valid tar archive containing all files."""
-    # Arrange
-    temp_dir = tmpdir_factory.mktemp("test_archive")
-    temp_dir_path = Path(temp_dir)
-
-    # Create test structure
-    (temp_dir_path / "file1.txt").write_text("content1")
-    (temp_dir_path / "file2.py").write_text("import os\nprint('hello')")
-
-    subdir = temp_dir_path / "subdir"
-    subdir.mkdir()
-    (subdir / "nested.json").write_text('{"key": "value"}')
-
-    # Act
-    tar_bytes = directory_to_tar_bytes(temp_dir_path)
-
-    # Assert
-    assert isinstance(tar_bytes, bytes)
-    assert len(tar_bytes) > 0
-
-    # Verify contents
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as tar:
-        members = {m.name for m in tar.getmembers()}
-        assert "file1.txt" in members
-        assert "file2.py" in members
-        assert "subdir/nested.json" in members
-
-        # Verify file contents
-        content = tar.extractfile("file1.txt")
-        assert content is not None
-        assert content.read().decode() == "content1"
-
-
-def test_directory_to_tar_bytes_handles_empty_directory(
-    tmpdir_factory: pytest.TempdirFactory,
-):
-    """directory_to_tar_bytes should handle empty directories gracefully."""
-    # Arrange
-    empty_dir = tmpdir_factory.mktemp("empty")
-    empty_dir_path = Path(empty_dir)
-
-    # Act
-    tar_bytes = directory_to_tar_bytes(empty_dir_path)
-
-    # Assert
-    assert isinstance(tar_bytes, bytes)
-    assert len(tar_bytes) > 0  # Even empty tar has headers
-
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as tar:
-        members = tar.getmembers()
-        # May contain the directory itself or be completely empty
-        assert len(members) >= 0
-
-
-def test_directory_to_tar_bytes_preserves_directory_structure(
-    tmpdir_factory: pytest.TempdirFactory,
-):
-    """directory_to_tar_bytes should preserve nested directory structure."""
-    # Arrange
-    root = tmpdir_factory.mktemp("root")
-    root_path = Path(root)
-
-    # Create nested structure
-    (root_path / "a" / "b" / "c").mkdir(parents=True)
-    (root_path / "a" / "file1.txt").write_text("in a")
-    (root_path / "a" / "b" / "file2.txt").write_text("in b")
-    (root_path / "a" / "b" / "c" / "file3.txt").write_text("in c")
-
-    # Act
-    tar_bytes = directory_to_tar_bytes(root_path)
-
-    # Assert
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as tar:
-        members = {m.name for m in tar.getmembers()}
-        assert "a/file1.txt" in members
-        assert "a/b/file2.txt" in members
-        assert "a/b/c/file3.txt" in members
-
-
-def test_directory_to_tar_bytes_with_exclusions(tmpdir_factory: pytest.TempdirFactory):
-    """Test directory_to_tar_bytes with files to exclude."""
-    temp_dir = tmpdir_factory.mktemp("test_exclude_dir")
-    temp_dir_path = Path(temp_dir)
-
-    # Create various files
-    (temp_dir_path / "include_me.txt").write_text("include")
-    (temp_dir_path / ".git").mkdir()
-    (temp_dir_path / ".git" / "config").write_text("git config")
-    (temp_dir_path / "__pycache__").mkdir()
-    (temp_dir_path / "__pycache__" / "module.pyc").write_bytes(b"pyc content")
-    (temp_dir_path / "normal_dir").mkdir()
-    (temp_dir_path / "normal_dir" / "file.py").write_text("python code")
-
-    tar_bytes = directory_to_tar_bytes(temp_dir_path)
-
-    # Check contents
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as tar:
-        member_names = {m.name for m in tar.getmembers()}
-
-        # Should include regular files and directories
-        assert "include_me.txt" in member_names
-        assert "normal_dir/file.py" in member_names
-
-        # Implementation might exclude common patterns like .git and __pycache__
-        # This depends on the actual implementation
-
-
-def test_directory_to_tar_bytes_empty_directory(tmpdir_factory: pytest.TempdirFactory):
-    """Test directory_to_tar_bytes with empty directory."""
-    temp_dir = tmpdir_factory.mktemp("empty_dir")
-    temp_dir_path = Path(temp_dir)
-
-    tar_bytes = directory_to_tar_bytes(temp_dir_path)
-
-    # Should still create a valid tar even if empty
-    assert tar_bytes is not None
-    assert len(tar_bytes) > 0
-
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as tar:
-        members = tar.getmembers()
-        # Might be empty or contain just the root directory
-        assert len(members) >= 0
-
-
-def test_directory_to_tar_bytes_symlinks(tmpdir_factory: pytest.TempdirFactory):
-    """Test directory_to_tar_bytes with symbolic links."""
-    temp_dir = tmpdir_factory.mktemp("symlink_dir")
-    temp_dir_path = Path(temp_dir)
-
-    # Create a file and a symlink to it
-    target_file = temp_dir_path / "target.txt"
-    target_file.write_text("target content")
-
-    symlink = temp_dir_path / "link_to_target.txt"
-    try:
-        symlink.symlink_to(target_file)
-        has_symlink = True
-    except OSError:
-        # Symlinks might not be supported on all systems (e.g., Windows without admin)
-        has_symlink = False
-
-    tar_bytes = directory_to_tar_bytes(temp_dir_path)
-
-    with tarfile.open(fileobj=io.BytesIO(tar_bytes), mode="r:*") as tar:
-        members = {m.name: m for m in tar.getmembers()}
-
-        assert "target.txt" in members
-
-        if has_symlink:
-            # Check how symlinks are handled (might be followed or preserved)
-            assert "link_to_target.txt" in members

hud/utils/tests/test_config.py

@@ -1,129 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from hud.utils.common import FunctionConfig
-from hud.utils.config import (
-    _is_list_of_configs,
-    _is_valid_python_name,
-    _split_and_validate_path,
-    _validate_hud_config,
-    expand_config,
-)
-
-
-@pytest.mark.parametrize(
-    "config, expected",
-    [
-        ("test", [{"function": "test", "args": [], "id": None}]),
-        (("test",), [{"function": "test", "args": [], "id": None}]),
-        (
-            [FunctionConfig(function="test", args=[])],
-            [{"function": "test", "args": [], "id": None}],
-        ),
-        ({"function": "test", "args": []}, [{"function": "test", "args": [], "id": None}]),
-        (
-            {"function": "test", "args": ["arg1"]},
-            [{"function": "test", "args": ["arg1"], "id": None}],
-        ),
-        (
-            {"function": "test", "args": ["arg1"], "id": "test_id"},
-            [{"function": "test", "args": ["arg1"], "id": "test_id"}],
-        ),
-        (("test", "arg1", "arg2"), [{"function": "test", "args": ["arg1", "arg2"], "id": None}]),
-    ],
-)
-def test_expand_config(config, expected):
-    result = expand_config(config)
-    assert len(result) == len(expected)
-    for i, item in enumerate(result):
-        assert item.function == expected[i]["function"]
-        assert item.args == expected[i]["args"]
-        assert item.id == expected[i]["id"]
-
-
-@pytest.mark.parametrize(
-    "name, expected",
-    [
-        ("valid_name", True),
-        ("ValidName", True),
-        ("valid_name_123", True),
-        ("_valid_name", True),
-        ("123_invalid", False),
-        ("invalid-name", False),
-        ("", False),
-    ],
-)
-def test_is_valid_python_name(name, expected):
-    assert _is_valid_python_name(name) == expected
-
-
-def test_validate_hud_config_valid():
-    config = {"function": "test.func", "args": ["arg1", "arg2"]}
-    result = _validate_hud_config(config)
-    assert result.function == "test.func"
-    assert result.args == ["arg1", "arg2"]
-    assert result.id is None
-
-    # Test with single arg (not in a list)
-    config = {"function": "test.func", "args": "arg1"}
-    result = _validate_hud_config(config)
-    assert result.function == "test.func"
-    assert result.args == ["arg1"]
-
-    # Test with ID
-    config = {"function": "test.func", "args": [], "id": "test_id"}
-    result = _validate_hud_config(config)
-    assert result.id == "test_id"
-
-
-def test_validate_hud_config_invalid():
-    with pytest.raises(ValueError, match="function must be a string"):
-        _validate_hud_config({"args": []})
-
-    with pytest.raises(ValueError, match="function must be a string"):
-        _validate_hud_config({"function": 123, "args": []})
-
-
-def test_split_and_validate_path_valid():
-    # none should raise
-    _split_and_validate_path("module.submodule.function")
-    _split_and_validate_path("function")
-    _split_and_validate_path("Module_123.function_456")
-
-
-def test_split_and_validate_path_invalid():
-    with pytest.raises(ValueError, match="Invalid Python identifier in path"):
-        _split_and_validate_path("invalid-module.function")
-
-
-def test_is_list_of_configs():
-    valid_list = [
-        FunctionConfig(function="test1", args=[]),
-        FunctionConfig(function="test2", args=["arg1"]),
-    ]
-    assert _is_list_of_configs(valid_list) is True
-
-    # Empty list
-    assert _is_list_of_configs([]) is True
-
-    # Invalid: not a list
-    assert _is_list_of_configs("not_a_list") is False
-
-    # Invalid: list with non-FunctionConfig items
-    invalid_list = [FunctionConfig(function="test", args=[]), "not_a_function_config"]
-    assert _is_list_of_configs(invalid_list) is False
-
-
-def test_expand_config_errors():
-    with pytest.raises(ValueError):
-        empty_tuple = ()
-        expand_config(empty_tuple)  # type: ignore
-
-    with pytest.raises(ValueError):
-        invalid_tuple = (123, "arg1")
-        expand_config(invalid_tuple)  # type: ignore
-
-    with pytest.raises(ValueError, match="Unknown configuration type"):
-        invalid_value = 123
-        expand_config(invalid_value)  # type: ignore