Add files using upload-large-folder tool

.gitattributes

@@ -146,3 +146,4 @@ parrot/lib/libreadline.a filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/wandb/vendor/pygments/lexers/__pycache__/_php_builtins.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/aiohttp/_http_writer.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libquadmath.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/pyarrow/_dataset_parquet.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

parrot/lib/python3.10/site-packages/pyarrow/_dataset_parquet.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:178e9547694aa62399bc0cf44c530a767396b5da9344416107b76c83bfe05d02
+size 364184

parrot/lib/python3.10/site-packages/wandb/sdk/launch/builder/build.py

@@ -0,0 +1,297 @@
+import hashlib
+import json
+import logging
+import os
+import pathlib
+import shlex
+from typing import Any, Dict, List, Tuple
+
+from dockerpycreds.utils import find_executable  # type: ignore
+
+import wandb
+import wandb.env
+from wandb import docker
+from wandb.apis.internal import Api
+from wandb.sdk.launch.loader import (
+    builder_from_config,
+    environment_from_config,
+    registry_from_config,
+)
+from wandb.util import get_module
+
+from .._project_spec import EntryPoint, LaunchProject
+from ..errors import ExecutionError, LaunchError
+from ..utils import LOG_PREFIX, event_loop_thread_exec
+from .templates.dockerfile import (
+    ACCELERATOR_SETUP_TEMPLATE,
+    ENTRYPOINT_TEMPLATE,
+    PIP_TEMPLATE,
+    PYTHON_SETUP_TEMPLATE,
+    USER_CREATE_TEMPLATE,
+)
+
+_logger = logging.getLogger(__name__)
+
+
+_WANDB_DOCKERFILE_NAME = "Dockerfile.wandb"
+
+
+async def validate_docker_installation() -> None:
+    """Verify if Docker is installed on host machine."""
+    find_exec = event_loop_thread_exec(find_executable)
+    if not await find_exec("docker"):
+        raise ExecutionError(
+            "Could not find Docker executable. "
+            "Ensure Docker is installed as per the instructions "
+            "at https://docs.docker.com/install/overview/."
+        )
+
+
+def join(split_command: List[str]) -> str:
+    """Return a shell-escaped string from *split_command*.
+
+    Also remove quotes from double quoted strings. Ex:
+    "'local container queue'" --> "local container queue"
+    """
+    return " ".join(shlex.quote(arg.replace("'", "")) for arg in split_command)
+
+
+async def build_image_from_project(
+    launch_project: LaunchProject,
+    api: Api,
+    launch_config: Dict[str, Any],
+) -> str:
+    """Construct a docker image from a project and returns the URI of the image.
+
+    Arguments:
+        launch_project: The project to build an image from.
+        api: The API object to use for fetching the project.
+        launch_config: The launch config to use for building the image.
+
+    Returns:
+        The URI of the built image.
+    """
+    assert launch_project.uri, "To build an image on queue a URI must be set."
+    launch_config = launch_config or {}
+    env_config = launch_config.get("environment", {})
+    if not isinstance(env_config, dict):
+        wrong_type = type(env_config).__name__
+        raise LaunchError(
+            f"Invalid environment config: {env_config} of type {wrong_type} "
+            "loaded from launch config. Expected dict."
+        )
+    environment = environment_from_config(env_config)
+
+    registry_config = launch_config.get("registry", {})
+    if not isinstance(registry_config, dict):
+        wrong_type = type(registry_config).__name__
+        raise LaunchError(
+            f"Invalid registry config: {registry_config} of type {wrong_type}"
+            " loaded from launch config. Expected dict."
+        )
+    registry = registry_from_config(registry_config, environment)
+
+    builder_config = launch_config.get("builder", {})
+    if not isinstance(builder_config, dict):
+        wrong_type = type(builder_config).__name__
+        raise LaunchError(
+            f"Invalid builder config: {builder_config} of type {wrong_type} "
+            "loaded from launch config. Expected dict."
+        )
+    builder = builder_from_config(builder_config, environment, registry)
+
+    if not builder:
+        raise LaunchError("Unable to build image. No builder found.")
+
+    launch_project.fetch_and_validate_project()
+
+    entry_point = (
+        launch_project.get_job_entry_point() or launch_project.override_entrypoint
+    )
+    assert entry_point is not None
+    wandb.termlog(f"{LOG_PREFIX}Building docker image from uri source")
+    image_uri = await builder.build_image(launch_project, entry_point)
+    if not image_uri:
+        raise LaunchError("Error building image uri")
+    else:
+        return image_uri
+
+
+def image_tag_from_dockerfile_and_source(
+    launch_project: LaunchProject, dockerfile_contents: str
+) -> str:
+    """Hashes the source and dockerfile contents into a unique tag."""
+    image_source_string = launch_project.get_image_source_string()
+    unique_id_string = image_source_string + dockerfile_contents
+    image_tag = hashlib.sha256(unique_id_string.encode("utf-8")).hexdigest()[:8]
+    return image_tag
+
+
+def get_docker_user(launch_project: LaunchProject, runner_type: str) -> Tuple[str, int]:
+    import getpass
+
+    username = getpass.getuser()
+
+    if runner_type == "sagemaker" and not launch_project.docker_image:
+        # unless user has provided their own image, sagemaker must run as root but keep the name for workdir etc
+        return username, 0
+
+    userid = launch_project.docker_user_id or os.geteuid()
+    return username, userid
+
+
+def get_base_setup(
+    launch_project: LaunchProject, py_version: str, py_major: str
+) -> str:
+    """Fill in the Dockerfile templates for stage 2 of build.
+
+    CPU version is built on python, Accelerator version is built on user provided.
+    """
+    minor = int(py_version.split(".")[1])
+    if minor < 12:
+        python_base_image = f"python:{py_version}-buster"
+    else:
+        python_base_image = f"python:{py_version}-bookworm"
+    if launch_project.accelerator_base_image:
+        _logger.info(
+            f"Using accelerator base image: {launch_project.accelerator_base_image}"
+        )
+        python_packages = [
+            f"python{py_version}",
+            f"libpython{py_version}",
+            "python3-pip",
+            "python3-setuptools",
+        ]
+        base_setup = ACCELERATOR_SETUP_TEMPLATE.format(
+            accelerator_base_image=launch_project.accelerator_base_image,
+            python_packages=" \\\n".join(python_packages),
+            py_version=py_version,
+        )
+    else:
+        python_packages = [
+            "python3-dev",
+            "gcc",
+        ]  # gcc required for python < 3.7 for some reason
+        base_setup = PYTHON_SETUP_TEMPLATE.format(py_base_image=python_base_image)
+    return base_setup
+
+
+# Move this into the build context manager.
+def get_requirements_section(
+    launch_project: LaunchProject, build_context_dir: str, builder_type: str
+) -> str:
+    if builder_type == "docker":
+        buildx_installed = docker.is_buildx_installed()
+        if not buildx_installed:
+            wandb.termwarn(
+                "Docker BuildX is not installed, for faster builds upgrade docker: https://github.com/docker/buildx#installing"
+            )
+            prefix = "RUN WANDB_DISABLE_CACHE=true"
+    elif builder_type == "kaniko":
+        prefix = "RUN WANDB_DISABLE_CACHE=true"
+        buildx_installed = False
+
+    if buildx_installed:
+        prefix = "RUN --mount=type=cache,mode=0777,target=/root/.cache/pip"
+
+    requirements_files = []
+    deps_install_line = None
+
+    base_path = pathlib.Path(build_context_dir)
+    # If there is a requirements.txt at root of build context, use that.
+    if (base_path / "src" / "requirements.txt").exists():
+        requirements_files += ["src/requirements.txt"]
+        deps_install_line = "pip install uv && uv pip install -r requirements.txt"
+        with open(base_path / "src" / "requirements.txt") as f:
+            requirements = f.readlines()
+        if not any(["wandb" in r for r in requirements]):
+            wandb.termwarn(f"{LOG_PREFIX}wandb is not present in requirements.txt.")
+        return PIP_TEMPLATE.format(
+            buildx_optional_prefix=prefix,
+            requirements_files=" ".join(requirements_files),
+            pip_install=deps_install_line,
+        )
+
+    # Elif there is pyproject.toml at build context, convert the dependencies
+    # section to a requirements.txt and use that.
+    elif (base_path / "src" / "pyproject.toml").exists():
+        tomli = get_module("tomli")
+        if tomli is None:
+            wandb.termwarn(
+                "pyproject.toml found but tomli could not be loaded. To "
+                "install dependencies from pyproject.toml please run "
+                "`pip install tomli` and try again."
+            )
+        else:
+            # First try to read deps from standard pyproject format.
+            with open(base_path / "src" / "pyproject.toml", "rb") as f:
+                contents = tomli.load(f)
+            project_deps = [
+                str(d) for d in contents.get("project", {}).get("dependencies", [])
+            ]
+            if project_deps:
+                if not any(["wandb" in d for d in project_deps]):
+                    wandb.termwarn(
+                        f"{LOG_PREFIX}wandb is not present as a dependency in pyproject.toml."
+                    )
+                with open(base_path / "src" / "requirements.txt", "w") as f:
+                    f.write("\n".join(project_deps))
+                requirements_files += ["src/requirements.txt"]
+                deps_install_line = (
+                    "pip install uv && uv pip install -r requirements.txt"
+                )
+                return PIP_TEMPLATE.format(
+                    buildx_optional_prefix=prefix,
+                    requirements_files=" ".join(requirements_files),
+                    pip_install=deps_install_line,
+                )
+
+    # Else use frozen requirements from wandb run.
+    if (
+        not deps_install_line
+        and (base_path / "src" / "requirements.frozen.txt").exists()
+    ):
+        requirements_files += [
+            "src/requirements.frozen.txt",
+            "_wandb_bootstrap.py",
+        ]
+        deps_install_line = (
+            launch_project.parse_existing_requirements() + "python _wandb_bootstrap.py"
+        )
+
+        if not deps_install_line:
+            raise LaunchError(f"No dependency sources found for {launch_project}")
+
+        with open(base_path / "src" / "requirements.frozen.txt") as f:
+            requirements = f.readlines()
+        if not any(["wandb" in r for r in requirements]):
+            wandb.termwarn(
+                f"{LOG_PREFIX}wandb is not present in requirements.frozen.txt."
+            )
+
+        return PIP_TEMPLATE.format(
+            buildx_optional_prefix=prefix,
+            requirements_files=" ".join(requirements_files),
+            pip_install=deps_install_line,
+        )
+
+    else:
+        # this means no deps file was found
+        requirements_line = "RUN mkdir -p env/"  # Docker fails otherwise
+        wandb.termwarn("No requirements file found. No packages will be installed.")
+        return requirements_line
+
+
+def get_user_setup(username: str, userid: int, runner_type: str) -> str:
+    if runner_type == "sagemaker":
+        # sagemaker must run as root
+        return "USER root"
+    user_create = USER_CREATE_TEMPLATE.format(uid=userid, user=username)
+    user_create += f"\nUSER {username}"
+    return user_create
+
+
+def get_entrypoint_setup(
+    entry_point: EntryPoint,
+) -> str:
+    return ENTRYPOINT_TEMPLATE.format(entrypoint=json.dumps(entry_point.command))

parrot/lib/python3.10/site-packages/wandb/sdk/launch/builder/docker_builder.py

@@ -0,0 +1,177 @@
+"""Implementation of the docker builder."""
+
+import logging
+import os
+from typing import Any, Dict, Optional
+
+import wandb
+import wandb.docker as docker
+from wandb.sdk.launch.agent.job_status_tracker import JobAndRunStatusTracker
+from wandb.sdk.launch.builder.abstract import AbstractBuilder, registry_from_uri
+from wandb.sdk.launch.environment.abstract import AbstractEnvironment
+from wandb.sdk.launch.registry.abstract import AbstractRegistry
+
+from .._project_spec import EntryPoint, LaunchProject
+from ..errors import LaunchDockerError, LaunchError
+from ..registry.anon import AnonynmousRegistry
+from ..registry.local_registry import LocalRegistry
+from ..utils import (
+    LOG_PREFIX,
+    event_loop_thread_exec,
+    warn_failed_packages_from_build_logs,
+)
+from .build import _WANDB_DOCKERFILE_NAME, validate_docker_installation
+from .context_manager import BuildContextManager
+
+_logger = logging.getLogger(__name__)
+
+
+class DockerBuilder(AbstractBuilder):
+    """Builds a docker image for a project.
+
+    Attributes:
+        builder_config (Dict[str, Any]): The builder config.
+
+    """
+
+    builder_type = "docker"
+    target_platform = "linux/amd64"
+
+    def __init__(
+        self,
+        environment: AbstractEnvironment,
+        registry: AbstractRegistry,
+        config: Dict[str, Any],
+    ):
+        """Initialize a DockerBuilder.
+
+        Arguments:
+            environment (AbstractEnvironment): The environment to use.
+            registry (AbstractRegistry): The registry to use.
+
+        Raises:
+            LaunchError: If docker is not installed
+        """
+        self.environment = environment  # Docker builder doesn't actually use this.
+        self.registry = registry
+        self.config = config
+
+    @classmethod
+    def from_config(
+        cls,
+        config: Dict[str, Any],
+        environment: AbstractEnvironment,
+        registry: AbstractRegistry,
+    ) -> "DockerBuilder":
+        """Create a DockerBuilder from a config.
+
+        Arguments:
+            config (Dict[str, Any]): The config.
+            registry (AbstractRegistry): The registry to use.
+            verify (bool, optional): Whether to verify the functionality of the builder.
+            login (bool, optional): Whether to login to the registry.
+
+        Returns:
+            DockerBuilder: The DockerBuilder.
+        """
+        # If the user provided a destination URI in the builder config
+        # we use that as the registry.
+        image_uri = config.get("destination")
+        if image_uri:
+            if registry is not None:
+                wandb.termwarn(
+                    f"{LOG_PREFIX}Overriding registry from registry config"
+                    f" with {image_uri} from builder config."
+                )
+            registry = registry_from_uri(image_uri)
+
+        return cls(environment, registry, config)
+
+    async def verify(self) -> None:
+        """Verify the builder."""
+        await validate_docker_installation()
+
+    async def login(self) -> None:
+        """Login to the registry."""
+        if isinstance(self.registry, LocalRegistry):
+            _logger.info(f"{LOG_PREFIX}No registry configured, skipping login.")
+        elif isinstance(self.registry, AnonynmousRegistry):
+            _logger.info(f"{LOG_PREFIX}Anonymous registry, skipping login.")
+        else:
+            username, password = await self.registry.get_username_password()
+            login = event_loop_thread_exec(docker.login)
+            await login(username, password, self.registry.uri)
+
+    async def build_image(
+        self,
+        launch_project: LaunchProject,
+        entrypoint: EntryPoint,
+        job_tracker: Optional[JobAndRunStatusTracker] = None,
+    ) -> str:
+        """Build the image for the given project.
+
+        Arguments:
+            launch_project (LaunchProject): The project to build.
+            entrypoint (EntryPoint): The entrypoint to use.
+        """
+        await self.verify()
+        await self.login()
+
+        build_context_manager = BuildContextManager(launch_project=launch_project)
+        build_ctx_path, image_tag = build_context_manager.create_build_context("docker")
+        dockerfile = os.path.join(build_ctx_path, _WANDB_DOCKERFILE_NAME)
+        repository = None if not self.registry else await self.registry.get_repo_uri()
+
+        # if repo is set, use the repo name as the image name
+        if repository:
+            image_uri = f"{repository}:{image_tag}"
+        # otherwise, base the image name off of the source
+        # which the launch_project checks in image_name
+        else:
+            image_uri = f"{launch_project.image_name}:{image_tag}"
+
+        if (
+            not launch_project.build_required()
+            and await self.registry.check_image_exists(image_uri)
+        ):
+            return image_uri
+
+        _logger.info(
+            f"image {image_uri} does not already exist in repository, building."
+        )
+        try:
+            output = await event_loop_thread_exec(docker.build)(
+                tags=[image_uri],
+                file=dockerfile,
+                context_path=build_ctx_path,
+                platform=self.config.get("platform"),
+            )
+
+            warn_failed_packages_from_build_logs(
+                output, image_uri, launch_project.api, job_tracker
+            )
+
+        except docker.DockerError as e:
+            if job_tracker:
+                job_tracker.set_err_stage("build")
+            raise LaunchDockerError(f"Error communicating with docker client: {e}")
+
+        try:
+            os.remove(build_ctx_path)
+        except Exception:
+            _msg = f"{LOG_PREFIX}Temporary docker context file {build_ctx_path} was not deleted."
+            _logger.info(_msg)
+
+        if repository:
+            reg, tag = image_uri.split(":")
+            wandb.termlog(f"{LOG_PREFIX}Pushing image {image_uri}")
+            push_resp = await event_loop_thread_exec(docker.push)(reg, tag)
+            if push_resp is None:
+                raise LaunchError("Failed to push image to repository")
+            elif (
+                launch_project.resource == "sagemaker"
+                and f"The push refers to repository [{repository}]" not in push_resp
+            ):
+                raise LaunchError(f"Unable to push image to ECR, response: {push_resp}")
+
+        return image_uri

