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

hud/env/remote_docker_client.py

@@ -1,292 +0,0 @@
-from __future__ import annotations
-
-import logging
-from base64 import b64decode, b64encode
-from typing import TYPE_CHECKING, Any
-
-import httpx
-
-from hud.env.docker_client import DockerClient
-from hud.exceptions import HudResponseError
-from hud.server import make_request
-from hud.settings import settings
-from hud.types import EnvironmentStatus
-from hud.utils import ExecuteResult
-from hud.utils.common import directory_to_zip_bytes, get_gym_id
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-logger = logging.getLogger("hud.env.remote_env_client")
-
-
-async def upload_bytes_to_presigned_url(
-    presigned_url: str,
-    data_bytes: bytes,
-    timeout: float = 600,  # noqa: ASYNC109
-) -> None:
-    try:
-        async with httpx.AsyncClient() as client:
-            response = await client.put(presigned_url, content=data_bytes, timeout=timeout)
-            response.raise_for_status()
-    except httpx.HTTPStatusError as e:
-        logger.exception("Failed to upload to presigned URL")
-        raise HudResponseError(message=f"Failed to upload to presigned URL: {e}") from e
-    except httpx.RequestError as e:
-        logger.exception("Network error uploading to presigned URL")
-        raise HudResponseError(message=f"Network error uploading to presigned URL: {e}") from e
-
-
-class RemoteDockerClient(DockerClient):
-    """
-    Remote environment client implementation.
-
-    Uses the HUD API to manage a remote environment.
-    """
-
-    @classmethod
-    async def build_image(cls, build_context: Path) -> tuple[str, dict[str, Any]]:
-        """
-        Build an image from a build context.
-        """
-        # create the presigned url by making a POST request to /v2/builds
-        logger.info("Creating build")
-        response = await make_request(
-            method="POST",
-            url=f"{settings.base_url}/v2/builds",
-            api_key=settings.api_key,
-        )
-        logger.info("Build created")
-        presigned_url = response["presigned_url"]
-
-        # List files in the build context
-        files = list(build_context.glob("**/*"))
-        logger.info("Found %d files in build context %s", len(files), build_context)
-
-        if len(files) == 0:
-            raise HudResponseError(message="Build context is empty")
-
-        # zip the build context
-        logger.info("Zipping build context")
-        zip_bytes = directory_to_zip_bytes(build_context)
-        logger.info("Created zip archive of size %d kb", len(zip_bytes) // 1024)
-        # upload the zip bytes to the presigned url
-        logger.info("Uploading build context")
-        await upload_bytes_to_presigned_url(presigned_url, zip_bytes)
-        logger.info("Build context uploaded")
-
-        # start the build and return uri and logs
-        logger.info("Starting build")
-        response = await make_request(
-            method="POST",
-            url=f"{settings.base_url}/v2/builds/{response['id']}/start",
-            api_key=settings.api_key,
-        )
-        logger.info("Build completed")
-
-        return response["uri"], {"logs": response["logs"]}
-
-    @classmethod
-    async def create(
-        cls,
-        image_uri: str,
-        *,
-        job_id: str | None = None,
-        task_id: str | None = None,
-        metadata: dict[str, Any] | None = None,
-    ) -> RemoteDockerClient:
-        """
-        Creates a remote environment client from an image.
-
-        Args:
-            image_uri: The image uri to create the environment from
-            job_id: The job_id of the environment to create
-            task_id: The task_id of the environment to create
-            metadata: Metadata to associate with the environment
-
-        Returns:
-            A tuple containing the remote environment client and the build metadata
-
-        Raises:
-            HudResponseError: If the environment creation fails.
-        """
-
-        # Validate arguments
-        if metadata is None:
-            metadata = {}
-
-        logger.info("Creating remote environment")
-
-        # true_gym_id = await get_gym_id("local-docker")
-        true_gym_id = await get_gym_id("docker")
-
-        # augment metadata with dockerfile
-        if "environment_config" not in metadata:
-            metadata["environment_config"] = {}
-
-        metadata["environment_config"]["image_uri"] = image_uri
-
-        # Create a new environment via the HUD API
-        response = await make_request(
-            method="POST",
-            url=f"{settings.base_url}/v2/create_environment",
-            json={
-                # still named run_id for backwards compatibility
-                "run_id": job_id,
-                "metadata": metadata,
-                "gym_id": true_gym_id,
-                "task_id": task_id,
-            },
-            api_key=settings.api_key,
-        )
-
-        # Get the environment ID from the response
-        env_id = response.get("id")
-        if not env_id:
-            raise HudResponseError(
-                message=(
-                    "Failed to create remote environment: No ID returned in API response. "
-                    "Please contact support if this issue persists."
-                ),
-                response_json=response,
-            )
-
-        return cls(env_id)
-
-    def __init__(self, env_id: str) -> None:
-        """
-        Initialize the RemoteClient.
-
-        Args:
-            env_id: ID of the remote environment to control
-        """
-        super().__init__()
-        self._env_id = env_id
-
-    @property
-    def env_id(self) -> str:
-        """The ID of the remote environment."""
-        return self._env_id
-
-    async def get_status(self) -> EnvironmentStatus:
-        """
-        Get the current status of the remote environment.
-
-        Returns:
-            EnvironmentStatus: The current status of the environment
-        """
-        try:
-            response = await make_request(
-                method="GET",
-                url=f"{settings.base_url}/v2/environments/{self.env_id}/state",
-                api_key=settings.api_key,
-            )
-            logger.debug("Environment status response: %s", response)
-
-            status = response.get("state", "").lower()
-
-            if status == "running":
-                return EnvironmentStatus.RUNNING
-            elif status == "initializing" or status == "pending":
-                return EnvironmentStatus.INITIALIZING
-            elif status == "completed" or status == "terminated":
-                return EnvironmentStatus.COMPLETED
-            else:
-                # Any other status is considered an error
-                logger.warning("Abnormal environment status response: %s", response)
-                return EnvironmentStatus.ERROR
-
-        except Exception:
-            # If we can't connect to the API or there's any other error
-            logger.info("(potentially transient) Error getting environment status")
-            return EnvironmentStatus.ERROR
-
-    async def execute(
-        self,
-        command: list[str],
-        *,
-        workdir: str | None = None,
-        timeout: float | None = None,  # noqa: ASYNC109
-    ) -> ExecuteResult:
-        """
-        Execute a command in the environment.
-        No-op in some environments (like browser use).
-
-        Args:
-            command: Command to execute
-            workdir: Working directory for the command (ignored for remote environments)
-
-        Returns:
-            ExecuteResult: Result of the command execution
-        """
-        data = await make_request(
-            method="POST",
-            url=f"{settings.base_url}/v2/environments/{self.env_id}/execute",
-            json={
-                "command": command,
-                "workdir": workdir,
-                "timeout": timeout,
-            },
-            api_key=settings.api_key,
-        )
-
-        return ExecuteResult(
-            stdout=b64decode(data["stdout"]),
-            stderr=b64decode(data["stderr"]),
-            exit_code=data["exit_code"],
-        )
-
-    async def get_archive(self, path: str) -> bytes:
-        """
-        Get an archive of a path from the environment.
-        May not be supported for all environments.
-
-        Args:
-            path: Path in the environment to archive
-
-        Returns:
-            bytes: Content of the file or archive
-        """
-        data = await make_request(
-            method="POST",
-            url=f"{settings.base_url}/v2/environments/{self.env_id}/get_archive",
-            json={"path": path},
-            api_key=settings.api_key,
-        )
-
-        # Return the content decoded from base64
-        return b64decode(data["content"])
-
-    async def put_archive(self, path: str, data: bytes) -> bool:
-        """
-        Put an archive of data at a path in the environment.
-        May not be supported for all environments.
-
-        Args:
-            path: Path in the environment to extract the archive to
-            data: Bytes of the data to send
-
-        Returns:
-            bool: True if successful
-        """
-        await make_request(
-            method="POST",
-            url=f"{settings.base_url}/v2/environments/{self.env_id}/put_archive",
-            json={
-                "path": path,
-                "content": b64encode(data).decode("utf-8"),
-            },
-            api_key=settings.api_key,
-        )
-
-        return True
-
-    async def close(self) -> None:
-        """
-        Close the remote environment by making a request to the server.
-        """
-        await make_request(
-            method="POST",
-            url=f"{settings.base_url}/v2/environments/{self.env_id}/close",
-            api_key=settings.api_key,
-        )

hud/gym.py

@@ -1,130 +0,0 @@
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from hud.env.environment import Environment
-from hud.env.local_docker_client import LocalDockerClient
-from hud.env.remote_client import RemoteClient
-from hud.env.remote_docker_client import RemoteDockerClient
-from hud.exceptions import GymMakeException
-from hud.task import Task
-from hud.telemetry.context import get_current_task_run_id
-from hud.types import CustomGym, Gym
-from hud.utils.common import get_gym_id
-
-if TYPE_CHECKING:
-    from hud.job import Job
-
-logger = logging.getLogger("hud.gym")
-
-
-async def make(
-    env_src: Gym | Task,
-    *,
-    job: Job | None = None,
-    job_id: str | None = None,
-    metadata: dict[str, Any] | None = None,
-) -> Environment:
-    """
-    Create an environment from an environment ID or a Task object.
-
-    Args:
-        env_src: Environment ID or Task object
-        job: Job object to associate with this environment
-        job_id: ID of job to associate with this environment (deprecated, use job instead)
-        metadata: Additional metadata for the environment
-    """
-    task = None
-    if isinstance(env_src, str | CustomGym):
-        gym = env_src
-    elif isinstance(env_src, Task):
-        gym = env_src.gym
-        task = env_src
-    else:
-        raise GymMakeException(f"Invalid gym source: {env_src}", {})
-
-    effective_job_id = None
-    if job is not None:
-        effective_job_id = job.id
-    elif job_id is not None:
-        effective_job_id = job_id
-
-    build_data = {}
-    try:
-        metadata_copy = {} if metadata is None else metadata.copy()
-
-        current_task_run_id = get_current_task_run_id()
-        if current_task_run_id:
-            metadata_copy["task_run_id"] = current_task_run_id
-            logger.debug(
-                "Passing task_run_id %s from hud.telemetry context to environment metadata.",
-                current_task_run_id,
-            )
-
-        if isinstance(gym, CustomGym):
-            if isinstance(gym.image_or_build_context, str):
-                uri = gym.image_or_build_context
-            elif isinstance(gym.image_or_build_context, Path):
-                if gym.location == "local":
-                    uri, build_data = await LocalDockerClient.build_image(
-                        gym.image_or_build_context
-                    )
-                elif gym.location == "remote":
-                    uri, build_data = await RemoteDockerClient.build_image(
-                        gym.image_or_build_context
-                    )
-                else:
-                    raise ValueError(f"Invalid environment location: {gym.location}")
-            else:
-                raise ValueError(f"Invalid image or build context: {gym.image_or_build_context}")
-
-            if gym.location == "local":
-                logger.info("Creating local environment")
-                if gym.host_config:
-                    logger.info("Using host config: %s", gym.host_config)
-                    client = await LocalDockerClient.create(uri, gym.host_config)
-                else:
-                    client = await LocalDockerClient.create(uri)
-
-            elif gym.location == "remote":
-                logger.info("Creating remote environment")
-
-                if gym.host_config:
-                    raise ValueError("host_config is not supported for remote environments")
-
-                client = await RemoteDockerClient.create(
-                    image_uri=uri,
-                    job_id=effective_job_id,
-                    task_id=task.id if task else None,
-                    metadata=metadata_copy,
-                )
-            else:
-                raise ValueError(f"Invalid environment location: {gym.location}")
-
-            if isinstance(gym.image_or_build_context, Path):
-                logger.info("Setting source path %s", gym.image_or_build_context)
-                client.set_source_path(gym.image_or_build_context)
-        elif isinstance(gym, str):
-            logger.debug("Creating private environment")
-            true_gym_id = await get_gym_id(gym)
-            client, build_data = await RemoteClient.create(
-                gym_id=true_gym_id,
-                job_id=effective_job_id,
-                task_id=task.id if task else None,
-                metadata=metadata_copy,
-            )
-        else:
-            raise ValueError(f"Invalid gym source: {gym}")
-
-        environment = Environment(
-            client=client, metadata=metadata_copy, task=task, build_data=build_data
-        )
-
-        if task:
-            await environment._setup()
-        return environment
-    except Exception as e:
-        build_data["exception"] = str(e)
-        raise GymMakeException("Failed to create environment", build_data) from e