From 4c8144056f3c05416c137cd46fd70485e4015332 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Wed, 8 Jan 2025 15:05:07 +0100 Subject: [PATCH 01/44] Add files for Foundry client and server --- .github/workflows/ci.yaml | 14 +- Dockerfile | 39 +++++ Makefile | 10 +- _docker_requirements.txt | 137 ++++++++++++++++ aurora/foundry/__init__.py | 12 ++ aurora/foundry/client/__init__.py | 1 + aurora/foundry/client/api.py | 125 +++++++++++++++ aurora/foundry/client/foundry.py | 61 +++++++ aurora/foundry/common/__init__.py | 1 + aurora/foundry/common/channel.py | 254 ++++++++++++++++++++++++++++++ aurora/foundry/common/model.py | 93 +++++++++++ aurora/foundry/server/__init__.py | 3 + aurora/foundry/server/score.py | 144 +++++++++++++++++ docs/_toc.yml | 32 ++-- docs/example_era5.ipynb | 2 +- docs/example_hres_0.1.ipynb | 2 +- docs/example_hres_t0.ipynb | 2 +- docs/foundry/api.rst | 29 ++++ docs/foundry/intro.md | 6 + docs/foundry/server.md | 17 ++ docs/foundry/submission.md | 66 ++++++++ pyproject.toml | 15 +- tests/foundry/__init__.py | 12 ++ tests/foundry/azcopy.py | 74 +++++++++ tests/foundry/conftest.py | 152 ++++++++++++++++++ tests/foundry/runner.py | 66 ++++++++ tests/foundry/test_api.py | 33 ++++ 27 files changed, 1379 insertions(+), 23 deletions(-) create mode 100644 Dockerfile create mode 100644 _docker_requirements.txt create mode 100644 aurora/foundry/__init__.py create mode 100644 aurora/foundry/client/__init__.py create mode 100644 aurora/foundry/client/api.py create mode 100644 aurora/foundry/client/foundry.py create mode 100644 aurora/foundry/common/__init__.py create mode 100644 aurora/foundry/common/channel.py create mode 100644 aurora/foundry/common/model.py create mode 100644 aurora/foundry/server/__init__.py create mode 100644 aurora/foundry/server/score.py create mode 100644 docs/foundry/api.rst create mode 100644 docs/foundry/intro.md create mode 100644 docs/foundry/server.md create mode 100644 docs/foundry/submission.md create mode 100644 tests/foundry/__init__.py create mode 100644 tests/foundry/azcopy.py create mode 100644 tests/foundry/conftest.py create mode 100644 tests/foundry/runner.py create mode 100644 tests/foundry/test_api.py diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 097fb18..8385f71 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -17,14 +17,24 @@ jobs: name: Test with Python ${{ matrix.version }} steps: - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.version }} uses: actions/setup-python@v2 with: python-version: ${{ matrix.version }} + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v3 + + - name: Build Foundry image + run: | + make docker + - name: Install dependencies run: | - python -m pip install --upgrade pip - python -m pip install --upgrade --no-cache-dir -e '.[dev]' + python -m pip install --upgrade pip + python -m pip install --upgrade --no-cache-dir -e '.[dev]' + - name: Run tests run: | pytest -v --cov=aurora --cov-report term-missing diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..c7e4725 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,39 @@ +# Use an official Python runtime as a parent image. +FROM mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04:latest + +WORKDIR /aurora_foundry +COPY ./pyproject.toml . + +# Assuming dependencies are fairly fixed, we can install them first and then copy the rest of the +# code to avoid re-installing dependencies when the code changes. +COPY requirements.txt . +RUN pip install --upgrade pip virtualenv && \ + virtualenv venv -p python3.10 && \ + . venv/bin/activate && \ + pip install -r requirements.txt + +# Download model weights. +RUN ./venv/bin/python -c 'from huggingface_hub import hf_hub_download; hf_hub_download(repo_id="microsoft/aurora", filename="aurora-0.25-small-pretrained.ckpt")' && \ + ./venv/bin/python -c 'from huggingface_hub import hf_hub_download; hf_hub_download(repo_id="microsoft/aurora", filename="aurora-0.25-finetuned.ckpt")' + +COPY ./aurora ./aurora +COPY ./LICENSE.txt . +COPY ./README.md . + +ARG AURORA_REPO_VERSION +RUN [ ! -z "${AURORA_REPO_VERSION}" ] || { echo "AURORA_REPO_VERSION must be set."; exit 1; } && \ + . venv/bin/activate && \ + SETUPTOOLS_SCM_PRETEND_VERSION="$AURORA_REPO_VERSION" pip install -e . + + +# Install `azcopy` and the AML inference server. +RUN wget https://aka.ms/downloadazcopy-v10-linux -O azcopy.tar.gz && \ + cp $(tar -xvzf azcopy.tar.gz | grep azcopy$) /usr/local/bin/azcopy +RUN . ./venv/bin/activate && \ + pip install azureml-inference-server-http + +# Make port 5001 available to the world outside this container. +EXPOSE 5001 +ENV PORT=5001 + +CMD ["./venv/bin/azmlinfsrv", "--entry_script", "aurora/foundry/server/score.py"] diff --git a/Makefile b/Makefile index c423c55..9aecbce 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: install test docs +.PHONY: install test docs docker-requirements docker install: pip install --upgrade pip @@ -11,3 +11,11 @@ test: docs: jupyter-book build docs cp -r docs/_extras/* docs/_build/html/ + +docker-requirements: pyproject.toml + (pip show pip-tools 1>/dev/null) || pip install pip-tools + pip-compile --verbose --output-file _docker_requirements.txt pyproject.toml + +docker: + (pip show setuptools-scm 1>/dev/null) || pip install setuptools-scm + AURORA_REPO_VERSION=`python -m setuptools_scm` docker build --build-arg AURORA_REPO_VERSION -t aurora-foundry:latest . diff --git a/_docker_requirements.txt b/_docker_requirements.txt new file mode 100644 index 0000000..c5151cd --- /dev/null +++ b/_docker_requirements.txt @@ -0,0 +1,137 @@ +# +# This file is autogenerated by pip-compile with Python 3.10 +# by the following command: +# +# pip-compile --output-file=requirements.txt pyproject.toml +# +annotated-types==0.7.0 + # via pydantic +certifi==2024.12.14 + # via + # netcdf4 + # requests +cftime==1.6.4.post1 + # via netcdf4 +charset-normalizer==3.4.1 + # via requests +einops==0.8.0 + # via microsoft-aurora (pyproject.toml) +filelock==3.16.1 + # via + # huggingface-hub + # torch + # triton +fsspec==2024.12.0 + # via + # huggingface-hub + # torch +huggingface-hub==0.27.1 + # via + # microsoft-aurora (pyproject.toml) + # timm +idna==3.10 + # via requests +jinja2==3.1.5 + # via torch +markupsafe==3.0.2 + # via jinja2 +mpmath==1.3.0 + # via sympy +netcdf4==1.7.2 + # via microsoft-aurora (pyproject.toml) +networkx==3.4.2 + # via torch +numpy==2.2.1 + # via + # cftime + # microsoft-aurora (pyproject.toml) + # netcdf4 + # pandas + # scipy + # torchvision + # xarray +nvidia-cublas-cu12==12.4.5.8 + # via + # nvidia-cudnn-cu12 + # nvidia-cusolver-cu12 + # torch +nvidia-cuda-cupti-cu12==12.4.127 + # via torch +nvidia-cuda-nvrtc-cu12==12.4.127 + # via torch +nvidia-cuda-runtime-cu12==12.4.127 + # via torch +nvidia-cudnn-cu12==9.1.0.70 + # via torch +nvidia-cufft-cu12==11.2.1.3 + # via torch +nvidia-curand-cu12==10.3.5.147 + # via torch +nvidia-cusolver-cu12==11.6.1.9 + # via torch +nvidia-cusparse-cu12==12.3.1.170 + # via + # nvidia-cusolver-cu12 + # torch +nvidia-nccl-cu12==2.21.5 + # via torch +nvidia-nvjitlink-cu12==12.4.127 + # via + # nvidia-cusolver-cu12 + # nvidia-cusparse-cu12 + # torch +nvidia-nvtx-cu12==12.4.127 + # via torch +packaging==24.2 + # via + # huggingface-hub + # xarray +pandas==2.2.3 + # via xarray +pillow==11.1.0 + # via torchvision +pydantic==2.10.4 + # via microsoft-aurora (pyproject.toml) +pydantic-core==2.27.2 + # via pydantic +python-dateutil==2.9.0.post0 + # via pandas +pytz==2024.2 + # via pandas +pyyaml==6.0.2 + # via + # huggingface-hub + # timm +requests==2.32.3 + # via huggingface-hub +scipy==1.15.0 + # via microsoft-aurora (pyproject.toml) +six==1.17.0 + # via python-dateutil +sympy==1.13.1 + # via torch +timm==0.6.13 + # via microsoft-aurora (pyproject.toml) +torch==2.5.1 + # via + # microsoft-aurora (pyproject.toml) + # timm + # torchvision +torchvision==0.20.1 + # via timm +tqdm==4.67.1 + # via huggingface-hub +triton==3.1.0 + # via torch +typing-extensions==4.12.2 + # via + # huggingface-hub + # pydantic + # pydantic-core + # torch +tzdata==2024.2 + # via pandas +urllib3==2.3.0 + # via requests +xarray==2025.1.0 + # via microsoft-aurora (pyproject.toml) diff --git a/aurora/foundry/__init__.py b/aurora/foundry/__init__.py new file mode 100644 index 0000000..5f5f373 --- /dev/null +++ b/aurora/foundry/__init__.py @@ -0,0 +1,12 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +from aurora.foundry.client.api import SubmissionError, submit +from aurora.foundry.client.foundry import FoundryClient +from aurora.foundry.common.channel import BlobStorageCommunication + +__all__ = [ + "BlobStorageCommunication", + "FoundryClient", + "submit", + "SubmissionError", +] diff --git a/aurora/foundry/client/__init__.py b/aurora/foundry/client/__init__.py new file mode 100644 index 0000000..a679a52 --- /dev/null +++ b/aurora/foundry/client/__init__.py @@ -0,0 +1 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py new file mode 100644 index 0000000..2159889 --- /dev/null +++ b/aurora/foundry/client/api.py @@ -0,0 +1,125 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license. + +This is the API that the end user uses to submit jobs to the model running on Azure AI Foundry. +""" + +import logging +from typing import Generator, Literal, Optional, Union + +from pydantic import BaseModel, Field + +from aurora import Batch +from aurora.foundry.client.foundry import AbstractFoundryClient +from aurora.foundry.common.channel import CommunicationChannel, iterate_prediction_files +from aurora.foundry.common.model import models + +__all__ = ["SubmissionError", "submit"] + +logger = logging.getLogger(__name__) + + +class SubmissionInfo(BaseModel): + kind: Literal["submission_info"] + uuid: str + + +class ProgressInfo(BaseModel): + kind: Literal["progress_info"] + uuid: str + completed: bool + progress_percentage: int + error: bool + error_info: str + + +class Answer(BaseModel): + success: bool + message: str + data: Optional[Union[SubmissionInfo, ProgressInfo]] = Field(..., discriminator="kind") + + +class SubmissionError(Exception): + """The submission could not be completed for some reason.""" + + +def submit( + batch: Batch, + model_name: str, + num_steps: int, + client_comm: CommunicationChannel, + host_comm: CommunicationChannel, + foundry_client: AbstractFoundryClient, +) -> Generator[Batch, None, None]: + """Submit a request to Azure AI Foundry and retrieve the predictions. + + Args: + batch (:class:`aurora.Batch`): Initial condition. + model_name (str): Name of the model. This name must be available in + :mod:`aurora_foundry.common.model`. + num_steps (int): Number of prediction steps. + client_comm (:class:`aurora_foundry.common.comm.CommunicationChannel`): Channel that the + client uses to send and receive data. + host_comm (:class:`aurora_foundry.common.comm.CommunicationChannel`): Channel that the host + uses to send and receive data. + foundry_client (:class:`aurora_foundry.client.foundry.AbstractFoundryClient`): Client to + communicate with Azure Foundry AI. + + Yields: + :class:`aurora.Batch`: Predictions. + """ + if model_name not in models: + raise KeyError(f"Model `{model_name}` is not a valid model.") + + # Send a request to the endpoint to produce the predictions. + data = { + "request": { + "action": "submit", + "model_name": model_name, + "num_steps": num_steps, + "host_comm": host_comm.to_spec(), + } + } + answer = Answer(**foundry_client.score(data)) + if not answer.success: + raise SubmissionError(answer.message) + submission_info = answer.data + if not isinstance(submission_info, SubmissionInfo): + raise SubmissionError( + "Server returned no submission information. " + "Cannot determine task UUID to track tasks." + ) + task_uuid = submission_info.uuid + logger.info("Submitted request to endpoint.") + + # Send the initial condition over. + client_comm.send(batch, task_uuid, "input.nc") + + previous_progress: int = 0 + + while True: + # Check on the progress of the task. + data = {"request": {"action": "check", "uuid": task_uuid}} + answer = Answer(**foundry_client.score(data)) + if not answer.success: + raise SubmissionError(answer.message) + progress_info = answer.data + if not isinstance(progress_info, ProgressInfo): + raise SubmissionError( + "Server returned no progress information. " + "Cannot determine whether the task has been completed or not." + ) + + if progress_info.error: + raise SubmissionError(f"Task failed: {progress_info.error_info}") + + if progress_info.progress_percentage > previous_progress: + logger.info(f"Task progress update: {progress_info.progress_percentage}%.") + previous_progress = progress_info.progress_percentage + + if progress_info.completed: + logger.info("Task has been completed!") + break + + logger.info("Retrieving predictions.") + for prediction_name in iterate_prediction_files("prediction.nc", num_steps): + yield client_comm.receive(task_uuid, prediction_name) diff --git a/aurora/foundry/client/foundry.py b/aurora/foundry/client/foundry.py new file mode 100644 index 0000000..09e21e8 --- /dev/null +++ b/aurora/foundry/client/foundry.py @@ -0,0 +1,61 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import abc +import logging +import os +from typing import Literal + +import requests + +__all__ = ["AbstractFoundryClient", "FoundryClient"] + + +logger = logging.getLogger(__name__) + + +class AbstractFoundryClient(metaclass=abc.ABCMeta): + """A client to talk to Azure AI Foundry.""" + + @abc.abstractmethod + def score(self, data: dict) -> dict: + """Send `data` to the scoring path. + + Args: + data (dict): Data to send. + + Returns: + dict: Answer. + """ + + +class FoundryClient(AbstractFoundryClient): + def __init__(self, endpoint: str, token: str) -> None: + """Initialise. + + Args: + endpoint (str): URL to the endpoint. + token (str): Authorisation token. + """ + self.endpoint = endpoint + self.token = token + + def _req( + self, + method: Literal["POST", "GET"], + path: str, + data: dict | None = None, + ) -> requests.Response: + return requests.request( + method, + os.path.join(self.endpoint, path), + headers={ + "Authorization": f"Bearer {self.token}", + "Content-Type": "application/json", + }, + json=data, + ) + + def score(self, data: dict) -> dict: + answer = self._req("POST", "score", {"data": data}) + answer.raise_for_status() + return answer.json() diff --git a/aurora/foundry/common/__init__.py b/aurora/foundry/common/__init__.py new file mode 100644 index 0000000..a679a52 --- /dev/null +++ b/aurora/foundry/common/__init__.py @@ -0,0 +1 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" diff --git a/aurora/foundry/common/channel.py b/aurora/foundry/common/channel.py new file mode 100644 index 0000000..9b394a9 --- /dev/null +++ b/aurora/foundry/common/channel.py @@ -0,0 +1,254 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import abc +import json +import logging +import os +import subprocess +import tempfile +import time +from pathlib import Path +from typing import Generator, Literal + +from pydantic import BaseModel, HttpUrl + +from aurora import Batch + +__all__ = [ + "CommunicationChannel", + "LocalCommunication", + "BlobStorageCommunication", + "iterate_prediction_files", +] + +logger = logging.getLogger(__name__) + + +class CommunicationChannel: + """A communication channel for sending very large files.""" + + def send(self, batch: Batch, uuid: str, name: str) -> None: + """Send `batch` under the file name `name` and mark the file as done. + + Args: + batch (:class:`aurora.Batch`): Batch to send. + uuid (str): UUID of the task. + name (str): Name of `batch`. + """ + name = f"{uuid}/{name}" + self._send(batch, name) + self._mark(name) + + def receive(self, uuid: str, name: str) -> Batch: + """Receive the batch under the file name `name`. + + This function blocks until the file is ready. + + Args: + uuid (str): UUID of the task. + name (str): Name to receive. + + Returns: + :class:`aurora.Batch`: Batch under the name `name`. + """ + name = f"{uuid}/{name}" + while not self._is_marked(name): + time.sleep(0.5) + return self._receive(name) + + @abc.abstractmethod + def _send(self, batch: Batch, name: str) -> None: + """Send `batch` under the file name `name` without marking the file. + + This method should be implemented. + + Args: + batch (:class:`aurora.Batch`): Batch to send. + name (str): Name of `batch`. + """ + + @abc.abstractmethod + def _receive(self, name: str) -> Batch: + """Receive the batch under the file name `name`. + + This function asserts that the file is ready and should be implemented by implementations. + + Args: + name (str): Name to receive. + + Returns: + :class:`aurora.Batch`: Batch under the file name `name`. + """ + + @abc.abstractmethod + def _mark(self, name: str) -> None: + """Mark the file `name` as done. + + Args: + name (str): File to mark. + """ + + @abc.abstractmethod + def _is_marked(self, name: str) -> bool: + """Check whether the file `name` has been marked. + + Args: + name (str): File to check. + + Returns: + bool: Whether `name` has been marked or not. + """ + + @abc.abstractmethod + def to_spec(self) -> dict[str, str]: + """Convert this channel to specification that can be serialised into JSON. + + Returns: + dict[str, str]: Specification. + """ + + +class LocalCommunication(CommunicationChannel): + """A communication channel via a local folder.""" + + def __init__(self, folder: str | Path) -> None: + """Instantiate. + + Args: + folder (str or Path): Folder to use. + """ + self.folder = Path(folder) + + def to_spec(self) -> dict[str, str]: + return { + "class_name": "LocalCommunication", + "folder": str(self.folder), + } + + class Spec(BaseModel): + class_name: Literal["LocalCommunication"] + folder: Path + + def construct(self) -> "LocalCommunication": + return LocalCommunication(folder=str(self.folder)) + + def _send(self, batch: Batch, name: str) -> None: + target = self.folder / name + target.parent.mkdir(exist_ok=True, parents=True) + batch.to_netcdf(target) + + def _receive(self, name: str) -> Batch: + return Batch.from_netcdf(self.folder / name) + + def _mark(self, name: str) -> None: + target = self.folder / f"{name}.finished" + target.parent.mkdir(exist_ok=True, parents=True) + target.touch() + + def _is_marked(self, name: str) -> bool: + return (self.folder / f"{name}.finished").exists() + + +class BlobStorageCommunication(CommunicationChannel): + """A communication channel via a folder in a Azure Blob Storage container.""" + + _AZCOPY_EXECUTABLE: list[str] = ["azcopy"] + + def __init__(self, blob_folder: str) -> None: + """Instantiate. + + Args: + blob_folder (str): Folder to use. This must be a full URL that includes a SAS token + with read and write permissions. + """ + self.blob_folder = blob_folder + if "?" not in blob_folder: + raise ValueError("Given URL does not appear to contain a SAS token.") + + def to_spec(self) -> dict[str, str]: + return { + "class_name": "BlobStorageCommunication", + "blob_folder": self.blob_folder, + } + + class Spec(BaseModel): + class_name: Literal["BlobStorageCommunication"] + blob_folder: HttpUrl # TODO: Can we force this to be `https`? + + def construct(self) -> "BlobStorageCommunication": + return BlobStorageCommunication(blob_folder=str(self.blob_folder)) + + def _blob_path(self, name: str) -> str: + """For a given file name `name`, get the full path including the SAS token. + + Args: + name (str): File name. + + Returns: + str: Full path including the SAS token. + """ + url, sas = self.blob_folder.split("?", 1) + # Don't use `pathlib.Path` for web URLs! It messes up the protocol. + return f"{os.path.join(url, name)}?{sas}" + + def _azcopy(self, command: list[str]) -> str: + result = subprocess.run( + self._AZCOPY_EXECUTABLE + command, + stdout=subprocess.PIPE, + check=True, + ) + return result.stdout.decode("utf-8") + + def _send(self, batch: Batch, name: str) -> None: + with tempfile.NamedTemporaryFile() as tf: + batch.to_netcdf(tf.name) + self._azcopy(["copy", tf.name, self._blob_path(name)]) + + def _receive(self, name: str) -> Batch: + with tempfile.NamedTemporaryFile() as tf: + self._azcopy(["copy", self._blob_path(name), tf.name]) + return Batch.from_netcdf(tf.name) + + def _mark(self, name: str) -> None: + with tempfile.TemporaryDirectory() as td: + mark_file_path = Path(td) / f"{name}.finished" + mark_file_path.parent.mkdir(exist_ok=True, parents=True) + mark_file_path.touch() + self._azcopy(["copy", str(mark_file_path), self._blob_path(f"{name}.finished")]) + + def _is_marked(self, name: str) -> bool: + out = json.loads( + self._azcopy( + [ + "list", + self._blob_path(f"{name}.finished"), + "--output-type", + "json", + "--output-level", + "essential", + ] + ) + ) + return ( + len(out) == 2 + and isinstance(out[0], dict) + and out[0].get("MessageType", None) == "ListObject" + and isinstance(out[1], dict) + and out[1].get("MessageType", None) == "EndOfJob" + ) + + +def iterate_prediction_files(name: str, num_steps: int) -> Generator[str, None, None]: + """For a file name `name`, generate `num_steps` variations of `name`: one for every prediction + step. + + Args: + name (str): Base file name to derive the file names of the predictions from. + num_steps (int): Number of prediction steps. + + Yields: + str: For every prediction, the derived file name. + """ + name, ext = os.path.splitext(name) + for i in range(num_steps): + yield f"{name}-{i:03d}{ext}" diff --git a/aurora/foundry/common/model.py b/aurora/foundry/common/model.py new file mode 100644 index 0000000..f978725 --- /dev/null +++ b/aurora/foundry/common/model.py @@ -0,0 +1,93 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import abc +import logging +from typing import Generator + +import torch + +import aurora +from aurora import Batch, rollout + +__all__ = ["Model", "models"] + +logger = logging.getLogger(__name__) + +if torch.cuda.is_available(): + logger.info("GPU detected. Running on GPU.") + target_device = torch.device("cuda") +else: + logger.warning("No GPU available. Running on CPU.") + target_device = torch.device("cpu") + + +class Model(metaclass=abc.ABCMeta): + """A model that can run predictions.""" + + def __init__(self): + """Initialise. + + This creates and loads the model. + """ + self.model = self.create_model() + self.model.eval() + + @abc.abstractmethod + def create_model(self) -> aurora.Aurora: + """Create the model. + + Returns: + :class:`aurora.Aurora`: Model. + """ + + @torch.inference_mode + def run(self, batch: Batch, num_steps: int) -> Generator[Batch, None, None]: + """Perform predictions on the target device. + + Args: + batch (:class:`aurora.Batch`): Initial condition. + num_steps (int): Number of prediction steps. + + Returns: + :class:`aurora.Aurora`: Model. + """ + # Move batch and model to target device. + self.model.to(target_device) # Modifies in-place! + batch = batch.to(target_device) + + # Perform predictions, immediately moving the output to the CPU. + for pred in rollout(self.model, batch, steps=num_steps): + yield pred.to("cpu") + + # Move batch and model back to the CPU. + batch = batch.to("cpu") + self.model.cpu() # Modifies in-place! + + +class AuroraSmall(Model): + name = "aurora-0.25-small-pretrained" + """str: Name of the model.""" + + def create_model(self) -> aurora.Aurora: + model = aurora.AuroraSmall() + model.load_checkpoint("microsoft/aurora", "aurora-0.25-small-pretrained.ckpt") + return model + + +class AuroraFineTuned(Model): + name = "aurora-0.25-finetuned" + """str: Name of the model.""" + + def create_model(self) -> aurora.Aurora: + model = aurora.Aurora() + model.load_checkpoint("microsoft/aurora", "aurora-0.25-finetuned.ckpt") + return model + + +models: dict[str, type[Model]] = {} +"""dict[str, type[Model]]: A dictionary that lists all available models by their name.""" + +for model_class in Model.__subclasses__(): + assert hasattr(model_class, "name"), f"`{model_class.__name__}` is missing `name`." + # `mypy` will complain, because `Model` is abstract, so it cannot be passed to `type`. + models[model_class.name] = model_class # type: ignore[type-abstract] diff --git a/aurora/foundry/server/__init__.py b/aurora/foundry/server/__init__.py new file mode 100644 index 0000000..a44d891 --- /dev/null +++ b/aurora/foundry/server/__init__.py @@ -0,0 +1,3 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +from .score import * # noqa: F403 diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py new file mode 100644 index 0000000..dddc701 --- /dev/null +++ b/aurora/foundry/server/score.py @@ -0,0 +1,144 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import json +import logging +import time +from concurrent.futures import ThreadPoolExecutor +from typing import Literal, Union +from uuid import uuid4 + +from pydantic import BaseModel, Field + +from aurora.foundry.common.channel import ( + BlobStorageCommunication, + LocalCommunication, + iterate_prediction_files, +) +from aurora.foundry.common.model import models + +__all__ = ["init", "run"] + +# Need to give the name explicitly here, because the script may be run stand-alone. +logger = logging.getLogger("aurora.foundry.server.score") + +CommSpecs = Union[LocalCommunication.Spec, BlobStorageCommunication.Spec] + + +class Submission(BaseModel): + action: Literal["submit"] + host_comm: CommSpecs = Field(..., discriminator="class_name") + model_name: str + num_steps: int + + +class Check(BaseModel): + action: Literal["check"] + uuid: str + + +class Request(BaseModel): + request: Union[Submission, Check] = Field(..., discriminator="action") + + +POOL = ThreadPoolExecutor(max_workers=1) +TASKS = dict() + + +class Task: + def __init__(self, request: Submission): + self.request: Submission = request + # TODO: Make sure that this `uuid` really is unique! + self.uuid: str = str(uuid4()) + self.progress_percentage: int = 0 + self.completed: bool = False + self.exc: Exception | None = None + + def __call__(self) -> None: + try: + request = self.request + host_comm = request.host_comm.construct() + + model_class = models[request.model_name] + model = model_class() + + batch = host_comm.receive(self.uuid, "input.nc") + + logger.info("Running predictions.") + for i, (pred, path) in enumerate( + zip( + model.run(batch, request.num_steps), + iterate_prediction_files("prediction.nc", request.num_steps), + ) + ): + host_comm.send(pred, self.uuid, path) + self.progress_percentage = int((100 * (i + 1)) / request.num_steps) + + self.completed = True + + except Exception as exc: + self.exc = exc + + +def init() -> None: + """Initialise. Do not load the model here, because which model we need depends on the + request.""" + POOL.__enter__() + + +def run(raw_data: str) -> dict: + """Perform predictions. + + Args: + raw_data (str): Request as JSON. + + Returns: + dict: Answer, which will be encoded as JSON. + """ + logger.info("Received request.") + raw = json.loads(raw_data) + request = Request(**raw["data"]).request + + if isinstance(request, Submission): + logger.info("Submitting new task to thread pool.") + task = Task(request) + POOL.submit(task) + TASKS[task.uuid] = task + return { + "success": True, + "message": "Request has been succesfully submitted.", + "data": { + "kind": "submission_info", + "uuid": task.uuid, + }, + } + + elif isinstance(request, Check): + logger.info("Returning the status of an existing task.") + uuid = request.uuid + time.sleep(1) # Sleep here, so the client does not need to. + if uuid not in TASKS: + return { + "success": False, + "message": "Task UUID cannot be found.", + } + else: + task = TASKS[uuid] + return { + "success": True, + "message": "Status check completed.", + "data": { + "kind": "progress_info", + "uuid": uuid, + "completed": task.completed, + "progress_percentage": task.progress_percentage, + "error": task.exc is not None, + "error_info": str(task.exc) if task.exc else "", + }, + } + + else: + # This branch should be unreachable. + return { + "success": False, + "message": "Invalid action.", + } diff --git a/docs/_toc.yml b/docs/_toc.yml index 347b057..b22099d 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -1,13 +1,23 @@ format: jb-book root: intro -chapters: -- file: usage -- file: batch -- file: models -- file: beware -- file: finetuning -- file: example_era5 -- file: example_hres_t0 -- file: example_hres_0.1 -- file: ai_models_plugin -- file: api +parts: +- caption: Main Usage + chapters: + - file: usage + - file: batch + - file: models + - file: beware + - file: finetuning + - file: ai_models_plugin + - file: api +- caption: Examples + chapters: + - file: example_era5 + - file: example_hres_t0 + - file: example_hres_0.1 +- caption: Foundry + chapters: + - file: foundry/intro + - file: foundry/submission + - file: foundry/server + - file: foundry/api diff --git a/docs/example_era5.ipynb b/docs/example_era5.ipynb index 9ba76c2..85c8f29 100644 --- a/docs/example_era5.ipynb +++ b/docs/example_era5.ipynb @@ -5,7 +5,7 @@ "id": "b2f57a10-13a1-4f66-a734-065fc16b17b2", "metadata": {}, "source": [ - "# Example: Predictions for ERA5\n", + "# Predictions for ERA5\n", "\n", "In this example, we will download ERA5 data for 1 Jan 2023 at 0.25 degrees resolution and run Aurora on this data. The fine-tuned version of Aurora specifically only works with IFS HRES T0, so we use the non-fine-tuned version of Aurora in this example.\n", "\n", diff --git a/docs/example_hres_0.1.ipynb b/docs/example_hres_0.1.ipynb index ac9da5a..8ef076e 100644 --- a/docs/example_hres_0.1.ipynb +++ b/docs/example_hres_0.1.ipynb @@ -5,7 +5,7 @@ "id": "b2f57a10-13a1-4f66-a734-065fc16b17b2", "metadata": {}, "source": [ - "# Example: Predictions for HRES at 0.1 degrees\n", + "# Predictions for HRES at 0.1 degrees\n", "\n", "In this example, we will download IFS HRES analysis data at 0.1 degrees resolution for 11 May 2022 from the [Research Data Archive](https://rda.ucar.edu/datasets/d113001/#) and run Aurora on this data. We will use the version of Aurora that was fine-tuned on IFS HRES analysis at 0.1 degrees resolution.\n", "\n", diff --git a/docs/example_hres_t0.ipynb b/docs/example_hres_t0.ipynb index 314b8c6..d765158 100644 --- a/docs/example_hres_t0.ipynb +++ b/docs/example_hres_t0.ipynb @@ -5,7 +5,7 @@ "id": "b2f57a10-13a1-4f66-a734-065fc16b17b2", "metadata": {}, "source": [ - "# Example: Predictions for HRES T0\n", + "# Predictions for HRES T0\n", "\n", "In this example, we will download HRES T0 data for 11 May 2022 from [WeatherBench2](https://weatherbench2.readthedocs.io/) at 0.25 degrees resolution and run Aurora on this data. We will use the version of Aurora that was fine-tuned on IFS HRES T0 in this example.\n", "\n", diff --git a/docs/foundry/api.rst b/docs/foundry/api.rst new file mode 100644 index 0000000..1138439 --- /dev/null +++ b/docs/foundry/api.rst @@ -0,0 +1,29 @@ +Application Programming Interface +================================= + +Submission +---------- +.. autofunction:: aurora.foundry.client.api.submit + +.. autoclass:: aurora.foundry.client.foundry.FoundryClient + :members: __init__ + +.. autoclass:: aurora.foundry.common.channel.BlobStorageCommunication + :members: __init__ + + +Available Models +---------------- +These models need to be referred to by the value of their attribute `name`. + +.. autoclass:: aurora.foundry.common.model.AuroraFineTuned + :members: name + +.. autoclass:: aurora.foundry.common.model.AuroraSmall + :members: name + +Server +------ +.. autofunction:: aurora.foundry.server.score.init + +.. autofunction:: aurora.foundry.server.score.run diff --git a/docs/foundry/intro.md b/docs/foundry/intro.md new file mode 100644 index 0000000..f5076ce --- /dev/null +++ b/docs/foundry/intro.md @@ -0,0 +1,6 @@ +# Aurora on Azure AI Foundry + +Aurora can be run as a model on [Azure AI Foundry](https://learn.microsoft.com/en-us/azure/ai-studio/what-is-ai-studio). + +This part of the documentation describes how you can produce predictions with Aurora running on Foundry, +and how you can launch a server that hosts Aurora. diff --git a/docs/foundry/server.md b/docs/foundry/server.md new file mode 100644 index 0000000..ed7a4e8 --- /dev/null +++ b/docs/foundry/server.md @@ -0,0 +1,17 @@ +# Running the Inference Server + +Build the Docker image: + +```bash +make docker +``` + +The resulting image will be tagged as `aurora-foundry:latest`. +Upload this image to Azure AI foundry. + +Building the Docker image depends on a list of precompiled dependencies. +If you change the requirements in `pyproject.toml`, this list must be updated: + +```bash +make docker-requirements +``` diff --git a/docs/foundry/submission.md b/docs/foundry/submission.md new file mode 100644 index 0000000..a697314 --- /dev/null +++ b/docs/foundry/submission.md @@ -0,0 +1,66 @@ +# Submitting Predictions + +To produce predictions on Azure AI Foundry, the client will communicate through +a blob storage container, so `azcopy` needs to be available in the local path. +[See here for instructions on how to install `azcopy`.](https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-v10) + +First, create a client that can communicate with your Azure AI Foundry endpoint: + +```python +from aurora.foundry import FoundryClient + +foundry_client = FoundryClient( + endpoint="https://endpoint/", + token="TOKEN", +) +``` + +Then set up a way to communicate with the model running on Foundry. +You likely want to send data back and forth via a folder in a blob storage container: + +```python +from aurora.foundry import BlobStorageCommunication + +communication = BlobStorageCommunication( + "https://my.blob.core.windows.net/container/folder?" +) +``` + +The SAS token needs read, write, and list rights. +This API does not automatically delete the model initial condition and predictions that are +uploaded to the blob storage folder. +You will need to do that yourself. + +You can now submit requests in the following way: + +```python +from datetime import datetime + +import torch +from aurora import Batch, Metadata + +from aurora.foundry import submit + + +initial_condition = Batch( + surf_vars={k: torch.randn(1, 2, 17, 32) for k in ("2t", "10u", "10v", "msl")}, + static_vars={k: torch.randn(17, 32) for k in ("lsm", "z", "slt")}, + atmos_vars={k: torch.randn(1, 2, 4, 17, 32) for k in ("z", "u", "v", "t", "q")}, + metadata=Metadata( + lat=torch.linspace(90, -90, 17), + lon=torch.linspace(0, 360, 32 + 1)[:-1], + time=(datetime(2020, 6, 1, 12, 0),), + atmos_levels=(100, 250, 500, 850), + ), +) + +for pred in submit( + batch=initial_condition, + model_name="aurora-0.25-small-pretrained", + num_steps=4, + client=communication, + host=communication, + foundry_client=foundry_client, +): + pass # Do something with `pred`. +``` diff --git a/pyproject.toml b/pyproject.toml index 50c76e3..6a3c2bd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -18,11 +18,13 @@ authors = [ license = {file = "LICENSE.txt"} readme = "README.md" keywords = [ - "aurora model", + "aurora model", "atmospheric dynamics", - "atmospheric chemistry", - "deep learning", - "foundation models", + "atmospheric chemistry", + "ocean waves", + "tropical cyclone tracking", + "weather prediction", + "foundation models", ] classifiers = [ "Programming Language :: Python :: 3", @@ -38,6 +40,9 @@ dependencies = [ "einops", "timm==0.6.13", "huggingface-hub", + "pydantic", + "xarray", + "netcdf4", ] [project.optional-dependencies] @@ -52,8 +57,6 @@ dev = [ "pre-commit", "jupyter-book", "scipy", - "xarray", - "netcdf4", ] [project.urls] diff --git a/tests/foundry/__init__.py b/tests/foundry/__init__.py new file mode 100644 index 0000000..3bc61b3 --- /dev/null +++ b/tests/foundry/__init__.py @@ -0,0 +1,12 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import logging +import sys + +# Expose logging messages. +logger = logging.getLogger() +logger.setLevel("INFO") +stream_handler = logging.StreamHandler(sys.stderr) +formatter = logging.Formatter("[%(levelname)s] %(asctime)s %(name)s: %(message)s") +stream_handler.setFormatter(formatter) +logger.addHandler(stream_handler) diff --git a/tests/foundry/azcopy.py b/tests/foundry/azcopy.py new file mode 100644 index 0000000..1ea2368 --- /dev/null +++ b/tests/foundry/azcopy.py @@ -0,0 +1,74 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license. + +A mock of `azcopy` designed specifically for the tests here. +""" + +import json +import logging +import shutil +import sys +from pathlib import Path + +import click + +# Expose logging messages. +logger = logging.getLogger() +logger.setLevel("INFO") +stream_handler = logging.StreamHandler(sys.stderr) +formatter = logging.Formatter("[%(levelname)s] %(asctime)s %(name)s: %(message)s") +stream_handler.setFormatter(formatter) +logger.addHandler(stream_handler) + + +def _parse_path(path: str, work_path: Path) -> Path: + if path.startswith("https://"): + path, _ = path.split("?", 1) # Split off the SAS token. + _, path = path.split("blob.core.windows.net/", 1) # Split off the storage account URL. + return work_path / path + else: + # Just a local path. + return Path(path) + + +@click.command(context_settings=dict(ignore_unknown_options=True)) +@click.argument( + "work_path", + required=True, + type=click.Path( + exists=False, file_okay=False, dir_okay=True, resolve_path=True, path_type=Path + ), +) +@click.argument("args", nargs=-1, type=click.UNPROCESSED) +def main(work_path: Path, args: tuple[str, ...]) -> None: + assert len(args) >= 1 + + logger.info(f'Faking `azcopy` call: `azcopy {" ".join(args)}`.') + + if args[0] in {"ls", "list"}: + assert len(args) >= 2 + + path = _parse_path(args[1], work_path) + + out: list[dict[str, str]] = [] + if path.exists(): + out.append({"MessageType": "ListObject"}) + for _ in path.rglob("*"): + out.append({"MessageType": "ListObject"}) + out.append({"MessageType": "EndOfJob"}) + + print(json.dumps(out)) + + elif args[0] in {"cp", "copy"}: + assert len(args) == 3 + + source = _parse_path(args[1], work_path) + target = _parse_path(args[2], work_path) + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copy(source, target) + + else: + raise RuntimeError(f"Unknown command `{args[0]}`.") + + +if __name__ == "__main__": + main() diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py new file mode 100644 index 0000000..a5c6f53 --- /dev/null +++ b/tests/foundry/conftest.py @@ -0,0 +1,152 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import json +import subprocess +import time +from pathlib import Path +from typing import Callable, Generator + +import pytest +import requests + +from aurora.foundry.client.foundry import AbstractFoundryClient +from aurora.foundry.common.channel import BlobStorageCommunication, LocalCommunication + + +class MockFoundryClient(AbstractFoundryClient): + def __init__(self, f: Callable[[dict], dict]): + self.f = f + + def score(self, data: dict) -> dict: + return self.f(data) + + +@pytest.fixture( + params=[ + "subprocess-local", + "subprocess-blob", + "docker-local", + ] +) +def mock_foundry_client( + request, + monkeypatch, + tmp_path: Path, + capsys, +) -> Generator[dict, None, None]: + if "subprocess" in request.param: + # Already determine a possible working path for the mock of `azcopy`. It might not be used, + # but we do already need to determine it. + azcopy_mock_work_dir = tmp_path / "azcopy_work" + + # Create a subprocess that mocks the runner. + score_script_path = Path(__file__).parents[2] / "aurora/foundry/server/score.py" + runner_path = Path(__file__).parents[0] / "runner.py" + p = subprocess.Popen( + ["python", runner_path, azcopy_mock_work_dir, score_script_path], + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + ) + stdin = p.stdin + stdout = p.stdout + assert stdin is not None and stdout is not None + + def _mock_send(message: dict) -> dict: + # Message will be wrapped into the field `data`. + stdin.write(json.dumps({"data": message}).encode("unicode_escape")) + stdin.write(b"\n") + stdin.flush() + + output = stdout.readline() + if not output: + raise RuntimeError("Runner returned no answer. It likely crashed.") + + return json.loads(output.decode("unicode_escape")) + + # Now we decide whether we do communication locally or via blob storage. If we do + # communication via blob storage, we must mock `azcopy` too. + comm_folder = tmp_path / "communication" + + if "local" in request.param: + # Communicate via a local folder. + yield { + "client_comm": LocalCommunication(comm_folder), + "host_comm": LocalCommunication(comm_folder), + "foundry_client": MockFoundryClient(_mock_send), + } + + else: + # Communicate via blob storage, so mock `azcopy` too. + azcopy_path = Path(__file__).parents[0] / "azcopy.py" + monkeypatch.setattr( + BlobStorageCommunication, + "_AZCOPY_EXECUTABLE", + ["python", str(azcopy_path), str(azcopy_mock_work_dir)], + ) + # The below test URL must start with `https`! + blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" + yield { + "client_comm": BlobStorageCommunication(blob_url_with_sas), + "host_comm": BlobStorageCommunication(blob_url_with_sas), + "foundry_client": MockFoundryClient(_mock_send), + } + + # Kill the process upon teardown. + p.terminate() + p.wait() + + elif request.param == "docker-local": + client_comm_folder = tmp_path / "communication" + + # It's important to create the communication folder on the client side already. If we don't, + # Docker will create it, and the permissions will then be wrong. + client_comm_folder.mkdir(exist_ok=True, parents=True) + + # Run the Docker container. Assume that it has already been built. + p = subprocess.Popen( + [ + "docker", + "run", + "-p", + "5001:5001", + "--rm", + "-t", + "-v", + f"{client_comm_folder}:/communication", + "aurora-foundry:latest", + ], + ) + + # Wait for the server to come online. + start = time.time() + while True: + try: + res = requests.get("http://127.0.0.1:5001/") + res.raise_for_status() + except (requests.ConnectionError, requests.HTTPError) as e: + # Try for at most 10 seconds. + if time.time() - start < 10: + time.sleep(0.5) + continue + else: + raise e + break + + def _mock_send(message: dict) -> dict: + # The message will be wrapped in a field `data`. + res = requests.post("http://127.0.0.1:5001/score", data=json.dumps({"data": message})) + res.raise_for_status() + return json.loads(res.text) + + yield { + "client_comm": LocalCommunication(client_comm_folder), + "host_comm": LocalCommunication("/communication"), + "foundry_client": MockFoundryClient(_mock_send), + } + + # Kill the container upon teardown. + p.terminate() + p.wait() + + else: + raise ValueError(f"Bad Foundry mock mode: `{request.param}`.") diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py new file mode 100644 index 0000000..53dee9e --- /dev/null +++ b/tests/foundry/runner.py @@ -0,0 +1,66 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license. + +A mock of the Azure ML inference server for more simple testing. +""" + +import importlib.util as util +import json +import logging +import sys +from pathlib import Path + +import click + +# Expose logging messages. +logger = logging.getLogger() +logger.setLevel("INFO") +stream_handler = logging.StreamHandler(sys.stderr) +formatter = logging.Formatter("[%(levelname)s] %(asctime)s %(name)s: %(message)s") +stream_handler.setFormatter(formatter) +logger.addHandler(stream_handler) + + +@click.command() +@click.argument( + "azcopy_mock_work_path", + required=True, + type=click.Path( + exists=False, file_okay=False, dir_okay=True, resolve_path=True, path_type=Path + ), +) +@click.argument( + "path", + required=True, + type=click.Path(exists=True, file_okay=True, dir_okay=False, resolve_path=True, path_type=Path), +) +def main(azcopy_mock_work_path: Path, path: Path) -> None: + spec = util.spec_from_file_location("score", path) + assert spec is not None, "Could not load specification." + score = util.module_from_spec(spec) + assert score is not None, "Could not load module from specification." + assert spec.loader is not None, "Specification has no loader." + spec.loader.exec_module(score) + + # At this point, we mock `azcopy` too. + azcopy_path = Path(__file__).parents[0] / "azcopy.py" + sys.modules["aurora.foundry"].BlobStorageCommunication._AZCOPY_EXECUTABLE = [ + "python", + str(azcopy_path), + str(azcopy_mock_work_path), + ] + + score.init() + + while True: + raw_data = sys.stdin.readline() + raw_data = raw_data.encode("utf-8").decode("unicode_escape") + + answer = json.dumps(score.run(raw_data)) + + sys.stdout.write(answer.encode("unicode_escape").decode("utf-8")) + sys.stdout.write("\n") + sys.stdout.flush() + + +if __name__ == "__main__": + main() diff --git a/tests/foundry/test_api.py b/tests/foundry/test_api.py new file mode 100644 index 0000000..f84de0d --- /dev/null +++ b/tests/foundry/test_api.py @@ -0,0 +1,33 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +from datetime import datetime + +import torch + +from aurora import Batch, Metadata +from aurora.foundry import submit + + +def test_api(tmp_path, mock_foundry_client: dict): + batch = Batch( + surf_vars={k: torch.randn(1, 2, 17, 32) for k in ("2t", "10u", "10v", "msl")}, + static_vars={k: torch.randn(17, 32) for k in ("lsm", "z", "slt")}, + atmos_vars={k: torch.randn(1, 2, 4, 17, 32) for k in ("z", "u", "v", "t", "q")}, + metadata=Metadata( + lat=torch.linspace(90, -90, 17), + lon=torch.linspace(0, 360, 32 + 1)[:-1], + time=(datetime(2020, 6, 1, 12, 0),), + atmos_levels=(100, 250, 500, 850), + ), + ) + + for i, pred in enumerate( + submit( + batch=batch, + model_name="aurora-0.25-small-pretrained", + num_steps=4, + **mock_foundry_client, + ) + ): + assert isinstance(pred, Batch) + assert pred.metadata.rollout_step == i + 1 From 1176d6f2c142369cb607420f71936132d91d2f98 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Wed, 8 Jan 2025 15:07:47 +0100 Subject: [PATCH 02/44] Fix Docker requirements --- Dockerfile | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/Dockerfile b/Dockerfile index c7e4725..3ba30b1 100644 --- a/Dockerfile +++ b/Dockerfile @@ -6,11 +6,11 @@ COPY ./pyproject.toml . # Assuming dependencies are fairly fixed, we can install them first and then copy the rest of the # code to avoid re-installing dependencies when the code changes. -COPY requirements.txt . +COPY _docker_requirements.txt . RUN pip install --upgrade pip virtualenv && \ virtualenv venv -p python3.10 && \ . venv/bin/activate && \ - pip install -r requirements.txt + pip install -r _docker_requirements.txt # Download model weights. RUN ./venv/bin/python -c 'from huggingface_hub import hf_hub_download; hf_hub_download(repo_id="microsoft/aurora", filename="aurora-0.25-small-pretrained.ckpt")' && \ @@ -25,7 +25,6 @@ RUN [ ! -z "${AURORA_REPO_VERSION}" ] || { echo "AURORA_REPO_VERSION must be set . venv/bin/activate && \ SETUPTOOLS_SCM_PRETEND_VERSION="$AURORA_REPO_VERSION" pip install -e . - # Install `azcopy` and the AML inference server. RUN wget https://aka.ms/downloadazcopy-v10-linux -O azcopy.tar.gz && \ cp $(tar -xvzf azcopy.tar.gz | grep azcopy$) /usr/local/bin/azcopy From fe534cf793a13c0c8e593dbd9ed159373175c62f Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Wed, 8 Jan 2025 15:34:02 +0100 Subject: [PATCH 03/44] add swagger3.json --- aurora/foundry/server/swagger3.json | 278 ++++++++++++++++++++++++++++ 1 file changed, 278 insertions(+) create mode 100644 aurora/foundry/server/swagger3.json diff --git a/aurora/foundry/server/swagger3.json b/aurora/foundry/server/swagger3.json new file mode 100644 index 0000000..1f7ce6e --- /dev/null +++ b/aurora/foundry/server/swagger3.json @@ -0,0 +1,278 @@ +{ + "openapi": "3.1.0", + "info": { + "title": "Aurora Endpoint", + "version": "0.1.0" + }, + "paths": { + "/": { + "get": { + "summary": "Check if alive", + "operationId": "ServiceHealthCheck", + "description": "Simple health check endpoint to ensure the service is up at any given point.", + "responses": { + "200": { + "description": "If service is up and running, this response will be returned with the content 'Healthy'", + "content": { + "text/plain": { + "schema": { + "type": "string", + "examples": [ + "Healthy" + ] + } + } + } + }, + "default": { + "description": "The service failed to execute due to an error.", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ErrorResponse" + } + } + } + } + } + } + }, + "/score/": { + "post": { + "summary": "Create Task", + "operationId": "create_item_score__post", + "requestBody": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateTask" + } + } + }, + "required": true + }, + "responses": { + "200": { + "description": "Successful Response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CreateTaskResponse" + } + } + } + }, + "422": { + "description": "Validation Error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" + } + } + } + } + } + }, + "get": { + "summary": "Fetch Result of a Task", + "operationId": "get_item_score_post", + "parameters": [ + { + "name": "taskId", + "in": "query", + "required": true, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "description": "Successfull Response", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/Answer" + } + } + } + } + } + } + } + }, + "components": { + "schemas": { + "CreateTaskResponse": { + "properties": { + "success": { + "type": "boolean", + "title": "Success" + }, + "message": { + "type": "string", + "title": "Message" + }, + "taskId": { + "type": "string", + "title": "Task ID" + } + } + }, + "ErrorResponse": { + "properties": { + "message": { + "type": "string" + } + } + }, + "Answer": { + "properties": { + "success": { + "type": "boolean", + "title": "Success" + }, + "message": { + "type": "string", + "title": "Message" + }, + "data": { + "$ref": "#/components/schemas/ProgressInfo", + "title": "Data" + } + }, + "type": "object", + "required": [ + "success", + "message", + "data" + ], + "title": "Answer" + }, + "HTTPValidationError": { + "properties": { + "detail": { + "items": { + "$ref": "#/components/schemas/ValidationError" + }, + "type": "array", + "title": "Detail" + } + }, + "type": "object", + "title": "HTTPValidationError" + }, + "ProgressInfo": { + "properties": { + "kind": { + "const": "progress_info", + "title": "Kind" + }, + "uuid": { + "type": "string", + "title": "Uuid" + }, + "completed": { + "type": "boolean", + "title": "Completed" + }, + "progress_percentage": { + "type": "integer", + "title": "Progress Percentage" + }, + "error": { + "type": "boolean", + "title": "Error" + }, + "error_info": { + "type": "string", + "title": "Error Info" + } + }, + "type": "object", + "title": "ProgressInfo" + }, + "CreateTask": { + "properties": { + "model_name": { + "type": "string", + "title": "Model Name" + }, + "num_steps": { + "type": "integer", + "title": "Num Steps" + }, + "client_comm": { + "type": "string", + "title": "Client Comm" + }, + "host_comm": { + "type": "string", + "title": "Host Comm" + } + }, + "type": "object", + "required": [ + "request" + ], + "title": "CreateTask" + }, + "SubmissionInfo": { + "properties": { + "kind": { + "const": "submission_info", + "title": "Kind" + }, + "uuid": { + "type": "string", + "title": "Uuid" + } + }, + "type": "object", + "title": "SubmissionInfo" + }, + "ValidationError": { + "properties": { + "loc": { + "items": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "integer" + } + ] + }, + "type": "array", + "title": "Location" + }, + "msg": { + "type": "string", + "title": "Message" + }, + "type": { + "type": "string", + "title": "Error Type" + } + }, + "type": "object", + "required": [ + "loc", + "msg", + "type" + ], + "title": "ValidationError" + }, + "securitySchemes": { + "Bearer": { + "type": "apiKey", + "name": "Authorization", + "in": "header", + "description": "For example Bearer abc123" + } + } + } + } +} From 18efcdc41979acedc71340ef248803f15dd6b050 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Wed, 8 Jan 2025 23:32:27 +0100 Subject: [PATCH 04/44] place swagger correctly, incorporate feedback --- Dockerfile | 4 ++++ aurora/foundry/server/swagger3.json | 23 +++++++++++++++++++---- 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/Dockerfile b/Dockerfile index 3ba30b1..1155993 100644 --- a/Dockerfile +++ b/Dockerfile @@ -35,4 +35,8 @@ RUN . ./venv/bin/activate && \ EXPOSE 5001 ENV PORT=5001 +# we don't have a swagger2.json file, so we'll just "ignore" the version option and always return a version 3 file +RUN cp ./aurora/foundry/server/swagger3.json ./swagger3.json +RUN cp ./aurora/foundry/server/swagger3.json ./swagger2.json + CMD ["./venv/bin/azmlinfsrv", "--entry_script", "aurora/foundry/server/score.py"] diff --git a/aurora/foundry/server/swagger3.json b/aurora/foundry/server/swagger3.json index 1f7ce6e..e8db81a 100644 --- a/aurora/foundry/server/swagger3.json +++ b/aurora/foundry/server/swagger3.json @@ -4,6 +4,11 @@ "title": "Aurora Endpoint", "version": "0.1.0" }, + "security": [ + { + "Bearer": [] + } + ], "paths": { "/": { "get": { @@ -37,8 +42,13 @@ } } }, - "/score/": { + "/score": { "post": { + "security": [ + { + "Bearer": [] + } + ], "summary": "Create Task", "operationId": "create_item_score__post", "requestBody": { @@ -75,11 +85,16 @@ } }, "get": { - "summary": "Fetch Result of a Task", + "security": [ + { + "Bearer": [] + } + ], + "summary": "Fetch Progress of a Task", "operationId": "get_item_score_post", "parameters": [ { - "name": "taskId", + "name": "task_id", "in": "query", "required": true, "schema": { @@ -114,7 +129,7 @@ "type": "string", "title": "Message" }, - "taskId": { + "task_id": { "type": "string", "title": "Task ID" } From deb9955221ad46da2cc351cfe7d588f2bb129642 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Wed, 8 Jan 2025 23:36:13 +0100 Subject: [PATCH 05/44] minor --- Dockerfile | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/Dockerfile b/Dockerfile index 1155993..8d5a518 100644 --- a/Dockerfile +++ b/Dockerfile @@ -36,7 +36,10 @@ EXPOSE 5001 ENV PORT=5001 # we don't have a swagger2.json file, so we'll just "ignore" the version option and always return a version 3 file -RUN cp ./aurora/foundry/server/swagger3.json ./swagger3.json -RUN cp ./aurora/foundry/server/swagger3.json ./swagger2.json +RUN cp ./aurora/foundry/server/swagger3.json ./swagger2.json && \ + cp ./aurora/foundry/server/swagger3.json ./swagger2.0.json && \ + cp ./aurora/foundry/server/swagger3.json ./swagger3.1.json && \ + cp ./aurora/foundry/server/swagger3.json ./swagger3.0.json && \ + cp ./aurora/foundry/server/swagger3.json ./swagger3.json CMD ["./venv/bin/azmlinfsrv", "--entry_script", "aurora/foundry/server/score.py"] From fb30897686939cce28e59dc0ee48b4b5f382905f Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 00:20:56 +0100 Subject: [PATCH 06/44] reorganize Dockerfile for faster iteration --- Dockerfile | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Dockerfile b/Dockerfile index 8d5a518..fe3c726 100644 --- a/Dockerfile +++ b/Dockerfile @@ -16,21 +16,21 @@ RUN pip install --upgrade pip virtualenv && \ RUN ./venv/bin/python -c 'from huggingface_hub import hf_hub_download; hf_hub_download(repo_id="microsoft/aurora", filename="aurora-0.25-small-pretrained.ckpt")' && \ ./venv/bin/python -c 'from huggingface_hub import hf_hub_download; hf_hub_download(repo_id="microsoft/aurora", filename="aurora-0.25-finetuned.ckpt")' -COPY ./aurora ./aurora COPY ./LICENSE.txt . COPY ./README.md . -ARG AURORA_REPO_VERSION -RUN [ ! -z "${AURORA_REPO_VERSION}" ] || { echo "AURORA_REPO_VERSION must be set."; exit 1; } && \ - . venv/bin/activate && \ - SETUPTOOLS_SCM_PRETEND_VERSION="$AURORA_REPO_VERSION" pip install -e . - # Install `azcopy` and the AML inference server. RUN wget https://aka.ms/downloadazcopy-v10-linux -O azcopy.tar.gz && \ cp $(tar -xvzf azcopy.tar.gz | grep azcopy$) /usr/local/bin/azcopy RUN . ./venv/bin/activate && \ pip install azureml-inference-server-http +COPY ./aurora ./aurora +ARG AURORA_REPO_VERSION +RUN [ ! -z "${AURORA_REPO_VERSION}" ] || { echo "AURORA_REPO_VERSION must be set."; exit 1; } && \ + . venv/bin/activate && \ + SETUPTOOLS_SCM_PRETEND_VERSION="$AURORA_REPO_VERSION" pip install -e . + # Make port 5001 available to the world outside this container. EXPOSE 5001 ENV PORT=5001 From 5ffd9f3c367b1062025bebfba65c841d4be5639a Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 00:21:24 +0100 Subject: [PATCH 07/44] dispatch based on HTTP method --- aurora/foundry/client/foundry.py | 2 +- aurora/foundry/server/score.py | 25 +++++++++++++------------ 2 files changed, 14 insertions(+), 13 deletions(-) diff --git a/aurora/foundry/client/foundry.py b/aurora/foundry/client/foundry.py index 09e21e8..a115880 100644 --- a/aurora/foundry/client/foundry.py +++ b/aurora/foundry/client/foundry.py @@ -56,6 +56,6 @@ def _req( ) def score(self, data: dict) -> dict: - answer = self._req("POST", "score", {"data": data}) + answer = self._req("POST", "score", data) answer.raise_for_status() return answer.json() diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index dddc701..f76c226 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -6,6 +6,9 @@ from concurrent.futures import ThreadPoolExecutor from typing import Literal, Union from uuid import uuid4 +from azureml_inference_server_http.api.aml_response import AMLResponse +from azureml_inference_server_http.api.aml_request import AMLRequest +from azureml_inference_server_http.api.aml_request import rawhttp from pydantic import BaseModel, Field @@ -85,7 +88,8 @@ def init() -> None: POOL.__enter__() -def run(raw_data: str) -> dict: +@rawhttp +def run(input_data: AMLRequest) -> dict: """Perform predictions. Args: @@ -95,12 +99,12 @@ def run(raw_data: str) -> dict: dict: Answer, which will be encoded as JSON. """ logger.info("Received request.") - raw = json.loads(raw_data) - request = Request(**raw["data"]).request - - if isinstance(request, Submission): + if input_data.method == "POST": logger.info("Submitting new task to thread pool.") - task = Task(request) + try: + task = Task(**input_data.get_json()) + except Exception as exc: + return AMLResponse(dict(message=str(exc)), 500, {}, json_str=True) POOL.submit(task) TASKS[task.uuid] = task return { @@ -112,9 +116,9 @@ def run(raw_data: str) -> dict: }, } - elif isinstance(request, Check): + elif input_data.method == "GET": logger.info("Returning the status of an existing task.") - uuid = request.uuid + uuid = input_data.args.get("task_id") time.sleep(1) # Sleep here, so the client does not need to. if uuid not in TASKS: return { @@ -138,7 +142,4 @@ def run(raw_data: str) -> dict: else: # This branch should be unreachable. - return { - "success": False, - "message": "Invalid action.", - } + return AMLRequest(dict(message="Method not allowed."), 405, {}, json_str=True) From 00e49aa4d08a82305496a34420ad2fabeb7df78f Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 00:28:41 +0100 Subject: [PATCH 08/44] minor --- aurora/foundry/server/score.py | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-) diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index f76c226..63f05eb 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -1,6 +1,5 @@ """Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" -import json import logging import time from concurrent.futures import ThreadPoolExecutor @@ -28,7 +27,6 @@ class Submission(BaseModel): - action: Literal["submit"] host_comm: CommSpecs = Field(..., discriminator="class_name") model_name: str num_steps: int @@ -39,10 +37,6 @@ class Check(BaseModel): uuid: str -class Request(BaseModel): - request: Union[Submission, Check] = Field(..., discriminator="action") - - POOL = ThreadPoolExecutor(max_workers=1) TASKS = dict() @@ -102,7 +96,7 @@ def run(input_data: AMLRequest) -> dict: if input_data.method == "POST": logger.info("Submitting new task to thread pool.") try: - task = Task(**input_data.get_json()) + task = Task(Submission(**input_data.get_json())) except Exception as exc: return AMLResponse(dict(message=str(exc)), 500, {}, json_str=True) POOL.submit(task) @@ -119,7 +113,8 @@ def run(input_data: AMLRequest) -> dict: elif input_data.method == "GET": logger.info("Returning the status of an existing task.") uuid = input_data.args.get("task_id") - time.sleep(1) # Sleep here, so the client does not need to. + if not uuid: + return AMLRequest(dict(message="Missing task_id query parameter."), 400, {}, json_str=True) if uuid not in TASKS: return { "success": False, @@ -127,6 +122,12 @@ def run(input_data: AMLRequest) -> dict: } else: task = TASKS[uuid] + # Allow the task some time to complete. + # We sleep here so the client does not query too frequently. + for _ in range(3): + if task.completed: + break + time.sleep(1) return { "success": True, "message": "Status check completed.", From 7eee7ed97afb52ea34a66a386afe023f521dd20e Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 00:38:15 +0100 Subject: [PATCH 09/44] docstr --- aurora/foundry/server/score.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 63f05eb..3a4007b 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -87,10 +87,10 @@ def run(input_data: AMLRequest) -> dict: """Perform predictions. Args: - raw_data (str): Request as JSON. + input_data (AMLRequest): Mostly a Flask Request object. Returns: - dict: Answer, which will be encoded as JSON. + dict/AMLResponse: The response to the request. dicts are implictitly 200 AMLResponses. """ logger.info("Received request.") if input_data.method == "POST": From f0af8d0cec0de33352bb8e9336af2ad9bcfe313e Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 09:35:44 +0100 Subject: [PATCH 10/44] linting --- aurora/foundry/server/score.py | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 3a4007b..f895444 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -5,10 +5,9 @@ from concurrent.futures import ThreadPoolExecutor from typing import Literal, Union from uuid import uuid4 -from azureml_inference_server_http.api.aml_response import AMLResponse -from azureml_inference_server_http.api.aml_request import AMLRequest -from azureml_inference_server_http.api.aml_request import rawhttp +from azureml_inference_server_http.api.aml_request import AMLRequest, rawhttp +from azureml_inference_server_http.api.aml_response import AMLResponse from pydantic import BaseModel, Field from aurora.foundry.common.channel import ( @@ -114,7 +113,12 @@ def run(input_data: AMLRequest) -> dict: logger.info("Returning the status of an existing task.") uuid = input_data.args.get("task_id") if not uuid: - return AMLRequest(dict(message="Missing task_id query parameter."), 400, {}, json_str=True) + return AMLRequest( + dict(message="Missing task_id query parameter."), + 400, + {}, + json_str=True, + ) if uuid not in TASKS: return { "success": False, From 26a9a983f09d20e7a7baf39b2d2dfdc9de95c8b9 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 10:18:22 +0100 Subject: [PATCH 11/44] update api.py --- aurora/foundry/client/api.py | 27 +++++++-------------------- aurora/foundry/client/foundry.py | 22 +++++++++++++++++++--- 2 files changed, 26 insertions(+), 23 deletions(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index 2159889..71e2755 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -73,23 +73,18 @@ def submit( # Send a request to the endpoint to produce the predictions. data = { "request": { - "action": "submit", "model_name": model_name, "num_steps": num_steps, "host_comm": host_comm.to_spec(), } } - answer = Answer(**foundry_client.score(data)) - if not answer.success: - raise SubmissionError(answer.message) - submission_info = answer.data - if not isinstance(submission_info, SubmissionInfo): - raise SubmissionError( - "Server returned no submission information. " - "Cannot determine task UUID to track tasks." - ) + response = foundry_client.submit_task(data) + try: + submission_info = SubmissionInfo(**response) + except Exception as e: + raise SubmissionError(response["message"]) from e task_uuid = submission_info.uuid - logger.info("Submitted request to endpoint.") + logger.info("Submitted task %r to endpoint.", task_uuid) # Send the initial condition over. client_comm.send(batch, task_uuid, "input.nc") @@ -99,15 +94,7 @@ def submit( while True: # Check on the progress of the task. data = {"request": {"action": "check", "uuid": task_uuid}} - answer = Answer(**foundry_client.score(data)) - if not answer.success: - raise SubmissionError(answer.message) - progress_info = answer.data - if not isinstance(progress_info, ProgressInfo): - raise SubmissionError( - "Server returned no progress information. " - "Cannot determine whether the task has been completed or not." - ) + progress_info = ProgressInfo(**foundry_client.get_progress(task_uuid)) if progress_info.error: raise SubmissionError(f"Task failed: {progress_info.error_info}") diff --git a/aurora/foundry/client/foundry.py b/aurora/foundry/client/foundry.py index a115880..21c46f5 100644 --- a/aurora/foundry/client/foundry.py +++ b/aurora/foundry/client/foundry.py @@ -17,14 +17,25 @@ class AbstractFoundryClient(metaclass=abc.ABCMeta): """A client to talk to Azure AI Foundry.""" @abc.abstractmethod - def score(self, data: dict) -> dict: + def submit_task(self, data: dict) -> dict: """Send `data` to the scoring path. Args: data (dict): Data to send. Returns: - dict: Answer. + dict: SubmissionInfo. + """ + + @abc.abstractmethod + def get_progress(self, task_id: str) -> dict: + """Get the progress of the task. + + Args: + task_id (str): Task ID to get progress info for. + + Returns: + dict: ProgressInfo. """ @@ -55,7 +66,12 @@ def _req( json=data, ) - def score(self, data: dict) -> dict: + def submit_task(self, data: dict) -> dict: answer = self._req("POST", "score", data) answer.raise_for_status() return answer.json() + + def get_progress(self, task_id: str) -> dict: + answer = self._req("GET", f"score?task_id={task_id}") + answer.raise_for_status() + return answer.json() From bc3a19aab54c68185382a8c86bd6d63d35fbf975 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 10:19:23 +0100 Subject: [PATCH 12/44] simplify --- aurora/foundry/client/api.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index 71e2755..79afe6e 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -71,14 +71,12 @@ def submit( raise KeyError(f"Model `{model_name}` is not a valid model.") # Send a request to the endpoint to produce the predictions. - data = { - "request": { - "model_name": model_name, - "num_steps": num_steps, - "host_comm": host_comm.to_spec(), - } + task = { + "model_name": model_name, + "num_steps": num_steps, + "host_comm": host_comm.to_spec(), } - response = foundry_client.submit_task(data) + response = foundry_client.submit_task(task) try: submission_info = SubmissionInfo(**response) except Exception as e: @@ -93,7 +91,6 @@ def submit( while True: # Check on the progress of the task. - data = {"request": {"action": "check", "uuid": task_uuid}} progress_info = ProgressInfo(**foundry_client.get_progress(task_uuid)) if progress_info.error: From 70371381b5abeaeaa93c406cde601f08a25fc3fd Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 11:17:09 +0100 Subject: [PATCH 13/44] WIP --- pyproject.toml | 1 + tests/foundry/conftest.py | 203 ++++++++++++++++++++------------------ 2 files changed, 108 insertions(+), 96 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 6a3c2bd..8d773ef 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,6 +55,7 @@ dev = [ "mypy", "ruff==0.4.1", "pre-commit", + "requests_mock", "jupyter-book", "scipy", ] diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index a5c6f53..a5120e0 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -3,22 +3,61 @@ import json import subprocess import time +from contextlib import contextmanager from pathlib import Path -from typing import Callable, Generator +from typing import Generator import pytest import requests -from aurora.foundry.client.foundry import AbstractFoundryClient +from aurora.foundry.client.foundry import FoundryClient from aurora.foundry.common.channel import BlobStorageCommunication, LocalCommunication - -class MockFoundryClient(AbstractFoundryClient): - def __init__(self, f: Callable[[dict], dict]): - self.f = f - - def score(self, data: dict) -> dict: - return self.f(data) +MOCK_ADDRESS = "https://mock-foundry.azurewebsites.net" + + +@contextmanager +def runner_process(): + score_script_path = Path(__file__).parents[2] / "aurora/foundry/server/score.py" + runner_path = Path(__file__).parents[0] / "runner.py" + p = subprocess.Popen( + ["python", runner_path, score_script_path], + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + ) + stdin = p.stdin + stdout = p.stdout + assert stdin is not None and stdout is not None + yield p, stdin, stdout + p.terminate() + p.wait() + + +@contextmanager +def mock_foundry_responses_subprocess(stdin, stdout, requests_mock, base_address=MOCK_ADDRESS): + def _mock_send(request, context) -> dict: + method = request.method.encode("unicode_escape") + stdin.write(method + b"\n") + stdin.write(method.url + b"\n") + stdin.write(request.text().encode("unicode_escape") + b"\n") + stdin.flush() + + output = stdout.readline() + if not output: + raise RuntimeError("Runner returned no answer. It likely crashed.") + + return json.loads(output.decode("unicode_escape")) + + task_uuid = "mock-uuid" + requests_mock.post( + f"{base_address}/score", + json=_mock_send, + ) + requests_mock.get( + f"{base_address}/score?uuid={task_uuid}", + json=_mock_send, + ) + yield @pytest.fixture( @@ -31,69 +70,47 @@ def score(self, data: dict) -> dict: def mock_foundry_client( request, monkeypatch, + requests_mock, tmp_path: Path, - capsys, ) -> Generator[dict, None, None]: + azcopy_mock_work_dir = tmp_path / "azcopy_work" + if "subprocess" in request.param: # Already determine a possible working path for the mock of `azcopy`. It might not be used, # but we do already need to determine it. - azcopy_mock_work_dir = tmp_path / "azcopy_work" - - # Create a subprocess that mocks the runner. - score_script_path = Path(__file__).parents[2] / "aurora/foundry/server/score.py" - runner_path = Path(__file__).parents[0] / "runner.py" - p = subprocess.Popen( - ["python", runner_path, azcopy_mock_work_dir, score_script_path], - stdin=subprocess.PIPE, - stdout=subprocess.PIPE, - ) - stdin = p.stdin - stdout = p.stdout - assert stdin is not None and stdout is not None - - def _mock_send(message: dict) -> dict: - # Message will be wrapped into the field `data`. - stdin.write(json.dumps({"data": message}).encode("unicode_escape")) - stdin.write(b"\n") - stdin.flush() - - output = stdout.readline() - if not output: - raise RuntimeError("Runner returned no answer. It likely crashed.") - return json.loads(output.decode("unicode_escape")) - - # Now we decide whether we do communication locally or via blob storage. If we do - # communication via blob storage, we must mock `azcopy` too. - comm_folder = tmp_path / "communication" - - if "local" in request.param: - # Communicate via a local folder. - yield { - "client_comm": LocalCommunication(comm_folder), - "host_comm": LocalCommunication(comm_folder), - "foundry_client": MockFoundryClient(_mock_send), - } - - else: - # Communicate via blob storage, so mock `azcopy` too. - azcopy_path = Path(__file__).parents[0] / "azcopy.py" - monkeypatch.setattr( - BlobStorageCommunication, - "_AZCOPY_EXECUTABLE", - ["python", str(azcopy_path), str(azcopy_mock_work_dir)], - ) - # The below test URL must start with `https`! - blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" - yield { - "client_comm": BlobStorageCommunication(blob_url_with_sas), - "host_comm": BlobStorageCommunication(blob_url_with_sas), - "foundry_client": MockFoundryClient(_mock_send), - } - - # Kill the process upon teardown. - p.terminate() - p.wait() + with runner_process() as (p, stdin, stdout), mock_foundry_responses_subprocess( + stdin, stdout, requests_mock + ): + # Now we decide whether we do communication locally or via blob storage. If we do + # communication via blob storage, we must mock `azcopy` too. + comm_folder = tmp_path / "communication" + + if "local" in request.param: + # Communicate via a local folder. + yield { + "client_comm": LocalCommunication(comm_folder), + "host_comm": LocalCommunication(comm_folder), + "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), + } + + else: + # Communicate via blob storage, so mock `azcopy` too. + azcopy_path = Path(__file__).parents[0] / "azcopy.py" + monkeypatch.setattr( + BlobStorageCommunication, + "_AZCOPY_EXECUTABLE", + ["python", str(azcopy_path), str(azcopy_mock_work_dir)], + ) + # The below test URL must start with `https`! + blob_url_with_sas = ( + "https://storageaccount.blob.core.windows.net/container/folder?SAS" + ) + yield { + "client_comm": BlobStorageCommunication(blob_url_with_sas), + "host_comm": BlobStorageCommunication(blob_url_with_sas), + "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), + } elif request.param == "docker-local": client_comm_folder = tmp_path / "communication" @@ -116,37 +133,31 @@ def _mock_send(message: dict) -> dict: "aurora-foundry:latest", ], ) + try: + # Wait for the server to come online. + start = time.time() + while True: + try: + res = requests.get("http://127.0.0.1:5001/") + res.raise_for_status() + except (requests.ConnectionError, requests.HTTPError) as e: + # Try for at most 10 seconds. + if time.time() - start < 10: + time.sleep(0.5) + continue + else: + raise e + break + + yield { + "client_comm": LocalCommunication(client_comm_folder), + "host_comm": LocalCommunication("/communication"), + "foundry_client": FoundryClient("https://127.0.0.1:5001", "mock-token"), + } - # Wait for the server to come online. - start = time.time() - while True: - try: - res = requests.get("http://127.0.0.1:5001/") - res.raise_for_status() - except (requests.ConnectionError, requests.HTTPError) as e: - # Try for at most 10 seconds. - if time.time() - start < 10: - time.sleep(0.5) - continue - else: - raise e - break - - def _mock_send(message: dict) -> dict: - # The message will be wrapped in a field `data`. - res = requests.post("http://127.0.0.1:5001/score", data=json.dumps({"data": message})) - res.raise_for_status() - return json.loads(res.text) - - yield { - "client_comm": LocalCommunication(client_comm_folder), - "host_comm": LocalCommunication("/communication"), - "foundry_client": MockFoundryClient(_mock_send), - } - - # Kill the container upon teardown. - p.terminate() - p.wait() + finally: + p.terminate() + p.wait() else: raise ValueError(f"Bad Foundry mock mode: `{request.param}`.") From cb2f8cc56666881399c2e8bc7f08be37a7bbff5e Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 12:13:44 +0100 Subject: [PATCH 14/44] WIP --- aurora/foundry/client/api.py | 13 +++---------- aurora/foundry/server/score.py | 7 +------ 2 files changed, 4 insertions(+), 16 deletions(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index 79afe6e..a597cf6 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -4,9 +4,9 @@ """ import logging -from typing import Generator, Literal, Optional, Union +from typing import Generator, Literal -from pydantic import BaseModel, Field +from pydantic import BaseModel from aurora import Batch from aurora.foundry.client.foundry import AbstractFoundryClient @@ -19,8 +19,7 @@ class SubmissionInfo(BaseModel): - kind: Literal["submission_info"] - uuid: str + task_id: str class ProgressInfo(BaseModel): @@ -32,12 +31,6 @@ class ProgressInfo(BaseModel): error_info: str -class Answer(BaseModel): - success: bool - message: str - data: Optional[Union[SubmissionInfo, ProgressInfo]] = Field(..., discriminator="kind") - - class SubmissionError(Exception): """The submission could not be completed for some reason.""" diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index f895444..04d8ecb 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -101,12 +101,7 @@ def run(input_data: AMLRequest) -> dict: POOL.submit(task) TASKS[task.uuid] = task return { - "success": True, - "message": "Request has been succesfully submitted.", - "data": { - "kind": "submission_info", - "uuid": task.uuid, - }, + "task_id": task.uuid, } elif input_data.method == "GET": From d0fe591beb1643b4f81e53cedd82ad98deac4ef7 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 12:14:11 +0100 Subject: [PATCH 15/44] WIP --- tests/foundry/conftest.py | 12 +++++++----- tests/foundry/runner.py | 30 ++++++++++++++++++++++++++---- 2 files changed, 33 insertions(+), 9 deletions(-) diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index a5120e0..97b4561 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -17,11 +17,11 @@ @contextmanager -def runner_process(): +def runner_process(azcopy_mock_work_dir): score_script_path = Path(__file__).parents[2] / "aurora/foundry/server/score.py" runner_path = Path(__file__).parents[0] / "runner.py" p = subprocess.Popen( - ["python", runner_path, score_script_path], + ["python", runner_path, azcopy_mock_work_dir, score_script_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE, ) @@ -38,8 +38,10 @@ def mock_foundry_responses_subprocess(stdin, stdout, requests_mock, base_address def _mock_send(request, context) -> dict: method = request.method.encode("unicode_escape") stdin.write(method + b"\n") - stdin.write(method.url + b"\n") - stdin.write(request.text().encode("unicode_escape") + b"\n") + stdin.write(request.path.encode("unicode_escape") + b"\n") + stdin.write(json.dumps(request.qs).encode("unicode_escape") + b"\n") + stdin.write(json.dumps(dict(request.headers)).encode("unicode_escape") + b"\n") + stdin.write(request.text.encode("unicode_escape") + b"\n") stdin.flush() output = stdout.readline() @@ -79,7 +81,7 @@ def mock_foundry_client( # Already determine a possible working path for the mock of `azcopy`. It might not be used, # but we do already need to determine it. - with runner_process() as (p, stdin, stdout), mock_foundry_responses_subprocess( + with runner_process(azcopy_mock_work_dir) as (p, stdin, stdout), mock_foundry_responses_subprocess( stdin, stdout, requests_mock ): # Now we decide whether we do communication locally or via blob storage. If we do diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py index 53dee9e..2806d6c 100644 --- a/tests/foundry/runner.py +++ b/tests/foundry/runner.py @@ -8,6 +8,9 @@ import logging import sys from pathlib import Path +from flask import Request +from werkzeug.test import EnvironBuilder +from werkzeug.wrappers import Request as WerkzeugRequest import click @@ -52,12 +55,31 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: score.init() while True: - raw_data = sys.stdin.readline() - raw_data = raw_data.encode("utf-8").decode("unicode_escape") + method = sys.stdin.readline().strip() + base_url = sys.stdin.readline().strip() + query_params = json.loads(sys.stdin.readline().encode("utf-8").strip()) + headers = json.loads(sys.stdin.readline().encode("utf-8").strip()) + payload = sys.stdin.readline().encode("utf-8").strip() - answer = json.dumps(score.run(raw_data)) + builder = EnvironBuilder( + method=method, + base_url=base_url, + headers={ + "Content-Type": "application/json" + }, + data=payload, + ) + env = builder.get_environ() + flask_request = Request(env) - sys.stdout.write(answer.encode("unicode_escape").decode("utf-8")) + resp = score.run(flask_request) + if isinstance(resp, dict): + answer = json.dumps(resp).encode("utf-8") + else: + answer = resp.data + print("DATA", answer) + + sys.stdout.write(answer.decode("utf-8")) sys.stdout.write("\n") sys.stdout.flush() From 27a8a646f5792c1339273a054deed427e9682026 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 12:42:02 +0100 Subject: [PATCH 16/44] api tests passing --- aurora/foundry/client/api.py | 14 +++++++------- aurora/foundry/server/score.py | 19 +++++++------------ tests/foundry/conftest.py | 10 ++++++---- tests/foundry/runner.py | 8 +++----- 4 files changed, 23 insertions(+), 28 deletions(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index a597cf6..af7eb3a 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -23,8 +23,7 @@ class SubmissionInfo(BaseModel): class ProgressInfo(BaseModel): - kind: Literal["progress_info"] - uuid: str + task_id: str completed: bool progress_percentage: int error: bool @@ -74,17 +73,18 @@ def submit( submission_info = SubmissionInfo(**response) except Exception as e: raise SubmissionError(response["message"]) from e - task_uuid = submission_info.uuid - logger.info("Submitted task %r to endpoint.", task_uuid) + task_id = submission_info.task_id + logger.info("Submitted task %r to endpoint.", task_id) # Send the initial condition over. - client_comm.send(batch, task_uuid, "input.nc") + client_comm.send(batch, task_id, "input.nc") previous_progress: int = 0 while True: # Check on the progress of the task. - progress_info = ProgressInfo(**foundry_client.get_progress(task_uuid)) + response = foundry_client.get_progress(task_id) + progress_info = ProgressInfo(**response) if progress_info.error: raise SubmissionError(f"Task failed: {progress_info.error_info}") @@ -99,4 +99,4 @@ def submit( logger.info("Retrieving predictions.") for prediction_name in iterate_prediction_files("prediction.nc", num_steps): - yield client_comm.receive(task_uuid, prediction_name) + yield client_comm.receive(task_id, prediction_name) diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 04d8ecb..a90681c 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -108,7 +108,7 @@ def run(input_data: AMLRequest) -> dict: logger.info("Returning the status of an existing task.") uuid = input_data.args.get("task_id") if not uuid: - return AMLRequest( + return AMLResponse( dict(message="Missing task_id query parameter."), 400, {}, @@ -128,18 +128,13 @@ def run(input_data: AMLRequest) -> dict: break time.sleep(1) return { - "success": True, - "message": "Status check completed.", - "data": { - "kind": "progress_info", - "uuid": uuid, - "completed": task.completed, - "progress_percentage": task.progress_percentage, - "error": task.exc is not None, - "error_info": str(task.exc) if task.exc else "", - }, + "task_id": uuid, + "completed": task.completed, + "progress_percentage": task.progress_percentage, + "error": task.exc is not None, + "error_info": str(task.exc) if task.exc else "", } else: # This branch should be unreachable. - return AMLRequest(dict(message="Method not allowed."), 405, {}, json_str=True) + return AMLResponse(dict(message="Method not allowed."), 405, {}, json_str=True) diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 97b4561..d91d41c 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -1,6 +1,7 @@ """Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" import json +import re import subprocess import time from contextlib import contextmanager @@ -37,11 +38,12 @@ def runner_process(azcopy_mock_work_dir): def mock_foundry_responses_subprocess(stdin, stdout, requests_mock, base_address=MOCK_ADDRESS): def _mock_send(request, context) -> dict: method = request.method.encode("unicode_escape") + text = request.text or "" stdin.write(method + b"\n") stdin.write(request.path.encode("unicode_escape") + b"\n") - stdin.write(json.dumps(request.qs).encode("unicode_escape") + b"\n") + stdin.write(request.url.partition('?')[2].encode("unicode_escape") + b"\n") stdin.write(json.dumps(dict(request.headers)).encode("unicode_escape") + b"\n") - stdin.write(request.text.encode("unicode_escape") + b"\n") + stdin.write(text.encode("unicode_escape") + b"\n") stdin.flush() output = stdout.readline() @@ -50,13 +52,12 @@ def _mock_send(request, context) -> dict: return json.loads(output.decode("unicode_escape")) - task_uuid = "mock-uuid" requests_mock.post( f"{base_address}/score", json=_mock_send, ) requests_mock.get( - f"{base_address}/score?uuid={task_uuid}", + re.compile(f"{base_address}/score\?task_id=.*"), json=_mock_send, ) yield @@ -115,6 +116,7 @@ def mock_foundry_client( } elif request.param == "docker-local": + requests_mock.real_http = True client_comm_folder = tmp_path / "communication" # It's important to create the communication folder on the client side already. If we don't, diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py index 2806d6c..86a6b9c 100644 --- a/tests/foundry/runner.py +++ b/tests/foundry/runner.py @@ -57,16 +57,15 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: while True: method = sys.stdin.readline().strip() base_url = sys.stdin.readline().strip() - query_params = json.loads(sys.stdin.readline().encode("utf-8").strip()) + query_params = sys.stdin.readline().strip() headers = json.loads(sys.stdin.readline().encode("utf-8").strip()) payload = sys.stdin.readline().encode("utf-8").strip() builder = EnvironBuilder( method=method, base_url=base_url, - headers={ - "Content-Type": "application/json" - }, + query_string=query_params, + headers=headers, data=payload, ) env = builder.get_environ() @@ -77,7 +76,6 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: answer = json.dumps(resp).encode("utf-8") else: answer = resp.data - print("DATA", answer) sys.stdout.write(answer.decode("utf-8")) sys.stdout.write("\n") From b8f473aa88a5a9f2dc4495dcfbde817300817d43 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 14:12:49 +0100 Subject: [PATCH 17/44] fix --- aurora/foundry/client/foundry.py | 2 +- pyproject.toml | 1 - tests/foundry/conftest.py | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/aurora/foundry/client/foundry.py b/aurora/foundry/client/foundry.py index 21c46f5..2d13bea 100644 --- a/aurora/foundry/client/foundry.py +++ b/aurora/foundry/client/foundry.py @@ -58,7 +58,7 @@ def _req( ) -> requests.Response: return requests.request( method, - os.path.join(self.endpoint, path), + self.endpoint.rstrip('/') + '/' + path.lstrip('/'), headers={ "Authorization": f"Bearer {self.token}", "Content-Type": "application/json", diff --git a/pyproject.toml b/pyproject.toml index 8d773ef..6a3c2bd 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,7 +55,6 @@ dev = [ "mypy", "ruff==0.4.1", "pre-commit", - "requests_mock", "jupyter-book", "scipy", ] diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index d91d41c..5144d81 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -156,7 +156,7 @@ def mock_foundry_client( yield { "client_comm": LocalCommunication(client_comm_folder), "host_comm": LocalCommunication("/communication"), - "foundry_client": FoundryClient("https://127.0.0.1:5001", "mock-token"), + "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), } finally: From afdc6a45cf1ca11f269e8b3f4f44ef91baa1bec8 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 15:13:09 +0100 Subject: [PATCH 18/44] minor --- pyproject.toml | 1 + tests/foundry/runner.py | 20 ++++++++------------ 2 files changed, 9 insertions(+), 12 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 6a3c2bd..8d773ef 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,6 +55,7 @@ dev = [ "mypy", "ruff==0.4.1", "pre-commit", + "requests_mock", "jupyter-book", "scipy", ] diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py index 86a6b9c..bc6a809 100644 --- a/tests/foundry/runner.py +++ b/tests/foundry/runner.py @@ -8,11 +8,10 @@ import logging import sys from pathlib import Path -from flask import Request -from werkzeug.test import EnvironBuilder -from werkzeug.wrappers import Request as WerkzeugRequest import click +from flask import Request +from werkzeug.test import EnvironBuilder # Expose logging messages. logger = logging.getLogger() @@ -62,20 +61,17 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: payload = sys.stdin.readline().encode("utf-8").strip() builder = EnvironBuilder( - method=method, - base_url=base_url, - query_string=query_params, - headers=headers, - data=payload, + method=method, + base_url=base_url, + query_string=query_params, + headers=headers, + data=payload, ) env = builder.get_environ() flask_request = Request(env) resp = score.run(flask_request) - if isinstance(resp, dict): - answer = json.dumps(resp).encode("utf-8") - else: - answer = resp.data + answer = json.dumps(resp).encode("utf-8") if isinstance(resp, dict) else resp.data sys.stdout.write(answer.decode("utf-8")) sys.stdout.write("\n") From 30c7e35da16b4c5b4ba9b0cacb61530d273d5a52 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Thu, 9 Jan 2025 17:46:47 +0100 Subject: [PATCH 19/44] Add missing dev dependencies --- pyproject.toml | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 8d773ef..a59b511 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -52,12 +52,13 @@ dev = [ "ghp-import", "pytest", "pytest-cov", + "requests_mock", "mypy", "ruff==0.4.1", "pre-commit", - "requests_mock", "jupyter-book", - "scipy", + "flask", + "azureml-inference-server-http", ] [project.urls] From c173425a1df4ed88291bc873dba4edd509651b29 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Thu, 9 Jan 2025 17:49:05 +0100 Subject: [PATCH 20/44] Fix formatting --- aurora/foundry/client/api.py | 2 +- aurora/foundry/client/foundry.py | 3 +-- tests/foundry/conftest.py | 12 +++++++----- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index af7eb3a..b3545b9 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -4,7 +4,7 @@ """ import logging -from typing import Generator, Literal +from typing import Generator from pydantic import BaseModel diff --git a/aurora/foundry/client/foundry.py b/aurora/foundry/client/foundry.py index 2d13bea..6c40c5e 100644 --- a/aurora/foundry/client/foundry.py +++ b/aurora/foundry/client/foundry.py @@ -2,7 +2,6 @@ import abc import logging -import os from typing import Literal import requests @@ -58,7 +57,7 @@ def _req( ) -> requests.Response: return requests.request( method, - self.endpoint.rstrip('/') + '/' + path.lstrip('/'), + self.endpoint.rstrip("/") + "/" + path.lstrip("/"), headers={ "Authorization": f"Bearer {self.token}", "Content-Type": "application/json", diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 5144d81..6b964f0 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -41,7 +41,7 @@ def _mock_send(request, context) -> dict: text = request.text or "" stdin.write(method + b"\n") stdin.write(request.path.encode("unicode_escape") + b"\n") - stdin.write(request.url.partition('?')[2].encode("unicode_escape") + b"\n") + stdin.write(request.url.partition("?")[2].encode("unicode_escape") + b"\n") stdin.write(json.dumps(dict(request.headers)).encode("unicode_escape") + b"\n") stdin.write(text.encode("unicode_escape") + b"\n") stdin.flush() @@ -57,7 +57,7 @@ def _mock_send(request, context) -> dict: json=_mock_send, ) requests_mock.get( - re.compile(f"{base_address}/score\?task_id=.*"), + re.compile(rf"{base_address}/score\?task_id=.*"), json=_mock_send, ) yield @@ -82,9 +82,11 @@ def mock_foundry_client( # Already determine a possible working path for the mock of `azcopy`. It might not be used, # but we do already need to determine it. - with runner_process(azcopy_mock_work_dir) as (p, stdin, stdout), mock_foundry_responses_subprocess( - stdin, stdout, requests_mock - ): + with runner_process(azcopy_mock_work_dir) as ( + p, + stdin, + stdout, + ), mock_foundry_responses_subprocess(stdin, stdout, requests_mock): # Now we decide whether we do communication locally or via blob storage. If we do # communication via blob storage, we must mock `azcopy` too. comm_folder = tmp_path / "communication" From 06ee747a74525871b63ce1d3e23a7dc1fb23c302 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Thu, 9 Jan 2025 21:11:19 +0100 Subject: [PATCH 21/44] Test blob storage protocol also for Docker image --- aurora/foundry/common/channel.py | 23 +------- aurora/foundry/server/_hook.py | 5 ++ aurora/foundry/server/score.py | 1 + tests/foundry/azcopy.py | 13 ++++- tests/foundry/conftest.py | 90 +++++++++++++++++++++++++++-- tests/foundry/docker_server_hook.py | 49 ++++++++++++++++ tests/foundry/runner.py | 75 ++++++++++++++++-------- 7 files changed, 204 insertions(+), 52 deletions(-) create mode 100644 aurora/foundry/server/_hook.py create mode 100644 tests/foundry/docker_server_hook.py diff --git a/aurora/foundry/common/channel.py b/aurora/foundry/common/channel.py index 9b394a9..83625c4 100644 --- a/aurora/foundry/common/channel.py +++ b/aurora/foundry/common/channel.py @@ -1,7 +1,6 @@ """Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" import abc -import json import logging import os import subprocess @@ -10,6 +9,7 @@ from pathlib import Path from typing import Generator, Literal +import requests from pydantic import BaseModel, HttpUrl from aurora import Batch @@ -217,25 +217,8 @@ def _mark(self, name: str) -> None: self._azcopy(["copy", str(mark_file_path), self._blob_path(f"{name}.finished")]) def _is_marked(self, name: str) -> bool: - out = json.loads( - self._azcopy( - [ - "list", - self._blob_path(f"{name}.finished"), - "--output-type", - "json", - "--output-level", - "essential", - ] - ) - ) - return ( - len(out) == 2 - and isinstance(out[0], dict) - and out[0].get("MessageType", None) == "ListObject" - and isinstance(out[1], dict) - and out[1].get("MessageType", None) == "EndOfJob" - ) + res = requests.head(self._blob_path(f"{name}.finished")) + return res.status_code == 200 def iterate_prediction_files(name: str, num_steps: int) -> Generator[str, None, None]: diff --git a/aurora/foundry/server/_hook.py b/aurora/foundry/server/_hook.py new file mode 100644 index 0000000..b8c2dff --- /dev/null +++ b/aurora/foundry/server/_hook.py @@ -0,0 +1,5 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license. + +The contents of this file can be replaced to modify the server. This is used to test the Docker +image. +""" diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index a90681c..012e180 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -10,6 +10,7 @@ from azureml_inference_server_http.api.aml_response import AMLResponse from pydantic import BaseModel, Field +import aurora.foundry.server._hook # noqa: F401 from aurora.foundry.common.channel import ( BlobStorageCommunication, LocalCommunication, diff --git a/tests/foundry/azcopy.py b/tests/foundry/azcopy.py index 1ea2368..0ce57cb 100644 --- a/tests/foundry/azcopy.py +++ b/tests/foundry/azcopy.py @@ -5,11 +5,19 @@ import json import logging +import os import shutil +import subprocess import sys from pathlib import Path -import click +try: + import click +except ImportError: + # This might be run in the release Docker image, where `click` won't be available. Just install + # it. + subprocess.check_call([sys.executable, "-m", "pip", "install", "--no-deps", "click"]) + import click # Expose logging messages. logger = logging.getLogger() @@ -65,6 +73,9 @@ def main(work_path: Path, args: tuple[str, ...]) -> None: target = _parse_path(args[2], work_path) target.parent.mkdir(parents=True, exist_ok=True) shutil.copy(source, target) + # If this is run from within the release Docker image, we need to give others execution + # permissions to copy and load the file on the client side. + os.chmod(target, 0o755) else: raise RuntimeError(f"Unknown command `{args[0]}`.") diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 6b964f0..0af5c0b 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -68,6 +68,7 @@ def _mock_send(request, context) -> dict: "subprocess-local", "subprocess-blob", "docker-local", + "docker-blob", ] ) def mock_foundry_client( @@ -111,21 +112,48 @@ def mock_foundry_client( blob_url_with_sas = ( "https://storageaccount.blob.core.windows.net/container/folder?SAS" ) + + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + if "blob.core.windows.net/" in request.url: + # Split off the SAS token. + path, _ = request.url.split("?", 1) + # Split off the storage account URL. + _, path = path.split("blob.core.windows.net/", 1) + + local_path = azcopy_mock_work_dir / path + + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + + return None + + requests_mock.add_matcher(_matcher) + yield { "client_comm": BlobStorageCommunication(blob_url_with_sas), "host_comm": BlobStorageCommunication(blob_url_with_sas), "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), } - elif request.param == "docker-local": + elif "docker" in request.param: requests_mock.real_http = True client_comm_folder = tmp_path / "communication" # It's important to create the communication folder on the client side already. If we don't, # Docker will create it, and the permissions will then be wrong. client_comm_folder.mkdir(exist_ok=True, parents=True) + azcopy_mock_work_dir.mkdir(exist_ok=True, parents=True) + + # Find the path of the server hook. + server_hook = Path(__file__).parents[0] / "docker_server_hook.py" # Run the Docker container. Assume that it has already been built. + azcopy_path = Path(__file__).parents[0] / "azcopy.py" p = subprocess.Popen( [ "docker", @@ -136,6 +164,17 @@ def mock_foundry_client( "-t", "-v", f"{client_comm_folder}:/communication", + "-v", + f"{azcopy_mock_work_dir}:/azcopy_work", + "--mount", + f"type=bind,src={azcopy_path},dst=/aurora_foundry/azcopy.py,readonly", + "--mount", + ( + f"type=bind" + f",src={server_hook}" + f",dst=/aurora_foundry/aurora/foundry/server/_hook.py" + f",readonly" + ), "aurora-foundry:latest", ], ) @@ -155,11 +194,50 @@ def mock_foundry_client( raise e break - yield { - "client_comm": LocalCommunication(client_comm_folder), - "host_comm": LocalCommunication("/communication"), - "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), - } + if "local" in request.param: + yield { + "client_comm": LocalCommunication(client_comm_folder), + "host_comm": LocalCommunication("/communication"), + "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), + } + else: + # Communicate via blob storage, so mock `azcopy` too. + monkeypatch.setattr( + BlobStorageCommunication, + "_AZCOPY_EXECUTABLE", + ["python", str(azcopy_path), str(azcopy_mock_work_dir)], + ) + # The below test URL must start with `https`! + blob_url_with_sas = ( + "https://storageaccount.blob.core.windows.net/container/folder?SAS" + ) + + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + if "blob.core.windows.net/" in request.url: + # Split off the SAS token. + path, _ = request.url.split("?", 1) + # Split off the storage account URL. + _, path = path.split("blob.core.windows.net/", 1) + + local_path = azcopy_mock_work_dir / path + + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + + return None + + requests_mock.add_matcher(_matcher) + + yield { + "client_comm": BlobStorageCommunication(blob_url_with_sas), + "host_comm": BlobStorageCommunication(blob_url_with_sas), + "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), + } finally: p.terminate() diff --git a/tests/foundry/docker_server_hook.py b/tests/foundry/docker_server_hook.py new file mode 100644 index 0000000..8c962a4 --- /dev/null +++ b/tests/foundry/docker_server_hook.py @@ -0,0 +1,49 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import subprocess +import sys +from pathlib import Path + +# This will be run in the release Docker image, so packages required for mocking are not available. +subprocess.check_call([sys.executable, "-m", "pip", "install", "--no-deps", "requests_mock"]) + + +import requests # noqa: E402 +import requests_mock # noqa: E402 + +# First, mock requests that check for the existence of blobs. + + +def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + if "blob.core.windows.net/" in request.url: + # Split off the SAS token. + path, _ = request.url.split("?", 1) + # Split off the storage account URL. + _, path = path.split("blob.core.windows.net/", 1) + + # Assume that the local folder `/azcopy_work` is used by the mock of `azcopy`. + local_path = Path("/azcopy_work") / path + + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + + return None + + +mock = requests_mock.Mocker().__enter__() +mock.real_http = True +mock.add_matcher(_matcher) + +from aurora.foundry.common.channel import BlobStorageCommunication # noqa: E402 + +# Second, mock `azcopy`, assuming that the `azcopy` mock working directory is `/azcopy_work`. +BlobStorageCommunication._AZCOPY_EXECUTABLE = [ + "python", + "/aurora_foundry/azcopy.py", + "/azcopy_work", +] diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py index bc6a809..e7035cb 100644 --- a/tests/foundry/runner.py +++ b/tests/foundry/runner.py @@ -10,6 +10,8 @@ from pathlib import Path import click +import requests +import requests_mock from flask import Request from werkzeug.test import EnvironBuilder @@ -51,31 +53,54 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: str(azcopy_mock_work_path), ] - score.init() - - while True: - method = sys.stdin.readline().strip() - base_url = sys.stdin.readline().strip() - query_params = sys.stdin.readline().strip() - headers = json.loads(sys.stdin.readline().encode("utf-8").strip()) - payload = sys.stdin.readline().encode("utf-8").strip() - - builder = EnvironBuilder( - method=method, - base_url=base_url, - query_string=query_params, - headers=headers, - data=payload, - ) - env = builder.get_environ() - flask_request = Request(env) - - resp = score.run(flask_request) - answer = json.dumps(resp).encode("utf-8") if isinstance(resp, dict) else resp.data - - sys.stdout.write(answer.decode("utf-8")) - sys.stdout.write("\n") - sys.stdout.flush() + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + if "blob.core.windows.net/" in request.url: + # Split off the SAS token. + path, _ = request.url.split("?", 1) + # Split off the storage account URL. + _, path = path.split("blob.core.windows.net/", 1) + + local_path = azcopy_mock_work_path / path + + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + + return None + + with requests_mock.Mocker() as mock: + mock.real_http = True + mock.add_matcher(_matcher) + + score.init() + + while True: + method = sys.stdin.readline().strip() + base_url = sys.stdin.readline().strip() + query_params = sys.stdin.readline().strip() + headers = json.loads(sys.stdin.readline().encode("utf-8").strip()) + payload = sys.stdin.readline().encode("utf-8").strip() + + builder = EnvironBuilder( + method=method, + base_url=base_url, + query_string=query_params, + headers=headers, + data=payload, + ) + env = builder.get_environ() + flask_request = Request(env) + + resp = score.run(flask_request) + answer = json.dumps(resp).encode("utf-8") if isinstance(resp, dict) else resp.data + + sys.stdout.write(answer.decode("utf-8")) + sys.stdout.write("\n") + sys.stdout.flush() if __name__ == "__main__": From 9930555943340500d1336985b1b7f3727e0b8816 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 23:03:17 +0100 Subject: [PATCH 22/44] simplify submission spec --- aurora/foundry/client/api.py | 2 +- aurora/foundry/common/channel.py | 14 +-- aurora/foundry/server/score.py | 70 ++++++------- tests/foundry/conftest.py | 166 ++++++++++++++----------------- 4 files changed, 111 insertions(+), 141 deletions(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index b3545b9..ad17f49 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -66,7 +66,7 @@ def submit( task = { "model_name": model_name, "num_steps": num_steps, - "host_comm": host_comm.to_spec(), + "data_folder_uri": host_comm.to_spec(), } response = foundry_client.submit_task(task) try: diff --git a/aurora/foundry/common/channel.py b/aurora/foundry/common/channel.py index 83625c4..e1d4063 100644 --- a/aurora/foundry/common/channel.py +++ b/aurora/foundry/common/channel.py @@ -100,7 +100,7 @@ def _is_marked(self, name: str) -> bool: """ @abc.abstractmethod - def to_spec(self) -> dict[str, str]: + def to_spec(self) -> str: """Convert this channel to specification that can be serialised into JSON. Returns: @@ -119,11 +119,8 @@ def __init__(self, folder: str | Path) -> None: """ self.folder = Path(folder) - def to_spec(self) -> dict[str, str]: - return { - "class_name": "LocalCommunication", - "folder": str(self.folder), - } + def to_spec(self) -> str: + return str(self.folder) class Spec(BaseModel): class_name: Literal["LocalCommunication"] @@ -166,10 +163,7 @@ def __init__(self, blob_folder: str) -> None: raise ValueError("Given URL does not appear to contain a SAS token.") def to_spec(self) -> dict[str, str]: - return { - "class_name": "BlobStorageCommunication", - "blob_folder": self.blob_folder, - } + return self.blob_folder class Spec(BaseModel): class_name: Literal["BlobStorageCommunication"] diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 012e180..1a3c93c 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -23,18 +23,23 @@ # Need to give the name explicitly here, because the script may be run stand-alone. logger = logging.getLogger("aurora.foundry.server.score") -CommSpecs = Union[LocalCommunication.Spec, BlobStorageCommunication.Spec] - class Submission(BaseModel): - host_comm: CommSpecs = Field(..., discriminator="class_name") + data_folder_uri: str model_name: str num_steps: int -class Check(BaseModel): - action: Literal["check"] - uuid: str +class SubmissionResponse(BaseModel): + task_id: str + + +class ProgressInfo(BaseModel): + task_id: str + completed: bool + progress_percentage: int + error: bool + error_info: str POOL = ThreadPoolExecutor(max_workers=1) @@ -53,7 +58,7 @@ def __init__(self, request: Submission): def __call__(self) -> None: try: request = self.request - host_comm = request.host_comm.construct() + host_comm = BlobStorageCommunication(request.data_folder_uri) model_class = models[request.model_name] model = model_class() @@ -95,47 +100,34 @@ def run(input_data: AMLRequest) -> dict: logger.info("Received request.") if input_data.method == "POST": logger.info("Submitting new task to thread pool.") - try: - task = Task(Submission(**input_data.get_json())) - except Exception as exc: - return AMLResponse(dict(message=str(exc)), 500, {}, json_str=True) + task = Task(Submission(**input_data.get_json())) POOL.submit(task) TASKS[task.uuid] = task - return { - "task_id": task.uuid, - } + return SubmissionResponse(task_id=task.uuid).dict() elif input_data.method == "GET": logger.info("Returning the status of an existing task.") - uuid = input_data.args.get("task_id") - if not uuid: - return AMLResponse( - dict(message="Missing task_id query parameter."), - 400, - {}, - json_str=True, - ) - if uuid not in TASKS: - return { - "success": False, - "message": "Task UUID cannot be found.", - } + task_id = input_data.args.get("task_id") + if not task_id: + raise Exception("Missing task_id query parameter.") + if task_id not in TASKS: + raise Exception("Task UUID cannot be found.") else: - task = TASKS[uuid] + task = TASKS[task_id] # Allow the task some time to complete. # We sleep here so the client does not query too frequently. for _ in range(3): if task.completed: break time.sleep(1) - return { - "task_id": uuid, - "completed": task.completed, - "progress_percentage": task.progress_percentage, - "error": task.exc is not None, - "error_info": str(task.exc) if task.exc else "", - } - - else: - # This branch should be unreachable. - return AMLResponse(dict(message="Method not allowed."), 405, {}, json_str=True) + + return ProgressInfo( + task_id=task_id, + completed=task.completed, + progress_percentage=task.progress_percentage, + error=task.exc is not None, + error_info=str(task.exc) if task.exc else "", + ).dict() + + # This branch should be unreachable. + raise Exception("Method not allowed.") diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 0af5c0b..50a8191 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -92,53 +92,44 @@ def mock_foundry_client( # communication via blob storage, we must mock `azcopy` too. comm_folder = tmp_path / "communication" - if "local" in request.param: - # Communicate via a local folder. - yield { - "client_comm": LocalCommunication(comm_folder), - "host_comm": LocalCommunication(comm_folder), - "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), - } - - else: - # Communicate via blob storage, so mock `azcopy` too. - azcopy_path = Path(__file__).parents[0] / "azcopy.py" - monkeypatch.setattr( - BlobStorageCommunication, - "_AZCOPY_EXECUTABLE", - ["python", str(azcopy_path), str(azcopy_mock_work_dir)], - ) - # The below test URL must start with `https`! - blob_url_with_sas = ( - "https://storageaccount.blob.core.windows.net/container/folder?SAS" - ) - - def _matcher(request: requests.Request) -> requests.Response | None: - """Mock requests that check for the existence of blobs.""" - if "blob.core.windows.net/" in request.url: - # Split off the SAS token. - path, _ = request.url.split("?", 1) - # Split off the storage account URL. - _, path = path.split("blob.core.windows.net/", 1) - - local_path = azcopy_mock_work_dir / path - - response = requests.Response() - if local_path.exists(): - response.status_code = 200 - else: - response.status_code = 404 - return response - - return None - - requests_mock.add_matcher(_matcher) - - yield { - "client_comm": BlobStorageCommunication(blob_url_with_sas), - "host_comm": BlobStorageCommunication(blob_url_with_sas), - "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), - } + # Communicate via blob storage, so mock `azcopy` too. + azcopy_path = Path(__file__).parents[0] / "azcopy.py" + monkeypatch.setattr( + BlobStorageCommunication, + "_AZCOPY_EXECUTABLE", + ["python", str(azcopy_path), str(azcopy_mock_work_dir)], + ) + # The below test URL must start with `https`! + blob_url_with_sas = ( + "https://storageaccount.blob.core.windows.net/container/folder?SAS" + ) + + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + if "blob.core.windows.net/" in request.url: + # Split off the SAS token. + path, _ = request.url.split("?", 1) + # Split off the storage account URL. + _, path = path.split("blob.core.windows.net/", 1) + + local_path = azcopy_mock_work_dir / path + + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + + return None + + requests_mock.add_matcher(_matcher) + + yield { + "client_comm": BlobStorageCommunication(blob_url_with_sas), + "host_comm": BlobStorageCommunication(blob_url_with_sas), + "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), + } elif "docker" in request.param: requests_mock.real_http = True @@ -194,50 +185,43 @@ def _matcher(request: requests.Request) -> requests.Response | None: raise e break - if "local" in request.param: - yield { - "client_comm": LocalCommunication(client_comm_folder), - "host_comm": LocalCommunication("/communication"), - "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), - } - else: - # Communicate via blob storage, so mock `azcopy` too. - monkeypatch.setattr( - BlobStorageCommunication, - "_AZCOPY_EXECUTABLE", - ["python", str(azcopy_path), str(azcopy_mock_work_dir)], - ) - # The below test URL must start with `https`! - blob_url_with_sas = ( - "https://storageaccount.blob.core.windows.net/container/folder?SAS" - ) - - def _matcher(request: requests.Request) -> requests.Response | None: - """Mock requests that check for the existence of blobs.""" - if "blob.core.windows.net/" in request.url: - # Split off the SAS token. - path, _ = request.url.split("?", 1) - # Split off the storage account URL. - _, path = path.split("blob.core.windows.net/", 1) - - local_path = azcopy_mock_work_dir / path - - response = requests.Response() - if local_path.exists(): - response.status_code = 200 - else: - response.status_code = 404 - return response - - return None - - requests_mock.add_matcher(_matcher) - - yield { - "client_comm": BlobStorageCommunication(blob_url_with_sas), - "host_comm": BlobStorageCommunication(blob_url_with_sas), - "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), - } + # Communicate via blob storage, so mock `azcopy` too. + monkeypatch.setattr( + BlobStorageCommunication, + "_AZCOPY_EXECUTABLE", + ["python", str(azcopy_path), str(azcopy_mock_work_dir)], + ) + # The below test URL must start with `https`! + blob_url_with_sas = ( + "https://storageaccount.blob.core.windows.net/container/folder?SAS" + ) + + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + if "blob.core.windows.net/" in request.url: + # Split off the SAS token. + path, _ = request.url.split("?", 1) + # Split off the storage account URL. + _, path = path.split("blob.core.windows.net/", 1) + + local_path = azcopy_mock_work_dir / path + + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + + return None + + requests_mock.add_matcher(_matcher) + + yield { + "client_comm": BlobStorageCommunication(blob_url_with_sas), + "host_comm": BlobStorageCommunication(blob_url_with_sas), + "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), + } finally: p.terminate() From 916d13567b788fa4183a339be4e4fb0275b59f50 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Thu, 9 Jan 2025 23:05:43 +0100 Subject: [PATCH 23/44] linting --- aurora/foundry/common/channel.py | 2 +- aurora/foundry/server/score.py | 5 +---- tests/foundry/conftest.py | 10 +++------- 3 files changed, 5 insertions(+), 12 deletions(-) diff --git a/aurora/foundry/common/channel.py b/aurora/foundry/common/channel.py index e1d4063..0489579 100644 --- a/aurora/foundry/common/channel.py +++ b/aurora/foundry/common/channel.py @@ -162,7 +162,7 @@ def __init__(self, blob_folder: str) -> None: if "?" not in blob_folder: raise ValueError("Given URL does not appear to contain a SAS token.") - def to_spec(self) -> dict[str, str]: + def to_spec(self) -> str: return self.blob_folder class Spec(BaseModel): diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 1a3c93c..6a61a1e 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -3,17 +3,14 @@ import logging import time from concurrent.futures import ThreadPoolExecutor -from typing import Literal, Union from uuid import uuid4 from azureml_inference_server_http.api.aml_request import AMLRequest, rawhttp -from azureml_inference_server_http.api.aml_response import AMLResponse -from pydantic import BaseModel, Field +from pydantic import BaseModel import aurora.foundry.server._hook # noqa: F401 from aurora.foundry.common.channel import ( BlobStorageCommunication, - LocalCommunication, iterate_prediction_files, ) from aurora.foundry.common.model import models diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 50a8191..2e8072f 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -12,7 +12,7 @@ import requests from aurora.foundry.client.foundry import FoundryClient -from aurora.foundry.common.channel import BlobStorageCommunication, LocalCommunication +from aurora.foundry.common.channel import BlobStorageCommunication MOCK_ADDRESS = "https://mock-foundry.azurewebsites.net" @@ -100,9 +100,7 @@ def mock_foundry_client( ["python", str(azcopy_path), str(azcopy_mock_work_dir)], ) # The below test URL must start with `https`! - blob_url_with_sas = ( - "https://storageaccount.blob.core.windows.net/container/folder?SAS" - ) + blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" def _matcher(request: requests.Request) -> requests.Response | None: """Mock requests that check for the existence of blobs.""" @@ -192,9 +190,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: ["python", str(azcopy_path), str(azcopy_mock_work_dir)], ) # The below test URL must start with `https`! - blob_url_with_sas = ( - "https://storageaccount.blob.core.windows.net/container/folder?SAS" - ) + blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" def _matcher(request: requests.Request) -> requests.Response | None: """Mock requests that check for the existence of blobs.""" From acbf8db08600d15858d9c8a7861830185137f2ed Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Fri, 10 Jan 2025 00:17:37 +0100 Subject: [PATCH 24/44] auto-generate swagger-file --- Makefile | 6 +- aurora/foundry/server/generate-swagger.py | 82 +++++++ aurora/foundry/server/score.py | 23 ++ aurora/foundry/server/swagger3.json | 250 ++++++++++------------ tests/foundry/conftest.py | 4 - 5 files changed, 227 insertions(+), 138 deletions(-) create mode 100644 aurora/foundry/server/generate-swagger.py diff --git a/Makefile b/Makefile index 9aecbce..8a4c183 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -.PHONY: install test docs docker-requirements docker +.PHONY: install test docs docker-requirements docker swagger-file install: pip install --upgrade pip @@ -19,3 +19,7 @@ docker-requirements: pyproject.toml docker: (pip show setuptools-scm 1>/dev/null) || pip install setuptools-scm AURORA_REPO_VERSION=`python -m setuptools_scm` docker build --build-arg AURORA_REPO_VERSION -t aurora-foundry:latest . + +swagger-file: + pip install fastapi + python aurora/foundry/server/generate-swagger.py aurora/foundry/server/swagger3.json diff --git a/aurora/foundry/server/generate-swagger.py b/aurora/foundry/server/generate-swagger.py new file mode 100644 index 0000000..94dccb5 --- /dev/null +++ b/aurora/foundry/server/generate-swagger.py @@ -0,0 +1,82 @@ +import json +import sys + +from fastapi import Depends, FastAPI, HTTPException, Query, status +from fastapi.security import APIKeyHeader +from score import ProgressInfo, Submission, SubmissionResponse + +app = FastAPI( + title="Aurora", + description="Evaluate Aurora Model", + version="1.0.0", +) +security = APIKeyHeader( + name="Authorization", auto_error=False, description="Example 'Bearer myApiKey'" +) + + +async def get_api_key(api_key: str = Depends(security)): + if api_key is None or not api_key.startswith("Bearer "): + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid or missing API key", + headers={"WWW-Authenticate": "Bearer"}, + ) + token = api_key.split("Bearer ") + # Here you can add your logic to validate the token + if token != "your_actual_api_key": + raise HTTPException( + status_code=status.HTTP_401_UNAUTHORIZED, + detail="Invalid API key", + headers={"WWW-Authenticate": "Bearer"}, + ) + return token + + +# POST method on /score endpoint +@app.post( + "/score", + response_model=SubmissionResponse, + summary="Submit a new task", +) +async def create_score(input: Submission, token: str = Depends(get_api_key)): ... + + +# GET method on /score endpoint +@app.get("/score", response_model=ProgressInfo, summary="Get progress info for a given task") +async def get_score( + task_id: str = Query( + ..., + description="The ID of the task", + examples=dict(task_id=dict(value="abc-123-def", summary="Sample Task ID")), + ), + token: str = Depends(get_api_key), +): ... + + +# Liveness route +@app.get("/", summary="Succeeds when the service is ready.") +async def read_root(): + return "Healthy" + + +# Route to get the Swagger file +@app.get("/swagger.json") +async def get_swagger(): + return app.openapi() + + +def dump_openapi_spec(fn): + openapi_spec = app.openapi() + with open(fn, "w") as f: + json.dump(openapi_spec, f, indent=2) + print(f"OpenAPI spec dumped to {fn}") + + +if __name__ == "__main__": + if not sys.argv[1:]: + import uvicorn + + uvicorn.run(app, host="0.0.0.0", port=8000) + else: + dump_openapi_spec(sys.argv[1]) diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 6a61a1e..d51c6ce 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -26,10 +26,22 @@ class Submission(BaseModel): model_name: str num_steps: int + class Config: + json_schema_extra = dict( + example=dict( + data_folder_uri="https://my.blob.core.windows.net/container/some/path?WRITABLE_SAS", + model_name="aurora-0.25-small-pretrained", + num_steps=5, + ) + ) + class SubmissionResponse(BaseModel): task_id: str + class Config: + json_schema_extra = dict(example=dict(task_id="abc-123-def")) + class ProgressInfo(BaseModel): task_id: str @@ -38,6 +50,17 @@ class ProgressInfo(BaseModel): error: bool error_info: str + class Config: + json_schema_extra = dict( + example=dict( + task_id="abc-123-def", + completed=True, + progress_percentage=100, + error=False, + error_info="", + ) + ) + POOL = ThreadPoolExecutor(max_workers=1) TASKS = dict() diff --git a/aurora/foundry/server/swagger3.json b/aurora/foundry/server/swagger3.json index e8db81a..8c399db 100644 --- a/aurora/foundry/server/swagger3.json +++ b/aurora/foundry/server/swagger3.json @@ -1,65 +1,29 @@ { "openapi": "3.1.0", "info": { - "title": "Aurora Endpoint", - "version": "0.1.0" + "title": "Aurora", + "description": "Evaluate Aurora Model", + "version": "1.0.0" }, - "security": [ - { - "Bearer": [] - } - ], "paths": { - "/": { - "get": { - "summary": "Check if alive", - "operationId": "ServiceHealthCheck", - "description": "Simple health check endpoint to ensure the service is up at any given point.", - "responses": { - "200": { - "description": "If service is up and running, this response will be returned with the content 'Healthy'", - "content": { - "text/plain": { - "schema": { - "type": "string", - "examples": [ - "Healthy" - ] - } - } - } - }, - "default": { - "description": "The service failed to execute due to an error.", - "content": { - "application/json": { - "schema": { - "$ref": "#/components/schemas/ErrorResponse" - } - } - } - } - } - } - }, "/score": { "post": { + "summary": "Submit a new task", + "operationId": "create_score_score_post", "security": [ { - "Bearer": [] + "APIKeyHeader": [] } ], - "summary": "Create Task", - "operationId": "create_item_score__post", "requestBody": { + "required": true, "content": { "application/json": { "schema": { - "$ref": "#/components/schemas/CreateTask" + "$ref": "#/components/schemas/Submission" } } - }, - "required": true + } }, "responses": { "200": { @@ -67,7 +31,7 @@ "content": { "application/json": { "schema": { - "$ref": "#/components/schemas/CreateTaskResponse" + "$ref": "#/components/schemas/SubmissionResponse" } } } @@ -85,86 +49,91 @@ } }, "get": { + "summary": "Get progress info for a given task", + "operationId": "get_score_score_get", "security": [ { - "Bearer": [] + "APIKeyHeader": [] } ], - "summary": "Fetch Progress of a Task", - "operationId": "get_item_score_post", "parameters": [ { "name": "task_id", "in": "query", "required": true, "schema": { - "type": "string" - } + "type": "string", + "description": "The ID of the task", + "examples": { + "task_id": { + "value": "abc-123-def", + "summary": "Sample Task ID" + } + }, + "title": "Task Id" + }, + "description": "The ID of the task" } ], "responses": { "200": { - "description": "Successfull Response", + "description": "Successful Response", "content": { "application/json": { "schema": { - "$ref": "#/components/schemas/Answer" + "$ref": "#/components/schemas/ProgressInfo" + } + } + } + }, + "422": { + "description": "Validation Error", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HTTPValidationError" } } } } } } - } - }, - "components": { - "schemas": { - "CreateTaskResponse": { - "properties": { - "success": { - "type": "boolean", - "title": "Success" - }, - "message": { - "type": "string", - "title": "Message" - }, - "task_id": { - "type": "string", - "title": "Task ID" + }, + "/": { + "get": { + "summary": "Succeeds when the service is ready.", + "operationId": "read_root__get", + "responses": { + "200": { + "description": "Successful Response", + "content": { + "application/json": { + "schema": {} + } + } } } - }, - "ErrorResponse": { - "properties": { - "message": { - "type": "string" + } + }, + "/swagger.json": { + "get": { + "summary": "Get Swagger", + "operationId": "get_swagger_swagger_json_get", + "responses": { + "200": { + "description": "Successful Response", + "content": { + "application/json": { + "schema": {} + } + } } } - }, - "Answer": { - "properties": { - "success": { - "type": "boolean", - "title": "Success" - }, - "message": { - "type": "string", - "title": "Message" - }, - "data": { - "$ref": "#/components/schemas/ProgressInfo", - "title": "Data" - } - }, - "type": "object", - "required": [ - "success", - "message", - "data" - ], - "title": "Answer" - }, + } + } + }, + "components": { + "schemas": { "HTTPValidationError": { "properties": { "detail": { @@ -180,13 +149,9 @@ }, "ProgressInfo": { "properties": { - "kind": { - "const": "progress_info", - "title": "Kind" - }, - "uuid": { + "task_id": { "type": "string", - "title": "Uuid" + "title": "Task Id" }, "completed": { "type": "boolean", @@ -206,10 +171,28 @@ } }, "type": "object", - "title": "ProgressInfo" + "required": [ + "task_id", + "completed", + "progress_percentage", + "error", + "error_info" + ], + "title": "ProgressInfo", + "example": { + "completed": true, + "error": false, + "error_info": "", + "progress_percentage": 100, + "task_id": "abc-123-def" + } }, - "CreateTask": { + "Submission": { "properties": { + "data_folder_uri": { + "type": "string", + "title": "Data Folder Uri" + }, "model_name": { "type": "string", "title": "Model Name" @@ -217,35 +200,36 @@ "num_steps": { "type": "integer", "title": "Num Steps" - }, - "client_comm": { - "type": "string", - "title": "Client Comm" - }, - "host_comm": { - "type": "string", - "title": "Host Comm" } }, "type": "object", "required": [ - "request" + "data_folder_uri", + "model_name", + "num_steps" ], - "title": "CreateTask" + "title": "Submission", + "example": { + "data_folder_uri": "https://my.blob.core.windows.net/container/some/path?WRITABLE_SAS", + "model_name": "aurora-0.25-small-pretrained", + "num_steps": 5 + } }, - "SubmissionInfo": { + "SubmissionResponse": { "properties": { - "kind": { - "const": "submission_info", - "title": "Kind" - }, - "uuid": { + "task_id": { "type": "string", - "title": "Uuid" + "title": "Task Id" } }, "type": "object", - "title": "SubmissionInfo" + "required": [ + "task_id" + ], + "title": "SubmissionResponse", + "example": { + "task_id": "abc-123-def" + } }, "ValidationError": { "properties": { @@ -279,14 +263,14 @@ "type" ], "title": "ValidationError" - }, - "securitySchemes": { - "Bearer": { - "type": "apiKey", - "name": "Authorization", - "in": "header", - "description": "For example Bearer abc123" - } + } + }, + "securitySchemes": { + "APIKeyHeader": { + "type": "apiKey", + "description": "Example 'Bearer myApiKey'", + "in": "header", + "name": "Authorization" } } } diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 2e8072f..95f6fb3 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -88,10 +88,6 @@ def mock_foundry_client( stdin, stdout, ), mock_foundry_responses_subprocess(stdin, stdout, requests_mock): - # Now we decide whether we do communication locally or via blob storage. If we do - # communication via blob storage, we must mock `azcopy` too. - comm_folder = tmp_path / "communication" - # Communicate via blob storage, so mock `azcopy` too. azcopy_path = Path(__file__).parents[0] / "azcopy.py" monkeypatch.setattr( From e3b670cfa0b467a4b02a2566d4707c6e8319fc48 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Fri, 10 Jan 2025 01:00:23 +0100 Subject: [PATCH 25/44] add make target to build docker image on ACR --- Makefile | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 8a4c183..906003e 100644 --- a/Makefile +++ b/Makefile @@ -18,7 +18,12 @@ docker-requirements: pyproject.toml docker: (pip show setuptools-scm 1>/dev/null) || pip install setuptools-scm - AURORA_REPO_VERSION=`python -m setuptools_scm` docker build --build-arg AURORA_REPO_VERSION -t aurora-foundry:latest . + AURORA_REPO_VERSION=`python -m setuptools_scm` docker build --build-arg AURORA_REPO_VERSION -t testwsacr.azurecr.io/aurora-foundry:20250110-1 . + +docker-acr: + (pip show setuptools-scm 1>/dev/null) || pip install setuptools-scm + [ ! -z "$(ACR)" ] + AURORA_REPO_VERSION=`python -m setuptools_scm` az acr build --build-arg AURORA_REPO_VERSION -r "$(ACR)" -t aurora-foundry:20250110-1 . swagger-file: pip install fastapi From 386dbcd80cd14e1c4c4481a97810c25c94152f0b Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 10:15:40 +0100 Subject: [PATCH 26/44] Simplify test and use right Docker image --- .github/workflows/ci.yaml | 4 +- Makefile | 9 +- aurora/foundry/server/score.py | 8 +- tests/foundry/conftest.py | 155 ++++++++++++--------------------- 4 files changed, 68 insertions(+), 108 deletions(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index 8385f71..d9f4fab 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -28,7 +28,7 @@ jobs: - name: Build Foundry image run: | - make docker + DOCKER_IMAGE=aurora-foundry make docker - name: Install dependencies run: | @@ -37,4 +37,4 @@ jobs: - name: Run tests run: | - pytest -v --cov=aurora --cov-report term-missing + DOCKER_IMAGE=aurora-foundry pytest -v --cov=aurora --cov-report term-missing diff --git a/Makefile b/Makefile index 906003e..6f3dde8 100644 --- a/Makefile +++ b/Makefile @@ -1,12 +1,15 @@ .PHONY: install test docs docker-requirements docker swagger-file +DOCKER_WS ?= testwsacr +DOCKER_IMAGE ?= aurora-foundry:20250110-1 + install: pip install --upgrade pip pip install -e ".[dev]" pre-commit install test: - pytest tests -v --cov=aurora --cov-report=term --cov-report=html + DOCKER_IMAGE=$(DOCKER_WS).azurecr.io/$(DOCKER_IMAGE) pytest tests -v --cov=aurora --cov-report=term --cov-report=html docs: jupyter-book build docs @@ -18,12 +21,12 @@ docker-requirements: pyproject.toml docker: (pip show setuptools-scm 1>/dev/null) || pip install setuptools-scm - AURORA_REPO_VERSION=`python -m setuptools_scm` docker build --build-arg AURORA_REPO_VERSION -t testwsacr.azurecr.io/aurora-foundry:20250110-1 . + AURORA_REPO_VERSION=`python -m setuptools_scm` docker build --build-arg AURORA_REPO_VERSION -t $(DOCKER_WS).azurecr.io/$(DOCKER_IMAGE) . docker-acr: (pip show setuptools-scm 1>/dev/null) || pip install setuptools-scm [ ! -z "$(ACR)" ] - AURORA_REPO_VERSION=`python -m setuptools_scm` az acr build --build-arg AURORA_REPO_VERSION -r "$(ACR)" -t aurora-foundry:20250110-1 . + AURORA_REPO_VERSION=`python -m setuptools_scm` az acr build --build-arg AURORA_REPO_VERSION -r "$(ACR)" -t $(DOCKER_IMAGE) . swagger-file: pip install fastapi diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index d51c6ce..1406036 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -118,6 +118,7 @@ def run(input_data: AMLRequest) -> dict: dict/AMLResponse: The response to the request. dicts are implictitly 200 AMLResponses. """ logger.info("Received request.") + if input_data.method == "POST": logger.info("Submitting new task to thread pool.") task = Task(Submission(**input_data.get_json())) @@ -129,9 +130,9 @@ def run(input_data: AMLRequest) -> dict: logger.info("Returning the status of an existing task.") task_id = input_data.args.get("task_id") if not task_id: - raise Exception("Missing task_id query parameter.") + raise Exception("Missing `task_id` query parameter.") if task_id not in TASKS: - raise Exception("Task UUID cannot be found.") + raise Exception("Task ID cannot be found.") else: task = TASKS[task_id] # Allow the task some time to complete. @@ -149,5 +150,4 @@ def run(input_data: AMLRequest) -> dict: error_info=str(task.exc) if task.exc else "", ).dict() - # This branch should be unreachable. - raise Exception("Method not allowed.") + raise Exception("Method not allowed.") # This branch should be unreachable. diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 95f6fb3..8a22bb8 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -1,6 +1,7 @@ """Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" import json +import os import re import subprocess import time @@ -18,7 +19,7 @@ @contextmanager -def runner_process(azcopy_mock_work_dir): +def runner_process(azcopy_mock_work_dir: Path): score_script_path = Path(__file__).parents[2] / "aurora/foundry/server/score.py" runner_path = Path(__file__).parents[0] / "runner.py" p = subprocess.Popen( @@ -63,82 +64,70 @@ def _mock_send(request, context) -> dict: yield -@pytest.fixture( - params=[ - "subprocess-local", - "subprocess-blob", - "docker-local", - "docker-blob", - ] -) +@pytest.fixture(params=["subprocess", "docker"]) def mock_foundry_client( request, monkeypatch, requests_mock, tmp_path: Path, ) -> Generator[dict, None, None]: + # Communicate via blob storage, so mock `azcopy` too. azcopy_mock_work_dir = tmp_path / "azcopy_work" - - if "subprocess" in request.param: - # Already determine a possible working path for the mock of `azcopy`. It might not be used, - # but we do already need to determine it. - - with runner_process(azcopy_mock_work_dir) as ( - p, - stdin, - stdout, - ), mock_foundry_responses_subprocess(stdin, stdout, requests_mock): - # Communicate via blob storage, so mock `azcopy` too. - azcopy_path = Path(__file__).parents[0] / "azcopy.py" - monkeypatch.setattr( - BlobStorageCommunication, - "_AZCOPY_EXECUTABLE", - ["python", str(azcopy_path), str(azcopy_mock_work_dir)], - ) - # The below test URL must start with `https`! - blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" - - def _matcher(request: requests.Request) -> requests.Response | None: - """Mock requests that check for the existence of blobs.""" - if "blob.core.windows.net/" in request.url: - # Split off the SAS token. - path, _ = request.url.split("?", 1) - # Split off the storage account URL. - _, path = path.split("blob.core.windows.net/", 1) - - local_path = azcopy_mock_work_dir / path - - response = requests.Response() - if local_path.exists(): - response.status_code = 200 - else: - response.status_code = 404 - return response - - return None - - requests_mock.add_matcher(_matcher) - - yield { - "client_comm": BlobStorageCommunication(blob_url_with_sas), - "host_comm": BlobStorageCommunication(blob_url_with_sas), - "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), - } - - elif "docker" in request.param: + # It's important to already create the work folder. If we don't then the Docker image will + # create it, and the permissions will then be wrong. + azcopy_mock_work_dir.mkdir(exist_ok=True, parents=True) + azcopy_path = Path(__file__).parents[0] / "azcopy.py" + monkeypatch.setattr( + BlobStorageCommunication, + "_AZCOPY_EXECUTABLE", + ["python", str(azcopy_path), str(azcopy_mock_work_dir)], + ) + # The below test URL must start with `https`! + blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" + + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + if "blob.core.windows.net/" in request.url: + # Split off the SAS token. + path, _ = request.url.split("?", 1) + # Split off the storage account URL. + _, path = path.split("blob.core.windows.net/", 1) + + local_path = azcopy_mock_work_dir / path + + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + + return None + + requests_mock.add_matcher(_matcher) + + if request.param == "subprocess": + with runner_process(azcopy_mock_work_dir) as (p, stdin, stdout): # noqa: SIM117 + with mock_foundry_responses_subprocess(stdin, stdout, requests_mock): + yield { + "client_comm": BlobStorageCommunication(blob_url_with_sas), + "host_comm": BlobStorageCommunication(blob_url_with_sas), + "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), + } + + elif request.param == "docker": requests_mock.real_http = True - client_comm_folder = tmp_path / "communication" - # It's important to create the communication folder on the client side already. If we don't, - # Docker will create it, and the permissions will then be wrong. - client_comm_folder.mkdir(exist_ok=True, parents=True) - azcopy_mock_work_dir.mkdir(exist_ok=True, parents=True) + if "DOCKER_IMAGE" not in os.environ: + raise RuntimeError( + "Set the environment variable `DOCKER_IMAGE` " + "to the release image of Aurora Foundry." + ) + docker_image = os.environ["DOCKER_IMAGE"] - # Find the path of the server hook. + # Run the Docker container. Assume that it has already been built. Insert the hook + # to mock things on the server side. server_hook = Path(__file__).parents[0] / "docker_server_hook.py" - - # Run the Docker container. Assume that it has already been built. - azcopy_path = Path(__file__).parents[0] / "azcopy.py" p = subprocess.Popen( [ "docker", @@ -148,8 +137,6 @@ def _matcher(request: requests.Request) -> requests.Response | None: "--rm", "-t", "-v", - f"{client_comm_folder}:/communication", - "-v", f"{azcopy_mock_work_dir}:/azcopy_work", "--mount", f"type=bind,src={azcopy_path},dst=/aurora_foundry/azcopy.py,readonly", @@ -160,7 +147,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: f",dst=/aurora_foundry/aurora/foundry/server/_hook.py" f",readonly" ), - "aurora-foundry:latest", + docker_image, ], ) try: @@ -179,36 +166,6 @@ def _matcher(request: requests.Request) -> requests.Response | None: raise e break - # Communicate via blob storage, so mock `azcopy` too. - monkeypatch.setattr( - BlobStorageCommunication, - "_AZCOPY_EXECUTABLE", - ["python", str(azcopy_path), str(azcopy_mock_work_dir)], - ) - # The below test URL must start with `https`! - blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" - - def _matcher(request: requests.Request) -> requests.Response | None: - """Mock requests that check for the existence of blobs.""" - if "blob.core.windows.net/" in request.url: - # Split off the SAS token. - path, _ = request.url.split("?", 1) - # Split off the storage account URL. - _, path = path.split("blob.core.windows.net/", 1) - - local_path = azcopy_mock_work_dir / path - - response = requests.Response() - if local_path.exists(): - response.status_code = 200 - else: - response.status_code = 404 - return response - - return None - - requests_mock.add_matcher(_matcher) - yield { "client_comm": BlobStorageCommunication(blob_url_with_sas), "host_comm": BlobStorageCommunication(blob_url_with_sas), From 1060e4abd9ef5d39d9728c027f37a484ee9644fd Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 11:49:07 +0100 Subject: [PATCH 27/44] Rework interaction between client and host --- Makefile | 2 +- aurora/foundry/client/api.py | 57 +++++--- aurora/foundry/common/channel.py | 126 ++++++++++++------ ...enerate-swagger.py => generate_swagger.py} | 12 +- aurora/foundry/server/score.py | 118 ++++++++++------ aurora/foundry/server/swagger3.json | 111 ++++++++------- 6 files changed, 268 insertions(+), 158 deletions(-) rename aurora/foundry/server/{generate-swagger.py => generate_swagger.py} (85%) diff --git a/Makefile b/Makefile index 6f3dde8..cffd08d 100644 --- a/Makefile +++ b/Makefile @@ -30,4 +30,4 @@ docker-acr: swagger-file: pip install fastapi - python aurora/foundry/server/generate-swagger.py aurora/foundry/server/swagger3.json + python aurora/foundry/server/generate_swagger.py aurora/foundry/server/swagger3.json diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index ad17f49..5cb7225 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -18,16 +18,17 @@ logger = logging.getLogger(__name__) -class SubmissionInfo(BaseModel): +class CreationInfo(BaseModel): task_id: str -class ProgressInfo(BaseModel): +class TaskInfo(BaseModel): task_id: str completed: bool progress_percentage: int - error: bool - error_info: str + success: bool | None + submitted: bool + status: str class SubmissionError(Exception): @@ -62,7 +63,7 @@ def submit( if model_name not in models: raise KeyError(f"Model `{model_name}` is not a valid model.") - # Send a request to the endpoint to produce the predictions. + # Create a task at the endpoint. task = { "model_name": model_name, "num_steps": num_steps, @@ -70,32 +71,46 @@ def submit( } response = foundry_client.submit_task(task) try: - submission_info = SubmissionInfo(**response) + submission_info = CreationInfo(**response) except Exception as e: - raise SubmissionError(response["message"]) from e + raise SubmissionError("Failed to create task.") from e task_id = submission_info.task_id - logger.info("Submitted task %r to endpoint.", task_id) + logger.info(f"Created task `{task_id}` at endpoint.") # Send the initial condition over. client_comm.send(batch, task_id, "input.nc") + previous_status: str = "No Status" previous_progress: int = 0 while True: - # Check on the progress of the task. + # Check on the progress of the task. The first progress check will trigger the task to be + # submitted. response = foundry_client.get_progress(task_id) - progress_info = ProgressInfo(**response) - - if progress_info.error: - raise SubmissionError(f"Task failed: {progress_info.error_info}") - - if progress_info.progress_percentage > previous_progress: - logger.info(f"Task progress update: {progress_info.progress_percentage}%.") - previous_progress = progress_info.progress_percentage - - if progress_info.completed: - logger.info("Task has been completed!") - break + task_info = TaskInfo(**response) + + if task_info.submitted: + # If the task has been submitted, we must be able to read the acknowledgement of the + # initial condition. + try: + client_comm.read(task_id, "input.nc.ack", timeout=120) + except TimeoutError as e: + raise SubmissionError("Could not read acknowledgement of initial condition.") from e + + if task_info.status != previous_status: + logger.info(f"Task status update: {task_info.status}") + previous_status = task_info.status + + if task_info.progress_percentage > previous_progress: + logger.info(f"Task progress update: {task_info.progress_percentage}%.") + previous_progress = task_info.progress_percentage + + if task_info.completed: + if task_info.success: + logger.info("Task has been successfully completed!") + break + else: + raise SubmissionError(f"Task failed: {task_info.status}") logger.info("Retrieving predictions.") for prediction_name in iterate_prediction_files("prediction.nc", num_steps): diff --git a/aurora/foundry/common/channel.py b/aurora/foundry/common/channel.py index 0489579..d1bfd5b 100644 --- a/aurora/foundry/common/channel.py +++ b/aurora/foundry/common/channel.py @@ -16,7 +16,6 @@ __all__ = [ "CommunicationChannel", - "LocalCommunication", "BlobStorageCommunication", "iterate_prediction_files", ] @@ -39,7 +38,7 @@ def send(self, batch: Batch, uuid: str, name: str) -> None: self._send(batch, name) self._mark(name) - def receive(self, uuid: str, name: str) -> Batch: + def receive(self, uuid: str, name: str, timeout: int = 120) -> Batch: """Receive the batch under the file name `name`. This function blocks until the file is ready. @@ -47,15 +46,65 @@ def receive(self, uuid: str, name: str) -> Batch: Args: uuid (str): UUID of the task. name (str): Name to receive. + timeout (int, optional): Timeout in seconds. Defaults to 2 minutes. Returns: :class:`aurora.Batch`: Batch under the name `name`. """ name = f"{uuid}/{name}" + start = time.time() while not self._is_marked(name): - time.sleep(0.5) + if time.time() - start < timeout: + time.sleep(1) + else: + raise TimeoutError("File was not marked within the timeout.") return self._receive(name) + def write(self, data: bytes, uuid: str, name: str) -> None: + """Write `data` to `name`. + + Args: + Data (bytes): Data to write. + uuid (str): UUID of the task. + name (str): Name to write to. + """ + name = f"{uuid}/{name}" + self._write(data, name) + self._mark(name) + + def read(self, uuid: str, name: str, timeout: int = 120) -> bytes: + """Read `name`. + + Args: + uuid (str): UUID of the task. + name (str): Name to read. + timeout (int, optional): Timeout in seconds. Defaults to 2 minutes. + + Returns: + bytes: Data of `name`. + """ + name = f"{uuid}/{name}" + start = time.time() + while not self._is_marked(name): + if time.time() - start < timeout: + time.sleep(1) + else: + raise TimeoutError("File was not marked within the timeout.") + return self._read(name) + + def exists(self, uuid: str, name: str) -> bool: + """Check whether `name` is available. + + Args: + uuid (str): UUID of the task. + name (str): Name to check for. + + Returns: + bool: Wether `name` is available. + """ + name = f"{uuid}/{name}" + return self._is_marked(name) + @abc.abstractmethod def _send(self, batch: Batch, name: str) -> None: """Send `batch` under the file name `name` without marking the file. @@ -80,6 +129,27 @@ def _receive(self, name: str) -> Batch: :class:`aurora.Batch`: Batch under the file name `name`. """ + @abc.abstractmethod + def _write(self, data: bytes, name: str) -> None: + """Send the data `data` under the file name `name` without marking the file. + + This method should be implemented. + + Args: + data (bytes): Data to send. + name (str): Name of `data`. + """ + + @abc.abstractmethod + def _read(self, name: str) -> bytes: + """Read data from `name`. + + This function asserts that the file is ready and should be implemented by implementations. + + Args: + name (str): Name to read. + """ + @abc.abstractmethod def _mark(self, name: str) -> None: """Mark the file `name` as done. @@ -108,44 +178,6 @@ def to_spec(self) -> str: """ -class LocalCommunication(CommunicationChannel): - """A communication channel via a local folder.""" - - def __init__(self, folder: str | Path) -> None: - """Instantiate. - - Args: - folder (str or Path): Folder to use. - """ - self.folder = Path(folder) - - def to_spec(self) -> str: - return str(self.folder) - - class Spec(BaseModel): - class_name: Literal["LocalCommunication"] - folder: Path - - def construct(self) -> "LocalCommunication": - return LocalCommunication(folder=str(self.folder)) - - def _send(self, batch: Batch, name: str) -> None: - target = self.folder / name - target.parent.mkdir(exist_ok=True, parents=True) - batch.to_netcdf(target) - - def _receive(self, name: str) -> Batch: - return Batch.from_netcdf(self.folder / name) - - def _mark(self, name: str) -> None: - target = self.folder / f"{name}.finished" - target.parent.mkdir(exist_ok=True, parents=True) - target.touch() - - def _is_marked(self, name: str) -> bool: - return (self.folder / f"{name}.finished").exists() - - class BlobStorageCommunication(CommunicationChannel): """A communication channel via a folder in a Azure Blob Storage container.""" @@ -203,6 +235,18 @@ def _receive(self, name: str) -> Batch: self._azcopy(["copy", self._blob_path(name), tf.name]) return Batch.from_netcdf(tf.name) + def _write(self, data: bytes, name: str) -> None: + with tempfile.NamedTemporaryFile() as tf: + with open(tf.name, "wb") as f: + f.write(data) + self._azcopy(["copy", tf.name, self._blob_path(name)]) + + def _read(self, name: str) -> bytes: + with tempfile.NamedTemporaryFile() as tf: + self._azcopy(["copy", self._blob_path(name), tf.name]) + with open(tf.name, "rb") as f: + return f.read() + def _mark(self, name: str) -> None: with tempfile.TemporaryDirectory() as td: mark_file_path = Path(td) / f"{name}.finished" diff --git a/aurora/foundry/server/generate-swagger.py b/aurora/foundry/server/generate_swagger.py similarity index 85% rename from aurora/foundry/server/generate-swagger.py rename to aurora/foundry/server/generate_swagger.py index 94dccb5..15e3462 100644 --- a/aurora/foundry/server/generate-swagger.py +++ b/aurora/foundry/server/generate_swagger.py @@ -1,13 +1,15 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + import json import sys from fastapi import Depends, FastAPI, HTTPException, Query, status from fastapi.security import APIKeyHeader -from score import ProgressInfo, Submission, SubmissionResponse +from score import CreationResponse, Submission, TaskInfo app = FastAPI( title="Aurora", - description="Evaluate Aurora Model", + description="Produce predictions with the Aurora model", version="1.0.0", ) security = APIKeyHeader( @@ -36,14 +38,14 @@ async def get_api_key(api_key: str = Depends(security)): # POST method on /score endpoint @app.post( "/score", - response_model=SubmissionResponse, - summary="Submit a new task", + response_model=CreationResponse, + summary="Create a new task", ) async def create_score(input: Submission, token: str = Depends(get_api_key)): ... # GET method on /score endpoint -@app.get("/score", response_model=ProgressInfo, summary="Get progress info for a given task") +@app.get("/score", response_model=TaskInfo, summary="Update an existing task") async def get_score( task_id: str = Query( ..., diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 1406036..3ad2f4f 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -6,7 +6,7 @@ from uuid import uuid4 from azureml_inference_server_http.api.aml_request import AMLRequest, rawhttp -from pydantic import BaseModel +from pydantic import BaseModel, HttpUrl import aurora.foundry.server._hook # noqa: F401 from aurora.foundry.common.channel import ( @@ -22,7 +22,7 @@ class Submission(BaseModel): - data_folder_uri: str + data_folder_uri: HttpUrl model_name: str num_steps: int @@ -36,19 +36,20 @@ class Config: ) -class SubmissionResponse(BaseModel): +class CreationResponse(BaseModel): task_id: str class Config: json_schema_extra = dict(example=dict(task_id="abc-123-def")) -class ProgressInfo(BaseModel): +class TaskInfo(BaseModel): task_id: str completed: bool progress_percentage: int - error: bool - error_info: str + success: bool | None + submitted: bool + status: str class Config: json_schema_extra = dict( @@ -56,8 +57,9 @@ class Config: task_id="abc-123-def", completed=True, progress_percentage=100, - error=False, - error_info="", + success=None, + submitted=True, + error_info="Queued", ) ) @@ -67,43 +69,56 @@ class Config: class Task: - def __init__(self, request: Submission): - self.request: Submission = request - # TODO: Make sure that this `uuid` really is unique! - self.uuid: str = str(uuid4()) - self.progress_percentage: int = 0 - self.completed: bool = False - self.exc: Exception | None = None + def __init__(self, submission: Submission): + self.submission: Submission = submission + + self.task_info = TaskInfo( + # TODO: Make sure that this `uuid` really is unique! + task_id=str(uuid4()), + completed=False, + progress_percentage=0, + success=None, + submitted=False, + status="Unsubmitted", + ) def __call__(self) -> None: + self.task_info.status = "Running" + try: - request = self.request - host_comm = BlobStorageCommunication(request.data_folder_uri) + submission = self.submission + host_comm = BlobStorageCommunication(str(submission.data_folder_uri)) - model_class = models[request.model_name] + model_class = models[submission.model_name] model = model_class() - batch = host_comm.receive(self.uuid, "input.nc") + batch = host_comm.receive(self.task_info.task_id, "input.nc") logger.info("Running predictions.") for i, (pred, path) in enumerate( zip( - model.run(batch, request.num_steps), - iterate_prediction_files("prediction.nc", request.num_steps), + model.run(batch, submission.num_steps), + iterate_prediction_files("prediction.nc", submission.num_steps), ) ): - host_comm.send(pred, self.uuid, path) - self.progress_percentage = int((100 * (i + 1)) / request.num_steps) + host_comm.send(pred, self.task_info.task_id, path) - self.completed = True + self.task_info.progress_percentage = int((100 * (i + 1)) / submission.num_steps) + + self.task_info.success = True + self.task_info.status = "Successfully completed" except Exception as exc: - self.exc = exc + self.task_info.success = False + self.task_info.status = f"Exception: {str(exc)}" + + finally: + self.task_info.completed = True def init() -> None: """Initialise. Do not load the model here, because which model we need depends on the - request.""" + submission.""" POOL.__enter__() @@ -120,34 +135,53 @@ def run(input_data: AMLRequest) -> dict: logger.info("Received request.") if input_data.method == "POST": - logger.info("Submitting new task to thread pool.") + logger.info("Creating a new task.") task = Task(Submission(**input_data.get_json())) - POOL.submit(task) - TASKS[task.uuid] = task - return SubmissionResponse(task_id=task.uuid).dict() + TASKS[task.task_info.task_id] = task + return CreationResponse(task_id=task.task_info.task_id).dict() elif input_data.method == "GET": - logger.info("Returning the status of an existing task.") + logger.info("Processing an existing task.") + task_id = input_data.args.get("task_id") if not task_id: raise Exception("Missing `task_id` query parameter.") if task_id not in TASKS: raise Exception("Task ID cannot be found.") + + task = TASKS[task_id] + + if not task.task_info.submitted: + # Attempt to submit the task if the initial condition is available. + + comm = BlobStorageCommunication(str(task.submission.data_folder_uri)) + if comm.exists(task_id, "input.nc"): + logger.info("Initial condition was found. Submitting task.") + # Send an acknowledgement back to test that the host can write. The client will + # check for this acknowledgement. + comm.write(b"", task_id, "input.nc.ack") + + # Queue the task. + task.task_info.submitted = True + task.task_info.status = "Queued" + POOL.submit(task) + + else: + logger.info("Initial condition not available. Waiting.") + + # Wait a little to prevent the client for querying too frequently. + time.sleep(3) + else: - task = TASKS[task_id] - # Allow the task some time to complete. - # We sleep here so the client does not query too frequently. + logger.info("Task still running. Waiting.") + + # Wait a little to prevent the client for querying too frequently. While waiting, + # do check for the task to be completed. for _ in range(3): - if task.completed: + if task.task_info.completed: break time.sleep(1) - return ProgressInfo( - task_id=task_id, - completed=task.completed, - progress_percentage=task.progress_percentage, - error=task.exc is not None, - error_info=str(task.exc) if task.exc else "", - ).dict() + return task.task_info.dict() raise Exception("Method not allowed.") # This branch should be unreachable. diff --git a/aurora/foundry/server/swagger3.json b/aurora/foundry/server/swagger3.json index 8c399db..f66470f 100644 --- a/aurora/foundry/server/swagger3.json +++ b/aurora/foundry/server/swagger3.json @@ -2,13 +2,13 @@ "openapi": "3.1.0", "info": { "title": "Aurora", - "description": "Evaluate Aurora Model", + "description": "Produce predictions with the Aurora model", "version": "1.0.0" }, "paths": { "/score": { "post": { - "summary": "Submit a new task", + "summary": "Create a new task", "operationId": "create_score_score_post", "security": [ { @@ -31,7 +31,7 @@ "content": { "application/json": { "schema": { - "$ref": "#/components/schemas/SubmissionResponse" + "$ref": "#/components/schemas/CreationResponse" } } } @@ -49,7 +49,7 @@ } }, "get": { - "summary": "Get progress info for a given task", + "summary": "Update an existing task", "operationId": "get_score_score_get", "security": [ { @@ -81,7 +81,7 @@ "content": { "application/json": { "schema": { - "$ref": "#/components/schemas/ProgressInfo" + "$ref": "#/components/schemas/TaskInfo" } } } @@ -134,63 +134,42 @@ }, "components": { "schemas": { - "HTTPValidationError": { - "properties": { - "detail": { - "items": { - "$ref": "#/components/schemas/ValidationError" - }, - "type": "array", - "title": "Detail" - } - }, - "type": "object", - "title": "HTTPValidationError" - }, - "ProgressInfo": { + "CreationResponse": { "properties": { "task_id": { "type": "string", "title": "Task Id" - }, - "completed": { - "type": "boolean", - "title": "Completed" - }, - "progress_percentage": { - "type": "integer", - "title": "Progress Percentage" - }, - "error": { - "type": "boolean", - "title": "Error" - }, - "error_info": { - "type": "string", - "title": "Error Info" } }, "type": "object", "required": [ - "task_id", - "completed", - "progress_percentage", - "error", - "error_info" + "task_id" ], - "title": "ProgressInfo", + "title": "CreationResponse", "example": { - "completed": true, - "error": false, - "error_info": "", - "progress_percentage": 100, "task_id": "abc-123-def" } }, + "HTTPValidationError": { + "properties": { + "detail": { + "items": { + "$ref": "#/components/schemas/ValidationError" + }, + "type": "array", + "title": "Detail" + } + }, + "type": "object", + "title": "HTTPValidationError" + }, "Submission": { "properties": { "data_folder_uri": { "type": "string", + "maxLength": 2083, + "minLength": 1, + "format": "uri", "title": "Data Folder Uri" }, "model_name": { @@ -215,19 +194,55 @@ "num_steps": 5 } }, - "SubmissionResponse": { + "TaskInfo": { "properties": { "task_id": { "type": "string", "title": "Task Id" + }, + "completed": { + "type": "boolean", + "title": "Completed" + }, + "progress_percentage": { + "type": "integer", + "title": "Progress Percentage" + }, + "success": { + "anyOf": [ + { + "type": "boolean" + }, + { + "type": "null" + } + ], + "title": "Success" + }, + "submitted": { + "type": "boolean", + "title": "Submitted" + }, + "status": { + "type": "string", + "title": "Status" } }, "type": "object", "required": [ - "task_id" + "task_id", + "completed", + "progress_percentage", + "success", + "submitted", + "status" ], - "title": "SubmissionResponse", + "title": "TaskInfo", "example": { + "completed": true, + "error_info": "Queued", + "progress_percentage": 100, + "submitted": true, "task_id": "abc-123-def" } }, From 61a543ff32fef3b8820fadd43e59bbe1bdb15ab3 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 11:59:53 +0100 Subject: [PATCH 28/44] Improve URL parsing --- tests/foundry/conftest.py | 9 ++++----- tests/foundry/docker_server_hook.py | 9 ++++----- 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 8a22bb8..a338db9 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -8,6 +8,7 @@ from contextlib import contextmanager from pathlib import Path from typing import Generator +from urllib.parse import urlparse import pytest import requests @@ -87,12 +88,10 @@ def mock_foundry_client( def _matcher(request: requests.Request) -> requests.Response | None: """Mock requests that check for the existence of blobs.""" - if "blob.core.windows.net/" in request.url: - # Split off the SAS token. - path, _ = request.url.split("?", 1) - # Split off the storage account URL. - _, path = path.split("blob.core.windows.net/", 1) + url = urlparse(request.url) + path = url.path[1:] # Remove leading slash. + if url.hostname and url.hostname.endswith("blob.core.windows.net"): local_path = azcopy_mock_work_dir / path response = requests.Response() diff --git a/tests/foundry/docker_server_hook.py b/tests/foundry/docker_server_hook.py index 8c962a4..9ce36ee 100644 --- a/tests/foundry/docker_server_hook.py +++ b/tests/foundry/docker_server_hook.py @@ -3,6 +3,7 @@ import subprocess import sys from pathlib import Path +from urllib.parse import urlparse # This will be run in the release Docker image, so packages required for mocking are not available. subprocess.check_call([sys.executable, "-m", "pip", "install", "--no-deps", "requests_mock"]) @@ -16,12 +17,10 @@ def _matcher(request: requests.Request) -> requests.Response | None: """Mock requests that check for the existence of blobs.""" - if "blob.core.windows.net/" in request.url: - # Split off the SAS token. - path, _ = request.url.split("?", 1) - # Split off the storage account URL. - _, path = path.split("blob.core.windows.net/", 1) + url = urlparse(request.url) + path = url.path[1:] # Remove leading slash. + if url.hostname and url.hostname.endswith("blob.core.windows.net"): # Assume that the local folder `/azcopy_work` is used by the mock of `azcopy`. local_path = Path("/azcopy_work") / path From 81f46e17546df4e6bab40a20aeeb6e151172b4e5 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 12:09:19 +0100 Subject: [PATCH 29/44] Only require one communication channel --- aurora/foundry/__init__.py | 4 ++-- aurora/foundry/client/api.py | 17 +++++++---------- aurora/foundry/common/channel.py | 10 +++++----- aurora/foundry/server/score.py | 14 +++++++------- docs/foundry/api.rst | 2 +- docs/foundry/submission.md | 19 ++++++++----------- tests/foundry/conftest.py | 10 ++++------ tests/foundry/docker_server_hook.py | 4 ++-- tests/foundry/runner.py | 2 +- 9 files changed, 37 insertions(+), 45 deletions(-) diff --git a/aurora/foundry/__init__.py b/aurora/foundry/__init__.py index 5f5f373..8543a8b 100644 --- a/aurora/foundry/__init__.py +++ b/aurora/foundry/__init__.py @@ -2,10 +2,10 @@ from aurora.foundry.client.api import SubmissionError, submit from aurora.foundry.client.foundry import FoundryClient -from aurora.foundry.common.channel import BlobStorageCommunication +from aurora.foundry.common.channel import BlobStorageChannel __all__ = [ - "BlobStorageCommunication", + "BlobStorageChannel", "FoundryClient", "submit", "SubmissionError", diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index 5cb7225..0e33d24 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -39,8 +39,7 @@ def submit( batch: Batch, model_name: str, num_steps: int, - client_comm: CommunicationChannel, - host_comm: CommunicationChannel, + channel: CommunicationChannel, foundry_client: AbstractFoundryClient, ) -> Generator[Batch, None, None]: """Submit a request to Azure AI Foundry and retrieve the predictions. @@ -50,10 +49,8 @@ def submit( model_name (str): Name of the model. This name must be available in :mod:`aurora_foundry.common.model`. num_steps (int): Number of prediction steps. - client_comm (:class:`aurora_foundry.common.comm.CommunicationChannel`): Channel that the - client uses to send and receive data. - host_comm (:class:`aurora_foundry.common.comm.CommunicationChannel`): Channel that the host - uses to send and receive data. + channel (:class:`aurora_foundry.common.channel.CommunicationChannel`): Channel to use for + sending and receiving data. foundry_client (:class:`aurora_foundry.client.foundry.AbstractFoundryClient`): Client to communicate with Azure Foundry AI. @@ -67,7 +64,7 @@ def submit( task = { "model_name": model_name, "num_steps": num_steps, - "data_folder_uri": host_comm.to_spec(), + "data_folder_uri": channel.to_spec(), } response = foundry_client.submit_task(task) try: @@ -78,7 +75,7 @@ def submit( logger.info(f"Created task `{task_id}` at endpoint.") # Send the initial condition over. - client_comm.send(batch, task_id, "input.nc") + channel.send(batch, task_id, "input.nc") previous_status: str = "No Status" previous_progress: int = 0 @@ -93,7 +90,7 @@ def submit( # If the task has been submitted, we must be able to read the acknowledgement of the # initial condition. try: - client_comm.read(task_id, "input.nc.ack", timeout=120) + channel.read(task_id, "input.nc.ack", timeout=120) except TimeoutError as e: raise SubmissionError("Could not read acknowledgement of initial condition.") from e @@ -114,4 +111,4 @@ def submit( logger.info("Retrieving predictions.") for prediction_name in iterate_prediction_files("prediction.nc", num_steps): - yield client_comm.receive(task_id, prediction_name) + yield channel.receive(task_id, prediction_name) diff --git a/aurora/foundry/common/channel.py b/aurora/foundry/common/channel.py index d1bfd5b..823903e 100644 --- a/aurora/foundry/common/channel.py +++ b/aurora/foundry/common/channel.py @@ -16,7 +16,7 @@ __all__ = [ "CommunicationChannel", - "BlobStorageCommunication", + "BlobStorageChannel", "iterate_prediction_files", ] @@ -178,7 +178,7 @@ def to_spec(self) -> str: """ -class BlobStorageCommunication(CommunicationChannel): +class BlobStorageChannel(CommunicationChannel): """A communication channel via a folder in a Azure Blob Storage container.""" _AZCOPY_EXECUTABLE: list[str] = ["azcopy"] @@ -198,11 +198,11 @@ def to_spec(self) -> str: return self.blob_folder class Spec(BaseModel): - class_name: Literal["BlobStorageCommunication"] + class_name: Literal["BlobStorageChannel"] blob_folder: HttpUrl # TODO: Can we force this to be `https`? - def construct(self) -> "BlobStorageCommunication": - return BlobStorageCommunication(blob_folder=str(self.blob_folder)) + def construct(self) -> "BlobStorageChannel": + return BlobStorageChannel(blob_folder=str(self.blob_folder)) def _blob_path(self, name: str) -> str: """For a given file name `name`, get the full path including the SAS token. diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index 3ad2f4f..af47d91 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -10,7 +10,7 @@ import aurora.foundry.server._hook # noqa: F401 from aurora.foundry.common.channel import ( - BlobStorageCommunication, + BlobStorageChannel, iterate_prediction_files, ) from aurora.foundry.common.model import models @@ -87,12 +87,12 @@ def __call__(self) -> None: try: submission = self.submission - host_comm = BlobStorageCommunication(str(submission.data_folder_uri)) + channel = BlobStorageChannel(str(submission.data_folder_uri)) model_class = models[submission.model_name] model = model_class() - batch = host_comm.receive(self.task_info.task_id, "input.nc") + batch = channel.receive(self.task_info.task_id, "input.nc") logger.info("Running predictions.") for i, (pred, path) in enumerate( @@ -101,7 +101,7 @@ def __call__(self) -> None: iterate_prediction_files("prediction.nc", submission.num_steps), ) ): - host_comm.send(pred, self.task_info.task_id, path) + channel.send(pred, self.task_info.task_id, path) self.task_info.progress_percentage = int((100 * (i + 1)) / submission.num_steps) @@ -154,12 +154,12 @@ def run(input_data: AMLRequest) -> dict: if not task.task_info.submitted: # Attempt to submit the task if the initial condition is available. - comm = BlobStorageCommunication(str(task.submission.data_folder_uri)) - if comm.exists(task_id, "input.nc"): + channel = BlobStorageChannel(str(task.submission.data_folder_uri)) + if channel.exists(task_id, "input.nc"): logger.info("Initial condition was found. Submitting task.") # Send an acknowledgement back to test that the host can write. The client will # check for this acknowledgement. - comm.write(b"", task_id, "input.nc.ack") + channel.write(b"", task_id, "input.nc.ack") # Queue the task. task.task_info.submitted = True diff --git a/docs/foundry/api.rst b/docs/foundry/api.rst index 1138439..eeeae0a 100644 --- a/docs/foundry/api.rst +++ b/docs/foundry/api.rst @@ -8,7 +8,7 @@ Submission .. autoclass:: aurora.foundry.client.foundry.FoundryClient :members: __init__ -.. autoclass:: aurora.foundry.common.channel.BlobStorageCommunication +.. autoclass:: aurora.foundry.common.channel.BlobStorageChannel :members: __init__ diff --git a/docs/foundry/submission.md b/docs/foundry/submission.md index a697314..1763850 100644 --- a/docs/foundry/submission.md +++ b/docs/foundry/submission.md @@ -1,6 +1,6 @@ # Submitting Predictions -To produce predictions on Azure AI Foundry, the client will communicate through +To produce predictions on Azure AI Foundry, the client will communicate with the host through a blob storage container, so `azcopy` needs to be available in the local path. [See here for instructions on how to install `azcopy`.](https://learn.microsoft.com/en-us/azure/storage/common/storage-use-azcopy-v10) @@ -15,21 +15,19 @@ foundry_client = FoundryClient( ) ``` -Then set up a way to communicate with the model running on Foundry. -You likely want to send data back and forth via a folder in a blob storage container: +Then set up a blob storage container for communication with the host: ```python -from aurora.foundry import BlobStorageCommunication +from aurora.foundry import BlobStorageChannel -communication = BlobStorageCommunication( +channel = BlobStorageChannel( "https://my.blob.core.windows.net/container/folder?" ) ``` -The SAS token needs read, write, and list rights. -This API does not automatically delete the model initial condition and predictions that are -uploaded to the blob storage folder. -You will need to do that yourself. +The SAS token needs read and write rights. +This blob storage container will be used to send the initial condition to the host and to retrieve +the predictions from the host. You can now submit requests in the following way: @@ -58,9 +56,8 @@ for pred in submit( batch=initial_condition, model_name="aurora-0.25-small-pretrained", num_steps=4, - client=communication, - host=communication, foundry_client=foundry_client, + channel=communication, ): pass # Do something with `pred`. ``` diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index a338db9..bcafa6b 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -14,7 +14,7 @@ import requests from aurora.foundry.client.foundry import FoundryClient -from aurora.foundry.common.channel import BlobStorageCommunication +from aurora.foundry.common.channel import BlobStorageChannel MOCK_ADDRESS = "https://mock-foundry.azurewebsites.net" @@ -79,7 +79,7 @@ def mock_foundry_client( azcopy_mock_work_dir.mkdir(exist_ok=True, parents=True) azcopy_path = Path(__file__).parents[0] / "azcopy.py" monkeypatch.setattr( - BlobStorageCommunication, + BlobStorageChannel, "_AZCOPY_EXECUTABLE", ["python", str(azcopy_path), str(azcopy_mock_work_dir)], ) @@ -109,8 +109,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: with runner_process(azcopy_mock_work_dir) as (p, stdin, stdout): # noqa: SIM117 with mock_foundry_responses_subprocess(stdin, stdout, requests_mock): yield { - "client_comm": BlobStorageCommunication(blob_url_with_sas), - "host_comm": BlobStorageCommunication(blob_url_with_sas), + "channel": BlobStorageChannel(blob_url_with_sas), "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), } @@ -166,8 +165,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: break yield { - "client_comm": BlobStorageCommunication(blob_url_with_sas), - "host_comm": BlobStorageCommunication(blob_url_with_sas), + "channel": BlobStorageChannel(blob_url_with_sas), "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), } diff --git a/tests/foundry/docker_server_hook.py b/tests/foundry/docker_server_hook.py index 9ce36ee..67c5536 100644 --- a/tests/foundry/docker_server_hook.py +++ b/tests/foundry/docker_server_hook.py @@ -38,10 +38,10 @@ def _matcher(request: requests.Request) -> requests.Response | None: mock.real_http = True mock.add_matcher(_matcher) -from aurora.foundry.common.channel import BlobStorageCommunication # noqa: E402 +from aurora.foundry.common.channel import BlobStorageChannel # noqa: E402 # Second, mock `azcopy`, assuming that the `azcopy` mock working directory is `/azcopy_work`. -BlobStorageCommunication._AZCOPY_EXECUTABLE = [ +BlobStorageChannel._AZCOPY_EXECUTABLE = [ "python", "/aurora_foundry/azcopy.py", "/azcopy_work", diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py index e7035cb..c71fc42 100644 --- a/tests/foundry/runner.py +++ b/tests/foundry/runner.py @@ -47,7 +47,7 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: # At this point, we mock `azcopy` too. azcopy_path = Path(__file__).parents[0] / "azcopy.py" - sys.modules["aurora.foundry"].BlobStorageCommunication._AZCOPY_EXECUTABLE = [ + sys.modules["aurora.foundry"].BlobStorageChannel._AZCOPY_EXECUTABLE = [ "python", str(azcopy_path), str(azcopy_mock_work_path), From dc29d3877d979e1fad7883792405709ed717af61 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 12:13:00 +0100 Subject: [PATCH 30/44] Simplify CI pipeline --- .github/workflows/ci.yaml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index d9f4fab..04949f6 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -28,7 +28,7 @@ jobs: - name: Build Foundry image run: | - DOCKER_IMAGE=aurora-foundry make docker + make docker - name: Install dependencies run: | @@ -37,4 +37,4 @@ jobs: - name: Run tests run: | - DOCKER_IMAGE=aurora-foundry pytest -v --cov=aurora --cov-report term-missing + make test From 472cbbf5585247dc6700af05af2014740d1b524f Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 12:22:15 +0100 Subject: [PATCH 31/44] Fix url parsing --- tests/foundry/conftest.py | 2 +- tests/foundry/docker_server_hook.py | 2 +- tests/foundry/runner.py | 11 ++++++----- 3 files changed, 8 insertions(+), 7 deletions(-) diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index bcafa6b..8b73459 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -91,7 +91,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: url = urlparse(request.url) path = url.path[1:] # Remove leading slash. - if url.hostname and url.hostname.endswith("blob.core.windows.net"): + if url.hostname and url.hostname.endswith(".blob.core.windows.net"): local_path = azcopy_mock_work_dir / path response = requests.Response() diff --git a/tests/foundry/docker_server_hook.py b/tests/foundry/docker_server_hook.py index 67c5536..52867b6 100644 --- a/tests/foundry/docker_server_hook.py +++ b/tests/foundry/docker_server_hook.py @@ -20,7 +20,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: url = urlparse(request.url) path = url.path[1:] # Remove leading slash. - if url.hostname and url.hostname.endswith("blob.core.windows.net"): + if url.hostname and url.hostname.endswith(".blob.core.windows.net"): # Assume that the local folder `/azcopy_work` is used by the mock of `azcopy`. local_path = Path("/azcopy_work") / path diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py index c71fc42..a88c964 100644 --- a/tests/foundry/runner.py +++ b/tests/foundry/runner.py @@ -8,6 +8,7 @@ import logging import sys from pathlib import Path +from urllib.parse import urlparse import click import requests @@ -55,11 +56,11 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: def _matcher(request: requests.Request) -> requests.Response | None: """Mock requests that check for the existence of blobs.""" - if "blob.core.windows.net/" in request.url: - # Split off the SAS token. - path, _ = request.url.split("?", 1) - # Split off the storage account URL. - _, path = path.split("blob.core.windows.net/", 1) + url = urlparse(request.url) + path = url.path[1:] # Remove leading slash. + + if url.hostname and url.hostname.endswith(".blob.core.windows.net"): + local_path = azcopy_mock_work_path / path local_path = azcopy_mock_work_path / path From 23ceb538d544b707f0cb1643c1766ff0ad8f8dd1 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 12:30:13 +0100 Subject: [PATCH 32/44] Add some types --- tests/foundry/conftest.py | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 8b73459..28bf935 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -7,7 +7,7 @@ import time from contextlib import contextmanager from pathlib import Path -from typing import Generator +from typing import IO, Generator, Tuple from urllib.parse import urlparse import pytest @@ -20,7 +20,10 @@ @contextmanager -def runner_process(azcopy_mock_work_dir: Path): +def runner_process( + azcopy_mock_work_dir: Path, +) -> Generator[Tuple[subprocess.Popen, IO, IO], None, None]: + """Launch a runner process that mocks the Azure ML Inference Server.""" score_script_path = Path(__file__).parents[2] / "aurora/foundry/server/score.py" runner_path = Path(__file__).parents[0] / "runner.py" p = subprocess.Popen( @@ -37,7 +40,11 @@ def runner_process(azcopy_mock_work_dir: Path): @contextmanager -def mock_foundry_responses_subprocess(stdin, stdout, requests_mock, base_address=MOCK_ADDRESS): +def mock_foundry_responses_subprocess( + stdin: IO, stdout: IO, requests_mock, base_address: str = MOCK_ADDRESS +) -> Generator[None, None, None]: + """Mock requests to Foundry by redirecting them to the subprocess.""" + def _mock_send(request, context) -> dict: method = request.method.encode("unicode_escape") text = request.text or "" From ad8769586fe79ea5886a19646bf4d451f72d6ccc Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 12:48:58 +0100 Subject: [PATCH 33/44] Add test that uses a real blob storage container --- tests/foundry/conftest.py | 72 +++++++++++++++++++++++------ tests/foundry/docker_server_hook.py | 17 +++---- tests/foundry/runner.py | 58 ++++++++++++----------- 3 files changed, 98 insertions(+), 49 deletions(-) diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index 28bf935..e41741d 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -21,13 +21,22 @@ @contextmanager def runner_process( - azcopy_mock_work_dir: Path, + azcopy_mock_work_path: Path | None, ) -> Generator[Tuple[subprocess.Popen, IO, IO], None, None]: """Launch a runner process that mocks the Azure ML Inference Server.""" score_script_path = Path(__file__).parents[2] / "aurora/foundry/server/score.py" runner_path = Path(__file__).parents[0] / "runner.py" p = subprocess.Popen( - ["python", runner_path, azcopy_mock_work_dir, score_script_path], + [ + "python", + runner_path, + *( + ["--azcopy-mock-work-path", str(azcopy_mock_work_path)] + if azcopy_mock_work_path + else [] + ), + score_script_path, + ], stdin=subprocess.PIPE, stdout=subprocess.PIPE, ) @@ -72,23 +81,18 @@ def _mock_send(request, context) -> dict: yield -@pytest.fixture(params=["subprocess", "docker"]) -def mock_foundry_client( - request, - monkeypatch, - requests_mock, - tmp_path: Path, -) -> Generator[dict, None, None]: +def mock_azcopy(tmp_path: Path, monkeypatch, requests_mock) -> Tuple[Path, Path, str]: + """Mock `azcopy`.""" # Communicate via blob storage, so mock `azcopy` too. - azcopy_mock_work_dir = tmp_path / "azcopy_work" + azcopy_mock_work_path = tmp_path / "azcopy_work" # It's important to already create the work folder. If we don't then the Docker image will # create it, and the permissions will then be wrong. - azcopy_mock_work_dir.mkdir(exist_ok=True, parents=True) + azcopy_mock_work_path.mkdir(exist_ok=True, parents=True) azcopy_path = Path(__file__).parents[0] / "azcopy.py" monkeypatch.setattr( BlobStorageChannel, "_AZCOPY_EXECUTABLE", - ["python", str(azcopy_path), str(azcopy_mock_work_dir)], + ["python", str(azcopy_path), str(azcopy_mock_work_path)], ) # The below test URL must start with `https`! blob_url_with_sas = "https://storageaccount.blob.core.windows.net/container/folder?SAS" @@ -99,7 +103,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: path = url.path[1:] # Remove leading slash. if url.hostname and url.hostname.endswith(".blob.core.windows.net"): - local_path = azcopy_mock_work_dir / path + local_path = azcopy_mock_work_path / path response = requests.Response() if local_path.exists(): @@ -112,8 +116,42 @@ def _matcher(request: requests.Request) -> requests.Response | None: requests_mock.add_matcher(_matcher) + return azcopy_path, azcopy_mock_work_path, blob_url_with_sas + + +@pytest.fixture( + params=[ + "subprocess", + "subprocess-real-container", + "docker", + ] +) +def mock_foundry_client( + request, + tmp_path: Path, + monkeypatch, + requests_mock, +) -> Generator[dict, None, None]: if request.param == "subprocess": - with runner_process(azcopy_mock_work_dir) as (p, stdin, stdout): # noqa: SIM117 + azcopy_path, azcopy_mock_work_path, blob_url_with_sas = mock_azcopy( + tmp_path, monkeypatch, requests_mock + ) + + with runner_process(azcopy_mock_work_path) as (p, stdin, stdout): # noqa: SIM117 + with mock_foundry_responses_subprocess(stdin, stdout, requests_mock): + yield { + "channel": BlobStorageChannel(blob_url_with_sas), + "foundry_client": FoundryClient(MOCK_ADDRESS, "mock-token"), + } + + elif request.param == "subprocess-real-container": + requests_mock.real_http = True + + if "TEST_BLOB_URL_WITH_SAS" not in os.environ: + pytest.skip("`TEST_BLOB_URL_WITH_SAS` is not set, so test cannot be run.") + blob_url_with_sas = os.environ["TEST_BLOB_URL_WITH_SAS"] + + with runner_process(None) as (p, stdin, stdout): # noqa: SIM117 with mock_foundry_responses_subprocess(stdin, stdout, requests_mock): yield { "channel": BlobStorageChannel(blob_url_with_sas), @@ -121,6 +159,10 @@ def _matcher(request: requests.Request) -> requests.Response | None: } elif request.param == "docker": + azcopy_path, azcopy_mock_work_path, blob_url_with_sas = mock_azcopy( + tmp_path, monkeypatch, requests_mock + ) + requests_mock.real_http = True if "DOCKER_IMAGE" not in os.environ: @@ -142,7 +184,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: "--rm", "-t", "-v", - f"{azcopy_mock_work_dir}:/azcopy_work", + f"{azcopy_mock_work_path}:/azcopy_work", "--mount", f"type=bind,src={azcopy_path},dst=/aurora_foundry/azcopy.py,readonly", "--mount", diff --git a/tests/foundry/docker_server_hook.py b/tests/foundry/docker_server_hook.py index 52867b6..ae311db 100644 --- a/tests/foundry/docker_server_hook.py +++ b/tests/foundry/docker_server_hook.py @@ -38,11 +38,12 @@ def _matcher(request: requests.Request) -> requests.Response | None: mock.real_http = True mock.add_matcher(_matcher) -from aurora.foundry.common.channel import BlobStorageChannel # noqa: E402 - -# Second, mock `azcopy`, assuming that the `azcopy` mock working directory is `/azcopy_work`. -BlobStorageChannel._AZCOPY_EXECUTABLE = [ - "python", - "/aurora_foundry/azcopy.py", - "/azcopy_work", -] +if Path("/azcopy_work").exists(): + from aurora.foundry.common.channel import BlobStorageChannel # noqa: E402 + + # Second, mock `azcopy`, assuming that the `azcopy` mock working directory is `/azcopy_work`. + BlobStorageChannel._AZCOPY_EXECUTABLE = [ + "python", + "/aurora_foundry/azcopy.py", + "/azcopy_work", + ] diff --git a/tests/foundry/runner.py b/tests/foundry/runner.py index a88c964..50c5e9b 100644 --- a/tests/foundry/runner.py +++ b/tests/foundry/runner.py @@ -8,6 +8,7 @@ import logging import sys from pathlib import Path +from typing import Callable from urllib.parse import urlparse import click @@ -26,9 +27,8 @@ @click.command() -@click.argument( - "azcopy_mock_work_path", - required=True, +@click.option( + "--azcopy-mock-work-path", type=click.Path( exists=False, file_okay=False, dir_okay=True, resolve_path=True, path_type=Path ), @@ -38,7 +38,7 @@ required=True, type=click.Path(exists=True, file_okay=True, dir_okay=False, resolve_path=True, path_type=Path), ) -def main(azcopy_mock_work_path: Path, path: Path) -> None: +def main(azcopy_mock_work_path: Path | None, path: Path) -> None: spec = util.spec_from_file_location("score", path) assert spec is not None, "Could not load specification." score = util.module_from_spec(spec) @@ -46,36 +46,42 @@ def main(azcopy_mock_work_path: Path, path: Path) -> None: assert spec.loader is not None, "Specification has no loader." spec.loader.exec_module(score) - # At this point, we mock `azcopy` too. - azcopy_path = Path(__file__).parents[0] / "azcopy.py" - sys.modules["aurora.foundry"].BlobStorageChannel._AZCOPY_EXECUTABLE = [ - "python", - str(azcopy_path), - str(azcopy_mock_work_path), - ] + if azcopy_mock_work_path: + # At this point, we mock `azcopy` too. + azcopy_path = Path(__file__).parents[0] / "azcopy.py" + sys.modules["aurora.foundry"].BlobStorageChannel._AZCOPY_EXECUTABLE = [ + "python", + str(azcopy_path), + str(azcopy_mock_work_path), + ] + + _matcher: Callable[[requests.Request], requests.Response | None] | None - def _matcher(request: requests.Request) -> requests.Response | None: - """Mock requests that check for the existence of blobs.""" - url = urlparse(request.url) - path = url.path[1:] # Remove leading slash. + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + url = urlparse(request.url) + path = url.path[1:] # Remove leading slash. - if url.hostname and url.hostname.endswith(".blob.core.windows.net"): - local_path = azcopy_mock_work_path / path + if url.hostname and url.hostname.endswith(".blob.core.windows.net"): + local_path = azcopy_mock_work_path / path - local_path = azcopy_mock_work_path / path + local_path = azcopy_mock_work_path / path - response = requests.Response() - if local_path.exists(): - response.status_code = 200 - else: - response.status_code = 404 - return response + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response - return None + return None + else: + _matcher = None with requests_mock.Mocker() as mock: mock.real_http = True - mock.add_matcher(_matcher) + if _matcher is not None: + mock.add_matcher(_matcher) score.init() From 993f8fd207be77097a028428380d2b3cee0fd4fb Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 12:58:07 +0100 Subject: [PATCH 34/44] Add Docker test for an actual container --- tests/foundry/conftest.py | 63 +++++++++++++++++++++++++++++ tests/foundry/docker_server_hook.py | 51 ++++++++++++----------- 2 files changed, 88 insertions(+), 26 deletions(-) diff --git a/tests/foundry/conftest.py b/tests/foundry/conftest.py index e41741d..28887a9 100644 --- a/tests/foundry/conftest.py +++ b/tests/foundry/conftest.py @@ -124,6 +124,7 @@ def _matcher(request: requests.Request) -> requests.Response | None: "subprocess", "subprocess-real-container", "docker", + "docker-real-container", ] ) def mock_foundry_client( @@ -197,6 +198,68 @@ def mock_foundry_client( docker_image, ], ) + + try: + # Wait for the server to come online. + start = time.time() + while True: + try: + res = requests.get("http://127.0.0.1:5001/") + res.raise_for_status() + except (requests.ConnectionError, requests.HTTPError) as e: + # Try for at most 10 seconds. + if time.time() - start < 10: + time.sleep(0.5) + continue + else: + raise e + break + + yield { + "channel": BlobStorageChannel(blob_url_with_sas), + "foundry_client": FoundryClient("http://127.0.0.1:5001", "mock-token"), + } + + finally: + p.terminate() + p.wait() + + elif request.param == "docker-real-container": + requests_mock.real_http = True + + if "TEST_BLOB_URL_WITH_SAS" not in os.environ: + pytest.skip("`TEST_BLOB_URL_WITH_SAS` is not set, so test cannot be run.") + blob_url_with_sas = os.environ["TEST_BLOB_URL_WITH_SAS"] + + if "DOCKER_IMAGE" not in os.environ: + raise RuntimeError( + "Set the environment variable `DOCKER_IMAGE` " + "to the release image of Aurora Foundry." + ) + docker_image = os.environ["DOCKER_IMAGE"] + + # Run the Docker container. Assume that it has already been built. Insert the hook + # to mock things on the server side. + server_hook = Path(__file__).parents[0] / "docker_server_hook.py" + p = subprocess.Popen( + [ + "docker", + "run", + "-p", + "5001:5001", + "--rm", + "-t", + "--mount", + ( + f"type=bind" + f",src={server_hook}" + f",dst=/aurora_foundry/aurora/foundry/server/_hook.py" + f",readonly" + ), + docker_image, + ], + ) + try: # Wait for the server to come online. start = time.time() diff --git a/tests/foundry/docker_server_hook.py b/tests/foundry/docker_server_hook.py index ae311db..e921820 100644 --- a/tests/foundry/docker_server_hook.py +++ b/tests/foundry/docker_server_hook.py @@ -5,40 +5,39 @@ from pathlib import Path from urllib.parse import urlparse -# This will be run in the release Docker image, so packages required for mocking are not available. -subprocess.check_call([sys.executable, "-m", "pip", "install", "--no-deps", "requests_mock"]) - - -import requests # noqa: E402 -import requests_mock # noqa: E402 - -# First, mock requests that check for the existence of blobs. +# If `/azcopy_work` does not exist, nothing needs to be mocked. +if Path("/azcopy_work").exists(): + # This will be run in the release Docker image, so packages required for mocking are not + # available. + subprocess.check_call([sys.executable, "-m", "pip", "install", "--no-deps", "requests_mock"]) + import requests # noqa: E402 + import requests_mock # noqa: E402 -def _matcher(request: requests.Request) -> requests.Response | None: - """Mock requests that check for the existence of blobs.""" - url = urlparse(request.url) - path = url.path[1:] # Remove leading slash. + # First, mock requests that check for the existence of blobs. - if url.hostname and url.hostname.endswith(".blob.core.windows.net"): - # Assume that the local folder `/azcopy_work` is used by the mock of `azcopy`. - local_path = Path("/azcopy_work") / path + def _matcher(request: requests.Request) -> requests.Response | None: + """Mock requests that check for the existence of blobs.""" + url = urlparse(request.url) + path = url.path[1:] # Remove leading slash. - response = requests.Response() - if local_path.exists(): - response.status_code = 200 - else: - response.status_code = 404 - return response + if url.hostname and url.hostname.endswith(".blob.core.windows.net"): + # Assume that the local folder `/azcopy_work` is used by the mock of `azcopy`. + local_path = Path("/azcopy_work") / path - return None + response = requests.Response() + if local_path.exists(): + response.status_code = 200 + else: + response.status_code = 404 + return response + return None -mock = requests_mock.Mocker().__enter__() -mock.real_http = True -mock.add_matcher(_matcher) + mock = requests_mock.Mocker().__enter__() + mock.real_http = True + mock.add_matcher(_matcher) -if Path("/azcopy_work").exists(): from aurora.foundry.common.channel import BlobStorageChannel # noqa: E402 # Second, mock `azcopy`, assuming that the `azcopy` mock working directory is `/azcopy_work`. From d33c147f418b859bb73b0dd7268aa71a7dbe889c Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 13:11:12 +0100 Subject: [PATCH 35/44] Remove deps from notebooks --- docs/example_era5.ipynb | 2 +- docs/example_hres_0.1.ipynb | 2 +- docs/example_hres_t0.ipynb | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/example_era5.ipynb b/docs/example_era5.ipynb index 85c8f29..19de4ee 100644 --- a/docs/example_era5.ipynb +++ b/docs/example_era5.ipynb @@ -12,7 +12,7 @@ "Running this notebook requires additional Python packages. You can install these as follows:\n", "\n", "```\n", - "pip install cdsapi xarray netcdf4 matplotlib\n", + "pip install cdsapi matplotlib\n", "```\n", "\n", "## Downloading the Data\n", diff --git a/docs/example_hres_0.1.ipynb b/docs/example_hres_0.1.ipynb index 8ef076e..20e42f0 100644 --- a/docs/example_hres_0.1.ipynb +++ b/docs/example_hres_0.1.ipynb @@ -12,7 +12,7 @@ "Running this notebook requires additional Python packages. You can install these as follows:\n", "\n", "```\n", - "pip install requests xarray cfgrib scipy matplotlib\n", + "pip install requests cfgrib matplotlib\n", "```\n", "\n", "\n", diff --git a/docs/example_hres_t0.ipynb b/docs/example_hres_t0.ipynb index d765158..bd192c6 100644 --- a/docs/example_hres_t0.ipynb +++ b/docs/example_hres_t0.ipynb @@ -12,7 +12,7 @@ "Running this notebook requires additional Python packages. You can install these as follows:\n", "\n", "```\n", - "pip install gcsfs cdsapi xarray zarr netcdf4 matplotlib\n", + "pip install gcsfs cdsapi zarr matplotlib\n", "```\n", "\n", "## Downloading the Data\n", From 27321cdbcfbc1b0611877270907cf8ef18c7a44c Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 13:41:24 +0100 Subject: [PATCH 36/44] Add outline of demo --- aurora/foundry/demo/__init__.py | 1 + aurora/foundry/demo/hres_t0_data.py | 140 ++++++++++++++++++++++++++++ docs/_toc.yml | 1 + docs/foundry/demo_hres_t0.ipynb | 124 ++++++++++++++++++++++++ docs/foundry/submission.md | 2 +- 5 files changed, 267 insertions(+), 1 deletion(-) create mode 100644 aurora/foundry/demo/__init__.py create mode 100644 aurora/foundry/demo/hres_t0_data.py create mode 100644 docs/foundry/demo_hres_t0.ipynb diff --git a/aurora/foundry/demo/__init__.py b/aurora/foundry/demo/__init__.py new file mode 100644 index 0000000..a679a52 --- /dev/null +++ b/aurora/foundry/demo/__init__.py @@ -0,0 +1 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" diff --git a/aurora/foundry/demo/hres_t0_data.py b/aurora/foundry/demo/hres_t0_data.py new file mode 100644 index 0000000..b70238a --- /dev/null +++ b/aurora/foundry/demo/hres_t0_data.py @@ -0,0 +1,140 @@ +"""Copyright (c) Microsoft Corporation. Licensed under the MIT license.""" + +import pickle +import subprocess +import sys +from datetime import datetime +from pathlib import Path + +import fsspec +import numpy as np +import torch +import xarray as xr +from huggingface_hub import hf_hub_download + +from aurora import Batch, Metadata + + +def load_batch(day: datetime = datetime(2022, 5, 11), cache_path: str = "~/downloads") -> Batch: + """Download and load an HRES T0 batch for UTC 12 on `day`. + + Automatically installs any required dependencies. + + Caches the data at `cache_path`. + + Requires no authentication. + + Args: + day (datetime, optional): Day to download and load a batch for. Defaults to 5 Nov 2022. + cache_path (str, optional): Path to cache the downloads at. + + Return: + :class:`aurora.batch.Batch`: Batch. + """ + return _load_batch(day.strftime("%Y-%m-%d"), Path(cache_path)) + + +def _load_batch(day: str, cache_path: Path) -> Batch: + subprocess.check_call( + [sys.executable, "-m", "pip", "install", "fsspec", "gcsfs", "zarr", "matplotlib"], + stdout=subprocess.DEVNULL, + ) + + cache_path = cache_path.expanduser() + cache_path.mkdir(parents=True, exist_ok=True) + + # We will download from Google Cloud. + url = "gs://weatherbench2/datasets/hres_t0/2016-2022-6h-1440x721.zarr" + ds: xr.Dataset | None = None + + # Download the surface-level variables. + if not (cache_path / f"{day}-surface-level.nc").exists(): + ds = ds or xr.open_zarr(fsspec.get_mapper(url), chunks=None) + surface_vars = [ + "10m_u_component_of_wind", + "10m_v_component_of_wind", + "2m_temperature", + "mean_sea_level_pressure", + ] + ds_surf = ds[surface_vars].sel(time=day).compute() + ds_surf.to_netcdf(str(cache_path / f"{day}-surface-level.nc")) + + # Download the static variables. + if not (cache_path / "static.nc").exists(): + path = hf_hub_download(repo_id="microsoft/aurora", filename="aurora-0.25-static.pickle") + with open(path, "rb") as f: + static_vars = pickle.load(f) + ds_static = xr.Dataset( + data_vars={k: (["lattitude", "longitude"], v) for k, v in static_vars.items()}, + coords={ + "latitude": ("latitude", np.linspace(90, -90, 721)), + "longitude": ("longitude", np.linspace(0, 360, 1440, endpoint=False)), + }, + ) + ds_static.to_netcdf(str(cache_path / "static.nc")) + + # Download the atmospheric variables. + if not (cache_path / f"{day}-atmospheric.nc").exists(): + ds = ds or xr.open_zarr(fsspec.get_mapper(url), chunks=None) + atmos_vars = [ + "temperature", + "u_component_of_wind", + "v_component_of_wind", + "specific_humidity", + "geopotential", + ] + ds_atmos = ds[atmos_vars].sel(time=day).compute() + ds_atmos.to_netcdf(str(cache_path / f"{day}-atmospheric.nc")) + + static_vars_ds = xr.open_dataset(cache_path / "static.nc", engine="netcdf4") + surf_vars_ds = xr.open_dataset(cache_path / f"{day}-surface-level.nc", engine="netcdf4") + atmos_vars_ds = xr.open_dataset(cache_path / f"{day}-atmospheric.nc", engine="netcdf4") + + i = 2 # Select this time index in the downloaded data. + + def _prepare(x: np.ndarray) -> torch.Tensor: + """Prepare a variable. + + This does the following things: + * Select time indices `i` and `i - 1`. + * Insert an empty batch dimension with `[None]`. + * Flip along the latitude axis to ensure that the latitudes are decreasing. + * Copy the data, because the data must be contiguous when converting to PyTorch. + * Convert to PyTorch. + """ + return torch.from_numpy(x[[i - 1, i]][None][..., ::-1, :].copy()) + + return Batch( + surf_vars={ + "2t": _prepare(surf_vars_ds["2m_temperature"].values), + "10u": _prepare(surf_vars_ds["10m_u_component_of_wind"].values), + "10v": _prepare(surf_vars_ds["10m_v_component_of_wind"].values), + "msl": _prepare(surf_vars_ds["mean_sea_level_pressure"].values), + }, + static_vars={ + # The static variables are constant, so we just get them for the first time. They + # don't need to be flipped along the latitude dimension, because they are from + # ERA5. + "z": torch.from_numpy(static_vars_ds["z"].values[0]), + "slt": torch.from_numpy(static_vars_ds["slt"].values[0]), + "lsm": torch.from_numpy(static_vars_ds["lsm"].values[0]), + }, + atmos_vars={ + "t": _prepare(atmos_vars_ds["temperature"].values), + "u": _prepare(atmos_vars_ds["u_component_of_wind"].values), + "v": _prepare(atmos_vars_ds["v_component_of_wind"].values), + "q": _prepare(atmos_vars_ds["specific_humidity"].values), + "z": _prepare(atmos_vars_ds["geopotential"].values), + }, + metadata=Metadata( + # Flip the latitudes! We need to copy because converting to PyTorch, because the + # data must be contiguous. + lat=torch.from_numpy(surf_vars_ds.latitude.values[::-1].copy()), + lon=torch.from_numpy(surf_vars_ds.longitude.values), + # Converting to `datetime64[s]` ensures that the output of `tolist()` gives + # `datetime.datetime`s. Note that this needs to be a tuple of length one: + # one value for every batch element. + time=(surf_vars_ds.time.values.astype("datetime64[s]").tolist()[i],), + atmos_levels=tuple(int(level) for level in atmos_vars_ds.level.values), + ), + ) diff --git a/docs/_toc.yml b/docs/_toc.yml index b22099d..bf6dc58 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -20,4 +20,5 @@ parts: - file: foundry/intro - file: foundry/submission - file: foundry/server + - file: foundry/demo_hres_t0 - file: foundry/api diff --git a/docs/foundry/demo_hres_t0.ipynb b/docs/foundry/demo_hres_t0.ipynb new file mode 100644 index 0000000..a483f6f --- /dev/null +++ b/docs/foundry/demo_hres_t0.ipynb @@ -0,0 +1,124 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2d2d6659-d16f-4736-91b0-16efdfa58147", + "metadata": {}, + "source": [ + "# Demo: HRES T0" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bba46076-2b4f-452f-b694-ee108eae839d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n", + "/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: '/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/torchvision/image.so: undefined symbol: _ZN3c1017RegisterOperatorsD1Ev'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?\n", + " warn(\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "torchdata 0.6.1 requires torch==2.0.1, but you have torch 2.2.0 which is incompatible.\u001b[0m\u001b[31m\n", + "\u001b[0m" + ] + } + ], + "source": [ + "from aurora.foundry.demo.hres_t0_data import load_batch\n", + "\n", + "initial_condition = load_batch()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "07fd311b-54c0-4144-beb6-4a81d2056507", + "metadata": {}, + "outputs": [], + "source": [ + "from datetime import datetime\n", + "\n", + "import torch\n", + "\n", + "from aurora import Batch, Metadata\n", + "from aurora.foundry import BlobStorageChannel, FoundryClient, submit\n", + "\n", + "foundry_client = FoundryClient(\n", + " endpoint=\"https://endpoint/\",\n", + " token=\"TOKEN\",\n", + ")\n", + "channel = BlobStorageChannel(\"https://my.blob.core.windows.net/container/folder?\")\n", + "\n", + "initial_condition = Batch(\n", + " surf_vars={k: torch.randn(1, 2, 17, 32) for k in (\"2t\", \"10u\", \"10v\", \"msl\")},\n", + " static_vars={k: torch.randn(17, 32) for k in (\"lsm\", \"z\", \"slt\")},\n", + " atmos_vars={k: torch.randn(1, 2, 4, 17, 32) for k in (\"z\", \"u\", \"v\", \"t\", \"q\")},\n", + " metadata=Metadata(\n", + " lat=torch.linspace(90, -90, 17),\n", + " lon=torch.linspace(0, 360, 32 + 1)[:-1],\n", + " time=(datetime(2020, 6, 1, 12, 0),),\n", + " atmos_levels=(100, 250, 500, 850),\n", + " ),\n", + ")\n", + "\n", + "predictions = list(\n", + " submit(\n", + " initial_condition,\n", + " model_name=\"aurora-0.25-finetuned\",\n", + " num_steps=4,\n", + " foundry_client=foundry_client,\n", + " channel=channel,\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5ea3d81c-6932-46f6-a91b-6fc79d549b29", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, ax = plt.subplots(2, 2, figsize=(12, 6.5))\n", + "\n", + "for i in range(ax.shape[0]):\n", + " pred = predictions[i]\n", + "\n", + " ax[i, 0].imshow(pred.surf_vars[\"2t\"][0, 0].numpy() - 273.15, vmin=-50, vmax=50)\n", + " ax[i, 0].set_title(str(pred.metadata.time[0]))\n", + " ax[i, 0].set_xticks([])\n", + " ax[i, 0].set_yticks([])\n", + "\n", + "plt.tight_layout()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/foundry/submission.md b/docs/foundry/submission.md index 1763850..18b7d74 100644 --- a/docs/foundry/submission.md +++ b/docs/foundry/submission.md @@ -57,7 +57,7 @@ for pred in submit( model_name="aurora-0.25-small-pretrained", num_steps=4, foundry_client=foundry_client, - channel=communication, + channel=channel, ): pass # Do something with `pred`. ``` From 842dbc7364b60fc26e55e76d002d52ac00d2d885 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 13:43:44 +0100 Subject: [PATCH 37/44] Let the demo depend on env vars --- docs/foundry/demo_hres_t0.ipynb | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/docs/foundry/demo_hres_t0.ipynb b/docs/foundry/demo_hres_t0.ipynb index a483f6f..1752ec7 100644 --- a/docs/foundry/demo_hres_t0.ipynb +++ b/docs/foundry/demo_hres_t0.ipynb @@ -41,6 +41,7 @@ "metadata": {}, "outputs": [], "source": [ + "import os\n", "from datetime import datetime\n", "\n", "import torch\n", @@ -49,10 +50,10 @@ "from aurora.foundry import BlobStorageChannel, FoundryClient, submit\n", "\n", "foundry_client = FoundryClient(\n", - " endpoint=\"https://endpoint/\",\n", - " token=\"TOKEN\",\n", + " endpoint=os.environ[\"FOUNDRY_ENDPOINT\"],\n", + " token=os.environ[\"FOUNDRY_TOKEN\"],\n", ")\n", - "channel = BlobStorageChannel(\"https://my.blob.core.windows.net/container/folder?\")\n", + "channel = BlobStorageChannel(os.environ[\"BLOB_URL_WITH_SAS\"])\n", "\n", "initial_condition = Batch(\n", " surf_vars={k: torch.randn(1, 2, 17, 32) for k in (\"2t\", \"10u\", \"10v\", \"msl\")},\n", From fd6ef690088734197f4403c08585021c4b4ae260 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 13:44:42 +0100 Subject: [PATCH 38/44] Fix plotting --- docs/foundry/demo_hres_t0.ipynb | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/docs/foundry/demo_hres_t0.ipynb b/docs/foundry/demo_hres_t0.ipynb index 1752ec7..fc2cac0 100644 --- a/docs/foundry/demo_hres_t0.ipynb +++ b/docs/foundry/demo_hres_t0.ipynb @@ -87,15 +87,16 @@ "source": [ "import matplotlib.pyplot as plt\n", "\n", - "fig, ax = plt.subplots(2, 2, figsize=(12, 6.5))\n", + "fig, axs = plt.subplots(2, 2, figsize=(12, 6.5))\n", "\n", - "for i in range(ax.shape[0]):\n", + "for i in range(4):\n", " pred = predictions[i]\n", "\n", - " ax[i, 0].imshow(pred.surf_vars[\"2t\"][0, 0].numpy() - 273.15, vmin=-50, vmax=50)\n", - " ax[i, 0].set_title(str(pred.metadata.time[0]))\n", - " ax[i, 0].set_xticks([])\n", - " ax[i, 0].set_yticks([])\n", + " ax = axs[i // 2, i % 2]\n", + " ax.imshow(pred.surf_vars[\"2t\"][0, 0].numpy() - 273.15, vmin=-50, vmax=50)\n", + " ax.set_title(str(pred.metadata.time[0]))\n", + " ax.set_xticks([])\n", + " ax.set_yticks([])\n", "\n", "plt.tight_layout()" ] From 6de5ca991457a2794dc32191641f5537fef594c3 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 13:45:46 +0100 Subject: [PATCH 39/44] Remove random data --- docs/foundry/demo_hres_t0.ipynb | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/docs/foundry/demo_hres_t0.ipynb b/docs/foundry/demo_hres_t0.ipynb index fc2cac0..2edc40a 100644 --- a/docs/foundry/demo_hres_t0.ipynb +++ b/docs/foundry/demo_hres_t0.ipynb @@ -42,11 +42,7 @@ "outputs": [], "source": [ "import os\n", - "from datetime import datetime\n", "\n", - "import torch\n", - "\n", - "from aurora import Batch, Metadata\n", "from aurora.foundry import BlobStorageChannel, FoundryClient, submit\n", "\n", "foundry_client = FoundryClient(\n", @@ -55,18 +51,6 @@ ")\n", "channel = BlobStorageChannel(os.environ[\"BLOB_URL_WITH_SAS\"])\n", "\n", - "initial_condition = Batch(\n", - " surf_vars={k: torch.randn(1, 2, 17, 32) for k in (\"2t\", \"10u\", \"10v\", \"msl\")},\n", - " static_vars={k: torch.randn(17, 32) for k in (\"lsm\", \"z\", \"slt\")},\n", - " atmos_vars={k: torch.randn(1, 2, 4, 17, 32) for k in (\"z\", \"u\", \"v\", \"t\", \"q\")},\n", - " metadata=Metadata(\n", - " lat=torch.linspace(90, -90, 17),\n", - " lon=torch.linspace(0, 360, 32 + 1)[:-1],\n", - " time=(datetime(2020, 6, 1, 12, 0),),\n", - " atmos_levels=(100, 250, 500, 850),\n", - " ),\n", - ")\n", - "\n", "predictions = list(\n", " submit(\n", " initial_condition,\n", From 22e8fd361418ac7249f9b4bb510f5953aba4d86c Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 14:13:40 +0100 Subject: [PATCH 40/44] Increment version --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index cffd08d..f5cec3a 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ .PHONY: install test docs docker-requirements docker swagger-file DOCKER_WS ?= testwsacr -DOCKER_IMAGE ?= aurora-foundry:20250110-1 +DOCKER_IMAGE ?= aurora-foundry:20250110-2 install: pip install --upgrade pip From cdb0e99e9bb8f132e2c9e38157e8cbaa04a4eb09 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 15:25:32 +0100 Subject: [PATCH 41/44] Run demo --- aurora/foundry/client/api.py | 4 +- aurora/foundry/demo/hres_t0_data.py | 6 +-- docs/foundry/demo_hres_t0.ipynb | 79 ++++++++++++++++++++++++----- 3 files changed, 71 insertions(+), 18 deletions(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index 0e33d24..cc28924 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -75,9 +75,10 @@ def submit( logger.info(f"Created task `{task_id}` at endpoint.") # Send the initial condition over. + logger.info("Uploading initial condition.") channel.send(batch, task_id, "input.nc") - previous_status: str = "No Status" + previous_status: str = "No status" previous_progress: int = 0 while True: @@ -112,3 +113,4 @@ def submit( logger.info("Retrieving predictions.") for prediction_name in iterate_prediction_files("prediction.nc", num_steps): yield channel.receive(task_id, prediction_name) + logger.info("All predictions have been retrieved.") diff --git a/aurora/foundry/demo/hres_t0_data.py b/aurora/foundry/demo/hres_t0_data.py index b70238a..f7600df 100644 --- a/aurora/foundry/demo/hres_t0_data.py +++ b/aurora/foundry/demo/hres_t0_data.py @@ -115,9 +115,9 @@ def _prepare(x: np.ndarray) -> torch.Tensor: # The static variables are constant, so we just get them for the first time. They # don't need to be flipped along the latitude dimension, because they are from # ERA5. - "z": torch.from_numpy(static_vars_ds["z"].values[0]), - "slt": torch.from_numpy(static_vars_ds["slt"].values[0]), - "lsm": torch.from_numpy(static_vars_ds["lsm"].values[0]), + "z": torch.from_numpy(static_vars_ds["z"].values), + "slt": torch.from_numpy(static_vars_ds["slt"].values), + "lsm": torch.from_numpy(static_vars_ds["lsm"].values), }, atmos_vars={ "t": _prepare(atmos_vars_ds["temperature"].values), diff --git a/docs/foundry/demo_hres_t0.ipynb b/docs/foundry/demo_hres_t0.ipynb index 2edc40a..b442a7b 100644 --- a/docs/foundry/demo_hres_t0.ipynb +++ b/docs/foundry/demo_hres_t0.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "bba46076-2b4f-452f-b694-ee108eae839d", "metadata": {}, "outputs": [ @@ -21,10 +21,7 @@ "/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", " from .autonotebook import tqdm as notebook_tqdm\n", "/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: '/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/torchvision/image.so: undefined symbol: _ZN3c1017RegisterOperatorsD1Ev'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?\n", - " warn(\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "torchdata 0.6.1 requires torch==2.0.1, but you have torch 2.2.0 which is incompatible.\u001b[0m\u001b[31m\n", - "\u001b[0m" + " warn(\n" ] } ], @@ -36,15 +33,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "07fd311b-54c0-4144-beb6-4a81d2056507", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-01-10 15:21:47,506 [INFO] Created task `d9100e57-15a4-49fe-8806-c5d67bc3870d` at endpoint.\n", + "2025-01-10 15:21:47,508 [INFO] Uploading initial condition.\n", + "2025-01-10 15:23:16,805 [INFO] Task status update: Queued\n", + "2025-01-10 15:23:23,864 [INFO] Task status update: Running\n", + "2025-01-10 15:23:52,220 [INFO] Task progress update: 25%.\n", + "2025-01-10 15:24:06,459 [INFO] Task progress update: 50%.\n", + "2025-01-10 15:24:13,532 [INFO] Task progress update: 75%.\n", + "2025-01-10 15:24:24,664 [INFO] Task status update: Successfully completed\n", + "2025-01-10 15:24:24,664 [INFO] Task progress update: 100%.\n", + "2025-01-10 15:24:24,665 [INFO] Task has been successfully completed!\n", + "2025-01-10 15:24:24,666 [INFO] Retrieving predictions.\n", + "2025-01-10 15:25:11,602 [INFO] All predictions have been retrieved.\n" + ] + } + ], "source": [ + "import logging\n", "import os\n", "\n", "from aurora.foundry import BlobStorageChannel, FoundryClient, submit\n", "\n", + "# Show what's happening!\n", + "logging.basicConfig(\n", + " level=logging.INFO,\n", + " format=\"%(asctime)s [%(levelname)s] %(message)s\",\n", + " handlers=[logging.StreamHandler()],\n", + " force=True,\n", + ")\n", + "\n", "foundry_client = FoundryClient(\n", " endpoint=os.environ[\"FOUNDRY_ENDPOINT\"],\n", " token=os.environ[\"FOUNDRY_TOKEN\"],\n", @@ -64,25 +89,51 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "5ea3d81c-6932-46f6-a91b-6fc79d549b29", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "from datetime import timedelta\n", + "\n", "import matplotlib.pyplot as plt\n", "\n", - "fig, axs = plt.subplots(2, 2, figsize=(12, 6.5))\n", + "fig, axs = plt.subplots(3, 2, figsize=(10, 8))\n", + "\n", + "ax = axs[0, 0]\n", + "ax.imshow(initial_condition.surf_vars[\"2t\"][0, 0].numpy() - 273.15, vmin=-50, vmax=50)\n", + "ax.set_title(f\"2T at {initial_condition.metadata.time[0] - timedelta(hours=6)} (observed)\")\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "\n", + "ax = axs[0, 1]\n", + "ax.imshow(initial_condition.surf_vars[\"2t\"][0, 1].numpy() - 273.15, vmin=-50, vmax=50)\n", + "ax.set_title(f\"2T at {initial_condition.metadata.time[0]} (observed)\")\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", "\n", - "for i in range(4):\n", - " pred = predictions[i]\n", + "for i in range(2, 6):\n", + " pred = predictions[i - 2]\n", "\n", " ax = axs[i // 2, i % 2]\n", " ax.imshow(pred.surf_vars[\"2t\"][0, 0].numpy() - 273.15, vmin=-50, vmax=50)\n", - " ax.set_title(str(pred.metadata.time[0]))\n", + " ax.set_title(f\"2T at {pred.metadata.time[0]} (prediction)\")\n", " ax.set_xticks([])\n", " ax.set_yticks([])\n", "\n", - "plt.tight_layout()" + "plt.tight_layout()\n", + "plt.subplots_adjust(hspace=0.2)" ] } ], From bbeaa2f35f7d9ccf6e6ab9eb20a298b77efbad94 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Fri, 10 Jan 2025 15:57:06 +0100 Subject: [PATCH 42/44] Silence warnings --- aurora/foundry/demo/hres_t0_data.py | 2 + docs/foundry/demo_hres_t0.ipynb | 57 +++++++++++++++-------------- 2 files changed, 32 insertions(+), 27 deletions(-) diff --git a/aurora/foundry/demo/hres_t0_data.py b/aurora/foundry/demo/hres_t0_data.py index f7600df..0eaecfb 100644 --- a/aurora/foundry/demo/hres_t0_data.py +++ b/aurora/foundry/demo/hres_t0_data.py @@ -35,9 +35,11 @@ def load_batch(day: datetime = datetime(2022, 5, 11), cache_path: str = "~/downl def _load_batch(day: str, cache_path: Path) -> Batch: + # Install any required packages and hide the output. This can be done in a nicer way. subprocess.check_call( [sys.executable, "-m", "pip", "install", "fsspec", "gcsfs", "zarr", "matplotlib"], stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, ) cache_path = cache_path.expanduser() diff --git a/docs/foundry/demo_hres_t0.ipynb b/docs/foundry/demo_hres_t0.ipynb index b442a7b..9ee592a 100644 --- a/docs/foundry/demo_hres_t0.ipynb +++ b/docs/foundry/demo_hres_t0.ipynb @@ -11,29 +11,32 @@ { "cell_type": "code", "execution_count": 1, + "id": "b7320530-4921-4b1f-b0fc-3d6aa6949631", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\") # Silence warnings in this demo." + ] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "bba46076-2b4f-452f-b694-ee108eae839d", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", - "/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/torchvision/io/image.py:13: UserWarning: Failed to load image Python extension: '/home/wessel/miniconda3/envs/climai_global/lib/python3.10/site-packages/torchvision/image.so: undefined symbol: _ZN3c1017RegisterOperatorsD1Ev'If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. Otherwise, there might be something wrong with your environment. Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?\n", - " warn(\n" - ] - } - ], + "outputs": [], "source": [ + "from datetime import datetime\n", + "\n", "from aurora.foundry.demo.hres_t0_data import load_batch\n", "\n", - "initial_condition = load_batch()" + "initial_condition = load_batch(day=datetime(2022, 5, 11))" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "07fd311b-54c0-4144-beb6-4a81d2056507", "metadata": {}, "outputs": [ @@ -41,18 +44,18 @@ "name": "stderr", "output_type": "stream", "text": [ - "2025-01-10 15:21:47,506 [INFO] Created task `d9100e57-15a4-49fe-8806-c5d67bc3870d` at endpoint.\n", - "2025-01-10 15:21:47,508 [INFO] Uploading initial condition.\n", - "2025-01-10 15:23:16,805 [INFO] Task status update: Queued\n", - "2025-01-10 15:23:23,864 [INFO] Task status update: Running\n", - "2025-01-10 15:23:52,220 [INFO] Task progress update: 25%.\n", - "2025-01-10 15:24:06,459 [INFO] Task progress update: 50%.\n", - "2025-01-10 15:24:13,532 [INFO] Task progress update: 75%.\n", - "2025-01-10 15:24:24,664 [INFO] Task status update: Successfully completed\n", - "2025-01-10 15:24:24,664 [INFO] Task progress update: 100%.\n", - "2025-01-10 15:24:24,665 [INFO] Task has been successfully completed!\n", - "2025-01-10 15:24:24,666 [INFO] Retrieving predictions.\n", - "2025-01-10 15:25:11,602 [INFO] All predictions have been retrieved.\n" + "2025-01-10 15:52:44,690 [INFO] Created task `405b219d-6cc5-4eca-b397-ad5f600e88da` at endpoint.\n", + "2025-01-10 15:52:44,692 [INFO] Uploading initial condition.\n", + "2025-01-10 15:54:09,879 [INFO] Task status update: Queued\n", + "2025-01-10 15:54:16,912 [INFO] Task status update: Running\n", + "2025-01-10 15:54:45,086 [INFO] Task progress update: 25%.\n", + "2025-01-10 15:54:59,139 [INFO] Task progress update: 50%.\n", + "2025-01-10 15:55:13,204 [INFO] Task progress update: 75%.\n", + "2025-01-10 15:55:20,279 [INFO] Task progress update: 100%.\n", + "2025-01-10 15:55:24,403 [INFO] Task status update: Successfully completed\n", + "2025-01-10 15:55:24,404 [INFO] Task has been successfully completed!\n", + "2025-01-10 15:55:24,404 [INFO] Retrieving predictions.\n", + "2025-01-10 15:56:21,104 [INFO] All predictions have been retrieved.\n" ] } ], @@ -89,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "5ea3d81c-6932-46f6-a91b-6fc79d549b29", "metadata": {}, "outputs": [ From 690e0a4564bbf0d2f7df7d853fd96e74fac53264 Mon Sep 17 00:00:00 2001 From: Wessel Bruinsma Date: Sat, 11 Jan 2025 15:56:56 +0100 Subject: [PATCH 43/44] Read the acknowledgement only once --- aurora/foundry/client/api.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/aurora/foundry/client/api.py b/aurora/foundry/client/api.py index cc28924..deb336b 100644 --- a/aurora/foundry/client/api.py +++ b/aurora/foundry/client/api.py @@ -80,6 +80,7 @@ def submit( previous_status: str = "No status" previous_progress: int = 0 + ack_read: bool = False while True: # Check on the progress of the task. The first progress check will trigger the task to be @@ -87,11 +88,12 @@ def submit( response = foundry_client.get_progress(task_id) task_info = TaskInfo(**response) - if task_info.submitted: + if task_info.submitted and not ack_read: # If the task has been submitted, we must be able to read the acknowledgement of the # initial condition. try: channel.read(task_id, "input.nc.ack", timeout=120) + ack_read = True # Read the acknowledgement only once. except TimeoutError as e: raise SubmissionError("Could not read acknowledgement of initial condition.") from e From 893fb196cb1e2aad9aed43927de5ec4960c7a283 Mon Sep 17 00:00:00 2001 From: Hannes Schulz Date: Sat, 11 Jan 2025 21:20:22 +0100 Subject: [PATCH 44/44] enable aurora logger --- aurora/foundry/server/score.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/aurora/foundry/server/score.py b/aurora/foundry/server/score.py index af47d91..ecd9ff5 100644 --- a/aurora/foundry/server/score.py +++ b/aurora/foundry/server/score.py @@ -119,6 +119,8 @@ def __call__(self) -> None: def init() -> None: """Initialise. Do not load the model here, because which model we need depends on the submission.""" + logging.getLogger("aurora").setLevel(logging.INFO) + logger.info("Starting ThreadPoolExecutor") POOL.__enter__()