parrot/lib/python3.10/site-packages/wandb/sdk/launch/builder/templates/dockerfile.py

@@ -0,0 +1,92 @@
+DOCKERFILE_TEMPLATE = """
+# ----- stage 1: build -----
+FROM {py_build_image} as build
+
+# requirements section depends on pip vs conda, and presence of buildx
+ENV PIP_PROGRESS_BAR off
+{requirements_section}
+
+# ----- stage 2: base -----
+{base_setup}
+
+COPY --from=build /env /env
+ENV PATH="/env/bin:$PATH"
+
+ENV SHELL /bin/bash
+
+# some resources (eg sagemaker) must run on root
+{user_setup}
+
+WORKDIR {workdir}
+RUN chown -R {uid} {workdir}
+
+# make artifacts cache dir unrelated to build
+RUN mkdir -p {workdir}/.cache && chown -R {uid} {workdir}/.cache
+
+# copy code/etc
+COPY --chown={uid} src/ {workdir}
+
+ENV PYTHONUNBUFFERED=1
+
+{entrypoint_section}
+"""
+
+# this goes into base_setup in TEMPLATE
+PYTHON_SETUP_TEMPLATE = """
+FROM {py_base_image} as base
+"""
+
+# this goes into base_setup in TEMPLATE
+ACCELERATOR_SETUP_TEMPLATE = """
+FROM {accelerator_base_image} as base
+
+# make non-interactive so build doesn't block on questions
+ENV DEBIAN_FRONTEND=noninteractive
+
+# install python
+RUN apt-get update -qq && apt-get install --no-install-recommends -y \
+    {python_packages} \
+    && apt-get -qq purge && apt-get -qq clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# make sure `python` points at the right version
+RUN update-alternatives --install /usr/bin/python python /usr/bin/python{py_version} 1 \
+    && update-alternatives --install /usr/local/bin/python python /usr/bin/python{py_version} 1
+"""
+
+# this goes into requirements_section in TEMPLATE
+PIP_TEMPLATE = """
+RUN python -m venv /env
+# make sure we install into the env
+ENV PATH="/env/bin:$PATH"
+
+COPY {requirements_files} ./
+{buildx_optional_prefix} {pip_install}
+"""
+
+# this goes into requirements_section in TEMPLATE
+CONDA_TEMPLATE = """
+COPY src/environment.yml .
+{buildx_optional_prefix} conda env create -f environment.yml -n env
+
+# pack the environment so that we can transfer to the base image
+RUN conda install -c conda-forge conda-pack
+RUN conda pack -n env -o /tmp/env.tar && \
+    mkdir /env && cd /env && tar xf /tmp/env.tar && \
+    rm /tmp/env.tar
+RUN /env/bin/conda-unpack
+"""
+
+USER_CREATE_TEMPLATE = """
+RUN useradd \
+    --create-home \
+    --no-log-init \
+    --shell /bin/bash \
+    --gid 0 \
+    --uid {uid} \
+    {user} || echo ""
+"""
+
+ENTRYPOINT_TEMPLATE = """
+ENTRYPOINT {entrypoint}
+"""

parrot/lib/python3.10/site-packages/wandb/sdk/launch/runner/abstract.py

@@ -0,0 +1,195 @@
+"""Implementation of the abstract runner class.
+
+This class defines the interface that the W&B launch runner uses to manage the lifecycle
+of runs launched in different environments (e.g. runs launched locally or in a cluster).
+"""
+
+import logging
+import os
+import subprocess
+import sys
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Union
+
+from dockerpycreds.utils import find_executable  # type: ignore
+
+import wandb
+from wandb.apis.internal import Api
+from wandb.sdk.lib import runid
+
+from .._project_spec import LaunchProject
+
+_logger = logging.getLogger(__name__)
+
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+State = Literal[
+    "unknown",
+    "starting",
+    "running",
+    "failed",
+    "finished",
+    "stopping",
+    "stopped",
+    "preempted",
+]
+
+
+class Status:
+    def __init__(self, state: "State" = "unknown", messages: List[str] = None):  # type: ignore
+        self.state = state
+        self.messages = messages or []
+
+    def __repr__(self) -> "State":
+        return self.state
+
+    def __str__(self) -> str:
+        return self.state
+
+    def __eq__(self, __value: object) -> bool:
+        if isinstance(__value, Status):
+            return self.state == __value.state
+        else:
+            return self.state == __value
+
+    def __hash__(self) -> int:
+        return hash(self.state)
+
+
+class AbstractRun(ABC):
+    """Wrapper around a W&B launch run.
+
+    A launched run is a subprocess running an entry point
+    command, that exposes methods for waiting on and cancelling the run.
+    This class defines the interface that the W&B launch runner uses to manage the lifecycle
+    of runs launched in different environments (e.g. runs launched locally or in a cluster).
+    ``AbstractRun`` is not thread-safe. That is, concurrent calls to wait() / cancel()
+    from multiple threads may inadvertently kill resources (e.g. local processes) unrelated to the
+    run.
+    """
+
+    def __init__(self) -> None:
+        self._status = Status()
+
+    @property
+    def status(self) -> Status:
+        return self._status
+
+    @abstractmethod
+    async def get_logs(self) -> Optional[str]:
+        """Return the logs associated with the run."""
+        pass
+
+    def _run_cmd(
+        self, cmd: List[str], output_only: Optional[bool] = False
+    ) -> Optional[Union["subprocess.Popen[bytes]", bytes]]:
+        """Run the command and returns a popen object or the stdout of the command.
+
+        Arguments:
+        cmd: The command to run
+        output_only: If true just return the stdout bytes
+        """
+        try:
+            env = os.environ
+            popen = subprocess.Popen(cmd, env=env, stdout=subprocess.PIPE)
+            if output_only:
+                popen.wait()
+                if popen.stdout is not None:
+                    return popen.stdout.read()
+            return popen
+        except subprocess.CalledProcessError as e:
+            wandb.termerror(f"Command failed: {e}")
+            return None
+
+    @abstractmethod
+    async def wait(self) -> bool:
+        """Wait for the run to finish, returning True if the run succeeded and false otherwise.
+
+        Note that in some cases, we may wait until the remote job completes rather than until the W&B run completes.
+        """
+        pass
+
+    @abstractmethod
+    async def get_status(self) -> Status:
+        """Get status of the run."""
+        pass
+
+    @abstractmethod
+    async def cancel(self) -> None:
+        """Cancel the run (interrupts the command subprocess, cancels the run, etc).
+
+        Cancels the run and waits for it to terminate. The W&B run status may not be
+        set correctly upon run cancellation.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def id(self) -> Optional[str]:
+        pass
+
+
+class AbstractRunner(ABC):
+    """Abstract plugin class defining the interface needed to execute W&B Launches.
+
+    You can define subclasses of ``AbstractRunner`` and expose them as third-party
+    plugins to enable running W&B projects against custom execution backends
+    (e.g. to run projects against your team's in-house cluster or job scheduler).
+    """
+
+    _type: str
+
+    def __init__(
+        self,
+        api: Api,
+        backend_config: Dict[str, Any],
+    ) -> None:
+        self._api = api
+        self.backend_config = backend_config
+        self._cwd = os.getcwd()
+        self._namespace = runid.generate_id()
+
+    def find_executable(
+        self, cmd: str
+    ) -> Any:  # should return a string, but mypy doesn't trust find_executable
+        """Cross platform utility for checking if a program is available."""
+        return find_executable(cmd)
+
+    @property
+    def api_key(self) -> Any:
+        return self._api.api_key
+
+    def verify(self) -> bool:
+        """This is called on first boot to verify the needed commands, and permissions are available.
+
+        For now just call `wandb.termerror` and `sys.exit(1)`
+        """
+        if self._api.api_key is None:
+            wandb.termerror(
+                "Couldn't find W&B api key, run wandb login or set WANDB_API_KEY"
+            )
+            sys.exit(1)
+        return True
+
+    @abstractmethod
+    async def run(
+        self,
+        launch_project: LaunchProject,
+        image_uri: str,
+    ) -> Optional[AbstractRun]:
+        """Submit an LaunchProject to be run.
+
+        Returns a SubmittedRun object to track the execution
+        Arguments:
+        launch_project: Object of _project_spec.LaunchProject class representing a wandb launch project
+
+        Returns:
+            A :py:class:`wandb.sdk.launch.runners.SubmittedRun`. This function is expected to run
+            the project asynchronously, i.e. it should trigger project execution and then
+            immediately return a `SubmittedRun` to track execution status.
+        """
+        pass

parrot/lib/python3.10/site-packages/wandb/sdk/launch/runner/kubernetes_monitor.py

@@ -0,0 +1,474 @@
+"""Monitors kubernetes resources managed by the launch agent."""
+
+import asyncio
+import logging
+import sys
+import traceback
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import kubernetes_asyncio  # type: ignore # noqa: F401
+import urllib3
+from kubernetes_asyncio import watch
+from kubernetes_asyncio.client import (  # type: ignore  # noqa: F401
+    ApiException,
+    BatchV1Api,
+    CoreV1Api,
+    CustomObjectsApi,
+    V1Pod,
+    V1PodStatus,
+)
+
+import wandb
+from wandb.sdk.launch.agent import LaunchAgent
+from wandb.sdk.launch.errors import LaunchError
+from wandb.sdk.launch.runner.abstract import State, Status
+from wandb.sdk.launch.utils import get_kube_context_and_api_client
+
+WANDB_K8S_LABEL_NAMESPACE = "wandb.ai"
+WANDB_K8S_RUN_ID = f"{WANDB_K8S_LABEL_NAMESPACE}/run-id"
+WANDB_K8S_LABEL_AGENT = f"{WANDB_K8S_LABEL_NAMESPACE}/agent"
+WANDB_K8S_LABEL_MONITOR = f"{WANDB_K8S_LABEL_NAMESPACE}/monitor"
+
+
+class Resources:
+    JOBS = "jobs"
+    PODS = "pods"
+
+
+class CustomResource:
+    """Class for custom resources."""
+
+    def __init__(self, group: str, version: str, plural: str) -> None:
+        """Initialize the CustomResource."""
+        self.group = group
+        self.version = version
+        self.plural = plural
+
+    def __str__(self) -> str:
+        """Return a string representation of the CustomResource."""
+        return f"{self.group}/{self.version}/{self.plural}"
+
+    def __hash__(self) -> int:
+        """Return a hash of the CustomResource."""
+        return hash(str(self))
+
+
+# Maps phases and conditions of custom objects to agent's internal run states.
+CRD_STATE_DICT: Dict[str, State] = {
+    "created": "starting",
+    "pending": "starting",
+    "running": "running",
+    "completing": "running",
+    "succeeded": "finished",
+    "completed": "finished",
+    "failed": "failed",
+    "aborted": "failed",
+    "timeout": "failed",
+    "terminated": "failed",
+    "terminating": "stopping",
+}
+
+_logger = logging.getLogger(__name__)
+
+
+def create_named_task(name: str, coro: Any, *args: Any, **kwargs: Any) -> asyncio.Task:
+    """Create a named task."""
+    task = asyncio.create_task(coro(*args, **kwargs))
+    if sys.version_info >= (3, 8):
+        task.set_name(name)
+    task.add_done_callback(_log_err_task_callback)
+    return task
+
+
+def _log_err_task_callback(task: asyncio.Task) -> None:
+    """Callback to log exceptions from tasks."""
+    exec = task.exception()
+    if exec is not None:
+        if isinstance(exec, asyncio.CancelledError):
+            wandb.termlog(f"Task {task.get_name()} was cancelled")
+            return
+        name = str(task) if sys.version_info < (3, 8) else task.get_name()
+        wandb.termerror(f"Exception in task {name}")
+        tb = exec.__traceback__
+        tb_str = "".join(traceback.format_tb(tb))
+        wandb.termerror(tb_str)
+
+
+def _is_preempted(status: "V1PodStatus") -> bool:
+    """Check if this pod has been preempted."""
+    if hasattr(status, "conditions") and status.conditions is not None:
+        for condition in status.conditions:
+            if condition.type == "DisruptionTarget" and condition.reason in [
+                "EvictionByEvictionAPI",
+                "PreemptionByScheduler",
+                "TerminationByKubelet",
+            ]:
+                return True
+    return False
+
+
+def _is_container_creating(status: "V1PodStatus") -> bool:
+    """Check if this pod has started creating containers."""
+    for container_status in status.container_statuses or []:
+        if (
+            container_status.state
+            and container_status.state.waiting
+            and container_status.state.waiting.reason == "ContainerCreating"
+        ):
+            return True
+    return False
+
+
+def _is_pod_unschedulable(status: "V1PodStatus") -> Tuple[bool, str]:
+    """Return whether the pod is unschedulable along with the reason message."""
+    if not status.conditions:
+        return False, ""
+    for condition in status.conditions:
+        if (
+            condition.type == "PodScheduled"
+            and condition.status == "False"
+            and condition.reason == "Unschedulable"
+        ):
+            return True, condition.message
+    return False, ""
+
+
+def _get_crd_job_name(object: "V1Pod") -> Optional[str]:
+    refs = object.metadata.owner_references
+    if refs:
+        return refs[0].name
+    return None
+
+
+def _state_from_conditions(conditions: List[Dict[str, Any]]) -> Optional[State]:
+    """Get the status from the pod conditions."""
+    true_conditions = [
+        c.get("type", "").lower() for c in conditions if c.get("status") == "True"
+    ]
+    detected_states = {
+        CRD_STATE_DICT[c] for c in true_conditions if c in CRD_STATE_DICT
+    }
+    # The list below is ordered so that returning the first state detected
+    # will accurately reflect the state of the job.
+    states_in_order: List[State] = [
+        "finished",
+        "failed",
+        "stopping",
+        "running",
+        "starting",
+    ]
+    for state in states_in_order:
+        if state in detected_states:
+            return state
+    return None
+
+
+def _state_from_replicated_status(status_dict: Dict[str, int]) -> Optional[State]:
+    """Infer overall job status from replicated job status for jobsets.
+
+    More info on jobset:
+    https://github.com/kubernetes-sigs/jobset/blob/main/docs/concepts/README.md
+
+    This is useful for detecting when jobsets are starting.
+    """
+    pods_ready = status_dict.get("ready", 0)
+    pods_active = status_dict.get("active", 0)
+    if pods_ready >= 1:
+        return "running"
+    elif pods_active >= 1:
+        return "starting"
+    return None
+
+
+class LaunchKubernetesMonitor:
+    """Monitors kubernetes resources managed by the launch agent.
+
+    Note: this class is forced to be a singleton in order to prevent multiple
+    threads from being created that monitor the same kubernetes resources.
+    """
+
+    _instance = None  # This is used to ensure only one instance is created.
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "LaunchKubernetesMonitor":
+        """Create a new instance of the LaunchKubernetesMonitor.
+
+        This method ensures that only one instance of the LaunchKubernetesMonitor
+        is created. This is done to prevent multiple threads from being created
+        that monitor the same kubernetes resources.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(
+        self,
+        core_api: CoreV1Api,
+        batch_api: BatchV1Api,
+        custom_api: CustomObjectsApi,
+        label_selector: str,
+    ):
+        """Initialize the LaunchKubernetesMonitor."""
+        self._core_api: CoreV1Api = core_api
+        self._batch_api: BatchV1Api = batch_api
+        self._custom_api: CustomObjectsApi = custom_api
+
+        self._label_selector: str = label_selector
+
+        # Dict mapping a tuple of (namespace, resource_type) to an
+        # asyncio.Task that is monitoring that resource type in that namespace.
+        self._monitor_tasks: Dict[
+            Tuple[str, Union[str, CustomResource]], asyncio.Task
+        ] = dict()
+
+        # Map from job name to job state.
+        self._job_states: Dict[str, Status] = dict()
+
+    @classmethod
+    async def ensure_initialized(
+        cls,
+    ) -> None:
+        """Initialize the LaunchKubernetesMonitor."""
+        if cls._instance is None:
+            _, api_client = await get_kube_context_and_api_client(
+                kubernetes_asyncio, {}
+            )
+            core_api = CoreV1Api(api_client)
+            batch_api = BatchV1Api(api_client)
+            custom_api = CustomObjectsApi(api_client)
+            label_selector = f"{WANDB_K8S_LABEL_MONITOR}=true"
+            if LaunchAgent.initialized():
+                label_selector += f",{WANDB_K8S_LABEL_AGENT}={LaunchAgent.name()}"
+            cls(
+                core_api=core_api,
+                batch_api=batch_api,
+                custom_api=custom_api,
+                label_selector=label_selector,
+            )
+
+    @classmethod
+    def monitor_namespace(
+        cls, namespace: str, custom_resource: Optional[CustomResource] = None
+    ) -> None:
+        """Start monitoring a namespaces for resources."""
+        if cls._instance is None:
+            raise LaunchError(
+                "LaunchKubernetesMonitor not initialized, cannot monitor namespace."
+            )
+        cls._instance.__monitor_namespace(namespace, custom_resource=custom_resource)
+
+    @classmethod
+    def get_status(cls, job_name: str) -> Status:
+        """Get the status of a job."""
+        if cls._instance is None:
+            raise LaunchError(
+                "LaunchKubernetesMonitor not initialized, cannot get status."
+            )
+        return cls._instance.__get_status(job_name)
+
+    @classmethod
+    def status_count(cls) -> Dict[State, int]:
+        """Get a dictionary mapping statuses to the # monitored jobs with each status."""
+        if cls._instance is None:
+            raise ValueError(
+                "LaunchKubernetesMonitor not initialized, cannot get status counts."
+            )
+        return cls._instance.__status_count()
+
+    def __monitor_namespace(
+        self, namespace: str, custom_resource: Optional[CustomResource] = None
+    ) -> None:
+        """Start monitoring a namespaces for resources."""
+        if (namespace, Resources.PODS) not in self._monitor_tasks:
+            self._monitor_tasks[(namespace, Resources.PODS)] = create_named_task(
+                f"monitor_pods_{namespace}",
+                self._monitor_pods,
+                namespace,
+            )
+        # If a custom resource is specified then we will start monitoring
+        # that resource type in the namespace instead of jobs.
+        if custom_resource is not None:
+            if (namespace, custom_resource) not in self._monitor_tasks:
+                self._monitor_tasks[(namespace, custom_resource)] = create_named_task(
+                    f"monitor_{custom_resource}_{namespace}",
+                    self._monitor_crd,
+                    namespace,
+                    custom_resource=custom_resource,
+                )
+        else:
+            if (namespace, Resources.JOBS) not in self._monitor_tasks:
+                self._monitor_tasks[(namespace, Resources.JOBS)] = create_named_task(
+                    f"monitor_jobs_{namespace}",
+                    self._monitor_jobs,
+                    namespace,
+                )
+
+    def __get_status(self, job_name: str) -> Status:
+        """Get the status of a job."""
+        if job_name not in self._job_states:
+            return Status("unknown")
+        state = self._job_states[job_name]
+        return state
+
+    def __status_count(self) -> Dict[State, int]:
+        """Get a dictionary mapping statuses to the # monitored jobs with each status."""
+        counts = dict()
+        for _, status in self._job_states.items():
+            state = status.state
+            if state not in counts:
+                counts[state] = 1
+            else:
+                counts[state] += 1
+        return counts
+
+    def _set_status_state(self, job_name: str, state: State) -> None:
+        """Set the status of the run."""
+        if job_name not in self._job_states:
+            self._job_states[job_name] = Status(state)
+        elif self._job_states[job_name].state != state:
+            self._job_states[job_name].state = state
+
+    def _add_status_message(self, job_name: str, message: str) -> None:
+        if job_name not in self._job_states:
+            self._job_states[job_name] = Status("unknown")
+        wandb.termwarn(f"Warning from Kubernetes for job {job_name}: {message}")
+        self._job_states[job_name].messages.append(message)
+
+    async def _monitor_pods(self, namespace: str) -> None:
+        """Monitor a namespace for changes."""
+        watcher = SafeWatch(watch.Watch())
+        async for event in watcher.stream(
+            self._core_api.list_namespaced_pod,
+            namespace=namespace,
+            label_selector=self._label_selector,
+        ):
+            obj = event.get("object")
+            job_name = obj.metadata.labels.get("job-name") or _get_crd_job_name(obj)
+            if job_name is None or not hasattr(obj, "status"):
+                continue
+            if self.__get_status(job_name) in ["finished", "failed"]:
+                continue
+
+            is_unschedulable, reason = _is_pod_unschedulable(obj.status)
+            if is_unschedulable:
+                self._add_status_message(job_name, reason)
+            if obj.status.phase == "Running" or _is_container_creating(obj.status):
+                self._set_status_state(job_name, "running")
+            elif _is_preempted(obj.status):
+                self._set_status_state(job_name, "preempted")
+
+    async def _monitor_jobs(self, namespace: str) -> None:
+        """Monitor a namespace for changes."""
+        watcher = SafeWatch(watch.Watch())
+        async for event in watcher.stream(
+            self._batch_api.list_namespaced_job,
+            namespace=namespace,
+            label_selector=self._label_selector,
+        ):
+            obj = event.get("object")
+            job_name = obj.metadata.name
+
+            if obj.status.succeeded == 1:
+                self._set_status_state(job_name, "finished")
+            elif obj.status.failed is not None and obj.status.failed >= 1:
+                self._set_status_state(job_name, "failed")
+
+            # If the job is deleted and we haven't seen a terminal state
+            # then we will consider the job failed.
+            if event.get("type") == "DELETED":
+                if self._job_states.get(job_name) != Status("finished"):
+                    self._set_status_state(job_name, "failed")
+
+    async def _monitor_crd(
+        self, namespace: str, custom_resource: CustomResource
+    ) -> None:
+        """Monitor a namespace for changes."""
+        watcher = SafeWatch(watch.Watch())
+        async for event in watcher.stream(
+            self._custom_api.list_namespaced_custom_object,
+            namespace=namespace,
+            plural=custom_resource.plural,
+            group=custom_resource.group,
+            version=custom_resource.version,
+            label_selector=self._label_selector,
+        ):
+            object = event.get("object")
+            name = object.get("metadata", dict()).get("name")
+            status = object.get("status")
+            state = None
+            if status is None:
+                continue
+            replicated_jobs_status = status.get("ReplicatedJobsStatus")
+            if isinstance(replicated_jobs_status, dict):
+                state = _state_from_replicated_status(replicated_jobs_status)
+            state_dict = status.get("state")
+            if isinstance(state_dict, dict):
+                phase = state_dict.get("phase")
+                if phase:
+                    state = CRD_STATE_DICT.get(phase.lower())
+            else:
+                conditions = status.get("conditions")
+                if isinstance(conditions, list):
+                    state = _state_from_conditions(conditions)
+                else:
+                    # This should never happen.
+                    _logger.warning(
+                        f"Unexpected conditions type {type(conditions)} "
+                        f"for CRD watcher in {namespace}"
+                    )
+            if state is None:
+                continue
+            self._set_status_state(name, state)
+
+
+class SafeWatch:
+    """Wrapper for the kubernetes watch class that can recover in more situations."""
+
+    def __init__(self, watcher: watch.Watch) -> None:
+        """Initialize the SafeWatch."""
+        self._watcher = watcher
+        self._last_seen_resource_version: Optional[str] = None
+        self._stopped = False
+
+    async def stream(self, func: Any, *args: Any, **kwargs: Any) -> Any:
+        """Stream the watcher.
+
+        This method will automatically resume the stream if it breaks. It will
+        also save the resource version so that the stream can be resumed from
+        the last seen resource version.
+        """
+        while True:
+            try:
+                async for event in self._watcher.stream(
+                    func, *args, **kwargs, timeout_seconds=30
+                ):
+                    if self._stopped:
+                        break
+                    # Save the resource version so that we can resume the stream
+                    # if it breaks.
+                    object = event.get("object")
+                    if isinstance(object, dict):
+                        self._last_seen_resource_version = object.get(
+                            "metadata", dict()
+                        ).get("resourceVersion")
+                    else:
+                        self._last_seen_resource_version = (
+                            object.metadata.resource_version
+                        )
+                    kwargs["resource_version"] = self._last_seen_resource_version
+                    yield event
+                # If stream ends after stop just break
+                if self._stopped:
+                    break
+            except urllib3.exceptions.ProtocolError as e:
+                wandb.termwarn(f"Broken event stream: {e}, attempting to recover")
+            except ApiException as e:
+                if e.status == 410:
+                    # If resource version is too old we need to start over.
+                    del kwargs["resource_version"]
+                    self._last_seen_resource_version = None
+            except Exception as E:
+                exc_type = type(E).__name__
+                stack_trace = traceback.format_exc()
+                wandb.termerror(
+                    f"Unknown exception in event stream of type {exc_type}: {E}, attempting to recover. Stack trace: {stack_trace}"
+                )

parrot/lib/python3.10/site-packages/wandb/sdk/launch/runner/kubernetes_runner.py

@@ -0,0 +1,963 @@
+"""Implementation of KubernetesRunner class for wandb launch."""
+
+import asyncio
+import base64
+import datetime
+import json
+import logging
+import os
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+
+import yaml
+
+import wandb
+from wandb.apis.internal import Api
+from wandb.sdk.launch.agent.agent import LaunchAgent
+from wandb.sdk.launch.environment.abstract import AbstractEnvironment
+from wandb.sdk.launch.registry.abstract import AbstractRegistry
+from wandb.sdk.launch.registry.azure_container_registry import AzureContainerRegistry
+from wandb.sdk.launch.registry.local_registry import LocalRegistry
+from wandb.sdk.launch.runner.abstract import Status
+from wandb.sdk.launch.runner.kubernetes_monitor import (
+    WANDB_K8S_LABEL_AGENT,
+    WANDB_K8S_LABEL_MONITOR,
+    WANDB_K8S_RUN_ID,
+    CustomResource,
+    LaunchKubernetesMonitor,
+)
+from wandb.sdk.lib.retry import ExponentialBackoff, retry_async
+from wandb.util import get_module
+
+from .._project_spec import EntryPoint, LaunchProject
+from ..errors import LaunchError
+from ..utils import (
+    CODE_MOUNT_DIR,
+    LOG_PREFIX,
+    MAX_ENV_LENGTHS,
+    PROJECT_SYNCHRONOUS,
+    get_kube_context_and_api_client,
+    make_name_dns_safe,
+)
+from .abstract import AbstractRun, AbstractRunner
+
+get_module(
+    "kubernetes_asyncio",
+    required="Kubernetes runner requires the kubernetes package. Please install it with `pip install wandb[launch]`.",
+)
+
+import kubernetes_asyncio  # type: ignore # noqa: E402
+from kubernetes_asyncio import client  # noqa: E402
+from kubernetes_asyncio.client.api.batch_v1_api import (  # type: ignore # noqa: E402
+    BatchV1Api,
+)
+from kubernetes_asyncio.client.api.core_v1_api import (  # type: ignore # noqa: E402
+    CoreV1Api,
+)
+from kubernetes_asyncio.client.api.custom_objects_api import (  # type: ignore # noqa: E402
+    CustomObjectsApi,
+)
+from kubernetes_asyncio.client.models.v1_secret import (  # type: ignore # noqa: E402
+    V1Secret,
+)
+from kubernetes_asyncio.client.rest import ApiException  # type: ignore # noqa: E402
+
+TIMEOUT = 5
+API_KEY_SECRET_MAX_RETRIES = 5
+
+_logger = logging.getLogger(__name__)
+
+
+SOURCE_CODE_PVC_MOUNT_PATH = os.environ.get("WANDB_LAUNCH_CODE_PVC_MOUNT_PATH")
+SOURCE_CODE_PVC_NAME = os.environ.get("WANDB_LAUNCH_CODE_PVC_NAME")
+
+
+class KubernetesSubmittedRun(AbstractRun):
+    """Wrapper for a launched run on Kubernetes."""
+
+    def __init__(
+        self,
+        batch_api: "BatchV1Api",
+        core_api: "CoreV1Api",
+        name: str,
+        namespace: Optional[str] = "default",
+        secret: Optional["V1Secret"] = None,
+    ) -> None:
+        """Initialize a KubernetesSubmittedRun.
+
+        Other implementations of the AbstractRun interface poll on the run
+        when `get_status` is called, but KubernetesSubmittedRun uses
+        Kubernetes watch streams to update the run status. One thread handles
+        events from the job object and another thread handles events from the
+        rank 0 pod. These threads updated the `_status` attributed of the
+        KubernetesSubmittedRun object. When `get_status` is called, the
+        `_status` attribute is returned.
+
+        Arguments:
+            batch_api: Kubernetes BatchV1Api object.
+            core_api: Kubernetes CoreV1Api object.
+            name: Name of the job.
+            namespace: Kubernetes namespace.
+            secret: Kubernetes secret.
+
+        Returns:
+            None.
+        """
+        self.batch_api = batch_api
+        self.core_api = core_api
+        self.name = name
+        self.namespace = namespace
+        self._fail_count = 0
+        self.secret = secret
+
+    @property
+    def id(self) -> str:
+        """Return the run id."""
+        return self.name
+
+    async def get_logs(self) -> Optional[str]:
+        try:
+            pods = await self.core_api.list_namespaced_pod(
+                label_selector=f"job-name={self.name}", namespace=self.namespace
+            )
+            pod_names = [pi.metadata.name for pi in pods.items]
+            if not pod_names:
+                wandb.termwarn(f"Found no pods for kubernetes job: {self.name}")
+                return None
+            logs = await self.core_api.read_namespaced_pod_log(
+                name=pod_names[0], namespace=self.namespace
+            )
+            if logs:
+                return str(logs)
+            else:
+                wandb.termwarn(f"No logs for kubernetes pod(s): {pod_names}")
+            return None
+        except Exception as e:
+            wandb.termerror(f"{LOG_PREFIX}Failed to get pod logs: {e}")
+            return None
+
+    async def wait(self) -> bool:
+        """Wait for the run to finish.
+
+        Returns:
+            True if the run finished successfully, False otherwise.
+        """
+        while True:
+            status = await self.get_status()
+            wandb.termlog(f"{LOG_PREFIX}Job {self.name} status: {status.state}")
+            if status.state in ["finished", "failed", "preempted"]:
+                break
+            await asyncio.sleep(5)
+
+        await self._delete_secret()
+        return (
+            status.state == "finished"
+        )  # todo: not sure if this (copied from aws runner) is the right approach? should we return false on failure
+
+    async def get_status(self) -> Status:
+        status = LaunchKubernetesMonitor.get_status(self.name)
+        if status in ["stopped", "failed", "finished", "preempted"]:
+            await self._delete_secret()
+        return status
+
+    async def cancel(self) -> None:
+        """Cancel the run."""
+        try:
+            await self.batch_api.delete_namespaced_job(
+                namespace=self.namespace,
+                name=self.name,
+            )
+            await self._delete_secret()
+        except ApiException as e:
+            raise LaunchError(
+                f"Failed to delete Kubernetes Job {self.name} in namespace {self.namespace}: {str(e)}"
+            ) from e
+
+    async def _delete_secret(self) -> None:
+        # Cleanup secret if not running in a helm-managed context
+        if not os.environ.get("WANDB_RELEASE_NAME") and self.secret:
+            await self.core_api.delete_namespaced_secret(
+                name=self.secret.metadata.name,
+                namespace=self.secret.metadata.namespace,
+            )
+            self.secret = None
+
+
+class CrdSubmittedRun(AbstractRun):
+    """Run submitted to a CRD backend, e.g. Volcano."""
+
+    def __init__(
+        self,
+        group: str,
+        version: str,
+        plural: str,
+        name: str,
+        namespace: str,
+        core_api: CoreV1Api,
+        custom_api: CustomObjectsApi,
+    ) -> None:
+        """Create a run object for tracking the progress of a CRD.
+
+        Arguments:
+            group: The API group of the CRD.
+            version: The API version of the CRD.
+            plural: The plural name of the CRD.
+            name: The name of the CRD instance.
+            namespace: The namespace of the CRD instance.
+            core_api: The Kubernetes core API client.
+            custom_api: The Kubernetes custom object API client.
+
+        Raises:
+            LaunchError: If the CRD instance does not exist.
+        """
+        self.group = group
+        self.version = version
+        self.plural = plural
+        self.name = name
+        self.namespace = namespace
+        self.core_api = core_api
+        self.custom_api = custom_api
+        self._fail_count = 0
+
+    @property
+    def id(self) -> str:
+        """Get the name of the custom object."""
+        return self.name
+
+    async def get_logs(self) -> Optional[str]:
+        """Get logs for custom object."""
+        # TODO: test more carefully once we release multi-node support
+        logs: Dict[str, Optional[str]] = {}
+        try:
+            pods = await self.core_api.list_namespaced_pod(
+                label_selector=f"wandb/run-id={self.name}", namespace=self.namespace
+            )
+            pod_names = [pi.metadata.name for pi in pods.items]
+            for pod_name in pod_names:
+                logs[pod_name] = await self.core_api.read_namespaced_pod_log(
+                    name=pod_name, namespace=self.namespace
+                )
+        except ApiException as e:
+            wandb.termwarn(f"Failed to get logs for {self.name}: {str(e)}")
+            return None
+        if not logs:
+            return None
+        logs_as_array = [f"Pod {pod_name}:\n{log}" for pod_name, log in logs.items()]
+        return "\n".join(logs_as_array)
+
+    async def get_status(self) -> Status:
+        """Get status of custom object."""
+        return LaunchKubernetesMonitor.get_status(self.name)
+
+    async def cancel(self) -> None:
+        """Cancel the custom object."""
+        try:
+            await self.custom_api.delete_namespaced_custom_object(
+                group=self.group,
+                version=self.version,
+                namespace=self.namespace,
+                plural=self.plural,
+                name=self.name,
+            )
+        except ApiException as e:
+            raise LaunchError(
+                f"Failed to delete CRD {self.name} in namespace {self.namespace}: {str(e)}"
+            ) from e
+
+    async def wait(self) -> bool:
+        """Wait for this custom object to finish running."""
+        while True:
+            status = await self.get_status()
+            wandb.termlog(f"{LOG_PREFIX}Job {self.name} status: {status}")
+            if status.state in ["finished", "failed", "preempted"]:
+                return status.state == "finished"
+            await asyncio.sleep(5)
+
+
+class KubernetesRunner(AbstractRunner):
+    """Launches runs onto kubernetes."""
+
+    def __init__(
+        self,
+        api: Api,
+        backend_config: Dict[str, Any],
+        environment: AbstractEnvironment,
+        registry: AbstractRegistry,
+    ) -> None:
+        """Create a Kubernetes runner.
+
+        Arguments:
+            api: The API client object.
+            backend_config: The backend configuration.
+            environment: The environment to launch runs into.
+
+        Raises:
+            LaunchError: If the Kubernetes configuration is invalid.
+        """
+        super().__init__(api, backend_config)
+        self.environment = environment
+        self.registry = registry
+
+    def get_namespace(
+        self, resource_args: Dict[str, Any], context: Dict[str, Any]
+    ) -> str:
+        """Get the namespace to launch into.
+
+        Arguments:
+            resource_args: The resource args to launch.
+            context: The k8s config context.
+
+        Returns:
+            The namespace to launch into.
+        """
+        default_namespace = (
+            context["context"].get("namespace", "default") if context else "default"
+        )
+        return (  # type: ignore[no-any-return]
+            resource_args.get("metadata", {}).get("namespace")
+            or resource_args.get(
+                "namespace"
+            )  # continue support for malformed namespace
+            or self.backend_config.get("runner", {}).get("namespace")
+            or default_namespace
+        )
+
+    async def _inject_defaults(
+        self,
+        resource_args: Dict[str, Any],
+        launch_project: LaunchProject,
+        image_uri: str,
+        namespace: str,
+        core_api: "CoreV1Api",
+    ) -> Tuple[Dict[str, Any], Optional["V1Secret"]]:
+        """Apply our default values, return job dict and api key secret.
+
+        Arguments:
+            resource_args (Dict[str, Any]): The resource args to launch.
+            launch_project (LaunchProject): The launch project.
+            builder (Optional[AbstractBuilder]): The builder.
+            namespace (str): The namespace.
+            core_api (CoreV1Api): The core api.
+
+        Returns:
+            Tuple[Dict[str, Any], Optional["V1Secret"]]: The resource args and api key secret.
+        """
+        job: Dict[str, Any] = {
+            "apiVersion": "batch/v1",
+            "kind": "Job",
+        }
+        job.update(resource_args)
+
+        job_metadata: Dict[str, Any] = job.get("metadata", {})
+        job_spec: Dict[str, Any] = {"backoffLimit": 0, "ttlSecondsAfterFinished": 60}
+        job_spec.update(job.get("spec", {}))
+        pod_template: Dict[str, Any] = job_spec.get("template", {})
+        pod_spec: Dict[str, Any] = {"restartPolicy": "Never"}
+        pod_spec.update(pod_template.get("spec", {}))
+        containers: List[Dict[str, Any]] = pod_spec.get("containers", [{}])
+
+        # Add labels to job metadata
+        job_metadata.setdefault("labels", {})
+        job_metadata["labels"][WANDB_K8S_RUN_ID] = launch_project.run_id
+        job_metadata["labels"][WANDB_K8S_LABEL_MONITOR] = "true"
+        if LaunchAgent.initialized():
+            job_metadata["labels"][WANDB_K8S_LABEL_AGENT] = LaunchAgent.name()
+        # name precedence: name in spec > generated name
+        if not job_metadata.get("name"):
+            job_metadata["generateName"] = make_name_dns_safe(
+                f"launch-{launch_project.target_entity}-{launch_project.target_project}-"
+            )
+
+        for i, cont in enumerate(containers):
+            if "name" not in cont:
+                cont["name"] = cont.get("name", "launch" + str(i))
+            if "securityContext" not in cont:
+                cont["securityContext"] = {
+                    "allowPrivilegeEscalation": False,
+                    "capabilities": {"drop": ["ALL"]},
+                    "seccompProfile": {"type": "RuntimeDefault"},
+                }
+
+        entry_point = (
+            launch_project.override_entrypoint or launch_project.get_job_entry_point()
+        )
+        if launch_project.docker_image:
+            # dont specify run id if user provided image, could have multiple runs
+            containers[0]["image"] = image_uri
+            # TODO: handle secret pulling image from registry
+        elif not any(["image" in cont for cont in containers]):
+            assert entry_point is not None
+            # in the non instance case we need to make an imagePullSecret
+            # so the new job can pull the image
+            containers[0]["image"] = image_uri
+        secret = await maybe_create_imagepull_secret(
+            core_api, self.registry, launch_project.run_id, namespace
+        )
+        if secret is not None:
+            pod_spec["imagePullSecrets"] = [
+                {"name": f"regcred-{launch_project.run_id}"}
+            ]
+
+        inject_entrypoint_and_args(
+            containers,
+            entry_point,
+            launch_project.override_args,
+            launch_project.override_entrypoint is not None,
+        )
+
+        env_vars = launch_project.get_env_vars_dict(
+            self._api, MAX_ENV_LENGTHS[self.__class__.__name__]
+        )
+        api_key_secret = None
+        for cont in containers:
+            # Add our env vars to user supplied env vars
+            env = cont.get("env") or []
+            for key, value in env_vars.items():
+                if (
+                    key == "WANDB_API_KEY"
+                    and value
+                    and (
+                        LaunchAgent.initialized()
+                        or self.backend_config[PROJECT_SYNCHRONOUS]
+                    )
+                ):
+                    # Override API key with secret. TODO: Do the same for other runners
+                    release_name = os.environ.get("WANDB_RELEASE_NAME")
+                    secret_name = "wandb-api-key"
+                    if release_name:
+                        secret_name += f"-{release_name}"
+                    else:
+                        secret_name += f"-{launch_project.run_id}"
+
+                    def handle_exception(e):
+                        wandb.termwarn(
+                            f"Exception when ensuring Kubernetes API key secret: {e}. Retrying..."
+                        )
+
+                    api_key_secret = await retry_async(
+                        backoff=ExponentialBackoff(
+                            initial_sleep=datetime.timedelta(seconds=1),
+                            max_sleep=datetime.timedelta(minutes=1),
+                            max_retries=API_KEY_SECRET_MAX_RETRIES,
+                        ),
+                        fn=ensure_api_key_secret,
+                        on_exc=handle_exception,
+                        core_api=core_api,
+                        secret_name=secret_name,
+                        namespace=namespace,
+                        api_key=value,
+                    )
+                    env.append(
+                        {
+                            "name": key,
+                            "valueFrom": {
+                                "secretKeyRef": {
+                                    "name": secret_name,
+                                    "key": "password",
+                                }
+                            },
+                        }
+                    )
+                else:
+                    env.append({"name": key, "value": value})
+            cont["env"] = env
+
+        pod_spec["containers"] = containers
+        pod_template["spec"] = pod_spec
+        job_spec["template"] = pod_template
+        job["spec"] = job_spec
+        job["metadata"] = job_metadata
+
+        add_label_to_pods(
+            job,
+            WANDB_K8S_LABEL_MONITOR,
+            "true",
+        )
+
+        if launch_project.job_base_image:
+            apply_code_mount_configuration(
+                job,
+                launch_project,
+            )
+
+        # Add wandb.ai/agent: current agent label on all pods
+        if LaunchAgent.initialized():
+            add_label_to_pods(
+                job,
+                WANDB_K8S_LABEL_AGENT,
+                LaunchAgent.name(),
+            )
+
+        return job, api_key_secret
+
+    async def run(
+        self, launch_project: LaunchProject, image_uri: str
+    ) -> Optional[AbstractRun]:  # noqa: C901
+        """Execute a launch project on Kubernetes.
+
+        Arguments:
+            launch_project: The launch project to execute.
+            builder: The builder to use to build the image.
+
+        Returns:
+            The run object if the run was successful, otherwise None.
+        """
+        await LaunchKubernetesMonitor.ensure_initialized()
+        resource_args = launch_project.fill_macros(image_uri).get("kubernetes", {})
+        if not resource_args:
+            wandb.termlog(
+                f"{LOG_PREFIX}Note: no resource args specified. Add a "
+                "Kubernetes yaml spec or other options in a json file "
+                "with --resource-args <json>."
+            )
+        _logger.info(f"Running Kubernetes job with resource args: {resource_args}")
+
+        context, api_client = await get_kube_context_and_api_client(
+            kubernetes_asyncio, resource_args
+        )
+
+        # If using pvc for code mount, move code there.
+        if launch_project.job_base_image is not None:
+            if SOURCE_CODE_PVC_NAME is None or SOURCE_CODE_PVC_MOUNT_PATH is None:
+                raise LaunchError(
+                    "WANDB_LAUNCH_SOURCE_CODE_PVC_ environment variables not set. "
+                    "Unable to mount source code PVC into base image. "
+                    "Use the `codeMountPvcName` variable in the agent helm chart "
+                    "to enable base image jobs for this agent. See "
+                    "https://github.com/wandb/helm-charts/tree/main/charts/launch-agent "
+                    "for more information."
+                )
+            code_subdir = launch_project.get_image_source_string()
+            launch_project.change_project_dir(
+                os.path.join(SOURCE_CODE_PVC_MOUNT_PATH, code_subdir)
+            )
+
+        # If the user specified an alternate api, we need will execute this
+        # run by creating a custom object.
+        api_version = resource_args.get("apiVersion", "batch/v1")
+
+        if api_version not in ["batch/v1", "batch/v1beta1"]:
+            env_vars = launch_project.get_env_vars_dict(
+                self._api, MAX_ENV_LENGTHS[self.__class__.__name__]
+            )
+            # Crawl the resource args and add our env vars to the containers.
+            add_wandb_env(resource_args, env_vars)
+
+            # Add our labels to the resource args. This is necessary for the
+            # agent to find the custom object later on.
+            resource_args["metadata"] = resource_args.get("metadata", {})
+            resource_args["metadata"]["labels"] = resource_args["metadata"].get(
+                "labels", {}
+            )
+            resource_args["metadata"]["labels"][WANDB_K8S_LABEL_MONITOR] = "true"
+
+            # Crawl the resource arsg and add our labels to the pods. This is
+            # necessary for the agent to find the pods later on.
+            add_label_to_pods(
+                resource_args,
+                WANDB_K8S_LABEL_MONITOR,
+                "true",
+            )
+
+            # Add wandb.ai/agent: current agent label on all pods
+            if LaunchAgent.initialized():
+                add_label_to_pods(
+                    resource_args,
+                    WANDB_K8S_LABEL_AGENT,
+                    LaunchAgent.name(),
+                )
+                resource_args["metadata"]["labels"][WANDB_K8S_LABEL_AGENT] = (
+                    LaunchAgent.name()
+                )
+
+            if launch_project.job_base_image:
+                apply_code_mount_configuration(resource_args, launch_project)
+
+            overrides = {}
+            if launch_project.override_args:
+                overrides["args"] = launch_project.override_args
+            if launch_project.override_entrypoint:
+                overrides["command"] = launch_project.override_entrypoint.command
+            add_entrypoint_args_overrides(
+                resource_args,
+                overrides,
+            )
+            api = client.CustomObjectsApi(api_client)
+            # Infer the attributes of a custom object from the apiVersion and/or
+            # a kind: attribute in the resource args.
+            namespace = self.get_namespace(resource_args, context)
+            group, version, *_ = api_version.split("/")
+            group = resource_args.get("group", group)
+            version = resource_args.get("version", version)
+            kind = resource_args.get("kind", version)
+            plural = f"{kind.lower()}s"
+            custom_resource = CustomResource(
+                group=group,
+                version=version,
+                plural=plural,
+            )
+            LaunchKubernetesMonitor.monitor_namespace(
+                namespace, custom_resource=custom_resource
+            )
+
+            try:
+                response = await api.create_namespaced_custom_object(
+                    group=group,
+                    version=version,
+                    namespace=namespace,
+                    plural=plural,
+                    body=resource_args,
+                )
+            except ApiException as e:
+                body = json.loads(e.body)
+                body_yaml = yaml.dump(body)
+                raise LaunchError(
+                    f"Error creating CRD of kind {kind}: {e.status} {e.reason}\n{body_yaml}"
+                ) from e
+            name = response.get("metadata", {}).get("name")
+            _logger.info(f"Created {kind} {response['metadata']['name']}")
+            submitted_run = CrdSubmittedRun(
+                name=name,
+                group=group,
+                version=version,
+                namespace=namespace,
+                plural=plural,
+                core_api=client.CoreV1Api(api_client),
+                custom_api=api,
+            )
+            if self.backend_config[PROJECT_SYNCHRONOUS]:
+                await submitted_run.wait()
+            return submitted_run
+
+        batch_api = kubernetes_asyncio.client.BatchV1Api(api_client)
+        core_api = kubernetes_asyncio.client.CoreV1Api(api_client)
+        namespace = self.get_namespace(resource_args, context)
+        job, secret = await self._inject_defaults(
+            resource_args, launch_project, image_uri, namespace, core_api
+        )
+        msg = "Creating Kubernetes job"
+        if "name" in resource_args:
+            msg += f": {resource_args['name']}"
+        _logger.info(msg)
+        try:
+            response = await kubernetes_asyncio.utils.create_from_dict(
+                api_client, job, namespace=namespace
+            )
+        except kubernetes_asyncio.utils.FailToCreateError as e:
+            for exc in e.api_exceptions:
+                resp = json.loads(exc.body)
+                msg = resp.get("message")
+                code = resp.get("code")
+                raise LaunchError(
+                    f"Failed to create Kubernetes job for run {launch_project.run_id} ({code} {exc.reason}): {msg}"
+                )
+        except Exception as e:
+            raise LaunchError(
+                f"Unexpected exception when creating Kubernetes job: {str(e)}\n"
+            )
+        job_response = response[0]
+        job_name = job_response.metadata.name
+        LaunchKubernetesMonitor.monitor_namespace(namespace)
+        submitted_job = KubernetesSubmittedRun(
+            batch_api, core_api, job_name, namespace, secret
+        )
+        if self.backend_config[PROJECT_SYNCHRONOUS]:
+            await submitted_job.wait()
+
+        return submitted_job
+
+
+def inject_entrypoint_and_args(
+    containers: List[dict],
+    entry_point: Optional[EntryPoint],
+    override_args: List[str],
+    should_override_entrypoint: bool,
+) -> None:
+    """Inject the entrypoint and args into the containers.
+
+    Arguments:
+        containers: The containers to inject the entrypoint and args into.
+        entry_point: The entrypoint to inject.
+        override_args: The args to inject.
+        should_override_entrypoint: Whether to override the entrypoint.
+
+    Returns:
+        None
+    """
+    for i in range(len(containers)):
+        if override_args:
+            containers[i]["args"] = override_args
+        if entry_point and (
+            not containers[i].get("command") or should_override_entrypoint
+        ):
+            containers[i]["command"] = entry_point.command
+
+
+async def ensure_api_key_secret(
+    core_api: "CoreV1Api",
+    secret_name: str,
+    namespace: str,
+    api_key: str,
+) -> "V1Secret":
+    """Create a secret containing a user's wandb API key.
+
+    Arguments:
+        core_api: The Kubernetes CoreV1Api object.
+        secret_name: The name to use for the secret.
+        namespace: The namespace to create the secret in.
+        api_key: The user's wandb API key
+
+    Returns:
+        The created secret
+    """
+    secret_data = {"password": base64.b64encode(api_key.encode()).decode()}
+    labels = {"wandb.ai/created-by": "launch-agent"}
+    secret = client.V1Secret(
+        data=secret_data,
+        metadata=client.V1ObjectMeta(
+            name=secret_name, namespace=namespace, labels=labels
+        ),
+        kind="Secret",
+        type="kubernetes.io/basic-auth",
+    )
+
+    try:
+        try:
+            return await core_api.create_namespaced_secret(namespace, secret)
+        except ApiException as e:
+            # 409 = conflict = secret already exists
+            if e.status == 409:
+                existing_secret = await core_api.read_namespaced_secret(
+                    name=secret_name, namespace=namespace
+                )
+                if existing_secret.data != secret_data:
+                    # If it's a previous secret made by launch agent, clean it up
+                    if (
+                        existing_secret.metadata.labels.get("wandb.ai/created-by")
+                        == "launch-agent"
+                    ):
+                        await core_api.delete_namespaced_secret(
+                            name=secret_name, namespace=namespace
+                        )
+                        return await core_api.create_namespaced_secret(
+                            namespace, secret
+                        )
+                    else:
+                        raise LaunchError(
+                            f"Kubernetes secret already exists in namespace {namespace} with incorrect data: {secret_name}"
+                        )
+                return existing_secret
+            raise
+    except Exception as e:
+        raise LaunchError(
+            f"Exception when ensuring Kubernetes API key secret: {str(e)}\n"
+        )
+
+
+async def maybe_create_imagepull_secret(
+    core_api: "CoreV1Api",
+    registry: AbstractRegistry,
+    run_id: str,
+    namespace: str,
+) -> Optional["V1Secret"]:
+    """Create a secret for pulling images from a private registry.
+
+    Arguments:
+        core_api: The Kubernetes CoreV1Api object.
+        registry: The registry to pull from.
+        run_id: The run id.
+        namespace: The namespace to create the secret in.
+
+    Returns:
+        A secret if one was created, otherwise None.
+    """
+    secret = None
+    if isinstance(registry, LocalRegistry) or isinstance(
+        registry, AzureContainerRegistry
+    ):
+        # Secret not required
+        return None
+    uname, token = await registry.get_username_password()
+    creds_info = {
+        "auths": {
+            registry.uri: {
+                "auth": base64.b64encode(f"{uname}:{token}".encode()).decode(),
+                # need an email but the use is deprecated
+                "email": "deprecated@wandblaunch.com",
+            }
+        }
+    }
+    secret_data = {
+        ".dockerconfigjson": base64.b64encode(json.dumps(creds_info).encode()).decode()
+    }
+    secret = client.V1Secret(
+        data=secret_data,
+        metadata=client.V1ObjectMeta(name=f"regcred-{run_id}", namespace=namespace),
+        kind="Secret",
+        type="kubernetes.io/dockerconfigjson",
+    )
+    try:
+        try:
+            return await core_api.create_namespaced_secret(namespace, secret)
+        except ApiException as e:
+            # 409 = conflict = secret already exists
+            if e.status == 409:
+                return await core_api.read_namespaced_secret(
+                    name=f"regcred-{run_id}", namespace=namespace
+                )
+            raise
+    except Exception as e:
+        raise LaunchError(f"Exception when creating Kubernetes secret: {str(e)}\n")
+
+
+def yield_containers(root: Any) -> Iterator[dict]:
+    """Yield all container specs in a manifest.
+
+    Recursively traverses the manifest and yields all container specs. Container
+    specs are identified by the presence of a "containers" key in the value.
+    """
+    if isinstance(root, dict):
+        for k, v in root.items():
+            if k == "containers":
+                if isinstance(v, list):
+                    yield from v
+            elif isinstance(v, (dict, list)):
+                yield from yield_containers(v)
+    elif isinstance(root, list):
+        for item in root:
+            yield from yield_containers(item)
+
+
+def add_wandb_env(root: Union[dict, list], env_vars: Dict[str, str]) -> None:
+    """Injects wandb environment variables into specs.
+
+    Recursively walks the spec and injects the environment variables into
+    every container spec. Containers are identified by the "containers" key.
+
+    This function treats the WANDB_RUN_ID and WANDB_GROUP_ID environment variables
+    specially. If they are present in the spec, they will be overwritten. If a setting
+    for WANDB_RUN_ID is provided in env_vars, then that environment variable will only be
+    set in the first container modified by this function.
+
+    Arguments:
+        root: The spec to modify.
+        env_vars: The environment variables to inject.
+
+    Returns: None.
+    """
+    for cont in yield_containers(root):
+        env = cont.setdefault("env", [])
+        env.extend([{"name": key, "value": value} for key, value in env_vars.items()])
+        cont["env"] = env
+        # After we have set WANDB_RUN_ID once, we don't want to set it again
+        if "WANDB_RUN_ID" in env_vars:
+            env_vars.pop("WANDB_RUN_ID")
+
+
+def yield_pods(manifest: Any) -> Iterator[dict]:
+    """Yield all pod specs in a manifest.
+
+    Recursively traverses the manifest and yields all pod specs. Pod specs are
+    identified by the presence of a "spec" key with a "containers" key in the
+    value.
+    """
+    if isinstance(manifest, list):
+        for item in manifest:
+            yield from yield_pods(item)
+    elif isinstance(manifest, dict):
+        if "spec" in manifest and "containers" in manifest["spec"]:
+            yield manifest
+        for value in manifest.values():
+            if isinstance(value, (dict, list)):
+                yield from yield_pods(value)
+
+
+def add_label_to_pods(
+    manifest: Union[dict, list], label_key: str, label_value: str
+) -> None:
+    """Add a label to all pod specs in a manifest.
+
+    Recursively traverses the manifest and adds the label to all pod specs.
+    Pod specs are identified by the presence of a "spec" key with a "containers"
+    key in the value.
+
+    Arguments:
+        manifest: The manifest to modify.
+        label_key: The label key to add.
+        label_value: The label value to add.
+
+    Returns: None.
+    """
+    for pod in yield_pods(manifest):
+        metadata = pod.setdefault("metadata", {})
+        labels = metadata.setdefault("labels", {})
+        labels[label_key] = label_value
+
+
+def add_entrypoint_args_overrides(manifest: Union[dict, list], overrides: dict) -> None:
+    """Add entrypoint and args overrides to all containers in a manifest.
+
+    Recursively traverses the manifest and adds the entrypoint and args overrides
+    to all containers. Containers are identified by the presence of a "spec" key
+    with a "containers" key in the value.
+
+    Arguments:
+        manifest: The manifest to modify.
+        overrides: Dictionary with args and entrypoint keys.
+
+    Returns: None.
+    """
+    if isinstance(manifest, list):
+        for item in manifest:
+            add_entrypoint_args_overrides(item, overrides)
+    elif isinstance(manifest, dict):
+        if "spec" in manifest and "containers" in manifest["spec"]:
+            containers = manifest["spec"]["containers"]
+            for container in containers:
+                if "command" in overrides:
+                    container["command"] = overrides["command"]
+                if "args" in overrides:
+                    container["args"] = overrides["args"]
+        for value in manifest.values():
+            add_entrypoint_args_overrides(value, overrides)
+
+
+def apply_code_mount_configuration(
+    manifest: Union[Dict, list], project: LaunchProject
+) -> None:
+    """Apply code mount configuration to all containers in a manifest.
+
+    Recursively traverses the manifest and adds the code mount configuration to
+    all containers. Containers are identified by the presence of a "spec" key
+    with a "containers" key in the value.
+
+    Arguments:
+        manifest: The manifest to modify.
+        project: The launch project.
+
+    Returns: None.
+    """
+    assert SOURCE_CODE_PVC_NAME is not None
+    source_dir = project.get_image_source_string()
+    for pod in yield_pods(manifest):
+        for container in yield_containers(pod):
+            if "volumeMounts" not in container:
+                container["volumeMounts"] = []
+            container["volumeMounts"].append(
+                {
+                    "name": "wandb-source-code-volume",
+                    "mountPath": CODE_MOUNT_DIR,
+                    "subPath": source_dir,
+                }
+            )
+            container["workingDir"] = CODE_MOUNT_DIR
+        spec = pod["spec"]
+        if "volumes" not in spec:
+            spec["volumes"] = []
+        spec["volumes"].append(
+            {
+                "name": "wandb-source-code-volume",
+                "persistentVolumeClaim": {
+                    "claimName": SOURCE_CODE_PVC_NAME,
+                },
+            }
+        )

parrot/lib/python3.10/site-packages/wandb/sdk/launch/runner/local_container.py

@@ -0,0 +1,301 @@
+import asyncio
+import logging
+import os
+import shlex
+import subprocess
+import sys
+import threading
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+import wandb
+from wandb.sdk.launch.environment.abstract import AbstractEnvironment
+from wandb.sdk.launch.registry.abstract import AbstractRegistry
+
+from .._project_spec import LaunchProject
+from ..errors import LaunchError
+from ..utils import (
+    CODE_MOUNT_DIR,
+    LOG_PREFIX,
+    MAX_ENV_LENGTHS,
+    PROJECT_SYNCHRONOUS,
+    _is_wandb_dev_uri,
+    _is_wandb_local_uri,
+    docker_image_exists,
+    event_loop_thread_exec,
+    pull_docker_image,
+    sanitize_wandb_api_key,
+)
+from .abstract import AbstractRun, AbstractRunner, Status
+
+if TYPE_CHECKING:
+    from wandb.apis.internal import Api
+
+_logger = logging.getLogger(__name__)
+
+
+class LocalSubmittedRun(AbstractRun):
+    """Instance of ``AbstractRun`` corresponding to a subprocess launched to run an entry point command locally."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._command_proc: Optional[subprocess.Popen] = None
+        self._stdout: Optional[str] = None
+        self._terminate_flag: bool = False
+        self._thread: Optional[threading.Thread] = None
+
+    def set_command_proc(self, command_proc: subprocess.Popen) -> None:
+        self._command_proc = command_proc
+
+    def set_thread(self, thread: threading.Thread) -> None:
+        self._thread = thread
+
+    @property
+    def id(self) -> Optional[str]:
+        if self._command_proc is None:
+            return None
+        return str(self._command_proc.pid)
+
+    async def wait(self) -> bool:
+        assert self._thread is not None
+        # if command proc is not set
+        # wait for thread to set it
+        if self._command_proc is None:
+            while self._thread.is_alive():
+                await asyncio.sleep(5)
+                # command proc can be updated by another thread
+                if self._command_proc is not None:
+                    break  # type: ignore  # mypy thinks this is unreachable
+            else:
+                return False
+        wait = event_loop_thread_exec(self._command_proc.wait)
+        return int(await wait()) == 0
+
+    async def get_logs(self) -> Optional[str]:
+        return self._stdout
+
+    async def cancel(self) -> None:
+        # thread is set immediately after starting, should always exist
+        assert self._thread is not None
+
+        # cancel called before the thread subprocess has started
+        # indicates to thread to not start command proc if not already started
+        self._terminate_flag = True
+
+    async def get_status(self) -> Status:
+        assert self._thread is not None, "Failed to get status, self._thread = None"
+        if self._command_proc is None:
+            if self._thread.is_alive():
+                return Status("running")
+            return Status("stopped")
+        exit_code = self._command_proc.poll()
+        if exit_code is None:
+            return Status("running")
+        if exit_code == 0:
+            return Status("finished")
+        return Status("failed")
+
+
+class LocalContainerRunner(AbstractRunner):
+    """Runner class, uses a project to create a LocallySubmittedRun."""
+
+    def __init__(
+        self,
+        api: "Api",
+        backend_config: Dict[str, Any],
+        environment: AbstractEnvironment,
+        registry: AbstractRegistry,
+    ) -> None:
+        super().__init__(api, backend_config)
+        self.environment = environment
+        self.registry = registry
+
+    def _populate_docker_args(
+        self, launch_project: LaunchProject, image_uri: str
+    ) -> Dict[str, Any]:
+        docker_args: Dict[str, Any] = launch_project.fill_macros(image_uri).get(
+            "local-container", {}
+        )
+        if _is_wandb_local_uri(self._api.settings("base_url")):
+            if sys.platform == "win32":
+                docker_args["net"] = "host"
+            else:
+                docker_args["network"] = "host"
+            if sys.platform == "linux" or sys.platform == "linux2":
+                docker_args["add-host"] = "host.docker.internal:host-gateway"
+        base_image = launch_project.job_base_image
+        if base_image is not None:
+            # Mount code into the container and set the working directory.
+            if "volume" not in docker_args:
+                docker_args["volume"] = []
+            docker_args["volume"].append(
+                f"{launch_project.project_dir}:{CODE_MOUNT_DIR}"
+            )
+            docker_args["workdir"] = CODE_MOUNT_DIR
+        return docker_args
+
+    async def run(
+        self,
+        launch_project: LaunchProject,
+        image_uri: str,
+    ) -> Optional[AbstractRun]:
+        docker_args = self._populate_docker_args(launch_project, image_uri)
+        synchronous: bool = self.backend_config[PROJECT_SYNCHRONOUS]
+
+        env_vars = launch_project.get_env_vars_dict(
+            self._api, MAX_ENV_LENGTHS[self.__class__.__name__]
+        )
+
+        # When running against local port, need to swap to local docker host
+        if (
+            _is_wandb_local_uri(self._api.settings("base_url"))
+            and sys.platform == "darwin"
+        ):
+            _, _, port = self._api.settings("base_url").split(":")
+            env_vars["WANDB_BASE_URL"] = f"http://host.docker.internal:{port}"
+        elif _is_wandb_dev_uri(self._api.settings("base_url")):
+            env_vars["WANDB_BASE_URL"] = "http://host.docker.internal:9001"
+
+        if launch_project.docker_image or launch_project.job_base_image:
+            try:
+                pull_docker_image(image_uri)
+            except Exception as e:
+                wandb.termwarn(f"Error attempting to pull docker image {image_uri}")
+                if not docker_image_exists(image_uri):
+                    raise LaunchError(
+                        f"Failed to pull docker image {image_uri} with error: {e}"
+                    )
+
+        entrypoint = launch_project.get_job_entry_point()
+        entry_cmd = None if entrypoint is None else entrypoint.command
+        command_str = " ".join(
+            get_docker_command(
+                image_uri,
+                env_vars,
+                docker_args=docker_args,
+                entry_cmd=entry_cmd,
+                additional_args=launch_project.override_args,
+            )
+        ).strip()
+        sanitized_cmd_str = sanitize_wandb_api_key(command_str)
+        _msg = f"{LOG_PREFIX}Launching run in docker with command: {sanitized_cmd_str}"
+        wandb.termlog(_msg)
+        run = _run_entry_point(command_str, launch_project.project_dir)
+        if synchronous:
+            await run.wait()
+        return run
+
+
+def _run_entry_point(command: str, work_dir: Optional[str]) -> AbstractRun:
+    """Run an entry point command in a subprocess.
+
+    Arguments:
+        command: Entry point command to run
+        work_dir: Working directory in which to run the command
+
+    Returns:
+        An instance of `LocalSubmittedRun`
+    """
+    if work_dir is None:
+        work_dir = os.getcwd()
+    env = os.environ.copy()
+    run = LocalSubmittedRun()
+    thread = threading.Thread(
+        target=_thread_process_runner,
+        args=(run, ["bash", "-c", command], work_dir, env),
+    )
+    run.set_thread(thread)
+    thread.start()
+    return run
+
+
+def _thread_process_runner(
+    run: LocalSubmittedRun, args: List[str], work_dir: str, env: Dict[str, str]
+) -> None:
+    # cancel was called before we started the subprocess
+    if run._terminate_flag:
+        return
+    # TODO: Make this async
+    process = subprocess.Popen(
+        args,
+        close_fds=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        universal_newlines=True,
+        bufsize=1,
+        cwd=work_dir,
+        env=env,
+    )
+    run.set_command_proc(process)
+    run._stdout = ""
+    while True:
+        # the agent thread could set the terminate flag
+        if run._terminate_flag:
+            process.terminate()  # type: ignore
+        chunk = os.read(process.stdout.fileno(), 4096)  # type: ignore
+        if not chunk:
+            break
+        index = chunk.find(b"\r")
+        decoded_chunk = None
+        while not decoded_chunk:
+            try:
+                decoded_chunk = chunk.decode()
+            except UnicodeDecodeError:
+                # Multi-byte character cut off, try to get the rest of it
+                chunk += os.read(process.stdout.fileno(), 1)  # type: ignore
+        if index != -1:
+            run._stdout += decoded_chunk
+            print(chunk.decode(), end="")
+        else:
+            run._stdout += decoded_chunk + "\r"
+            print(chunk.decode(), end="\r")
+
+
+def get_docker_command(
+    image: str,
+    env_vars: Dict[str, str],
+    entry_cmd: Optional[List[str]] = None,
+    docker_args: Optional[Dict[str, Any]] = None,
+    additional_args: Optional[List[str]] = None,
+) -> List[str]:
+    """Construct the docker command using the image and docker args.
+
+    Arguments:
+    image: a Docker image to be run
+    env_vars: a dictionary of environment variables for the command
+    entry_cmd: the entry point command to run
+    docker_args: a dictionary of additional docker args for the command
+    """
+    docker_path = "docker"
+    cmd: List[Any] = [docker_path, "run", "--rm"]
+
+    # hacky handling of env vars, needs to be improved
+    for env_key, env_value in env_vars.items():
+        cmd += ["-e", f"{shlex.quote(env_key)}={shlex.quote(env_value)}"]
+
+    if docker_args:
+        for name, value in docker_args.items():
+            if len(name) == 1:
+                prefix = "-" + shlex.quote(name)
+            else:
+                prefix = "--" + shlex.quote(name)
+            if isinstance(value, list):
+                for v in value:
+                    cmd += [prefix, shlex.quote(str(v))]
+            elif isinstance(value, bool) and value:
+                cmd += [prefix]
+            else:
+                cmd += [prefix, shlex.quote(str(value))]
+
+    if entry_cmd:
+        cmd += ["--entrypoint", entry_cmd[0]]
+    cmd += [shlex.quote(image)]
+    if entry_cmd and len(entry_cmd) > 1:
+        cmd += entry_cmd[1:]
+    if additional_args:
+        cmd += additional_args
+    return cmd
+
+
+def join(split_command: List[str]) -> str:
+    """Return a shell-escaped string from *split_command*."""
+    return " ".join(shlex.quote(arg) for arg in split_command)

parrot/lib/python3.10/site-packages/wandb/sdk/lib/__init__.py

@@ -0,0 +1,5 @@
+from . import lazyloader
+from .disabled import RunDisabled, SummaryDisabled
+from .run_moment import RunMoment
+
+__all__ = ("lazyloader", "RunDisabled", "SummaryDisabled", "RunMoment")

parrot/lib/python3.10/site-packages/wandb/sdk/lib/_settings_toposort_generate.py

@@ -0,0 +1,159 @@
+import inspect
+import sys
+from typing import Dict, List, Set, Tuple
+
+from wandb.errors import UsageError
+from wandb.sdk.wandb_settings import Settings
+
+if sys.version_info >= (3, 8):
+    from typing import get_type_hints
+else:
+    from typing_extensions import get_type_hints
+
+
+template = """
+__all__ = ("SETTINGS_TOPOLOGICALLY_SORTED", "_Setting")
+
+import sys
+from typing import Tuple
+
+if sys.version_info >= (3, 8):
+    from typing import Final, Literal
+else:
+    from typing_extensions import Final, Literal
+
+
+_Setting = Literal[
+    $settings_literal_list
+]
+
+SETTINGS_TOPOLOGICALLY_SORTED: Final[Tuple[_Setting, ...]] = (
+    $settings_topologically_sorted
+)
+"""
+
+
+class Graph:
+    # A simple class representing an unweighted directed graph
+    # that uses an adjacency list representation.
+    # We use to ensure that we don't have cyclic dependencies in the settings
+    # and that modifications to the settings are applied in the correct order.
+    def __init__(self) -> None:
+        self.adj_list: Dict[str, Set[str]] = {}
+
+    def add_node(self, node: str) -> None:
+        if node not in self.adj_list:
+            self.adj_list[node] = set()
+
+    def add_edge(self, node1: str, node2: str) -> None:
+        self.adj_list[node1].add(node2)
+
+    def get_neighbors(self, node: str) -> Set[str]:
+        return self.adj_list[node]
+
+    # return a list of nodes sorted in topological order
+    def topological_sort_dfs(self) -> List[str]:
+        sorted_copy = {k: sorted(v) for k, v in self.adj_list.items()}
+
+        sorted_nodes: List[str] = []
+        visited_nodes: Set[str] = set()
+        current_nodes: Set[str] = set()
+
+        def visit(n: str) -> None:
+            if n in visited_nodes:
+                return None
+            if n in current_nodes:
+                raise UsageError("Cyclic dependency detected in wandb.Settings")
+
+            current_nodes.add(n)
+            for neighbor in sorted_copy[n]:
+                visit(neighbor)
+
+            current_nodes.remove(n)
+            visited_nodes.add(n)
+            sorted_nodes.append(n)
+
+            return None
+
+        for node in self.adj_list:
+            if node not in visited_nodes:
+                visit(node)
+
+        return sorted_nodes
+
+
+def _get_modification_order(
+    settings: Settings,
+) -> Tuple[Tuple[str, ...], Tuple[str, ...]]:
+    """Return the order in which settings should be modified, based on dependencies."""
+    dependency_graph = Graph()
+
+    props = tuple(get_type_hints(Settings).keys())
+
+    # discover prop dependencies from validator methods and runtime hooks
+
+    prefix = "_validate_"
+    symbols = set(dir(settings))
+    validator_methods = tuple(sorted(m for m in symbols if m.startswith(prefix)))
+
+    # extract dependencies from validator methods
+    for m in validator_methods:
+        setting = m.split(prefix)[1]
+        dependency_graph.add_node(setting)
+        # if the method is not static, inspect its code to find the attributes it depends on
+        if (
+            not isinstance(Settings.__dict__[m], staticmethod)
+            and not isinstance(Settings.__dict__[m], classmethod)
+            and Settings.__dict__[m].__code__.co_argcount > 0
+        ):
+            unbound_closure_vars = inspect.getclosurevars(Settings.__dict__[m]).unbound
+            dependencies = (v for v in unbound_closure_vars if v in props)
+            for d in dependencies:
+                dependency_graph.add_node(d)
+                dependency_graph.add_edge(setting, d)
+
+    # extract dependencies from props' runtime hooks
+    default_props = settings._default_props()
+    for prop, spec in default_props.items():
+        if "hook" not in spec:
+            continue
+
+        dependency_graph.add_node(prop)
+
+        hook = spec["hook"]
+        if callable(hook):
+            hook = [hook]
+
+        for h in hook:
+            unbound_closure_vars = inspect.getclosurevars(h).unbound
+            dependencies = (v for v in unbound_closure_vars if v in props)
+            for d in dependencies:
+                dependency_graph.add_node(d)
+                dependency_graph.add_edge(prop, d)
+
+    modification_order = dependency_graph.topological_sort_dfs()
+    return props, tuple(modification_order)
+
+
+def generate(settings: Settings) -> None:
+    _settings_literal_list, _settings_topologically_sorted = _get_modification_order(
+        settings
+    )
+    settings_literal_list = ", ".join(f'"{s}"' for s in _settings_literal_list)
+    settings_topologically_sorted = ", ".join(
+        f'"{s}"' for s in _settings_topologically_sorted
+    )
+
+    print(
+        template.replace(
+            "$settings_literal_list",
+            settings_literal_list,
+        ).replace(
+            "$settings_topologically_sorted",
+            settings_topologically_sorted,
+        )
+    )
+
+
+if __name__ == "__main__":
+    generate(Settings())

parrot/lib/python3.10/site-packages/wandb/sdk/lib/_settings_toposort_generated.py

@@ -0,0 +1,249 @@
+# DO NOT EDIT -- GENERATED BY: `generate-tool.py --generate`
+__all__ = ("SETTINGS_TOPOLOGICALLY_SORTED", "_Setting")
+
+import sys
+from typing import Tuple
+
+if sys.version_info >= (3, 8):
+    from typing import Final, Literal
+else:
+    from typing_extensions import Final, Literal
+
+
+_Setting = Literal[
+    "_args",
+    "_aws_lambda",
+    "_cli_only_mode",
+    "_code_path_local",
+    "_colab",
+    "_cuda",
+    "_disable_meta",
+    "_disable_service",
+    "_disable_setproctitle",
+    "_disable_stats",
+    "_disable_update_check",
+    "_disable_viewer",
+    "_disable_machine_info",
+    "_executable",
+    "_extra_http_headers",
+    "_file_stream_max_bytes",
+    "_file_stream_retry_max",
+    "_file_stream_retry_wait_min_seconds",
+    "_file_stream_retry_wait_max_seconds",
+    "_file_stream_timeout_seconds",
+    "_file_transfer_retry_max",
+    "_file_transfer_retry_wait_min_seconds",
+    "_file_transfer_retry_wait_max_seconds",
+    "_file_transfer_timeout_seconds",
+    "_flow_control_custom",
+    "_flow_control_disabled",
+    "_graphql_retry_max",
+    "_graphql_retry_wait_min_seconds",
+    "_graphql_retry_wait_max_seconds",
+    "_graphql_timeout_seconds",
+    "_internal_check_process",
+    "_internal_queue_timeout",
+    "_ipython",
+    "_jupyter",
+    "_jupyter_name",
+    "_jupyter_path",
+    "_jupyter_root",
+    "_kaggle",
+    "_live_policy_rate_limit",
+    "_live_policy_wait_time",
+    "_log_level",
+    "_network_buffer",
+    "_noop",
+    "_notebook",
+    "_offline",
+    "_sync",
+    "_os",
+    "_platform",
+    "_proxies",
+    "_python",
+    "_runqueue_item_id",
+    "_require_legacy_service",
+    "_save_requirements",
+    "_service_transport",
+    "_service_wait",
+    "_shared",
+    "_start_datetime",
+    "_start_time",
+    "_stats_pid",
+    "_stats_sampling_interval",
+    "_stats_sample_rate_seconds",
+    "_stats_samples_to_average",
+    "_stats_join_assets",
+    "_stats_neuron_monitor_config_path",
+    "_stats_open_metrics_endpoints",
+    "_stats_open_metrics_filters",
+    "_stats_disk_paths",
+    "_stats_buffer_size",
+    "_tmp_code_dir",
+    "_tracelog",
+    "_unsaved_keys",
+    "_windows",
+    "allow_val_change",
+    "anonymous",
+    "api_key",
+    "azure_account_url_to_access_key",
+    "base_url",
+    "code_dir",
+    "colab_url",
+    "config_paths",
+    "console",
+    "console_multipart",
+    "credentials_file",
+    "deployment",
+    "disable_code",
+    "disable_git",
+    "disable_hints",
+    "disable_job_creation",
+    "disabled",
+    "docker",
+    "email",
+    "entity",
+    "files_dir",
+    "force",
+    "fork_from",
+    "resume_from",
+    "git_commit",
+    "git_remote",
+    "git_remote_url",
+    "git_root",
+    "heartbeat_seconds",
+    "host",
+    "http_proxy",
+    "https_proxy",
+    "identity_token_file",
+    "ignore_globs",
+    "init_timeout",
+    "is_local",
+    "job_name",
+    "job_source",
+    "label_disable",
+    "launch",
+    "launch_config_path",
+    "log_dir",
+    "log_internal",
+    "log_symlink_internal",
+    "log_symlink_user",
+    "log_user",
+    "login_timeout",
+    "mode",
+    "notebook_name",
+    "program",
+    "program_abspath",
+    "program_relpath",
+    "project",
+    "project_url",
+    "quiet",
+    "reinit",
+    "relogin",
+    "resume",
+    "resume_fname",
+    "resumed",
+    "root_dir",
+    "run_group",
+    "run_id",
+    "run_job_type",
+    "run_mode",
+    "run_name",
+    "run_notes",
+    "run_tags",
+    "run_url",
+    "sagemaker_disable",
+    "save_code",
+    "settings_system",
+    "settings_workspace",
+    "show_colors",
+    "show_emoji",
+    "show_errors",
+    "show_info",
+    "show_warnings",
+    "silent",
+    "start_method",
+    "strict",
+    "summary_errors",
+    "summary_timeout",
+    "summary_warnings",
+    "sweep_id",
+    "sweep_param_path",
+    "sweep_url",
+    "symlink",
+    "sync_dir",
+    "sync_file",
+    "sync_symlink_latest",
+    "table_raise_on_max_row_limit_exceeded",
+    "timespec",
+    "tmp_dir",
+    "username",
+    "wandb_dir",
+]
+
+SETTINGS_TOPOLOGICALLY_SORTED: Final[Tuple[_Setting, ...]] = (
+    "_service_wait",
+    "_stats_sample_rate_seconds",
+    "_stats_samples_to_average",
+    "_stats_sampling_interval",
+    "anonymous",
+    "api_key",
+    "base_url",
+    "console",
+    "job_source",
+    "mode",
+    "project",
+    "run_id",
+    "start_method",
+    "_aws_lambda",
+    "program",
+    "_code_path_local",
+    "_colab",
+    "_disable_machine_info",
+    "_disable_meta",
+    "_disable_stats",
+    "_network_buffer",
+    "_flow_control_disabled",
+    "_flow_control_custom",
+    "_ipython",
+    "_jupyter",
+    "_kaggle",
+    "_noop",
+    "_notebook",
+    "disabled",
+    "_offline",
+    "_shared",
+    "_stats_neuron_monitor_config_path",
+    "run_mode",
+    "_start_datetime",
+    "timespec",
+    "root_dir",
+    "wandb_dir",
+    "tmp_dir",
+    "_tmp_code_dir",
+    "_windows",
+    "colab_url",
+    "is_local",
+    "deployment",
+    "disable_code",
+    "disable_git",
+    "disable_job_creation",
+    "files_dir",
+    "_proxies",
+    "http_proxy",
+    "https_proxy",
+    "log_dir",
+    "log_internal",
+    "log_symlink_internal",
+    "log_symlink_user",
+    "log_user",
+    "project_url",
+    "resume_fname",
+    "run_url",
+    "settings_system",
+    "settings_workspace",
+    "sweep_url",
+    "sync_dir",
+    "sync_file",
+    "sync_symlink_latest",
+)

parrot/lib/python3.10/site-packages/wandb/sdk/lib/_wburls_generate.py

@@ -0,0 +1,25 @@
+from wburls import wburls  # type: ignore
+
+template = """
+import sys
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+
+URLS = Literal[
+    $literal_list
+]
+"""
+
+
+def generate() -> None:
+    urls = wburls._get_urls()
+    literal_list = ", ".join([f"{key!r}" for key in urls])
+    print(template.replace("$literal_list", literal_list))
+
+
+if __name__ == "__main__":
+    generate()

parrot/lib/python3.10/site-packages/wandb/sdk/lib/apikey.py

@@ -0,0 +1,273 @@
+"""apikey util."""
+
+import os
+import platform
+import stat
+import sys
+import textwrap
+from functools import partial
+from typing import TYPE_CHECKING, Callable, Dict, Optional, Union
+from urllib.parse import urlparse
+
+# import Literal
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+import click
+from requests.utils import NETRC_FILES, get_netrc_auth
+
+import wandb
+from wandb.apis import InternalApi
+from wandb.errors import term
+from wandb.util import _is_databricks, isatty, prompt_choices
+
+from .wburls import wburls
+
+LOGIN_CHOICE_ANON = "Private W&B dashboard, no account required"
+LOGIN_CHOICE_NEW = "Create a W&B account"
+LOGIN_CHOICE_EXISTS = "Use an existing W&B account"
+LOGIN_CHOICE_DRYRUN = "Don't visualize my results"
+LOGIN_CHOICE_NOTTY = "Unconfigured"
+LOGIN_CHOICES = [
+    LOGIN_CHOICE_ANON,
+    LOGIN_CHOICE_NEW,
+    LOGIN_CHOICE_EXISTS,
+    LOGIN_CHOICE_DRYRUN,
+]
+
+Mode = Literal["allow", "must", "never", "false", "true"]
+
+if TYPE_CHECKING:
+    from wandb.sdk.wandb_settings import Settings
+
+
+getpass = partial(click.prompt, hide_input=True, err=True)
+
+
+def _fixup_anon_mode(default: Optional[Mode]) -> Optional[Mode]:
+    # Convert weird anonymode values from legacy settings files
+    # into one of our expected values.
+    anon_mode = default or "never"
+    mapping: Dict[Mode, Mode] = {"true": "allow", "false": "never"}
+    return mapping.get(anon_mode, anon_mode)
+
+
+def get_netrc_file_path() -> str:
+    """Return the path to the netrc file."""
+    # if the NETRC environment variable is set, use that
+    netrc_file = os.environ.get("NETRC")
+    if netrc_file:
+        return os.path.expanduser(netrc_file)
+
+    # if either .netrc or _netrc exists in the home directory, use that
+    for netrc_file in NETRC_FILES:
+        home_dir = os.path.expanduser("~")
+        if os.path.exists(os.path.join(home_dir, netrc_file)):
+            return os.path.join(home_dir, netrc_file)
+
+    # otherwise, use .netrc on non-Windows platforms and _netrc on Windows
+    netrc_file = ".netrc" if platform.system() != "Windows" else "_netrc"
+
+    return os.path.join(os.path.expanduser("~"), netrc_file)
+
+
+def prompt_api_key(  # noqa: C901
+    settings: "Settings",
+    api: Optional[InternalApi] = None,
+    input_callback: Optional[Callable] = None,
+    browser_callback: Optional[Callable] = None,
+    no_offline: bool = False,
+    no_create: bool = False,
+    local: bool = False,
+) -> Union[str, bool, None]:
+    """Prompt for api key.
+
+    Returns:
+        str - if key is configured
+        None - if dryrun is selected
+        False - if unconfigured (notty)
+    """
+    input_callback = input_callback or getpass
+    log_string = term.LOG_STRING
+    api = api or InternalApi(settings)
+    anon_mode = _fixup_anon_mode(settings.anonymous)  # type: ignore
+    jupyter = settings._jupyter or False
+    app_url = api.app_url
+
+    choices = [choice for choice in LOGIN_CHOICES]
+    if anon_mode == "never":
+        # Omit LOGIN_CHOICE_ANON as a choice if the env var is set to never
+        choices.remove(LOGIN_CHOICE_ANON)
+    if (jupyter and not settings.login_timeout) or no_offline:
+        choices.remove(LOGIN_CHOICE_DRYRUN)
+    if (jupyter and not settings.login_timeout) or no_create:
+        choices.remove(LOGIN_CHOICE_NEW)
+
+    if jupyter and "google.colab" in sys.modules:
+        log_string = term.LOG_STRING_NOCOLOR
+        key = wandb.jupyter.attempt_colab_login(app_url)  # type: ignore
+        if key is not None:
+            write_key(settings, key, api=api)
+            return key  # type: ignore
+
+    if anon_mode == "must":
+        result = LOGIN_CHOICE_ANON
+    # If we're not in an interactive environment, default to dry-run.
+    elif (
+        not jupyter and (not isatty(sys.stdout) or not isatty(sys.stdin))
+    ) or _is_databricks():
+        result = LOGIN_CHOICE_NOTTY
+    elif local:
+        result = LOGIN_CHOICE_EXISTS
+    elif len(choices) == 1:
+        result = choices[0]
+    else:
+        result = prompt_choices(
+            choices, input_timeout=settings.login_timeout, jupyter=jupyter
+        )
+
+    api_ask = (
+        f"{log_string}: Paste an API key from your profile and hit enter, "
+        "or press ctrl+c to quit"
+    )
+    if result == LOGIN_CHOICE_ANON:
+        key = api.create_anonymous_api_key()
+
+        write_key(settings, key, api=api, anonymous=True)
+        return key  # type: ignore
+    elif result == LOGIN_CHOICE_NEW:
+        key = browser_callback(signup=True) if browser_callback else None
+
+        if not key:
+            wandb.termlog(f"Create an account here: {app_url}/authorize?signup=true")
+            key = input_callback(api_ask).strip()
+
+        write_key(settings, key, api=api)
+        return key  # type: ignore
+    elif result == LOGIN_CHOICE_EXISTS:
+        key = browser_callback() if browser_callback else None
+
+        if not key:
+            if not (settings.is_local or local):
+                host = app_url
+                for prefix in ("http://", "https://"):
+                    if app_url.startswith(prefix):
+                        host = app_url[len(prefix) :]
+                wandb.termlog(
+                    f"Logging into {host}. (Learn how to deploy a W&B server locally: {wburls.get('wandb_server')})"
+                )
+            wandb.termlog(
+                f"You can find your API key in your browser here: {app_url}/authorize"
+            )
+            key = input_callback(api_ask).strip()
+        write_key(settings, key, api=api)
+        return key  # type: ignore
+    elif result == LOGIN_CHOICE_NOTTY:
+        # TODO: Needs refactor as this needs to be handled by caller
+        return False
+    elif result == LOGIN_CHOICE_DRYRUN:
+        return None
+    else:
+        # Jupyter environments don't have a tty, but we can still try logging in using
+        # the browser callback if one is supplied.
+        key, anonymous = (
+            browser_callback() if jupyter and browser_callback else (None, False)
+        )
+
+        write_key(settings, key, api=api)
+        return key  # type: ignore
+
+
+def write_netrc(host: str, entity: str, key: str) -> Optional[bool]:
+    """Add our host and key to .netrc."""
+    _, key_suffix = key.split("-", 1) if "-" in key else ("", key)
+    if len(key_suffix) != 40:
+        wandb.termerror(
+            "API-key must be exactly 40 characters long: {} ({} chars)".format(
+                key_suffix, len(key_suffix)
+            )
+        )
+        return None
+    try:
+        normalized_host = urlparse(host).netloc.split(":")[0]
+        netrc_path = get_netrc_file_path()
+        wandb.termlog(
+            f"Appending key for {normalized_host} to your netrc file: {netrc_path}"
+        )
+        machine_line = f"machine {normalized_host}"
+        orig_lines = None
+        try:
+            with open(netrc_path) as f:
+                orig_lines = f.read().strip().split("\n")
+        except OSError:
+            pass
+        with open(netrc_path, "w") as f:
+            if orig_lines:
+                # delete this machine from the file if it's already there.
+                skip = 0
+                for line in orig_lines:
+                    # we fix invalid netrc files with an empty host that we wrote before
+                    # verifying host...
+                    if line == "machine " or machine_line in line:
+                        skip = 2
+                    elif skip:
+                        skip -= 1
+                    else:
+                        f.write("{}\n".format(line))
+            f.write(
+                textwrap.dedent(
+                    """\
+            machine {host}
+              login {entity}
+              password {key}
+            """
+                ).format(host=normalized_host, entity=entity, key=key)
+            )
+        os.chmod(netrc_path, stat.S_IRUSR | stat.S_IWUSR)
+        return True
+    except OSError:
+        wandb.termerror(f"Unable to read {netrc_path}")
+        return None
+
+
+def write_key(
+    settings: "Settings",
+    key: Optional[str],
+    api: Optional["InternalApi"] = None,
+    anonymous: bool = False,
+) -> None:
+    if not key:
+        raise ValueError("No API key specified.")
+
+    # TODO(jhr): api shouldn't be optional or it shouldn't be passed, clean up callers
+    api = api or InternalApi()
+
+    # Normal API keys are 40-character hex strings. On-prem API keys have a
+    # variable-length prefix, a dash, then the 40-char string.
+    _, suffix = key.split("-", 1) if "-" in key else ("", key)
+
+    if len(suffix) != 40:
+        raise ValueError(
+            "API key must be 40 characters long, yours was {}".format(len(key))
+        )
+
+    if anonymous:
+        api.set_setting("anonymous", "true", globally=True, persist=True)
+    else:
+        api.clear_setting("anonymous", globally=True, persist=True)
+
+    write_netrc(settings.base_url, "user", key)
+
+
+def api_key(settings: Optional["Settings"] = None) -> Optional[str]:
+    if settings is None:
+        settings = wandb.setup().settings  # type: ignore
+        assert settings is not None
+    if settings.api_key:
+        return settings.api_key
+    auth = get_netrc_auth(settings.base_url)
+    if auth:
+        return auth[-1]
+    return None

parrot/lib/python3.10/site-packages/wandb/sdk/lib/capped_dict.py

@@ -0,0 +1,26 @@
+import collections
+from typing import Any, Optional
+
+
+class CappedDict(collections.OrderedDict):
+    default_max_size = 50
+
+    def __init__(self, max_size: Optional[int] = None) -> None:
+        self.max_size = max_size or self.default_max_size
+        super().__init__()
+
+    def __setitem__(self, key: str, val: Any) -> None:
+        if key not in self:
+            max_size = self.max_size - 1
+            self._prune_dict(max_size)
+        super().__setitem__(key, val)
+
+    def update(self, **kwargs: Any) -> None:  # type: ignore[override]
+        super().update(**kwargs)
+        self._prune_dict(self.max_size)
+
+    def _prune_dict(self, max_size: int) -> None:
+        if len(self) >= max_size:
+            diff = len(self) - max_size
+            for k in list(self.keys())[:diff]:
+                del self[k]

parrot/lib/python3.10/site-packages/wandb/sdk/lib/config_util.py

@@ -0,0 +1,101 @@
+import json
+import logging
+import os
+from typing import Any, Dict, Optional
+
+import yaml
+
+import wandb
+from wandb.errors import Error
+from wandb.util import load_yaml
+
+from . import filesystem
+
+logger = logging.getLogger("wandb")
+
+
+class ConfigError(Error):
+    pass
+
+
+def dict_from_proto_list(obj_list):
+    d = dict()
+    for item in obj_list:
+        d[item.key] = dict(desc=None, value=json.loads(item.value_json))
+    return d
+
+
+def dict_strip_value_dict(config_dict):
+    d = dict()
+    for k, v in config_dict.items():
+        d[k] = v["value"]
+    return d
+
+
+def dict_no_value_from_proto_list(obj_list):
+    d = dict()
+    for item in obj_list:
+        possible_dict = json.loads(item.value_json)
+        if not isinstance(possible_dict, dict) or "value" not in possible_dict:
+            continue
+        d[item.key] = possible_dict["value"]
+
+    return d
+
+
+# TODO(jhr): these functions should go away once we merge jobspec PR
+def save_config_file_from_dict(config_filename, config_dict):
+    s = b"wandb_version: 1"
+    if config_dict:  # adding an empty dictionary here causes a parse error
+        s += b"\n\n" + yaml.dump(
+            config_dict,
+            Dumper=yaml.SafeDumper,
+            default_flow_style=False,
+            allow_unicode=True,
+            encoding="utf-8",
+            sort_keys=False,
+        )
+    data = s.decode("utf-8")
+    filesystem.mkdir_exists_ok(os.path.dirname(config_filename))
+    with open(config_filename, "w") as conf_file:
+        conf_file.write(data)
+
+
+def dict_from_config_file(
+    filename: str, must_exist: bool = False
+) -> Optional[Dict[str, Any]]:
+    if not os.path.exists(filename):
+        if must_exist:
+            raise ConfigError("config file {} doesn't exist".format(filename))
+        logger.debug("no default config file found in {}".format(filename))
+        return None
+    try:
+        conf_file = open(filename)
+    except OSError:
+        raise ConfigError("Couldn't read config file: {}".format(filename))
+    try:
+        loaded = load_yaml(conf_file)
+    except yaml.parser.ParserError:
+        raise ConfigError("Invalid YAML in config yaml")
+    if loaded is None:
+        wandb.termwarn(
+            "Found an empty default config file (config-defaults.yaml). Proceeding with no defaults."
+        )
+        return None
+    config_version = loaded.pop("wandb_version", None)
+    if config_version is not None and config_version != 1:
+        raise ConfigError("Unknown config version")
+    data = dict()
+    for k, v in loaded.items():
+        data[k] = v["value"]
+    return data
+
+
+def merge_dicts(dest: dict, src: dict) -> dict:
+    """Recursively merge two dictionaries. Similar to Lodash's _.merge()."""
+    for key, value in src.items():
+        if isinstance(value, dict) and key in dest and isinstance(dest[key], dict):
+            merge_dicts(dest[key], value)
+        else:
+            dest[key] = value
+    return dest

parrot/lib/python3.10/site-packages/wandb/sdk/lib/credentials.py

@@ -0,0 +1,141 @@
+import json
+import os
+from datetime import datetime, timedelta
+from pathlib import Path
+
+import requests.utils
+
+from wandb.errors import AuthenticationError
+
+DEFAULT_WANDB_CREDENTIALS_FILE = Path(
+    os.path.expanduser("~/.config/wandb/credentials.json")
+)
+
+_expires_at_fmt = "%Y-%m-%d %H:%M:%S"
+
+
+def access_token(base_url: str, token_file: Path, credentials_file: Path) -> str:
+    """Retrieve an access token from the credentials file.
+
+    If no access token exists, create a new one by exchanging the identity
+    token from the token file, and save it to the credentials file.
+
+    Args:
+        base_url (str): The base URL of the server
+        token_file (pathlib.Path): The path to the file containing the
+        identity token
+        credentials_file (pathlib.Path): The path to file used to save
+        temporary access tokens
+
+    Returns:
+        str: The access token
+    """
+    if not credentials_file.exists():
+        _write_credentials_file(base_url, token_file, credentials_file)
+
+    data = _fetch_credentials(base_url, token_file, credentials_file)
+    return data["access_token"]
+
+
+def _write_credentials_file(base_url: str, token_file: Path, credentials_file: Path):
+    """Obtain an access token from the server and write it to the credentials file.
+
+    Args:
+        base_url (str): The base URL of the server
+        token_file (pathlib.Path): The path to the file containing the
+        identity token
+        credentials_file (pathlib.Path): The path to file used to save
+        temporary access tokens
+    """
+    credentials = _create_access_token(base_url, token_file)
+    data = {"credentials": {base_url: credentials}}
+    with open(credentials_file, "w") as file:
+        json.dump(data, file, indent=4)
+
+        # Set file permissions to be read/write by the owner only
+        os.chmod(credentials_file, 0o600)
+
+
+def _fetch_credentials(base_url: str, token_file: Path, credentials_file: Path) -> dict:
+    """Fetch the access token from the credentials file.
+
+    If the access token has expired, fetch a new one from the server and save it
+    to the credentials file.
+
+    Args:
+        base_url (str): The base URL of the server
+        token_file (pathlib.Path): The path to the file containing the
+        identity token
+        credentials_file (pathlib.Path): The path to file used to save
+        temporary access tokens
+
+    Returns:
+        dict: The credentials including the access token.
+    """
+    creds = {}
+    with open(credentials_file) as file:
+        data = json.load(file)
+        if "credentials" not in data:
+            data["credentials"] = {}
+        if base_url in data["credentials"]:
+            creds = data["credentials"][base_url]
+
+    expires_at = datetime.utcnow()
+    if "expires_at" in creds:
+        expires_at = datetime.strptime(creds["expires_at"], _expires_at_fmt)
+
+    if expires_at <= datetime.utcnow():
+        creds = _create_access_token(base_url, token_file)
+        with open(credentials_file, "w") as file:
+            data["credentials"][base_url] = creds
+            json.dump(data, file, indent=4)
+
+    return creds
+
+
+def _create_access_token(base_url: str, token_file: Path) -> dict:
+    """Exchange an identity token for an access token from the server.
+
+    Args:
+        base_url (str): The base URL of the server.
+        token_file (pathlib.Path): The path to the file containing the
+        identity token
+
+    Returns:
+        dict: The access token and its expiration.
+
+    Raises:
+        FileNotFoundError: If the token file is not found.
+        OSError: If there is an issue reading the token file.
+        AuthenticationError: If the server fails to provide an access token.
+    """
+    try:
+        with open(token_file) as file:
+            token = file.read().strip()
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"Identity token file not found: {token_file}") from e
+    except OSError as e:
+        raise OSError(
+            f"Failed to read the identity token from file: {token_file}"
+        ) from e
+
+    url = f"{base_url}/oidc/token"
+    data = {
+        "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        "assertion": token,
+    }
+    headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+    response = requests.post(url, data=data, headers=headers)
+
+    if response.status_code != 200:
+        raise AuthenticationError(
+            f"Failed to retrieve access token: {response.status_code}, {response.text}"
+        )
+
+    resp_json = response.json()
+    expires_at = datetime.utcnow() + timedelta(seconds=float(resp_json["expires_in"]))
+    resp_json["expires_at"] = expires_at.strftime(_expires_at_fmt)
+    del resp_json["expires_in"]
+
+    return resp_json

parrot/lib/python3.10/site-packages/wandb/sdk/lib/deprecate.py

@@ -0,0 +1,42 @@
+__all__ = ["deprecate", "Deprecated"]
+
+from typing import TYPE_CHECKING, Optional, Tuple
+
+import wandb
+from wandb.proto.wandb_deprecated import DEPRECATED_FEATURES, Deprecated
+from wandb.proto.wandb_telemetry_pb2 import Deprecated as TelemetryDeprecated
+
+# avoid cycle, use string type reference
+if TYPE_CHECKING:
+    from .. import wandb_run
+
+
+deprecated_field_names: Tuple[str, ...] = tuple(
+    str(v) for k, v in Deprecated.__dict__.items() if not k.startswith("_")
+)
+
+
+def deprecate(
+    field_name: DEPRECATED_FEATURES,
+    warning_message: str,
+    run: Optional["wandb_run.Run"] = None,
+) -> None:
+    """Warn the user that a feature has been deprecated.
+
+    Also stores the information about the event in telemetry.
+
+    Args:
+        field_name: The name of the feature that has been deprecated.
+                    Defined in wandb/proto/wandb_telemetry.proto::Deprecated
+        warning_message: The message to display to the user.
+        run: The run to whose telemetry the event will be added.
+    """
+    known_fields = TelemetryDeprecated.DESCRIPTOR.fields_by_name.keys()
+    if field_name not in known_fields:
+        raise ValueError(
+            f"Unknown field name: {field_name}. Known fields: {known_fields}"
+        )
+    _run = run or wandb.run
+    with wandb.wandb_lib.telemetry.context(run=_run) as tel:  # type: ignore[attr-defined]
+        setattr(tel.deprecated, field_name, True)
+    wandb.termwarn(warning_message, repeat=False)

parrot/lib/python3.10/site-packages/wandb/sdk/lib/disabled.py

@@ -0,0 +1,29 @@
+from typing import Any
+
+from wandb.sdk.lib import deprecate
+
+
+class SummaryDisabled(dict):
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+    def __getattr__(self, key):
+        return self[key]
+
+    def __getitem__(self, key):
+        val = dict.__getitem__(self, key)
+        if isinstance(val, dict) and not isinstance(val, SummaryDisabled):
+            val = SummaryDisabled(val)
+            self[key] = val
+        return val
+
+
+class RunDisabled:
+    """Compatibility class for integrations that explicitly check for wandb.RunDisabled."""
+
+    def __getattr__(self, name: str) -> Any:
+        deprecate.deprecate(
+            field_name=deprecate.Deprecated.run_disabled,
+            warning_message="RunDisabled is deprecated and is a no-op. "
+            '`wandb.init(mode="disabled")` now returns and instance of `wandb.sdk.wandb_run.Run`.',
+        )

parrot/lib/python3.10/site-packages/wandb/sdk/lib/exit_hooks.py

@@ -0,0 +1,54 @@
+import sys
+import traceback
+from types import TracebackType
+from typing import TYPE_CHECKING, Optional, Type
+
+import wandb
+from wandb.errors import Error
+
+if TYPE_CHECKING:
+    from typing import NoReturn
+
+
+class ExitHooks:
+    exception: Optional[BaseException] = None
+
+    def __init__(self) -> None:
+        self.exit_code = 0
+        self.exception = None
+
+    def hook(self) -> None:
+        self._orig_exit = sys.exit
+        sys.exit = self.exit
+        self._orig_excepthook = (
+            sys.excepthook
+            if sys.excepthook
+            != sys.__excepthook__  # respect hooks by other libraries like pdb
+            else None
+        )
+        sys.excepthook = self.exc_handler  # type: ignore
+
+    def exit(self, code: object = 0) -> "NoReturn":
+        orig_code = code
+        code = code if code is not None else 0
+        code = code if isinstance(code, int) else 1
+        self.exit_code = code
+        self._orig_exit(orig_code)  # type: ignore
+
+    def was_ctrl_c(self) -> bool:
+        return isinstance(self.exception, KeyboardInterrupt)
+
+    def exc_handler(
+        self, exc_type: Type[BaseException], exc: BaseException, tb: TracebackType
+    ) -> None:
+        self.exit_code = 1
+        self.exception = exc
+        if issubclass(exc_type, Error):
+            wandb.termerror(str(exc), repeat=False)
+
+        if self.was_ctrl_c():
+            self.exit_code = 255
+
+        traceback.print_exception(exc_type, exc, tb)
+        if self._orig_excepthook:
+            self._orig_excepthook(exc_type, exc, tb)

parrot/lib/python3.10/site-packages/wandb/sdk/lib/filenames.py

@@ -0,0 +1,64 @@
+import os
+from typing import Callable, Generator, Union
+
+WANDB_DIRS = ("wandb", ".wandb")
+
+CONFIG_FNAME = "config.yaml"
+OUTPUT_FNAME = "output.log"
+DIFF_FNAME = "diff.patch"
+SUMMARY_FNAME = "wandb-summary.json"
+METADATA_FNAME = "wandb-metadata.json"
+REQUIREMENTS_FNAME = "requirements.txt"
+HISTORY_FNAME = "wandb-history.jsonl"
+EVENTS_FNAME = "wandb-events.jsonl"
+JOBSPEC_FNAME = "wandb-jobspec.json"
+CONDA_ENVIRONMENTS_FNAME = "conda-environment.yaml"
+
+
+def is_wandb_file(name: str) -> bool:
+    return (
+        name.startswith("wandb")
+        or name == METADATA_FNAME
+        or name == CONFIG_FNAME
+        or name == REQUIREMENTS_FNAME
+        or name == OUTPUT_FNAME
+        or name == DIFF_FNAME
+        or name == CONDA_ENVIRONMENTS_FNAME
+    )
+
+
+def filtered_dir(
+    root: str,
+    include_fn: Union[Callable[[str, str], bool], Callable[[str], bool]],
+    exclude_fn: Union[Callable[[str, str], bool], Callable[[str], bool]],
+) -> Generator[str, None, None]:
+    """Simple generator to walk a directory."""
+    import inspect
+
+    # compatibility with old API, which didn't pass root
+    def _include_fn(path: str, root: str) -> bool:
+        return (
+            include_fn(path, root)  # type: ignore
+            if len(inspect.signature(include_fn).parameters) == 2
+            else include_fn(path)  # type: ignore
+        )
+
+    def _exclude_fn(path: str, root: str) -> bool:
+        return (
+            exclude_fn(path, root)  # type: ignore
+            if len(inspect.signature(exclude_fn).parameters) == 2
+            else exclude_fn(path)  # type: ignore
+        )
+
+    for dirpath, _, files in os.walk(root):
+        for fname in files:
+            file_path = os.path.join(dirpath, fname)
+            if _include_fn(file_path, root) and not _exclude_fn(file_path, root):
+                yield file_path
+
+
+def exclude_wandb_fn(path: str, root: str) -> bool:
+    return any(
+        os.path.relpath(path, root).startswith(wandb_dir + os.sep)
+        for wandb_dir in WANDB_DIRS
+    )

parrot/lib/python3.10/site-packages/wandb/sdk/lib/filesystem.py

@@ -0,0 +1,372 @@
+import contextlib
+import ctypes
+import errno
+import logging
+import os
+import platform
+import re
+import shutil
+import tempfile
+import threading
+from pathlib import Path
+from typing import IO, Any, BinaryIO, Generator, Optional
+
+from wandb.sdk.lib.paths import StrPath
+
+logger = logging.getLogger(__name__)
+
+# https://en.wikipedia.org/wiki/Filename#Comparison_of_filename_limitations
+PROBLEMATIC_PATH_CHARS = "".join(chr(i) for i in range(0, 32)) + ':"*<>?|'
+
+
+def mkdir_exists_ok(dir_name: StrPath) -> None:
+    """Create `dir_name` and any parent directories if they don't exist.
+
+    Raises:
+        FileExistsError: if `dir_name` exists and is not a directory.
+        PermissionError: if `dir_name` is not writable.
+    """
+    try:
+        os.makedirs(dir_name, exist_ok=True)
+    except FileExistsError as e:
+        raise FileExistsError(f"{dir_name!s} exists and is not a directory") from e
+    except PermissionError as e:
+        raise PermissionError(f"{dir_name!s} is not writable") from e
+
+
+def path_fallbacks(path: StrPath) -> Generator[str, None, None]:
+    """Yield variations of `path` that may exist on the filesystem.
+
+    Return a sequence of paths that should be checked in order for existence or
+    create-ability. Essentially, keep replacing "suspect" characters until we run out.
+    """
+    path = str(path)
+    root, tail = os.path.splitdrive(path)
+    yield os.path.join(root, tail)
+    for char in PROBLEMATIC_PATH_CHARS:
+        if char in tail:
+            tail = tail.replace(char, "-")
+            yield os.path.join(root, tail)
+
+
+def mkdir_allow_fallback(dir_name: StrPath) -> StrPath:
+    """Create `dir_name`, removing invalid path characters if necessary.
+
+    Returns:
+        The path to the created directory, which may not be the original path.
+    """
+    for new_name in path_fallbacks(dir_name):
+        try:
+            os.makedirs(new_name, exist_ok=True)
+            if Path(new_name) != Path(dir_name):
+                logger.warning(f"Creating '{new_name}' instead of '{dir_name}'")
+            return Path(new_name) if isinstance(dir_name, Path) else new_name
+        except (ValueError, NotADirectoryError):
+            pass
+        except OSError as e:
+            if e.errno != 22:
+                raise
+
+    raise OSError(f"Unable to create directory '{dir_name}'")
+
+
+def files_in(path: StrPath) -> Generator[os.DirEntry, None, None]:
+    """Yield a directory entry for each file under a given path (recursive)."""
+    if not os.path.isdir(path):
+        return
+    for entry in os.scandir(path):
+        if entry.is_dir():
+            yield from files_in(entry.path)
+        else:
+            yield entry
+
+
+class WriteSerializingFile:
+    """Wrapper for a file object that serializes writes."""
+
+    def __init__(self, f: BinaryIO) -> None:
+        self.lock = threading.Lock()
+        self.f = f
+
+    def write(self, *args, **kargs) -> None:  # type: ignore
+        self.lock.acquire()
+        try:
+            self.f.write(*args, **kargs)
+            self.f.flush()
+        finally:
+            self.lock.release()
+
+    def close(self) -> None:
+        self.lock.acquire()  # wait for pending writes
+        try:
+            self.f.close()
+        finally:
+            self.lock.release()
+
+
+class CRDedupedFile(WriteSerializingFile):
+    def __init__(self, f: BinaryIO) -> None:
+        super().__init__(f=f)
+        self._buff = b""
+
+    def write(self, data) -> None:  # type: ignore
+        lines = re.split(b"\r\n|\n", data)
+        ret = []  # type: ignore
+        for line in lines:
+            if line[:1] == b"\r":
+                if ret:
+                    ret.pop()
+                elif self._buff:
+                    self._buff = b""
+            line = line.split(b"\r")[-1]
+            if line:
+                ret.append(line)
+        if self._buff:
+            ret.insert(0, self._buff)
+        if ret:
+            self._buff = ret.pop()
+        super().write(b"\n".join(ret) + b"\n")
+
+    def close(self) -> None:
+        if self._buff:
+            super().write(self._buff)
+        super().close()
+
+
+def copy_or_overwrite_changed(source_path: StrPath, target_path: StrPath) -> StrPath:
+    """Copy source_path to target_path, unless it already exists with the same mtime.
+
+    We liberally add write permissions to deal with the case of multiple users needing
+    to share the same cache or run directory.
+
+    Args:
+        source_path: The path to the file to copy.
+        target_path: The path to copy the file to.
+
+    Returns:
+        The path to the copied file (which may be different from target_path).
+    """
+    return_type = type(target_path)
+
+    target_path = system_preferred_path(target_path, warn=True)
+
+    need_copy = (
+        not os.path.isfile(target_path)
+        or os.stat(source_path).st_mtime != os.stat(target_path).st_mtime
+    )
+
+    permissions_plus_write = os.stat(source_path).st_mode
+    if need_copy:
+        dir_name, file_name = os.path.split(target_path)
+        target_path = os.path.join(mkdir_allow_fallback(dir_name), file_name)
+        try:
+            # Use copy2 to preserve file metadata (including modified time).
+            shutil.copy2(source_path, target_path)
+        except PermissionError:
+            # If the file is read-only try to make it writable.
+            try:
+                os.chmod(target_path, permissions_plus_write)
+                shutil.copy2(source_path, target_path)
+            except PermissionError as e:
+                raise PermissionError("Unable to overwrite '{target_path!s}'") from e
+        # Prevent future permissions issues by universal write permissions now.
+        os.chmod(target_path, permissions_plus_write)
+
+    return return_type(target_path)  # type: ignore  # 'os.PathLike' is abstract.
+
+
+@contextlib.contextmanager
+def safe_open(
+    path: StrPath, mode: str = "r", *args: Any, **kwargs: Any
+) -> Generator[IO, None, None]:
+    """Open a file, ensuring any changes only apply atomically after close.
+
+    This context manager ensures that even unsuccessful writes will not leave a "dirty"
+    file or overwrite good data, and that all temp data is cleaned up.
+
+    The semantics and behavior are intended to be nearly identical to the built-in
+    open() function. Differences:
+        - It creates any parent directories that don't exist, rather than raising.
+        - In 'x' mode, it checks at the beginning AND end of the write and fails if the
+            file exists either time.
+    """
+    path = Path(path).resolve()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if "x" in mode and path.exists():
+        raise FileExistsError(f"{path!s} already exists")
+
+    if "r" in mode and "+" not in mode:
+        # This is read-only, so we can just open the original file.
+        # TODO (hugh): create a reflink and read from that.
+        with path.open(mode, *args, **kwargs) as f:
+            yield f
+        return
+
+    with tempfile.TemporaryDirectory(dir=path.parent) as tmp_dir:
+        tmp_path = Path(tmp_dir) / path.name
+
+        if ("r" in mode or "a" in mode) and path.exists():
+            # We need to copy the original file in order to support reads and appends.
+            # TODO (hugh): use reflinks to avoid the copy on platforms that support it.
+            shutil.copy2(path, tmp_path)
+
+        with tmp_path.open(mode, *args, **kwargs) as f:
+            yield f
+            f.flush()
+            os.fsync(f.fileno())
+
+        if "x" in mode:
+            # Ensure that if another process has beaten us to writing the file we raise
+            # rather than overwrite. os.link() atomically creates a hard link to the
+            # target file and will raise FileExistsError if the target already exists.
+            os.link(tmp_path, path)
+            os.unlink(tmp_path)
+        else:
+            tmp_path.replace(path)
+
+
+def safe_copy(source_path: StrPath, target_path: StrPath) -> StrPath:
+    """Copy a file atomically.
+
+    Copying is not usually atomic, and on operating systems that allow multiple
+    writers to the same file, the result can get corrupted. If two writers copy
+    to the same file, the contents can become interleaved.
+
+    We mitigate the issue somewhat by copying to a temporary file first and
+    then renaming. Renaming is atomic: if process 1 renames file A to X and
+    process 2 renames file B to X, then X will either contain the contents
+    of A or the contents of B, not some mixture of both.
+    """
+    # TODO (hugh): check that there is enough free space.
+    output_path = Path(target_path).resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(dir=output_path.parent) as tmp_dir:
+        tmp_path = (Path(tmp_dir) / Path(source_path).name).with_suffix(".tmp")
+        shutil.copy2(source_path, tmp_path)
+        tmp_path.replace(output_path)
+    return target_path
+
+
+def _reflink_linux(existing_path: Path, new_path: Path) -> None:
+    """Create a reflink to `existing_path` at `new_path` on Linux."""
+    import fcntl
+
+    FICLONE = 0x40049409  # magic number from <linux/fs.h>  # noqa: N806
+    with open(existing_path, "rb") as t_f, open(new_path, "wb+") as l_f:
+        fcntl.ioctl(l_f.fileno(), FICLONE, t_f.fileno())
+
+
+def _reflink_macos(existing_path: Path, new_path: Path) -> None:
+    try:
+        clib = ctypes.CDLL("libc.dylib", use_errno=True)
+    except (FileNotFoundError, OSError) as e:
+        if ctypes.get_errno() != errno.ENOENT and not isinstance(e, FileNotFoundError):
+            raise
+        # Before macOS 11 (<Nov 2020) clib was in libSystem.dylib, so we can try there.
+        clib = ctypes.CDLL("/usr/lib/libSystem.dylib", use_errno=True)
+
+    try:
+        clonefile = clib.clonefile
+    except AttributeError:
+        raise OSError(errno.ENOTSUP, "'clonefile' is not available on this system")
+
+    clonefile.argtypes = (ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int)
+    clonefile.restype = ctypes.c_int
+
+    if clonefile(os.fsencode(existing_path), os.fsencode(new_path), ctypes.c_int(0)):
+        # Anything other than 0 is an error.
+        err = ctypes.get_errno()
+        raise OSError(err, os.strerror(err), existing_path)
+
+
+def reflink(existing_path: StrPath, new_path: StrPath, overwrite: bool = False) -> None:
+    """Create a reflink to `existing_path` at `new_path`.
+
+    A reflink (reflective link) is a copy-on-write reference to a file. Once linked, the
+    file and link are both "real" files (not symbolic or hard links) and each can be
+    modified independently without affecting the other; however, they share the same
+    underlying data blocks on disk so until one is modified they are "zero-cost" copies.
+
+    Reflinks have all the functionality of copies, so we should use them wherever they
+    are supported if we would otherwise copy a file. (This is not particularly radical--
+    GNU `cp` defaults to `reflink=auto`, using it whenever available) However, support
+    for them is limited to a small number of filesystems. They should work on:
+    - Linux with a Btrfs or XFS filesystem (NOT ext4)
+    - macOS 10.13 or later with an APFS filesystem (called clone files)
+
+    Reflinks are also supported on Solaris and Windows with ReFSv2, but we haven't
+    implemented support for them.
+
+    Like hard links, a reflink can only be created on the same filesystem as the target.
+    """
+    if platform.system() == "Linux":
+        link_fn = _reflink_linux
+    elif platform.system() == "Darwin":
+        link_fn = _reflink_macos
+    else:
+        raise OSError(
+            errno.ENOTSUP, f"reflinks are not supported on {platform.system()}"
+        )
+
+    new_path = Path(new_path).resolve()
+    existing_path = Path(existing_path).resolve()
+    if new_path.exists():
+        if not overwrite:
+            raise FileExistsError(f"{new_path} already exists")
+        logger.warning(f"Overwriting existing file {new_path}.")
+        new_path.unlink()
+
+    # Create any missing parent directories.
+    new_path.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        link_fn(existing_path, new_path)
+    except OSError as e:
+        base_msg = f"failed to create reflink from {existing_path} to {new_path}."
+        if e.errno in (errno.EPERM, errno.EACCES):
+            raise PermissionError(f"Insufficient permissions; {base_msg}") from e
+        if e.errno == errno.ENOENT:
+            raise FileNotFoundError(f"File not found; {base_msg}") from e
+        if e.errno == errno.EXDEV:
+            raise ValueError(f"Cannot link across filesystems; {base_msg}") from e
+        if e.errno == errno.EISDIR:
+            raise IsADirectoryError(f"Cannot reflink a directory; {base_msg}") from e
+        if e.errno in (errno.EOPNOTSUPP, errno.ENOTSUP):
+            raise OSError(
+                errno.ENOTSUP,
+                f"Filesystem does not support reflinks; {base_msg}",
+            ) from e
+        if e.errno == errno.EINVAL:
+            raise ValueError(f"Cannot link file ranges; {base_msg}") from e
+        raise
+
+
+def check_exists(path: StrPath) -> Optional[StrPath]:
+    """Look for variations of `path` and return the first found.
+
+    This exists to support former behavior around system-dependent paths; we used to use
+    ':' in Artifact paths unless we were on Windows, but this has issues when e.g. a
+    Linux machine is accessing an NTFS filesystem; we might need to look for the
+    alternate path. This checks all the possible directories we would consider creating.
+    """
+    for dest in path_fallbacks(path):
+        if os.path.exists(dest):
+            return Path(dest) if isinstance(path, Path) else dest
+    return None
+
+
+def system_preferred_path(path: StrPath, warn: bool = False) -> StrPath:
+    """Replace ':' with '-' in paths on Windows.
+
+    Args:
+        path: The path to convert.
+        warn: Whether to warn if ':' is replaced.
+    """
+    if platform.system() != "Windows":
+        return path
+    head, tail = os.path.splitdrive(path)
+    if warn and ":" in tail:
+        logger.warning(f"Replacing ':' in {tail} with '-'")
+    new_path = head + tail.replace(":", "-")
+    return Path(new_path) if isinstance(path, Path) else new_path