Add files using upload-large-folder tool

parrot/lib/python3.10/site-packages/wandb/sdk/data_types/base_types/json_metadata.py

@@ -0,0 +1,55 @@
+import codecs
+import os
+from typing import TYPE_CHECKING, Type, Union
+
+from wandb import util
+from wandb.sdk.lib import runid
+
+from .._private import MEDIA_TMP
+from .media import Media
+
+if TYPE_CHECKING:  # pragma: no cover
+    from wandb.sdk.artifacts.artifact import Artifact
+
+    from ...wandb_run import Run as LocalRun
+
+
+# Allows encoding of arbitrary JSON structures
+# as a file
+#
+# This class should be used as an abstract class
+# extended to have validation methods
+
+
+class JSONMetadata(Media):
+    """JSONMetadata is a type for encoding arbitrary metadata as files."""
+
+    def __init__(self, val: dict) -> None:
+        super().__init__()
+
+        self.validate(val)
+        self._val = val
+
+        ext = "." + self.type_name() + ".json"
+        tmp_path = os.path.join(MEDIA_TMP.name, runid.generate_id() + ext)
+        with codecs.open(tmp_path, "w", encoding="utf-8") as fp:
+            util.json_dump_uncompressed(self._val, fp)
+        self._set_file(tmp_path, is_tmp=True, extension=ext)
+
+    @classmethod
+    def get_media_subdir(cls: Type["JSONMetadata"]) -> str:
+        return os.path.join("media", "metadata", cls.type_name())
+
+    def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
+        json_dict = super().to_json(run_or_artifact)
+        json_dict["_type"] = self.type_name()
+
+        return json_dict
+
+    # These methods should be overridden in the child class
+    @classmethod
+    def type_name(cls) -> str:
+        return "metadata"
+
+    def validate(self, val: dict) -> bool:
+        return True

parrot/lib/python3.10/site-packages/wandb/sdk/data_types/base_types/media.py

@@ -0,0 +1,315 @@
+import hashlib
+import os
+import platform
+import re
+import shutil
+from typing import TYPE_CHECKING, Optional, Sequence, Type, Union, cast
+
+import wandb
+from wandb import util
+from wandb._globals import _datatypes_callback
+from wandb.sdk.lib import filesystem
+from wandb.sdk.lib.paths import LogicalPath
+
+from .wb_value import WBValue
+
+if TYPE_CHECKING:  # pragma: no cover
+    import numpy as np
+
+    from wandb.sdk.artifacts.artifact import Artifact
+
+    from ...wandb_run import Run as LocalRun
+
+
+SYS_PLATFORM = platform.system()
+
+
+def _wb_filename(
+    key: Union[str, int], step: Union[str, int], id: Union[str, int], extension: str
+) -> str:
+    return f"{str(key)}_{str(step)}_{str(id)}{extension}"
+
+
+class Media(WBValue):
+    """A WBValue stored as a file outside JSON that can be rendered in a media panel.
+
+    If necessary, we move or copy the file into the Run's media directory so that it
+    gets uploaded.
+    """
+
+    _path: Optional[str]
+    _run: Optional["LocalRun"]
+    _caption: Optional[str]
+    _is_tmp: Optional[bool]
+    _extension: Optional[str]
+    _sha256: Optional[str]
+    _size: Optional[int]
+
+    def __init__(self, caption: Optional[str] = None) -> None:
+        super().__init__()
+        self._path = None
+        # The run under which this object is bound, if any.
+        self._run = None
+        self._caption = caption
+
+    def _set_file(
+        self, path: str, is_tmp: bool = False, extension: Optional[str] = None
+    ) -> None:
+        self._path = path
+        self._is_tmp = is_tmp
+        self._extension = extension
+        assert extension is None or path.endswith(
+            extension
+        ), f'Media file extension "{extension}" must occur at the end of path "{path}".'
+
+        with open(self._path, "rb") as f:
+            self._sha256 = hashlib.sha256(f.read()).hexdigest()
+        self._size = os.path.getsize(self._path)
+
+    @classmethod
+    def get_media_subdir(cls: Type["Media"]) -> str:
+        raise NotImplementedError
+
+    @staticmethod
+    def captions(
+        media_items: Sequence["Media"],
+    ) -> Union[bool, Sequence[Optional[str]]]:
+        if media_items[0]._caption is not None:
+            return [m._caption for m in media_items]
+        else:
+            return False
+
+    def is_bound(self) -> bool:
+        return self._run is not None
+
+    def file_is_set(self) -> bool:
+        return self._path is not None and self._sha256 is not None
+
+    def bind_to_run(
+        self,
+        run: "LocalRun",
+        key: Union[int, str],
+        step: Union[int, str],
+        id_: Optional[Union[int, str]] = None,
+        ignore_copy_err: Optional[bool] = None,
+    ) -> None:
+        """Bind this object to a particular Run.
+
+        Calling this function is necessary so that we have somewhere specific to put the
+        file associated with this object, from which other Runs can refer to it.
+        """
+        assert self.file_is_set(), "bind_to_run called before _set_file"
+
+        if SYS_PLATFORM == "Windows" and not util.check_windows_valid_filename(key):
+            raise ValueError(
+                f"Media {key} is invalid. Please remove invalid filename characters"
+            )
+
+        # The following two assertions are guaranteed to pass
+        # by definition file_is_set, but are needed for
+        # mypy to understand that these are strings below.
+        assert isinstance(self._path, str)
+        assert isinstance(self._sha256, str)
+
+        assert run is not None, 'Argument "run" must not be None.'
+        self._run = run
+
+        if self._extension is None:
+            _, extension = os.path.splitext(os.path.basename(self._path))
+        else:
+            extension = self._extension
+
+        if id_ is None:
+            id_ = self._sha256[:20]
+
+        file_path = _wb_filename(key, step, id_, extension)
+        media_path = os.path.join(self.get_media_subdir(), file_path)
+        new_path = os.path.join(self._run.dir, media_path)
+        filesystem.mkdir_exists_ok(os.path.dirname(new_path))
+
+        if self._is_tmp:
+            shutil.move(self._path, new_path)
+            self._path = new_path
+            self._is_tmp = False
+            _datatypes_callback(media_path)
+        else:
+            try:
+                shutil.copy(self._path, new_path)
+            except shutil.SameFileError as e:
+                if not ignore_copy_err:
+                    raise e
+            self._path = new_path
+            _datatypes_callback(media_path)
+
+    def to_json(self, run: Union["LocalRun", "Artifact"]) -> dict:
+        """Serialize the object into a JSON blob.
+
+        Uses run or artifact to store additional data. If `run_or_artifact` is a
+        wandb.Run then `self.bind_to_run()` must have been previously been called.
+
+        Args:
+            run_or_artifact (wandb.Run | wandb.Artifact): the Run or Artifact for which
+                this object should be generating JSON for - this is useful to store
+                additional data if needed.
+
+        Returns:
+            dict: JSON representation
+        """
+        # NOTE: uses of Audio in this class are a temporary hack -- when Ref support moves up
+        # into Media itself we should get rid of them
+        from wandb import Image
+        from wandb.data_types import Audio
+        from wandb.sdk.wandb_run import Run
+
+        json_obj = {}
+
+        if isinstance(run, Run):
+            json_obj.update(
+                {
+                    "_type": "file",  # TODO(adrian): This isn't (yet) a real media type we support on the frontend.
+                    "sha256": self._sha256,
+                    "size": self._size,
+                }
+            )
+            artifact_entry_url = self._get_artifact_entry_ref_url()
+            if artifact_entry_url is not None:
+                json_obj["artifact_path"] = artifact_entry_url
+            artifact_entry_latest_url = self._get_artifact_entry_latest_ref_url()
+            if artifact_entry_latest_url is not None:
+                json_obj["_latest_artifact_path"] = artifact_entry_latest_url
+
+            if artifact_entry_url is None or self.is_bound():
+                assert self.is_bound(), "Value of type {} must be bound to a run with bind_to_run() before being serialized to JSON.".format(
+                    type(self).__name__
+                )
+
+                assert (
+                    self._run is run
+                ), "We don't support referring to media files across runs."
+
+                # The following two assertions are guaranteed to pass
+                # by definition is_bound, but are needed for
+                # mypy to understand that these are strings below.
+                assert isinstance(self._path, str)
+                json_obj["path"] = LogicalPath(
+                    os.path.relpath(self._path, self._run.dir)
+                )
+
+        elif isinstance(run, wandb.Artifact):
+            if self.file_is_set():
+                # The following two assertions are guaranteed to pass
+                # by definition of the call above, but are needed for
+                # mypy to understand that these are strings below.
+                assert isinstance(self._path, str)
+                assert isinstance(self._sha256, str)
+                artifact = run  # Checks if the concrete image has already been added to this artifact
+                name = artifact.get_added_local_path_name(self._path)
+                if name is None:
+                    if self._is_tmp:
+                        name = os.path.join(
+                            self.get_media_subdir(), os.path.basename(self._path)
+                        )
+                    else:
+                        # If the files is not temporary, include the first 8 characters of the file's SHA256 to
+                        # avoid name collisions. This way, if there are two images `dir1/img.png` and `dir2/img.png`
+                        # we end up with a unique path for each.
+                        name = os.path.join(
+                            self.get_media_subdir(),
+                            self._sha256[:20],
+                            os.path.basename(self._path),
+                        )
+
+                    # if not, check to see if there is a source artifact for this object
+                    if (
+                        self._artifact_source is not None
+                        # and self._artifact_source.artifact != artifact
+                    ):
+                        default_root = self._artifact_source.artifact._default_root()
+                        # if there is, get the name of the entry (this might make sense to move to a helper off artifact)
+                        if self._path.startswith(default_root):
+                            name = self._path[len(default_root) :]
+                            name = name.lstrip(os.sep)
+
+                        # Add this image as a reference
+                        path = self._artifact_source.artifact.get_entry(name)
+                        artifact.add_reference(path.ref_url(), name=name)
+                    elif (
+                        isinstance(self, Audio) or isinstance(self, Image)
+                    ) and self.path_is_reference(self._path):
+                        artifact.add_reference(self._path, name=name)
+                    else:
+                        entry = artifact.add_file(
+                            self._path, name=name, is_tmp=self._is_tmp
+                        )
+                        name = entry.path
+
+                json_obj["path"] = name
+                json_obj["sha256"] = self._sha256
+            json_obj["_type"] = self._log_type
+        return json_obj
+
+    @classmethod
+    def from_json(
+        cls: Type["Media"], json_obj: dict, source_artifact: "Artifact"
+    ) -> "Media":
+        """Likely will need to override for any more complicated media objects."""
+        return cls(source_artifact.get_entry(json_obj["path"]).download())
+
+    def __eq__(self, other: object) -> bool:
+        """Likely will need to override for any more complicated media objects."""
+        return (
+            isinstance(other, self.__class__)
+            and hasattr(self, "_sha256")
+            and hasattr(other, "_sha256")
+            and self._sha256 == other._sha256
+        )
+
+    @staticmethod
+    def path_is_reference(path: Optional[str]) -> bool:
+        return bool(path and re.match(r"^(gs|s3|https?)://", path))
+
+
+class BatchableMedia(Media):
+    """Media that is treated in batches.
+
+    E.g. images and thumbnails. Apart from images, we just use these batches to help
+    organize files by name in the media directory.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    @classmethod
+    def seq_to_json(
+        cls: Type["BatchableMedia"],
+        seq: Sequence["BatchableMedia"],
+        run: "LocalRun",
+        key: str,
+        step: Union[int, str],
+    ) -> dict:
+        raise NotImplementedError
+
+
+def _numpy_arrays_to_lists(
+    payload: Union[dict, Sequence, "np.ndarray"],
+) -> Union[Sequence, dict, str, int, float, bool]:
+    # Casts all numpy arrays to lists so we don't convert them to histograms, primarily for Plotly
+
+    if isinstance(payload, dict):
+        res = {}
+        for key, val in payload.items():
+            res[key] = _numpy_arrays_to_lists(val)
+        return res
+    elif isinstance(payload, Sequence) and not isinstance(payload, str):
+        return [_numpy_arrays_to_lists(v) for v in payload]
+    elif util.is_numpy_array(payload):
+        if TYPE_CHECKING:
+            payload = cast("np.ndarray", payload)
+        return [
+            _numpy_arrays_to_lists(v)
+            for v in (payload.tolist() if payload.ndim > 0 else [payload.tolist()])
+        ]
+    # Protects against logging non serializable objects
+    elif isinstance(payload, Media):
+        return str(payload.__class__.__name__)
+    return payload  # type: ignore

parrot/lib/python3.10/site-packages/wandb/sdk/data_types/base_types/wb_value.py

@@ -0,0 +1,274 @@
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Type, Union
+
+from wandb import util
+
+if TYPE_CHECKING:  # pragma: no cover
+    from wandb.sdk.artifacts.artifact import Artifact
+
+    from ...wandb_run import Run as LocalRun
+
+    TypeMappingType = Dict[str, Type["WBValue"]]
+
+
+def _server_accepts_client_ids() -> bool:
+    from wandb.util import parse_version
+
+    # First, if we are offline, assume the backend server cannot
+    # accept client IDs. Unfortunately, this is the best we can do
+    # until we are sure that all local versions are > "0.11.0" max_cli_version.
+    # The practical implication is that tables logged in offline mode
+    # will not show up in the workspace (but will still show up in artifacts). This
+    # means we never lose data, and we can still view using weave. If we decided
+    # to use client ids in offline mode, then the manifests and artifact data
+    # would never be resolvable and would lead to failed uploads. Our position
+    # is to never lose data - and instead take the tradeoff in the UI.
+    if util._is_offline():
+        return False
+
+    # If the script is online, request the max_cli_version and ensure the server
+    # is of a high enough version.
+    max_cli_version = util._get_max_cli_version()
+    if max_cli_version is None:
+        return False
+    accepts_client_ids: bool = parse_version("0.11.0") <= parse_version(max_cli_version)
+    return accepts_client_ids
+
+
+class _WBValueArtifactSource:
+    artifact: "Artifact"
+    name: Optional[str]
+
+    def __init__(self, artifact: "Artifact", name: Optional[str] = None) -> None:
+        self.artifact = artifact
+        self.name = name
+
+
+class _WBValueArtifactTarget:
+    artifact: "Artifact"
+    name: Optional[str]
+
+    def __init__(self, artifact: "Artifact", name: Optional[str] = None) -> None:
+        self.artifact = artifact
+        self.name = name
+
+
+class WBValue:
+    """Typed objects that can be logged with `wandb.log()` and visualized by wandb.
+
+    The objects will be serialized as JSON and always have a _type attribute that
+    indicates how to interpret the other fields.
+    """
+
+    # Class Attributes
+    _type_mapping: ClassVar[Optional["TypeMappingType"]] = None
+    # override _log_type to indicate the type which the subclass deserializes
+    _log_type: ClassVar[Optional[str]] = None
+
+    # Instance Attributes
+    _artifact_source: Optional[_WBValueArtifactSource]
+    _artifact_target: Optional[_WBValueArtifactTarget]
+
+    def __init__(self) -> None:
+        self._artifact_source = None
+        self._artifact_target = None
+
+    def to_json(self, run_or_artifact: Union["LocalRun", "Artifact"]) -> dict:
+        """Serialize the object into a JSON blob.
+
+        Uses current run or artifact to store additional data.
+
+        Args:
+            run_or_artifact (wandb.Run | wandb.Artifact): the Run or Artifact for which
+                this object should be generating JSON for - this is useful to to store
+                additional data if needed.
+
+        Returns:
+            dict: JSON representation
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def from_json(
+        cls: Type["WBValue"], json_obj: dict, source_artifact: "Artifact"
+    ) -> "WBValue":
+        """Deserialize a `json_obj` into it's class representation.
+
+        If additional resources were stored in the `run_or_artifact` artifact during the
+        `to_json` call, then those resources should be in the `source_artifact`.
+
+        Args:
+            json_obj (dict): A JSON dictionary to deserialize source_artifact
+            (wandb.Artifact): An artifact which will hold any additional
+                resources which were stored during the `to_json` function.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    def with_suffix(cls: Type["WBValue"], name: str, filetype: str = "json") -> str:
+        """Get the name with the appropriate suffix.
+
+        Args:
+            name (str): the name of the file
+            filetype (str, optional): the filetype to use. Defaults to "json".
+
+        Returns:
+            str: a filename which is suffixed with it's `_log_type` followed by the
+                filetype.
+        """
+        if cls._log_type is not None:
+            suffix = cls._log_type + "." + filetype
+        else:
+            suffix = filetype
+        if not name.endswith(suffix):
+            return name + "." + suffix
+        return name
+
+    @staticmethod
+    def init_from_json(
+        json_obj: dict, source_artifact: "Artifact"
+    ) -> Optional["WBValue"]:
+        """Initialize a `WBValue` from a JSON blob based on the class that creatd it.
+
+        Looks through all subclasses and tries to match the json obj with the class
+        which created it. It will then call that subclass' `from_json` method.
+        Importantly, this function will set the return object's `source_artifact`
+        attribute to the passed in source artifact. This is critical for artifact
+        bookkeeping. If you choose to create a wandb.Value via it's `from_json` method,
+        make sure to properly set this `artifact_source` to avoid data duplication.
+
+        Args:
+            json_obj (dict): A JSON dictionary to deserialize. It must contain a `_type`
+                key. This is used to lookup the correct subclass to use.
+            source_artifact (wandb.Artifact): An artifact which will hold any additional
+                resources which were stored during the `to_json` function.
+
+        Returns:
+            wandb.Value: a newly created instance of a subclass of wandb.Value
+        """
+        class_option = WBValue.type_mapping().get(json_obj["_type"])
+        if class_option is not None:
+            obj = class_option.from_json(json_obj, source_artifact)
+            obj._set_artifact_source(source_artifact)
+            return obj
+
+        return None
+
+    @staticmethod
+    def type_mapping() -> "TypeMappingType":
+        """Return a map from `_log_type` to subclass. Used to lookup correct types for deserialization.
+
+        Returns:
+            dict: dictionary of str:class
+        """
+        if WBValue._type_mapping is None:
+            WBValue._type_mapping = {}
+            frontier = [WBValue]
+            explored = set()
+            while len(frontier) > 0:
+                class_option = frontier.pop()
+                explored.add(class_option)
+                if class_option._log_type is not None:
+                    WBValue._type_mapping[class_option._log_type] = class_option
+                for subclass in class_option.__subclasses__():
+                    if subclass not in explored:
+                        frontier.append(subclass)
+        return WBValue._type_mapping
+
+    def __eq__(self, other: object) -> bool:
+        return id(self) == id(other)
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def to_data_array(self) -> List[Any]:
+        """Convert the object to a list of primitives representing the underlying data."""
+        raise NotImplementedError
+
+    def _set_artifact_source(
+        self, artifact: "Artifact", name: Optional[str] = None
+    ) -> None:
+        assert (
+            self._artifact_source is None
+        ), "Cannot update artifact_source. Existing source: {}/{}".format(
+            self._artifact_source.artifact, self._artifact_source.name
+        )
+        self._artifact_source = _WBValueArtifactSource(artifact, name)
+
+    def _set_artifact_target(
+        self, artifact: "Artifact", name: Optional[str] = None
+    ) -> None:
+        assert (
+            self._artifact_target is None
+        ), "Cannot update artifact_target. Existing target: {}/{}".format(
+            self._artifact_target.artifact, self._artifact_target.name
+        )
+        self._artifact_target = _WBValueArtifactTarget(artifact, name)
+
+    def _get_artifact_entry_ref_url(self) -> Optional[str]:
+        # If the object is coming from another artifact
+        if self._artifact_source and self._artifact_source.name:
+            ref_entry = self._artifact_source.artifact.get_entry(
+                type(self).with_suffix(self._artifact_source.name)
+            )
+            return str(ref_entry.ref_url())
+        # Else, if the object is destined for another artifact and we support client IDs
+        elif (
+            self._artifact_target
+            and self._artifact_target.name
+            and self._artifact_target.artifact._client_id is not None
+            and self._artifact_target.artifact._final
+            and _server_accepts_client_ids()
+        ):
+            return "wandb-client-artifact://{}/{}".format(
+                self._artifact_target.artifact._client_id,
+                type(self).with_suffix(self._artifact_target.name),
+            )
+        # Else if we do not support client IDs, but online, then block on upload
+        # Note: this is old behavior just to stay backwards compatible
+        # with older server versions. This code path should be removed
+        # once those versions are no longer supported. This path uses a .wait
+        # which blocks the user process on artifact upload.
+        elif (
+            self._artifact_target
+            and self._artifact_target.name
+            and self._artifact_target.artifact._is_draft_save_started()
+            and not util._is_offline()
+            and not _server_accepts_client_ids()
+        ):
+            self._artifact_target.artifact.wait()
+            ref_entry = self._artifact_target.artifact.get_entry(
+                type(self).with_suffix(self._artifact_target.name)
+            )
+            return str(ref_entry.ref_url())
+        return None
+
+    def _get_artifact_entry_latest_ref_url(self) -> Optional[str]:
+        if (
+            self._artifact_target
+            and self._artifact_target.name
+            and self._artifact_target.artifact._client_id is not None
+            and self._artifact_target.artifact._final
+            and _server_accepts_client_ids()
+        ):
+            return "wandb-client-artifact://{}:latest/{}".format(
+                self._artifact_target.artifact._sequence_client_id,
+                type(self).with_suffix(self._artifact_target.name),
+            )
+        # Else if we do not support client IDs, then block on upload
+        # Note: this is old behavior just to stay backwards compatible
+        # with older server versions. This code path should be removed
+        # once those versions are no longer supported. This path uses a .wait
+        # which blocks the user process on artifact upload.
+        elif (
+            self._artifact_target
+            and self._artifact_target.name
+            and self._artifact_target.artifact._is_draft_save_started()
+            and not util._is_offline()
+            and not _server_accepts_client_ids()
+        ):
+            self._artifact_target.artifact.wait()
+            ref_entry = self._artifact_target.artifact.get_entry(
+                type(self).with_suffix(self._artifact_target.name)
+            )
+            return str(ref_entry.ref_url())
+        return None

parrot/lib/python3.10/site-packages/wandb/sdk/data_types/helper_types/classes.py

@@ -0,0 +1,159 @@
+import os
+from typing import TYPE_CHECKING, Any, Dict, Optional, Sequence, Type, Union
+
+from .. import _dtypes
+from ..base_types.media import Media
+
+if TYPE_CHECKING:  # pragma: no cover
+    from wandb.sdk.artifacts.artifact import Artifact
+
+    from ...wandb_run import Run as LocalRun
+
+
+class Classes(Media):
+    _log_type = "classes"
+
+    _class_set: Sequence[dict]
+
+    def __init__(self, class_set: Sequence[dict]) -> None:
+        """Classes is holds class metadata intended to be used in concert with other objects when visualizing artifacts.
+
+        Args:
+            class_set (list): list of dicts in the form of {"id":int|str, "name":str}
+        """
+        super().__init__()
+        for class_obj in class_set:
+            assert "id" in class_obj and "name" in class_obj
+        self._class_set = class_set
+
+    @classmethod
+    def from_json(
+        cls: Type["Classes"],
+        json_obj: dict,
+        source_artifact: Optional["Artifact"],
+    ) -> "Classes":
+        return cls(json_obj.get("class_set"))  # type: ignore
+
+    def to_json(self, run_or_artifact: Optional[Union["LocalRun", "Artifact"]]) -> dict:
+        json_obj = {}
+        # This is a bit of a hack to allow _ClassesIdType to
+        # be able to operate fully without an artifact in play.
+        # In all other cases, artifact should be a true artifact.
+        if run_or_artifact is not None:
+            json_obj = super().to_json(run_or_artifact)
+        json_obj["_type"] = Classes._log_type
+        json_obj["class_set"] = self._class_set
+        return json_obj
+
+    def get_type(self) -> "_ClassesIdType":
+        return _ClassesIdType(self)
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Classes):
+            return self._class_set == other._class_set
+        else:
+            return False
+
+
+class _ClassesIdType(_dtypes.Type):
+    name = "classesId"
+    legacy_names = ["wandb.Classes_id"]
+    types = [Classes]
+
+    def __init__(
+        self,
+        classes_obj: Optional[Classes] = None,
+        valid_ids: Optional["_dtypes.UnionType"] = None,
+    ):
+        if valid_ids is None:
+            valid_ids = _dtypes.UnionType()
+        elif isinstance(valid_ids, list):
+            valid_ids = _dtypes.UnionType(
+                [_dtypes.ConstType(item) for item in valid_ids]
+            )
+        elif isinstance(valid_ids, _dtypes.UnionType):
+            valid_ids = valid_ids
+        else:
+            raise TypeError("valid_ids must be None, list, or UnionType")
+
+        if classes_obj is None:
+            classes_obj = Classes(
+                [
+                    {"id": _id.params["val"], "name": str(_id.params["val"])}
+                    for _id in valid_ids.params["allowed_types"]
+                ]
+            )
+        elif not isinstance(classes_obj, Classes):
+            raise TypeError("valid_ids must be None, or instance of Classes")
+        else:
+            valid_ids = _dtypes.UnionType(
+                [
+                    _dtypes.ConstType(class_obj["id"])
+                    for class_obj in classes_obj._class_set
+                ]
+            )
+
+        self.wb_classes_obj_ref = classes_obj
+        self.params.update({"valid_ids": valid_ids})
+
+    def assign(self, py_obj: Optional[Any] = None) -> "_dtypes.Type":
+        return self.assign_type(_dtypes.ConstType(py_obj))
+
+    def assign_type(self, wb_type: "_dtypes.Type") -> "_dtypes.Type":
+        valid_ids = self.params["valid_ids"].assign_type(wb_type)
+        if not isinstance(valid_ids, _dtypes.InvalidType):
+            return self
+
+        return _dtypes.InvalidType()
+
+    @classmethod
+    def from_obj(cls, py_obj: Optional[Any] = None) -> "_dtypes.Type":
+        return cls(py_obj)
+
+    def to_json(self, artifact: Optional["Artifact"] = None) -> Dict[str, Any]:
+        cl_dict = super().to_json(artifact)
+        # TODO (tss): Refactor this block with the similar one in wandb.Image.
+        # This is a bit of a smell that the classes object does not follow
+        # the same file-pattern as other media types.
+        if artifact is not None:
+            class_name = os.path.join("media", "cls")
+            classes_entry = artifact.add(self.wb_classes_obj_ref, class_name)
+            cl_dict["params"]["classes_obj"] = {
+                "type": "classes-file",
+                "path": classes_entry.path,
+                "digest": classes_entry.digest,  # is this needed really?
+            }
+        else:
+            cl_dict["params"]["classes_obj"] = self.wb_classes_obj_ref.to_json(artifact)
+        return cl_dict
+
+    @classmethod
+    def from_json(
+        cls,
+        json_dict: Dict[str, Any],
+        artifact: Optional["Artifact"] = None,
+    ) -> "_dtypes.Type":
+        classes_obj = None
+        if (
+            json_dict.get("params", {}).get("classes_obj", {}).get("type")
+            == "classes-file"
+        ):
+            if artifact is not None:
+                classes_obj = artifact.get(
+                    json_dict.get("params", {}).get("classes_obj", {}).get("path")
+                )
+                assert classes_obj is None or isinstance(classes_obj, Classes)
+            else:
+                raise RuntimeError("Expected artifact to be non-null.")
+        else:
+            classes_obj = Classes.from_json(
+                json_dict["params"]["classes_obj"], artifact
+            )
+
+        return cls(classes_obj)
+
+
+_dtypes.TypeRegistry.add(_ClassesIdType)

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

@@ -0,0 +1,14 @@
+from ._launch import launch
+from ._launch_add import launch_add
+from .agent.agent import LaunchAgent
+from .inputs.manage import manage_config_file, manage_wandb_config
+from .utils import load_wandb_config
+
+__all__ = [
+    "LaunchAgent",
+    "launch",
+    "launch_add",
+    "load_wandb_config",
+    "manage_config_file",
+    "manage_wandb_config",
+]

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

@@ -0,0 +1,330 @@
+import asyncio
+import logging
+import os
+import sys
+from typing import Any, Dict, List, Optional, Tuple
+
+import yaml
+
+import wandb
+from wandb.apis.internal import Api
+
+from . import loader
+from ._project_spec import LaunchProject
+from .agent import LaunchAgent
+from .agent.agent import construct_agent_configs
+from .environment.local_environment import LocalEnvironment
+from .errors import ExecutionError, LaunchError
+from .runner.abstract import AbstractRun
+from .utils import (
+    LAUNCH_CONFIG_FILE,
+    PROJECT_SYNCHRONOUS,
+    construct_launch_spec,
+    validate_launch_spec_source,
+)
+
+_logger = logging.getLogger(__name__)
+
+
+def set_launch_logfile(logfile: str) -> None:
+    """Set the logfile for the launch agent."""
+    # Get logger of parent module
+    _launch_logger = logging.getLogger("wandb.sdk.launch")
+    if logfile == "-":
+        logfile_stream = sys.stdout
+    else:
+        try:
+            logfile_stream = open(logfile, "w")
+        # check if file is writable
+        except Exception as e:
+            wandb.termerror(
+                f"Could not open {logfile} for writing logs. Please check "
+                f"the path and permissions.\nError: {e}"
+            )
+            return
+
+    wandb.termlog(
+        f"Internal agent logs printing to {'stdout' if logfile == '-' else logfile}. "
+    )
+    handler = logging.StreamHandler(logfile_stream)
+    handler.formatter = logging.Formatter(
+        "%(asctime)s %(levelname)-7s %(threadName)-10s:%(process)d "
+        "[%(filename)s:%(funcName)s():%(lineno)s] %(message)s"
+    )
+    _launch_logger.addHandler(handler)
+    _launch_logger.log(logging.INFO, "Internal agent logs printing to %s", logfile)
+
+
+def resolve_agent_config(  # noqa: C901
+    entity: Optional[str],
+    max_jobs: Optional[int],
+    queues: Optional[Tuple[str]],
+    config: Optional[str],
+    verbosity: Optional[int],
+) -> Tuple[Dict[str, Any], Api]:
+    """Resolve the agent config.
+
+    Arguments:
+        api (Api): The api.
+        entity (str): The entity.
+        max_jobs (int): The max number of jobs.
+        queues (Tuple[str]): The queues.
+        config (str): The config.
+        verbosity (int): How verbose to print, 0 or None = default, 1 = print status every 20 seconds, 2 = also print debugging information
+
+    Returns:
+        Tuple[Dict[str, Any], Api]: The resolved config and api.
+    """
+    defaults = {
+        "max_jobs": 1,
+        "max_schedulers": 1,
+        "queues": [],
+        "registry": {},
+        "builder": {},
+        "verbosity": 0,
+    }
+    resolved_config: Dict[str, Any] = defaults
+    config_path = config or os.path.expanduser(LAUNCH_CONFIG_FILE)
+    if os.path.isfile(config_path):
+        launch_config = {}
+        with open(config_path) as f:
+            try:
+                launch_config = yaml.safe_load(f)
+                # This is considered unreachable by mypy, but it's not.
+                if launch_config is None:
+                    launch_config = {}  # type: ignore
+            except yaml.YAMLError as e:
+                raise LaunchError(f"Invalid launch agent config: {e}")
+        resolved_config.update(launch_config.items())
+    elif config is not None:
+        raise LaunchError(
+            f"Could not find use specified launch config file: {config_path}"
+        )
+    if os.environ.get("WANDB_ENTITY") is not None:
+        resolved_config.update({"entity": os.environ.get("WANDB_ENTITY")})
+    if os.environ.get("WANDB_LAUNCH_MAX_JOBS") is not None:
+        resolved_config.update(
+            {"max_jobs": int(os.environ.get("WANDB_LAUNCH_MAX_JOBS", 1))}
+        )
+
+    if entity is not None:
+        resolved_config.update({"entity": entity})
+    if max_jobs is not None:
+        resolved_config.update({"max_jobs": int(max_jobs)})
+    if queues:
+        resolved_config.update({"queues": list(queues)})
+    if verbosity:
+        resolved_config.update({"verbosity": int(verbosity)})
+    # queue -> queues
+    if resolved_config.get("queue"):
+        if isinstance(resolved_config.get("queue"), str):
+            resolved_config["queues"].append(resolved_config["queue"])
+        else:
+            raise LaunchError(
+                f"Invalid launch agent config for key 'queue' with type: {type(resolved_config.get('queue'))}"
+                + " (expected str). Specify multiple queues with the 'queues' key"
+            )
+
+    keys = ["entity"]
+    settings = {
+        k: resolved_config.get(k) for k in keys if resolved_config.get(k) is not None
+    }
+
+    api = Api(default_settings=settings)
+
+    if resolved_config.get("entity") is None:
+        resolved_config.update({"entity": api.default_entity})
+
+    return resolved_config, api
+
+
+def create_and_run_agent(
+    api: Api,
+    config: Dict[str, Any],
+) -> None:
+    try:
+        from wandb.sdk.launch.agent import config as agent_config
+    except ModuleNotFoundError:
+        raise LaunchError(
+            "wandb launch-agent requires pydantic to be installed. "
+            "Please install with `pip install wandb[launch]`"
+        )
+    try:
+        agent_config.AgentConfig(**config)
+    except agent_config.ValidationError as e:
+        errors = e.errors()
+        for error in errors:
+            loc = ".".join([str(x) for x in error.get("loc", [])])
+            msg = f"Agent config error in field {loc}"
+            value = error.get("input")
+            if not isinstance(value, dict):
+                msg += f" (value: {value})"
+            msg += f": {error['msg']}"
+            wandb.termerror(msg)
+        raise LaunchError("Invalid launch agent config")
+    agent = LaunchAgent(api, config)
+    try:
+        asyncio.run(agent.loop())
+    except asyncio.CancelledError:
+        pass
+
+
+async def _launch(
+    api: Api,
+    job: Optional[str] = None,
+    name: Optional[str] = None,
+    project: Optional[str] = None,
+    entity: Optional[str] = None,
+    docker_image: Optional[str] = None,
+    entry_point: Optional[List[str]] = None,
+    version: Optional[str] = None,
+    resource: Optional[str] = None,
+    resource_args: Optional[Dict[str, Any]] = None,
+    launch_config: Optional[Dict[str, Any]] = None,
+    synchronous: Optional[bool] = None,
+    run_id: Optional[str] = None,
+    repository: Optional[str] = None,
+) -> AbstractRun:
+    """Helper that delegates to the project-running method corresponding to the passed-in backend."""
+    if launch_config is None:
+        launch_config = {}
+    if resource is None:
+        resource = "local-container"
+    launch_spec = construct_launch_spec(
+        None,
+        job,
+        api,
+        name,
+        project,
+        entity,
+        docker_image,
+        resource,
+        entry_point,
+        version,
+        resource_args,
+        launch_config,
+        run_id,
+        repository,
+        author=None,
+    )
+    validate_launch_spec_source(launch_spec)
+    launch_project = LaunchProject.from_spec(launch_spec, api)
+    launch_project.fetch_and_validate_project()
+    entrypoint = launch_project.get_job_entry_point()
+    image_uri = (
+        launch_project.docker_image or launch_project.job_base_image
+    )  # Either set by user or None.
+
+    # construct runner config.
+    runner_config: Dict[str, Any] = {}
+    runner_config[PROJECT_SYNCHRONOUS] = synchronous
+
+    config = launch_config or {}
+    environment_config, build_config, registry_config = construct_agent_configs(config)
+    environment = loader.environment_from_config(environment_config)
+    if environment is not None and not isinstance(environment, LocalEnvironment):
+        await environment.verify()
+    registry = loader.registry_from_config(registry_config, environment)
+    builder = loader.builder_from_config(build_config, environment, registry)
+    if not (launch_project.docker_image or launch_project.job_base_image):
+        assert entrypoint
+        image_uri = await builder.build_image(launch_project, entrypoint, None)
+    backend = loader.runner_from_config(
+        resource, api, runner_config, environment, registry
+    )
+    if backend:
+        assert image_uri
+        submitted_run = await backend.run(launch_project, image_uri)
+        # this check will always pass, run is only optional in the agent case where
+        # a run queue id is present on the backend config
+        assert submitted_run
+        return submitted_run
+    else:
+        raise ExecutionError(
+            f"Unavailable backend {resource}, available backends: {', '.join(loader.WANDB_RUNNERS)}"
+        )
+
+
+def launch(
+    api: Api,
+    job: Optional[str] = None,
+    entry_point: Optional[List[str]] = None,
+    version: Optional[str] = None,
+    name: Optional[str] = None,
+    resource: Optional[str] = None,
+    resource_args: Optional[Dict[str, Any]] = None,
+    project: Optional[str] = None,
+    entity: Optional[str] = None,
+    docker_image: Optional[str] = None,
+    config: Optional[Dict[str, Any]] = None,
+    synchronous: Optional[bool] = True,
+    run_id: Optional[str] = None,
+    repository: Optional[str] = None,
+) -> AbstractRun:
+    """Launch a W&B launch experiment.
+
+    Arguments:
+        job: string reference to a wandb.Job eg: wandb/test/my-job:latest
+        api: An instance of a wandb Api from wandb.apis.internal.
+        entry_point: Entry point to run within the project. Defaults to using the entry point used
+            in the original run for wandb URIs, or main.py for git repository URIs.
+        version: For Git-based projects, either a commit hash or a branch name.
+        name: Name run under which to launch the run.
+        resource: Execution backend for the run.
+        resource_args: Resource related arguments for launching runs onto a remote backend.
+            Will be stored on the constructed launch config under ``resource_args``.
+        project: Target project to send launched run to
+        entity: Target entity to send launched run to
+        config: A dictionary containing the configuration for the run. May also contain
+        resource specific arguments under the key "resource_args".
+        synchronous: Whether to block while waiting for a run to complete. Defaults to True.
+            Note that if ``synchronous`` is False and ``backend`` is "local-container", this
+            method will return, but the current process will block when exiting until
+            the local run completes. If the current process is interrupted, any
+            asynchronous runs launched via this method will be terminated. If
+            ``synchronous`` is True and the run fails, the current process will
+            error out as well.
+        run_id: ID for the run (To ultimately replace the :name: field)
+        repository: string name of repository path for remote registry
+
+    Example:
+        ```python
+        from wandb.sdk.launch import launch
+
+        job = "wandb/jobs/Hello World:latest"
+        params = {"epochs": 5}
+        # Run W&B project and create a reproducible docker environment
+        # on a local host
+        api = wandb.apis.internal.Api()
+        launch(api, job, parameters=params)
+        ```
+
+
+    Returns:
+        an instance of`wandb.launch.SubmittedRun` exposing information (e.g. run ID)
+        about the launched run.
+
+    Raises:
+        `wandb.exceptions.ExecutionError` If a run launched in blocking mode
+        is unsuccessful.
+    """
+    submitted_run_obj = asyncio.run(
+        _launch(
+            job=job,
+            name=name,
+            project=project,
+            entity=entity,
+            docker_image=docker_image,
+            entry_point=entry_point,
+            version=version,
+            resource=resource,
+            resource_args=resource_args,
+            launch_config=config,
+            synchronous=synchronous,
+            api=api,
+            run_id=run_id,
+            repository=repository,
+        )
+    )
+
+    return submitted_run_obj

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

@@ -0,0 +1,255 @@
+import asyncio
+import pprint
+from typing import Any, Dict, List, Optional, Union
+
+import wandb
+import wandb.apis.public as public
+from wandb.apis.internal import Api
+from wandb.errors import CommError
+from wandb.sdk.launch.builder.build import build_image_from_project
+from wandb.sdk.launch.errors import LaunchError
+from wandb.sdk.launch.utils import (
+    LAUNCH_DEFAULT_PROJECT,
+    LOG_PREFIX,
+    construct_launch_spec,
+    validate_launch_spec_source,
+)
+
+from ._project_spec import LaunchProject
+
+
+def push_to_queue(
+    api: Api,
+    queue_name: str,
+    launch_spec: Dict[str, Any],
+    template_variables: Optional[dict],
+    project_queue: str,
+    priority: Optional[int] = None,
+) -> Any:
+    return api.push_to_run_queue(
+        queue_name, launch_spec, template_variables, project_queue, priority
+    )
+
+
+def launch_add(
+    uri: Optional[str] = None,
+    job: Optional[str] = None,
+    config: Optional[Dict[str, Any]] = None,
+    template_variables: Optional[Dict[str, Union[float, int, str]]] = None,
+    project: Optional[str] = None,
+    entity: Optional[str] = None,
+    queue_name: Optional[str] = None,
+    resource: Optional[str] = None,
+    entry_point: Optional[List[str]] = None,
+    name: Optional[str] = None,
+    version: Optional[str] = None,
+    docker_image: Optional[str] = None,
+    project_queue: Optional[str] = None,
+    resource_args: Optional[Dict[str, Any]] = None,
+    run_id: Optional[str] = None,
+    build: Optional[bool] = False,
+    repository: Optional[str] = None,
+    sweep_id: Optional[str] = None,
+    author: Optional[str] = None,
+    priority: Optional[int] = None,
+) -> "public.QueuedRun":
+    """Enqueue a W&B launch experiment. With either a source uri, job or docker_image.
+
+    Arguments:
+        uri: URI of experiment to run. A wandb run uri or a Git repository URI.
+        job: string reference to a wandb.Job eg: wandb/test/my-job:latest
+        config: A dictionary containing the configuration for the run. May also contain
+            resource specific arguments under the key "resource_args"
+        template_variables: A dictionary containing values of template variables for a run queue.
+            Expected format of {"VAR_NAME": VAR_VALUE}
+        project: Target project to send launched run to
+        entity: Target entity to send launched run to
+        queue: the name of the queue to enqueue the run to
+        priority: the priority level of the job, where 1 is the highest priority
+        resource: Execution backend for the run: W&B provides built-in support for "local-container" backend
+        entry_point: Entry point to run within the project. Defaults to using the entry point used
+            in the original run for wandb URIs, or main.py for git repository URIs.
+        name: Name run under which to launch the run.
+        version: For Git-based projects, either a commit hash or a branch name.
+        docker_image: The name of the docker image to use for the run.
+        resource_args: Resource related arguments for launching runs onto a remote backend.
+            Will be stored on the constructed launch config under ``resource_args``.
+        run_id: optional string indicating the id of the launched run
+        build: optional flag defaulting to false, requires queue to be set
+            if build, an image is created, creates a job artifact, pushes a reference
+                to that job artifact to queue
+        repository: optional string to control the name of the remote repository, used when
+            pushing images to a registry
+        project_queue: optional string to control the name of the project for the queue. Primarily used
+            for back compatibility with project scoped queues
+
+
+    Example:
+    ```python
+    from wandb.sdk.launch import launch_add
+
+    project_uri = "https://github.com/wandb/examples"
+    params = {"alpha": 0.5, "l1_ratio": 0.01}
+    # Run W&B project and create a reproducible docker environment
+    # on a local host
+    api = wandb.apis.internal.Api()
+    launch_add(uri=project_uri, parameters=params)
+    ```
+
+
+    Returns:
+        an instance of`wandb.api.public.QueuedRun` which gives information about the
+        queued run, or if `wait_until_started` or `wait_until_finished` are called, gives access
+        to the underlying Run information.
+
+    Raises:
+        `wandb.exceptions.LaunchError` if unsuccessful
+    """
+    api = Api()
+
+    return _launch_add(
+        api,
+        job,
+        config,
+        template_variables,
+        project,
+        entity,
+        queue_name,
+        resource,
+        entry_point,
+        name,
+        version,
+        docker_image,
+        project_queue,
+        resource_args,
+        run_id=run_id,
+        build=build,
+        repository=repository,
+        sweep_id=sweep_id,
+        author=author,
+        priority=priority,
+    )
+
+
+def _launch_add(
+    api: Api,
+    job: Optional[str],
+    config: Optional[Dict[str, Any]],
+    template_variables: Optional[dict],
+    project: Optional[str],
+    entity: Optional[str],
+    queue_name: Optional[str],
+    resource: Optional[str],
+    entry_point: Optional[List[str]],
+    name: Optional[str],
+    version: Optional[str],
+    docker_image: Optional[str],
+    project_queue: Optional[str],
+    resource_args: Optional[Dict[str, Any]] = None,
+    run_id: Optional[str] = None,
+    build: Optional[bool] = False,
+    repository: Optional[str] = None,
+    sweep_id: Optional[str] = None,
+    author: Optional[str] = None,
+    priority: Optional[int] = None,
+) -> "public.QueuedRun":
+    launch_spec = construct_launch_spec(
+        None,
+        job,
+        api,
+        name,
+        project,
+        entity,
+        docker_image,
+        resource,
+        entry_point,
+        version,
+        resource_args,
+        config,
+        run_id,
+        repository,
+        author,
+        sweep_id,
+    )
+
+    if build:
+        if resource == "local-process":
+            raise LaunchError(
+                "Cannot build a docker image for the resource: local-process"
+            )
+
+        if launch_spec.get("job") is not None:
+            wandb.termwarn("Build doesn't support setting a job. Overwriting job.")
+            launch_spec["job"] = None
+
+        launch_project = LaunchProject.from_spec(launch_spec, api)
+        docker_image_uri = asyncio.run(
+            build_image_from_project(launch_project, api, config or {})
+        )
+        run = wandb.run or wandb.init(
+            project=launch_spec["project"],
+            entity=launch_spec["entity"],
+            job_type="launch_job",
+        )
+
+        job_artifact = run._log_job_artifact_with_image(  # type: ignore
+            docker_image_uri, launch_project.override_args
+        )
+        job_name = job_artifact.wait().name
+
+        job = f"{launch_spec['entity']}/{launch_spec['project']}/{job_name}"
+        launch_spec["job"] = job
+        launch_spec["uri"] = None  # Remove given URI --> now in job
+
+    if queue_name is None:
+        queue_name = "default"
+    if project_queue is None:
+        project_queue = LAUNCH_DEFAULT_PROJECT
+    spec_template_vars = launch_spec.get("template_variables")
+    if isinstance(spec_template_vars, dict):
+        launch_spec.pop("template_variables")
+        if template_variables is None:
+            template_variables = spec_template_vars
+        else:
+            template_variables = {
+                **spec_template_vars,
+                **template_variables,
+            }
+
+    validate_launch_spec_source(launch_spec)
+    res = push_to_queue(
+        api, queue_name, launch_spec, template_variables, project_queue, priority
+    )
+
+    if res is None or "runQueueItemId" not in res:
+        raise LaunchError("Error adding run to queue")
+
+    updated_spec = res.get("runSpec")
+    if updated_spec:
+        if updated_spec.get("resource_args"):
+            launch_spec["resource_args"] = updated_spec.get("resource_args")
+        if updated_spec.get("resource"):
+            launch_spec["resource"] = updated_spec.get("resource")
+
+    if project_queue == LAUNCH_DEFAULT_PROJECT:
+        wandb.termlog(f"{LOG_PREFIX}Added run to queue {queue_name}.")
+    else:
+        wandb.termlog(f"{LOG_PREFIX}Added run to queue {project_queue}/{queue_name}.")
+    wandb.termlog(f"{LOG_PREFIX}Launch spec:\n{pprint.pformat(launch_spec)}\n")
+
+    public_api = public.Api()
+    if job is not None:
+        try:
+            public_api.artifact(job, type="job")
+        except (ValueError, CommError) as e:
+            raise LaunchError(f"Unable to fetch job with name {job}: {e}")
+
+    queued_run = public_api.queued_run(
+        launch_spec["entity"],
+        launch_spec["project"],
+        queue_name,
+        res["runQueueItemId"],
+        project_queue,
+        priority,
+    )
+    return queued_run  # type: ignore

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

@@ -0,0 +1,566 @@
+"""Convert launch arguments into a runnable wandb launch script.
+
+Arguments can come from a launch spec or call to wandb launch.
+"""
+
+import enum
+import json
+import logging
+import os
+import shutil
+import tempfile
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+
+from six.moves import shlex_quote
+
+import wandb
+from wandb.apis.internal import Api
+from wandb.errors import CommError
+from wandb.sdk.launch.utils import get_entrypoint_file
+from wandb.sdk.lib.runid import generate_id
+
+from .errors import LaunchError
+from .utils import LOG_PREFIX, recursive_macro_sub
+
+if TYPE_CHECKING:
+    from wandb.sdk.artifacts.artifact import Artifact
+
+_logger = logging.getLogger(__name__)
+
+
+# need to make user root for sagemaker, so users have access to /opt/ml directories
+# that let users create artifacts and access input data
+RESOURCE_UID_MAP = {"local": 1000, "sagemaker": 0}
+IMAGE_TAG_MAX_LENGTH = 32
+
+
+class LaunchSource(enum.IntEnum):
+    """Enumeration of possible sources for a launch project.
+
+    Attributes:
+        DOCKER: Source is a Docker image. This can happen if a user runs
+            `wandb launch -d <docker-image>`.
+        JOB: Source is a job. This is standard case.
+        SCHEDULER: Source is a wandb sweep scheduler command.
+    """
+
+    DOCKER: int = 1
+    JOB: int = 2
+    SCHEDULER: int = 3
+
+
+class LaunchProject:
+    """A launch project specification.
+
+    The LaunchProject is initialized from a raw launch spec an internal API
+    object. The project encapsulates logic for taking a launch spec and converting
+    it into the executable code.
+
+    The LaunchProject needs to ultimately produce a full container spec for
+    execution in docker, k8s, sagemaker, or vertex. This container spec includes:
+    - container image uri
+    - environment variables for configuring wandb etc.
+    - entrypoint command and arguments
+    - additional arguments specific to the target resource (e.g. instance type, node selector)
+
+    This class is stateful and certain methods can only be called after
+    `LaunchProject.fetch_and_validate_project()` has been called.
+
+    Notes on the entrypoint:
+    - The entrypoint is the command that will be run inside the container.
+    - The LaunchProject stores two entrypoints
+        - The job entrypoint is the entrypoint specified in the job's config.
+        - The override entrypoint is the entrypoint specified in the launch spec.
+    - The override entrypoint takes precedence over the job entrypoint.
+    """
+
+    # This init is way to long, and there are too many attributes on this sucker.
+    def __init__(
+        self,
+        uri: Optional[str],
+        job: Optional[str],
+        api: Api,
+        launch_spec: Dict[str, Any],
+        target_entity: str,
+        target_project: str,
+        name: Optional[str],
+        docker_config: Dict[str, Any],
+        git_info: Dict[str, str],
+        overrides: Dict[str, Any],
+        resource: str,
+        resource_args: Dict[str, Any],
+        run_id: Optional[str],
+        sweep_id: Optional[str] = None,
+    ):
+        self.uri = uri
+        self.job = job
+        if job is not None:
+            wandb.termlog(f"{LOG_PREFIX}Launching job: {job}")
+        self._job_artifact: Optional[Artifact] = None
+        self.api = api
+        self.launch_spec = launch_spec
+        self.target_entity = target_entity
+        self.target_project = target_project.lower()
+        self.name = name  # TODO: replace with run_id
+        # the builder key can be passed in through the resource args
+        # but these resource_args are then passed to the appropriate
+        # runner, so we need to pop the builder key out
+        resource_args_copy = deepcopy(resource_args)
+        resource_args_build = resource_args_copy.get(resource, {}).pop("builder", {})
+        self.resource = resource
+        self.resource_args = resource_args_copy
+        self.sweep_id = sweep_id
+        self.author = launch_spec.get("author")
+        self.python_version: Optional[str] = launch_spec.get("python_version")
+        self._job_dockerfile: Optional[str] = None
+        self._job_build_context: Optional[str] = None
+        self._job_base_image: Optional[str] = None
+        self.accelerator_base_image: Optional[str] = resource_args_build.get(
+            "accelerator", {}
+        ).get("base_image") or resource_args_build.get("cuda", {}).get("base_image")
+        self.docker_image: Optional[str] = docker_config.get(
+            "docker_image"
+        ) or launch_spec.get("image_uri")
+        self.docker_user_id = docker_config.get("user_id", 1000)
+        self._entry_point: Optional[EntryPoint] = (
+            None  # todo: keep multiple entrypoint support?
+        )
+        self.init_overrides(overrides)
+        self.init_source()
+        self.init_git(git_info)
+        self.deps_type: Optional[str] = None
+        self._runtime: Optional[str] = None
+        self.run_id = run_id or generate_id()
+        self._queue_name: Optional[str] = None
+        self._queue_entity: Optional[str] = None
+        self._run_queue_item_id: Optional[str] = None
+
+    def init_source(self) -> None:
+        if self.docker_image is not None:
+            self.source = LaunchSource.DOCKER
+            self.project_dir = None
+        elif self.job is not None:
+            self.source = LaunchSource.JOB
+            self.project_dir = tempfile.mkdtemp()
+        elif self.uri and self.uri.startswith("placeholder"):
+            self.source = LaunchSource.SCHEDULER
+            self.project_dir = os.getcwd()
+            self._entry_point = self.override_entrypoint
+
+    def change_project_dir(self, new_dir: str) -> None:
+        """Change the project directory to a new directory."""
+        # Copy the contents of the old project dir to the new project dir.
+        old_dir = self.project_dir
+        if old_dir is not None:
+            shutil.copytree(
+                old_dir,
+                new_dir,
+                symlinks=True,
+                dirs_exist_ok=True,
+                ignore=shutil.ignore_patterns("fsmonitor--daemon.ipc", ".git"),
+            )
+            shutil.rmtree(old_dir)
+        self.project_dir = new_dir
+
+    def init_git(self, git_info: Dict[str, str]) -> None:
+        self.git_version = git_info.get("version")
+        self.git_repo = git_info.get("repo")
+
+    def init_overrides(self, overrides: Dict[str, Any]) -> None:
+        """Initialize override attributes for a launch project."""
+        self.overrides = overrides
+        self.override_args: List[str] = overrides.get("args", [])
+        self.override_config: Dict[str, Any] = overrides.get("run_config", {})
+        self.override_artifacts: Dict[str, Any] = overrides.get("artifacts", {})
+        self.override_files: Dict[str, Any] = overrides.get("files", {})
+        self.override_entrypoint: Optional[EntryPoint] = None
+        self.override_dockerfile: Optional[str] = overrides.get("dockerfile")
+        override_entrypoint = overrides.get("entry_point")
+        if override_entrypoint:
+            _logger.info("Adding override entry point")
+            self.override_entrypoint = EntryPoint(
+                name=get_entrypoint_file(override_entrypoint),
+                command=override_entrypoint,
+            )
+
+    def __repr__(self) -> str:
+        """String representation of LaunchProject."""
+        if self.source == LaunchSource.JOB:
+            return f"{self.job}"
+        return f"{self.uri}"
+
+    @classmethod
+    def from_spec(cls, launch_spec: Dict[str, Any], api: Api) -> "LaunchProject":
+        """Constructs a LaunchProject instance using a launch spec.
+
+        Arguments:
+            launch_spec: Dictionary representation of launch spec
+            api: Instance of wandb.apis.internal Api
+
+        Returns:
+            An initialized `LaunchProject` object
+        """
+        name: Optional[str] = None
+        if launch_spec.get("name"):
+            name = launch_spec["name"]
+        return LaunchProject(
+            launch_spec.get("uri"),
+            launch_spec.get("job"),
+            api,
+            launch_spec,
+            launch_spec["entity"],
+            launch_spec["project"],
+            name,
+            launch_spec.get("docker", {}),
+            launch_spec.get("git", {}),
+            launch_spec.get("overrides", {}),
+            launch_spec.get("resource", None),
+            launch_spec.get("resource_args", {}),
+            launch_spec.get("run_id", None),
+            launch_spec.get("sweep_id", {}),
+        )
+
+    @property
+    def job_dockerfile(self) -> Optional[str]:
+        return self._job_dockerfile
+
+    @property
+    def job_build_context(self) -> Optional[str]:
+        return self._job_build_context
+
+    @property
+    def job_base_image(self) -> Optional[str]:
+        return self._job_base_image
+
+    def set_job_dockerfile(self, dockerfile: str) -> None:
+        self._job_dockerfile = dockerfile
+
+    def set_job_build_context(self, build_context: str) -> None:
+        self._job_build_context = build_context
+
+    def set_job_base_image(self, base_image: str) -> None:
+        self._job_base_image = base_image
+
+    @property
+    def image_name(self) -> str:
+        if self.job_base_image is not None:
+            return self.job_base_image
+        if self.docker_image is not None:
+            return self.docker_image
+        elif self.uri is not None:
+            cleaned_uri = self.uri.replace("https://", "/")
+            first_sep = cleaned_uri.find("/")
+            shortened_uri = cleaned_uri[first_sep:]
+            return wandb.util.make_docker_image_name_safe(shortened_uri)
+        else:
+            # this will always pass since one of these 3 is required
+            assert self.job is not None
+            return wandb.util.make_docker_image_name_safe(self.job.split(":")[0])
+
+    @property
+    def queue_name(self) -> Optional[str]:
+        return self._queue_name
+
+    @queue_name.setter
+    def queue_name(self, value: str) -> None:
+        self._queue_name = value
+
+    @property
+    def queue_entity(self) -> Optional[str]:
+        return self._queue_entity
+
+    @queue_entity.setter
+    def queue_entity(self, value: str) -> None:
+        self._queue_entity = value
+
+    @property
+    def run_queue_item_id(self) -> Optional[str]:
+        return self._run_queue_item_id
+
+    @run_queue_item_id.setter
+    def run_queue_item_id(self, value: str) -> None:
+        self._run_queue_item_id = value
+
+    def fill_macros(self, image: str) -> Dict[str, Any]:
+        """Substitute values for macros in resource arguments.
+
+        Certain macros can be used in resource args. These macros allow the
+        user to set resource args dynamically in the context of the
+        run being launched. The macros are given in the ${macro} format. The
+        following macros are currently supported:
+
+        ${project_name} - the name of the project the run is being launched to.
+        ${entity_name} - the owner of the project the run being launched to.
+        ${run_id} - the id of the run being launched.
+        ${run_name} - the name of the run that is launching.
+        ${image_uri} - the URI of the container image for this run.
+
+        Additionally, you may use ${<ENV-VAR-NAME>} to refer to the value of any
+        environment variables that you plan to set in the environment of any
+        agents that will receive these resource args.
+
+        Calling this method will overwrite the contents of self.resource_args
+        with the substituted values.
+
+        Args:
+            image (str): The image name to fill in for ${wandb-image}.
+
+        Returns:
+            Dict[str, Any]: The resource args with all macros filled in.
+        """
+        update_dict = {
+            "project_name": self.target_project,
+            "entity_name": self.target_entity,
+            "run_id": self.run_id,
+            "run_name": self.name,
+            "image_uri": image,
+            "author": self.author,
+        }
+        update_dict.update(os.environ)
+        result = recursive_macro_sub(self.resource_args, update_dict)
+        # recursive_macro_sub given a dict returns a dict with the same keys
+        # but with other input types behaves differently. The cast is for mypy.
+        return cast(Dict[str, Any], result)
+
+    def build_required(self) -> bool:
+        """Checks the source to see if a build is required."""
+        if self.job_base_image is not None:
+            return False
+        if self.source != LaunchSource.JOB:
+            return True
+        return False
+
+    @property
+    def docker_image(self) -> Optional[str]:
+        """Returns the Docker image associated with this LaunchProject.
+
+        This will only be set if an image_uri is being run outside a job.
+
+        Returns:
+            Optional[str]: The Docker image or None if not specified.
+        """
+        if self._docker_image:
+            return self._docker_image
+        return None
+
+    @docker_image.setter
+    def docker_image(self, value: str) -> None:
+        """Sets the Docker image for the project.
+
+        Args:
+            value (str): The Docker image to set.
+
+        Returns:
+            None
+        """
+        self._docker_image = value
+        self._ensure_not_docker_image_and_local_process()
+
+    def get_job_entry_point(self) -> Optional["EntryPoint"]:
+        """Returns the job entrypoint for the project."""
+        # assuming project only has 1 entry point, pull that out
+        # tmp fn until we figure out if we want to support multiple entry points or not
+        if not self._entry_point:
+            if not self.docker_image and not self.job_base_image:
+                raise LaunchError(
+                    "Project must have at least one entry point unless docker image is specified."
+                )
+            return None
+        return self._entry_point
+
+    def set_job_entry_point(self, command: List[str]) -> "EntryPoint":
+        """Set job entrypoint for the project."""
+        assert (
+            self._entry_point is None
+        ), "Cannot set entry point twice. Use LaunchProject.override_entrypoint"
+        new_entrypoint = EntryPoint(name=command[-1], command=command)
+        self._entry_point = new_entrypoint
+        return new_entrypoint
+
+    def fetch_and_validate_project(self) -> None:
+        """Fetches a project into a local directory, adds the config values to the directory, and validates the first entrypoint for the project.
+
+        Arguments:
+            launch_project: LaunchProject to fetch and validate.
+            api: Instance of wandb.apis.internal Api
+
+        Returns:
+            A validated `LaunchProject` object.
+
+        """
+        if self.source == LaunchSource.DOCKER:
+            return
+        elif self.source == LaunchSource.JOB:
+            self._fetch_job()
+        assert self.project_dir is not None
+
+    # Let's make sure we document this very clearly.
+    def get_image_source_string(self) -> str:
+        """Returns a unique string identifying the source of an image."""
+        if self.source == LaunchSource.JOB:
+            assert self._job_artifact is not None
+            return f"{self._job_artifact.name}:v{self._job_artifact.version}"
+        elif self.source == LaunchSource.DOCKER:
+            assert isinstance(self.docker_image, str)
+            return self.docker_image
+        else:
+            raise LaunchError(
+                "Unknown source type when determining image source string"
+            )
+
+    def _ensure_not_docker_image_and_local_process(self) -> None:
+        """Ensure that docker image is not specified with local-process resource runner.
+
+        Raises:
+            LaunchError: If docker image is specified with local-process resource runner.
+        """
+        if self.docker_image is not None and self.resource == "local-process":
+            raise LaunchError(
+                "Cannot specify docker image with local-process resource runner"
+            )
+
+    def _fetch_job(self) -> None:
+        """Fetches the job details from the public API and configures the launch project.
+
+        Raises:
+            LaunchError: If there is an error accessing the job.
+        """
+        public_api = wandb.apis.public.Api()
+        job_dir = tempfile.mkdtemp()
+        try:
+            job = public_api.job(self.job, path=job_dir)
+        except CommError as e:
+            msg = e.message
+            raise LaunchError(
+                f"Error accessing job {self.job}: {msg} on {public_api.settings.get('base_url')}"
+            )
+        job.configure_launch_project(self)  # Why is this a method of the job?
+        self._job_artifact = job._job_artifact
+
+    def get_env_vars_dict(self, api: Api, max_env_length: int) -> Dict[str, str]:
+        """Generate environment variables for the project.
+
+        Arguments:
+        launch_project: LaunchProject to generate environment variables for.
+
+        Returns:
+            Dictionary of environment variables.
+        """
+        env_vars = {}
+        env_vars["WANDB_BASE_URL"] = api.settings("base_url")
+        override_api_key = self.launch_spec.get("_wandb_api_key")
+        env_vars["WANDB_API_KEY"] = override_api_key or api.api_key
+        if self.target_project:
+            env_vars["WANDB_PROJECT"] = self.target_project
+        env_vars["WANDB_ENTITY"] = self.target_entity
+        env_vars["WANDB_LAUNCH"] = "True"
+        env_vars["WANDB_RUN_ID"] = self.run_id
+        if self.docker_image:
+            env_vars["WANDB_DOCKER"] = self.docker_image
+        if self.name is not None:
+            env_vars["WANDB_NAME"] = self.name
+        if "author" in self.launch_spec and not override_api_key:
+            env_vars["WANDB_USERNAME"] = self.launch_spec["author"]
+        if self.sweep_id:
+            env_vars["WANDB_SWEEP_ID"] = self.sweep_id
+        if self.launch_spec.get("_resume_count", 0) > 0:
+            env_vars["WANDB_RESUME"] = "allow"
+        if self.queue_name:
+            env_vars[wandb.env.LAUNCH_QUEUE_NAME] = self.queue_name
+        if self.queue_entity:
+            env_vars[wandb.env.LAUNCH_QUEUE_ENTITY] = self.queue_entity
+        if self.run_queue_item_id:
+            env_vars[wandb.env.LAUNCH_TRACE_ID] = self.run_queue_item_id
+
+        _inject_wandb_config_env_vars(self.override_config, env_vars, max_env_length)
+        _inject_file_overrides_env_vars(self.override_files, env_vars, max_env_length)
+
+        artifacts = {}
+        # if we're spinning up a launch process from a job
+        # we should tell the run to use that artifact
+        if self.job:
+            artifacts = {wandb.util.LAUNCH_JOB_ARTIFACT_SLOT_NAME: self.job}
+        env_vars["WANDB_ARTIFACTS"] = json.dumps(
+            {**artifacts, **self.override_artifacts}
+        )
+        return env_vars
+
+    def parse_existing_requirements(self) -> str:
+        import pkg_resources
+
+        requirements_line = ""
+        assert self.project_dir is not None
+        base_requirements = os.path.join(self.project_dir, "requirements.txt")
+        if os.path.exists(base_requirements):
+            include_only = set()
+            with open(base_requirements) as f:
+                iter = pkg_resources.parse_requirements(f)
+                while True:
+                    try:
+                        pkg = next(iter)
+                        if hasattr(pkg, "name"):
+                            name = pkg.name.lower()
+                        else:
+                            name = str(pkg)
+                        include_only.add(shlex_quote(name))
+                    except StopIteration:
+                        break
+                    # Different versions of pkg_resources throw different errors
+                    # just catch them all and ignore packages we can't parse
+                    except Exception as e:
+                        _logger.warn(f"Unable to parse requirements.txt: {e}")
+                        continue
+            requirements_line += "WANDB_ONLY_INCLUDE={} ".format(",".join(include_only))
+            if "wandb" not in requirements_line:
+                wandb.termwarn(f"{LOG_PREFIX}wandb is not present in requirements.txt.")
+        return requirements_line
+
+
+class EntryPoint:
+    """An entry point into a wandb launch specification."""
+
+    def __init__(self, name: Optional[str], command: List[str]):
+        self.name = name
+        self.command = command
+
+    def update_entrypoint_path(self, new_path: str) -> None:
+        """Updates the entrypoint path to a new path."""
+        if len(self.command) == 2 and (
+            self.command[0].startswith("python") or self.command[0] == "bash"
+        ):
+            self.command[1] = new_path
+
+
+def _inject_wandb_config_env_vars(
+    config: Dict[str, Any], env_dict: Dict[str, Any], maximum_env_length: int
+) -> None:
+    str_config = json.dumps(config)
+    if len(str_config) <= maximum_env_length:
+        env_dict["WANDB_CONFIG"] = str_config
+        return
+
+    chunks = [
+        str_config[i : i + maximum_env_length]
+        for i in range(0, len(str_config), maximum_env_length)
+    ]
+    config_chunks_dict = {f"WANDB_CONFIG_{i}": chunk for i, chunk in enumerate(chunks)}
+    env_dict.update(config_chunks_dict)
+
+
+def _inject_file_overrides_env_vars(
+    overrides: Dict[str, Any], env_dict: Dict[str, Any], maximum_env_length: int
+) -> None:
+    str_overrides = json.dumps(overrides)
+    if len(str_overrides) <= maximum_env_length:
+        env_dict["WANDB_LAUNCH_FILE_OVERRIDES"] = str_overrides
+        return
+
+    chunks = [
+        str_overrides[i : i + maximum_env_length]
+        for i in range(0, len(str_overrides), maximum_env_length)
+    ]
+    overrides_chunks_dict = {
+        f"WANDB_LAUNCH_FILE_OVERRIDES_{i}": chunk for i, chunk in enumerate(chunks)
+    }
+    env_dict.update(overrides_chunks_dict)

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

@@ -0,0 +1,5 @@
+from .agent import LaunchAgent
+
+LaunchAgent = LaunchAgent
+
+__all__ = ["LaunchAgent"]

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

@@ -0,0 +1,924 @@
+"""Implementation of launch agent."""
+
+import asyncio
+import logging
+import os
+import pprint
+import threading
+import time
+import traceback
+from dataclasses import dataclass
+from multiprocessing import Event
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import yaml
+
+import wandb
+from wandb.apis.internal import Api
+from wandb.errors import CommError
+from wandb.sdk.launch._launch_add import launch_add
+from wandb.sdk.launch.runner.local_container import LocalSubmittedRun
+from wandb.sdk.launch.runner.local_process import LocalProcessRunner
+from wandb.sdk.launch.sweeps.scheduler import Scheduler
+from wandb.sdk.launch.utils import LAUNCH_CONFIG_FILE, resolve_build_and_registry_config
+from wandb.sdk.lib import runid
+
+from .. import loader
+from .._project_spec import LaunchProject
+from ..errors import LaunchDockerError, LaunchError
+from ..utils import (
+    LAUNCH_DEFAULT_PROJECT,
+    LOG_PREFIX,
+    PROJECT_SYNCHRONOUS,
+    event_loop_thread_exec,
+)
+from .job_status_tracker import JobAndRunStatusTracker
+from .run_queue_item_file_saver import RunQueueItemFileSaver
+
+AGENT_POLLING_INTERVAL = 10
+RECEIVED_JOB_POLLING_INTERVAL = 0.0  # more frequent when we know we have jobs
+
+AGENT_POLLING = "POLLING"
+AGENT_RUNNING = "RUNNING"
+AGENT_KILLED = "KILLED"
+
+HIDDEN_AGENT_RUN_TYPE = "sweep-controller"
+
+MAX_RESUME_COUNT = 5
+
+RUN_INFO_GRACE_PERIOD = 60
+
+DEFAULT_STOPPED_RUN_TIMEOUT = 60
+
+DEFAULT_PRINT_INTERVAL = 5 * 60
+VERBOSE_PRINT_INTERVAL = 20
+
+_env_timeout = os.environ.get("WANDB_LAUNCH_START_TIMEOUT")
+if _env_timeout:
+    try:
+        RUN_START_TIMEOUT = float(_env_timeout)
+    except ValueError:
+        raise LaunchError(
+            f"Invalid value for WANDB_LAUNCH_START_TIMEOUT: {_env_timeout}"
+        )
+else:
+    RUN_START_TIMEOUT = 60 * 30  # default 30 minutes
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass
+class JobSpecAndQueue:
+    job: Dict[str, Any]
+    queue: str
+
+
+def _convert_access(access: str) -> str:
+    """Convert access string to a value accepted by wandb."""
+    access = access.upper()
+    assert (
+        access == "PROJECT" or access == "USER"
+    ), "Queue access must be either project or user"
+    return access
+
+
+def _max_from_config(
+    config: Dict[str, Any], key: str, default: int = 1
+) -> Union[int, float]:
+    """Get an integer from the config, or float.inf if -1.
+
+    Utility for parsing integers from the agent config with a default, infinity
+    handling, and integer parsing. Raises more informative error if parse error.
+    """
+    try:
+        val = config.get(key)
+        if val is None:
+            val = default
+        max_from_config = int(val)
+    except ValueError as e:
+        raise LaunchError(
+            f"Error when parsing LaunchAgent config key: ['{key}': "
+            f"{config.get(key)}]. Error: {str(e)}"
+        )
+    if max_from_config == -1:
+        return float("inf")
+
+    if max_from_config < 0:
+        raise LaunchError(
+            f"Error when parsing LaunchAgent config key: ['{key}': "
+            f"{config.get(key)}]. Error: negative value."
+        )
+    return max_from_config
+
+
+class InternalAgentLogger:
+    def __init__(self, verbosity=0):
+        self._print_to_terminal = verbosity >= 2
+
+    def error(self, message: str):
+        if self._print_to_terminal:
+            wandb.termerror(f"{LOG_PREFIX}{message}")
+        _logger.error(f"{LOG_PREFIX}{message}")
+
+    def warn(self, message: str):
+        if self._print_to_terminal:
+            wandb.termwarn(f"{LOG_PREFIX}{message}")
+        _logger.warn(f"{LOG_PREFIX}{message}")
+
+    def info(self, message: str):
+        if self._print_to_terminal:
+            wandb.termlog(f"{LOG_PREFIX}{message}")
+        _logger.info(f"{LOG_PREFIX}{message}")
+
+    def debug(self, message: str):
+        if self._print_to_terminal:
+            wandb.termlog(f"{LOG_PREFIX}{message}")
+        _logger.debug(f"{LOG_PREFIX}{message}")
+
+
+def construct_agent_configs(
+    launch_config: Optional[Dict] = None,
+    build_config: Optional[Dict] = None,
+) -> Tuple[Optional[Dict[str, Any]], Dict[str, Any], Dict[str, Any]]:
+    registry_config = None
+    environment_config = None
+    if launch_config is not None:
+        build_config = launch_config.get("builder")
+        registry_config = launch_config.get("registry")
+
+    default_launch_config = None
+    if os.path.exists(os.path.expanduser(LAUNCH_CONFIG_FILE)):
+        with open(os.path.expanduser(LAUNCH_CONFIG_FILE)) as f:
+            default_launch_config = (
+                yaml.safe_load(f) or {}
+            )  # In case the config is empty, we want it to be {} instead of None.
+        environment_config = default_launch_config.get("environment")
+
+    build_config, registry_config = resolve_build_and_registry_config(
+        default_launch_config, build_config, registry_config
+    )
+
+    return environment_config, build_config, registry_config
+
+
+class LaunchAgent:
+    """Launch agent class which polls run given run queues and launches runs for wandb launch."""
+
+    _instance = None
+
+    def __new__(cls, *args: Any, **kwargs: Any) -> "LaunchAgent":
+        """Create a new instance of the LaunchAgent.
+
+        This method ensures that only one instance of the LaunchAgent is created.
+        This is done so that information about the agent can be accessed from
+        elsewhere in the library.
+        """
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    @classmethod
+    def name(cls) -> str:
+        """Return the name of the agent."""
+        if cls._instance is None:
+            raise LaunchError("LaunchAgent has not been initialized")
+        name = cls._instance._name
+        if isinstance(name, str):
+            return name
+        raise LaunchError(f"Found invalid name for agent {name}")
+
+    @classmethod
+    def initialized(cls) -> bool:
+        """Return whether the agent is initialized."""
+        return cls._instance is not None
+
+    def __init__(self, api: Api, config: Dict[str, Any]):
+        """Initialize a launch agent.
+
+        Arguments:
+            api: Api object to use for making requests to the backend.
+            config: Config dictionary for the agent.
+        """
+        self._entity = config["entity"]
+        self._project = LAUNCH_DEFAULT_PROJECT
+        self._api = api
+        self._base_url = self._api.settings().get("base_url")
+        self._ticks = 0
+        self._jobs: Dict[int, JobAndRunStatusTracker] = {}
+        self._jobs_lock = threading.Lock()
+        self._jobs_event = Event()
+        self._jobs_event.set()
+        self._cwd = os.getcwd()
+        self._namespace = runid.generate_id()
+        self._access = _convert_access("project")
+        self._max_jobs = _max_from_config(config, "max_jobs")
+        self._max_schedulers = _max_from_config(config, "max_schedulers")
+        self._secure_mode = config.get("secure_mode", False)
+        self._verbosity = config.get("verbosity", 0)
+        self._internal_logger = InternalAgentLogger(verbosity=self._verbosity)
+        self._last_status_print_time = 0.0
+        self.default_config: Dict[str, Any] = config
+        self._stopped_run_timeout = config.get(
+            "stopped_run_timeout", DEFAULT_STOPPED_RUN_TIMEOUT
+        )
+        self._known_warnings: List[str] = []
+
+        # Get agent version from env var if present, otherwise wandb version
+        self.version: str = "wandb@" + wandb.__version__
+        env_agent_version = os.environ.get("WANDB_AGENT_VERSION")
+        if env_agent_version and env_agent_version != "wandb-launch-agent":
+            self.version = env_agent_version
+
+        # serverside creation
+        self.gorilla_supports_agents = (
+            self._api.launch_agent_introspection() is not None
+        )
+        self._gorilla_supports_fail_run_queue_items = (
+            self._api.fail_run_queue_item_introspection()
+        )
+
+        self._queues: List[str] = config.get("queues", ["default"])
+
+        # remove project field from agent config before sending to back end
+        # because otherwise it shows up in the config in the UI and confuses users
+        sent_config = config.copy()
+        if "project" in sent_config:
+            del sent_config["project"]
+
+        create_response = self._api.create_launch_agent(
+            self._entity,
+            self._project,
+            self._queues,
+            sent_config,
+            self.version,
+            self.gorilla_supports_agents,
+        )
+        self._id = create_response["launchAgentId"]
+        if self._api.entity_is_team(self._entity):
+            wandb.termwarn(
+                f"{LOG_PREFIX}Agent is running on team entity ({self._entity}). Members of this team will be able to run code on this device."
+            )
+
+        agent_response = self._api.get_launch_agent(
+            self._id, self.gorilla_supports_agents
+        )
+        self._name = agent_response["name"]
+        self._init_agent_run()
+
+    def _is_scheduler_job(self, run_spec: Dict[str, Any]) -> bool:
+        """Determine whether a job/runSpec is a sweep scheduler."""
+        if not run_spec:
+            self._internal_logger.debug(
+                "Received runSpec in _is_scheduler_job that was empty"
+            )
+
+        if run_spec.get("uri") != Scheduler.PLACEHOLDER_URI:
+            return False
+
+        if run_spec.get("resource") == "local-process":
+            # Any job pushed to a run queue that has a scheduler uri is
+            # allowed to use local-process
+            if run_spec.get("job"):
+                return True
+
+            # If a scheduler is local-process and run through CLI, also
+            #    confirm command is in format: [wandb scheduler <sweep>]
+            cmd = run_spec.get("overrides", {}).get("entry_point", [])
+            if len(cmd) < 3:
+                return False
+
+            if cmd[:2] != ["wandb", "scheduler"]:
+                return False
+
+        return True
+
+    async def fail_run_queue_item(
+        self,
+        run_queue_item_id: str,
+        message: str,
+        phase: str,
+        files: Optional[List[str]] = None,
+    ) -> None:
+        if self._gorilla_supports_fail_run_queue_items:
+            fail_rqi = event_loop_thread_exec(self._api.fail_run_queue_item)
+            await fail_rqi(run_queue_item_id, message, phase, files)
+
+    def _init_agent_run(self) -> None:
+        # TODO: has it been long enough that all backends support agents?
+        self._wandb_run = None
+
+        if self.gorilla_supports_agents:
+            settings = wandb.Settings(
+                silent=True, disable_git=True, disable_job_creation=True
+            )
+            self._wandb_run = wandb.init(
+                project=self._project,
+                entity=self._entity,
+                settings=settings,
+                id=self._name,
+                job_type=HIDDEN_AGENT_RUN_TYPE,
+            )
+
+    @property
+    def thread_ids(self) -> List[int]:
+        """Returns a list of keys running thread ids for the agent."""
+        with self._jobs_lock:
+            return list(self._jobs.keys())
+
+    @property
+    def num_running_schedulers(self) -> int:
+        """Return just the number of schedulers."""
+        with self._jobs_lock:
+            return len([x for x in self._jobs if self._jobs[x].is_scheduler])
+
+    @property
+    def num_running_jobs(self) -> int:
+        """Return the number of jobs not including schedulers."""
+        with self._jobs_lock:
+            return len([x for x in self._jobs if not self._jobs[x].is_scheduler])
+
+    async def pop_from_queue(self, queue: str) -> Any:
+        """Pops an item off the runqueue to run as a job.
+
+        Arguments:
+            queue: Queue to pop from.
+
+        Returns:
+            Item popped off the queue.
+
+        Raises:
+            Exception: if there is an error popping from the queue.
+        """
+        try:
+            pop = event_loop_thread_exec(self._api.pop_from_run_queue)
+            ups = await pop(
+                queue,
+                entity=self._entity,
+                project=self._project,
+                agent_id=self._id,
+            )
+            return ups
+        except Exception as e:
+            print("Exception:", e)
+            return None
+
+    def print_status(self) -> None:
+        """Prints the current status of the agent."""
+        self._last_status_print_time = time.time()
+        output_str = "agent "
+        if self._name:
+            output_str += f"{self._name} "
+        if self.num_running_jobs < self._max_jobs:
+            output_str += f"polling on queues {','.join(self._queues)}, "
+        output_str += (
+            f"running {self.num_running_jobs} out of a maximum of {self._max_jobs} jobs"
+        )
+
+        wandb.termlog(f"{LOG_PREFIX}{output_str}")
+        if self.num_running_jobs > 0:
+            output_str += f": {','.join(str(job_id) for job_id in self.thread_ids)}"
+
+        _logger.info(output_str)
+
+    async def update_status(self, status: str) -> None:
+        """Update the status of the agent.
+
+        Arguments:
+            status: Status to update the agent to.
+        """
+        _update_status = event_loop_thread_exec(self._api.update_launch_agent_status)
+        update_ret = await _update_status(
+            self._id, status, self.gorilla_supports_agents
+        )
+        if not update_ret["success"]:
+            wandb.termerror(f"{LOG_PREFIX}Failed to update agent status to {status}")
+
+    def _check_run_exists_and_inited(
+        self, entity: str, project: str, run_id: str, rqi_id: str
+    ) -> bool:
+        """Checks the stateof the run to ensure it has been inited. Note this will not behave well with resuming."""
+        # Checks the _wandb key in the run config for the run queue item id. If it exists, the
+        # submitted run definitely called init. Falls back to checking state of run.
+        # TODO: handle resuming runs
+
+        # Sweep runs exist but are in pending state, normal launch runs won't exist
+        # so will raise a CommError.
+        try:
+            run_state = self._api.get_run_state(entity, project, run_id)
+            if run_state.lower() != "pending":
+                return True
+        except CommError:
+            self._internal_logger.info(
+                f"Run {entity}/{project}/{run_id} with rqi id: {rqi_id} did not have associated run",
+            )
+        return False
+
+    async def finish_thread_id(
+        self,
+        thread_id: int,
+        exception: Optional[Union[Exception, LaunchDockerError]] = None,
+    ) -> None:
+        """Removes the job from our list for now."""
+        with self._jobs_lock:
+            job_and_run_status = self._jobs[thread_id]
+        if (
+            job_and_run_status.entity is not None
+            and job_and_run_status.entity != self._entity
+        ):
+            self._internal_logger.info(
+                "Skipping check for completed run status because run is on a different entity than agent",
+            )
+        elif exception is not None:
+            tb_str = traceback.format_exception(
+                type(exception), value=exception, tb=exception.__traceback__
+            )
+            fnames = job_and_run_status.saver.save_contents(
+                "".join(tb_str), "error.log", "error"
+            )
+            await self.fail_run_queue_item(
+                job_and_run_status.run_queue_item_id,
+                str(exception),
+                job_and_run_status.err_stage,
+                fnames,
+            )
+        elif job_and_run_status.project is None or job_and_run_status.run_id is None:
+            self._internal_logger.info(
+                f"called finish_thread_id on thread whose tracker has no project or run id. RunQueueItemID: {job_and_run_status.run_queue_item_id}",
+            )
+            wandb.termerror(
+                "Missing project or run id on thread called finish thread id"
+            )
+            await self.fail_run_queue_item(
+                job_and_run_status.run_queue_item_id,
+                "submitted job was finished without assigned project or run id",
+                "agent",
+            )
+        elif job_and_run_status.run is not None:
+            called_init = False
+            # We do some weird stuff here getting run info to check for a
+            # created in run in W&B.
+            #
+            # We retry for 60 seconds with an exponential backoff in case
+            # upsert run is taking a while.
+            logs = None
+            interval = 1
+            while True:
+                called_init = self._check_run_exists_and_inited(
+                    self._entity,
+                    job_and_run_status.project,
+                    job_and_run_status.run_id,
+                    job_and_run_status.run_queue_item_id,
+                )
+                if called_init or interval > RUN_INFO_GRACE_PERIOD:
+                    break
+                if not called_init:
+                    # Fetch the logs now if we don't get run info on the
+                    # first try, in case the logs are cleaned from the runner
+                    # environment (e.g. k8s) during the run info grace period.
+                    if interval == 1:
+                        logs = await job_and_run_status.run.get_logs()
+                    await asyncio.sleep(interval)
+                    interval *= 2
+            if not called_init:
+                fnames = None
+                if job_and_run_status.completed_status == "finished":
+                    _msg = "The submitted job exited successfully but failed to call wandb.init"
+                else:
+                    _msg = "The submitted run was not successfully started"
+                if logs:
+                    fnames = job_and_run_status.saver.save_contents(
+                        logs, "error.log", "error"
+                    )
+                await self.fail_run_queue_item(
+                    job_and_run_status.run_queue_item_id, _msg, "run", fnames
+                )
+        else:
+            self._internal_logger.info(
+                f"Finish thread id {thread_id} had no exception and no run"
+            )
+            wandb._sentry.exception(
+                "launch agent called finish thread id on thread without run or exception"
+            )
+
+        # TODO:  keep logs or something for the finished jobs
+        with self._jobs_lock:
+            del self._jobs[thread_id]
+
+        # update status back to polling if no jobs are running
+        if len(self.thread_ids) == 0:
+            await self.update_status(AGENT_POLLING)
+
+    async def run_job(
+        self, job: Dict[str, Any], queue: str, file_saver: RunQueueItemFileSaver
+    ) -> None:
+        """Set up project and run the job.
+
+        Arguments:
+            job: Job to run.
+        """
+        _msg = f"{LOG_PREFIX}Launch agent received job:\n{pprint.pformat(job)}\n"
+        wandb.termlog(_msg)
+        _logger.info(_msg)
+        # update agent status
+        await self.update_status(AGENT_RUNNING)
+
+        # parse job
+        self._internal_logger.info("Parsing launch spec")
+        launch_spec = job["runSpec"]
+
+        # Abort if this job attempts to override secure mode
+        self._assert_secure(launch_spec)
+        job_tracker = JobAndRunStatusTracker(job["runQueueItemId"], queue, file_saver)
+
+        asyncio.create_task(
+            self.task_run_job(
+                launch_spec,
+                job,
+                self.default_config,
+                self._api,
+                job_tracker,
+            )
+        )
+
+    def _assert_secure(self, launch_spec: Dict[str, Any]) -> None:
+        """If secure mode is set, make sure no vulnerable keys are overridden."""
+        if not self._secure_mode:
+            return
+        k8s_config = launch_spec.get("resource_args", {}).get("kubernetes", {})
+
+        pod_secure_keys = ["hostPID", "hostIPC", "hostNetwork", "initContainers"]
+        pod_spec = k8s_config.get("spec", {}).get("template", {}).get("spec", {})
+        for key in pod_secure_keys:
+            if key in pod_spec:
+                raise ValueError(
+                    f'This agent is configured to lock "{key}" in pod spec '
+                    "but the job specification attempts to override it."
+                )
+
+        container_specs = pod_spec.get("containers", [])
+        for container_spec in container_specs:
+            if "command" in container_spec:
+                raise ValueError(
+                    'This agent is configured to lock "command" in container spec '
+                    "but the job specification attempts to override it."
+                )
+
+        if launch_spec.get("overrides", {}).get("entry_point"):
+            raise ValueError(
+                'This agent is configured to lock the "entrypoint" override '
+                "but the job specification attempts to override it."
+            )
+
+    async def loop(self) -> None:
+        """Loop infinitely to poll for jobs and run them.
+
+        Raises:
+            KeyboardInterrupt: if the agent is requested to stop.
+        """
+        self.print_status()
+        if self._verbosity == 0:
+            print_interval = DEFAULT_PRINT_INTERVAL
+        else:
+            print_interval = VERBOSE_PRINT_INTERVAL
+        try:
+            while True:
+                job = None
+                self._ticks += 1
+                agent_response = self._api.get_launch_agent(
+                    self._id, self.gorilla_supports_agents
+                )
+                if agent_response["stopPolling"]:
+                    # shutdown process and all jobs if requested from ui
+                    raise KeyboardInterrupt
+                if self.num_running_jobs < self._max_jobs:
+                    # only check for new jobs if we're not at max
+                    job_and_queue = await self.get_job_and_queue()
+                    # these will either both be None, or neither will be None
+                    if job_and_queue is not None:
+                        job = job_and_queue.job
+                        queue = job_and_queue.queue
+                        try:
+                            file_saver = RunQueueItemFileSaver(
+                                self._wandb_run, job["runQueueItemId"]
+                            )
+                            if self._is_scheduler_job(job.get("runSpec", {})):
+                                # If job is a scheduler, and we are already at the cap, ignore,
+                                #    don't ack, and it will be pushed back onto the queue in 1 min
+                                if self.num_running_schedulers >= self._max_schedulers:
+                                    wandb.termwarn(
+                                        f"{LOG_PREFIX}Agent already running the maximum number "
+                                        f"of sweep schedulers: {self._max_schedulers}. To set "
+                                        "this value use `max_schedulers` key in the agent config"
+                                    )
+                                    continue
+                            await self.run_job(job, queue, file_saver)
+                        except Exception as e:
+                            wandb.termerror(
+                                f"{LOG_PREFIX}Error running job: {traceback.format_exc()}"
+                            )
+                            wandb._sentry.exception(e)
+
+                            # always the first phase, because we only enter phase 2 within the thread
+                            files = file_saver.save_contents(
+                                contents=traceback.format_exc(),
+                                fname="error.log",
+                                file_sub_type="error",
+                            )
+                            await self.fail_run_queue_item(
+                                run_queue_item_id=job["runQueueItemId"],
+                                message=str(e),
+                                phase="agent",
+                                files=files,
+                            )
+
+                if self._ticks % 2 == 0:
+                    if len(self.thread_ids) == 0:
+                        await self.update_status(AGENT_POLLING)
+                    else:
+                        await self.update_status(AGENT_RUNNING)
+                if time.time() - self._last_status_print_time > print_interval:
+                    self.print_status()
+
+                if self.num_running_jobs == self._max_jobs or job is None:
+                    # all threads busy or did not receive job
+                    await asyncio.sleep(AGENT_POLLING_INTERVAL)
+                else:
+                    await asyncio.sleep(RECEIVED_JOB_POLLING_INTERVAL)
+
+        except KeyboardInterrupt:
+            await self.update_status(AGENT_KILLED)
+            wandb.termlog(f"{LOG_PREFIX}Shutting down, active jobs:")
+            self.print_status()
+        finally:
+            self._jobs_event.clear()
+
+    # Threaded functions
+    async def task_run_job(
+        self,
+        launch_spec: Dict[str, Any],
+        job: Dict[str, Any],
+        default_config: Dict[str, Any],
+        api: Api,
+        job_tracker: JobAndRunStatusTracker,
+    ) -> None:
+        rqi_id = job["runQueueItemId"]
+        assert rqi_id
+        exception: Optional[Union[LaunchDockerError, Exception]] = None
+        try:
+            with self._jobs_lock:
+                self._jobs[rqi_id] = job_tracker
+            await self._task_run_job(
+                launch_spec, job, default_config, api, rqi_id, job_tracker
+            )
+        except LaunchDockerError as e:
+            wandb.termerror(
+                f"{LOG_PREFIX}agent {self._name} encountered an issue while starting Docker, see above output for details."
+            )
+            exception = e
+            wandb._sentry.exception(e)
+        except LaunchError as e:
+            wandb.termerror(f"{LOG_PREFIX}Error running job: {e}")
+            exception = e
+            wandb._sentry.exception(e)
+        except Exception as e:
+            wandb.termerror(f"{LOG_PREFIX}Error running job: {traceback.format_exc()}")
+            exception = e
+            wandb._sentry.exception(e)
+        finally:
+            await self.finish_thread_id(rqi_id, exception)
+
+    async def _task_run_job(
+        self,
+        launch_spec: Dict[str, Any],
+        job: Dict[str, Any],
+        default_config: Dict[str, Any],
+        api: Api,
+        thread_id: int,
+        job_tracker: JobAndRunStatusTracker,
+    ) -> None:
+        project = LaunchProject.from_spec(launch_spec, api)
+        self._set_queue_and_rqi_in_project(project, job, job_tracker.queue)
+        ack = event_loop_thread_exec(api.ack_run_queue_item)
+        await ack(job["runQueueItemId"], project.run_id)
+        # don't launch sweep runs if the sweep isn't healthy
+        await self.check_sweep_state(launch_spec, api)
+
+        job_tracker.update_run_info(project)
+        self._internal_logger.info("Fetching and validating project...")
+        project.fetch_and_validate_project()
+        self._internal_logger.info("Fetching resource...")
+        resource = launch_spec.get("resource") or "local-container"
+        backend_config: Dict[str, Any] = {
+            PROJECT_SYNCHRONOUS: False,  # agent always runs async
+        }
+        self._internal_logger.info("Loading backend")
+        override_build_config = launch_spec.get("builder")
+
+        _, build_config, registry_config = construct_agent_configs(
+            default_config, override_build_config
+        )
+        image_uri = project.docker_image or project.job_base_image
+        entrypoint = project.get_job_entry_point()
+        environment = loader.environment_from_config(
+            default_config.get("environment", {})
+        )
+        registry = loader.registry_from_config(registry_config, environment)
+        builder = loader.builder_from_config(build_config, environment, registry)
+        backend = loader.runner_from_config(
+            resource, api, backend_config, environment, registry
+        )
+        if not (
+            project.docker_image
+            or project.job_base_image
+            or isinstance(backend, LocalProcessRunner)
+        ):
+            assert entrypoint is not None
+            image_uri = await builder.build_image(project, entrypoint, job_tracker)
+
+        self._internal_logger.info("Backend loaded...")
+        if isinstance(backend, LocalProcessRunner):
+            run = await backend.run(project, image_uri)
+        else:
+            assert image_uri
+            run = await backend.run(project, image_uri)
+        if self._is_scheduler_job(launch_spec):
+            with self._jobs_lock:
+                self._jobs[thread_id].is_scheduler = True
+            wandb.termlog(
+                f"{LOG_PREFIX}Preparing to run sweep scheduler "
+                f"({self.num_running_schedulers}/{self._max_schedulers})"
+            )
+
+        if not run:
+            with self._jobs_lock:
+                job_tracker.failed_to_start = True
+            return
+        with self._jobs_lock:
+            job_tracker.run = run
+        start_time = time.time()
+        stopped_time: Optional[float] = None
+        while self._jobs_event.is_set():
+            # If run has failed to start before timeout, kill it
+            state = (await run.get_status()).state
+            if state == "starting" and RUN_START_TIMEOUT > 0:
+                if time.time() - start_time > RUN_START_TIMEOUT:
+                    await run.cancel()
+                    raise LaunchError(
+                        f"Run failed to start within {RUN_START_TIMEOUT} seconds. "
+                        "If you want to increase this timeout, set WANDB_LAUNCH_START_TIMEOUT "
+                        "to a larger value."
+                    )
+            if await self._check_run_finished(job_tracker, launch_spec):
+                return
+            if await job_tracker.check_wandb_run_stopped(self._api):
+                if stopped_time is None:
+                    stopped_time = time.time()
+                else:
+                    if time.time() - stopped_time > self._stopped_run_timeout:
+                        await run.cancel()
+            await asyncio.sleep(AGENT_POLLING_INTERVAL)
+
+        # temp: for local, kill all jobs. we don't yet have good handling for different
+        # types of runners in general
+        if isinstance(run, LocalSubmittedRun) and run._command_proc is not None:
+            run._command_proc.kill()
+
+    async def check_sweep_state(self, launch_spec: Dict[str, Any], api: Api) -> None:
+        """Check the state of a sweep before launching a run for the sweep."""
+        if launch_spec.get("sweep_id"):
+            try:
+                get_sweep_state = event_loop_thread_exec(api.get_sweep_state)
+                state = await get_sweep_state(
+                    sweep=launch_spec["sweep_id"],
+                    entity=launch_spec["entity"],
+                    project=launch_spec["project"],
+                )
+            except Exception as e:
+                self._internal_logger.debug(f"Fetch sweep state error: {e}")
+                state = None
+
+            if state != "RUNNING" and state != "PAUSED":
+                raise LaunchError(
+                    f"Launch agent picked up sweep job, but sweep ({launch_spec['sweep_id']}) was in a terminal state ({state})"
+                )
+
+    async def _check_run_finished(
+        self, job_tracker: JobAndRunStatusTracker, launch_spec: Dict[str, Any]
+    ) -> bool:
+        if job_tracker.completed_status:
+            return True
+
+        # the run can be done before the run has started
+        # but can also be none if the run failed to start
+        # so if there is no run, either the run hasn't started yet
+        # or it has failed
+        if job_tracker.run is None:
+            if job_tracker.failed_to_start:
+                return True
+            return False
+
+        known_error = False
+        try:
+            run = job_tracker.run
+            status = await run.get_status()
+            state = status.state
+
+            for warning in status.messages:
+                if warning not in self._known_warnings:
+                    self._known_warnings.append(warning)
+                    success = self._api.update_run_queue_item_warning(
+                        job_tracker.run_queue_item_id,
+                        warning,
+                        "Kubernetes",
+                        [],
+                    )
+                    if not success:
+                        _logger.warning(
+                            f"Error adding warning {warning} to run queue item {job_tracker.run_queue_item_id}"
+                        )
+                        self._known_warnings.remove(warning)
+
+            if state == "preempted" and job_tracker.entity == self._entity:
+                config = launch_spec.copy()
+                config["run_id"] = job_tracker.run_id
+                config["_resume_count"] = config.get("_resume_count", 0) + 1
+                with self._jobs_lock:
+                    job_tracker.completed_status = state
+                if config["_resume_count"] > MAX_RESUME_COUNT:
+                    wandb.termlog(
+                        f"{LOG_PREFIX}Run {job_tracker.run_id} has already resumed {MAX_RESUME_COUNT} times."
+                    )
+                    return True
+                wandb.termlog(
+                    f"{LOG_PREFIX}Run {job_tracker.run_id} was preempted, requeueing..."
+                )
+
+                if "sweep_id" in config:
+                    # allow resumed runs from sweeps that have already completed by removing
+                    # the sweep id before pushing to queue
+                    del config["sweep_id"]
+
+                launch_add(
+                    config=config,
+                    project_queue=self._project,
+                    queue_name=job_tracker.queue,
+                )
+                return True
+            # TODO change these statuses to an enum
+            if state in ["stopped", "failed", "finished", "preempted"]:
+                if job_tracker.is_scheduler:
+                    wandb.termlog(f"{LOG_PREFIX}Scheduler finished with ID: {run.id}")
+                    if state == "failed":
+                        # on fail, update sweep state. scheduler run_id should == sweep_id
+                        try:
+                            self._api.set_sweep_state(
+                                sweep=job_tracker.run_id,
+                                entity=job_tracker.entity,
+                                project=job_tracker.project,
+                                state="CANCELED",
+                            )
+                        except Exception as e:
+                            raise LaunchError(f"Failed to update sweep state: {e}")
+                else:
+                    wandb.termlog(f"{LOG_PREFIX}Job finished with ID: {run.id}")
+                with self._jobs_lock:
+                    job_tracker.completed_status = state
+                return True
+
+            return False
+        except LaunchError as e:
+            wandb.termerror(
+                f"{LOG_PREFIX}Terminating job {run.id} because it failed to start: {str(e)}"
+            )
+            known_error = True
+            with self._jobs_lock:
+                job_tracker.failed_to_start = True
+        # TODO: make get_status robust to errors for each runner, and handle them
+        except Exception as e:
+            wandb.termerror(f"{LOG_PREFIX}Error getting status for job {run.id}")
+            wandb.termerror(traceback.format_exc())
+            _logger.info("---")
+            _logger.info("Caught exception while getting status.")
+            _logger.info(f"Job ID: {run.id}")
+            _logger.info(traceback.format_exc())
+            _logger.info("---")
+            wandb._sentry.exception(e)
+        return known_error
+
+    async def get_job_and_queue(self) -> Optional[JobSpecAndQueue]:
+        for queue in self._queues:
+            job = await self.pop_from_queue(queue)
+            if job is not None:
+                self._queues.remove(queue)
+                self._queues.append(queue)
+                return JobSpecAndQueue(job, queue)
+        return None
+
+    def _set_queue_and_rqi_in_project(
+        self, project: LaunchProject, job: Dict[str, Any], queue: str
+    ) -> None:
+        project.queue_name = queue
+
+        # queue entity currently always matches the agent
+        project.queue_entity = self._entity
+        project.run_queue_item_id = job["runQueueItemId"]

parrot/lib/python3.10/site-packages/wandb/sdk/launch/agent/config.py

@@ -0,0 +1,296 @@
+"""Definition of the config object used by the Launch agent."""
+
+from enum import Enum
+from typing import List, Optional
+
+# ValidationError is imported for exception type checking purposes only.
+from pydantic import (  # type: ignore
+    BaseModel,
+    Field,
+    ValidationError,  # noqa: F401
+    root_validator,
+    validator,
+)
+
+import wandb
+from wandb.sdk.launch.utils import (
+    AZURE_BLOB_REGEX,
+    AZURE_CONTAINER_REGISTRY_URI_REGEX,
+    ELASTIC_CONTAINER_REGISTRY_URI_REGEX,
+    GCP_ARTIFACT_REGISTRY_URI_REGEX,
+    GCS_URI_RE,
+    S3_URI_RE,
+)
+
+__all__ = [
+    "ValidationError",
+    "AgentConfig",
+]
+
+
+class EnvironmentType(str, Enum):
+    """Enum of valid environment types."""
+
+    aws = "aws"
+    gcp = "gcp"
+    azure = "azure"
+
+
+class RegistryType(str, Enum):
+    """Enum of valid registry types."""
+
+    ecr = "ecr"
+    acr = "acr"
+    gcr = "gcr"
+
+
+class BuilderType(str, Enum):
+    """Enum of valid builder types."""
+
+    docker = "docker"
+    kaniko = "kaniko"
+    noop = "noop"
+
+
+class TargetPlatform(str, Enum):
+    """Enum of valid target platforms."""
+
+    linux_amd64 = "linux/amd64"
+    linux_arm64 = "linux/arm64"
+
+
+class RegistryConfig(BaseModel):
+    """Configuration for registry block.
+
+    Note that we don't forbid extra fields here because:
+    - We want to allow all fields supported by each registry
+    - We will perform validation on the registry object itself later
+    - Registry block is being deprecated in favor of destination field in builder
+    """
+
+    type: Optional[RegistryType] = Field(
+        None,
+        description="The type of registry to use.",
+    )
+    uri: Optional[str] = Field(
+        None,
+        description="The URI of the registry.",
+    )
+
+    @validator("uri")  # type: ignore
+    @classmethod
+    def validate_uri(cls, uri: str) -> str:
+        return validate_registry_uri(uri)
+
+
+class EnvironmentConfig(BaseModel):
+    """Configuration for the environment block."""
+
+    type: Optional[EnvironmentType] = Field(
+        None,
+        description="The type of environment to use.",
+    )
+    region: Optional[str] = Field(..., description="The region to use.")
+
+    class Config:
+        extra = "allow"
+
+    @root_validator(pre=True)  # type: ignore
+    @classmethod
+    def check_extra_fields(cls, values: dict) -> dict:
+        """Check for extra fields and print a warning."""
+        for key in values:
+            if key not in ["type", "region"]:
+                wandb.termwarn(
+                    f"Unrecognized field {key} in environment block. Please check your config file."
+                )
+        return values
+
+
+class BuilderConfig(BaseModel):
+    type: Optional[BuilderType] = Field(
+        None,
+        description="The type of builder to use.",
+    )
+    destination: Optional[str] = Field(
+        None,
+        description="The destination to use for the built image. If not provided, "
+        "the image will be pushed to the registry.",
+    )
+
+    platform: Optional[TargetPlatform] = Field(
+        None,
+        description="The platform to use for the built image. If not provided, "
+        "the platform will be detected automatically.",
+    )
+
+    build_context_store: Optional[str] = Field(
+        None,
+        description="The build context store to use. Required for kaniko builds.",
+        alias="build-context-store",
+    )
+    build_job_name: Optional[str] = Field(
+        "wandb-launch-container-build",
+        description="Name prefix of the build job.",
+        alias="build-job-name",
+    )
+    secret_name: Optional[str] = Field(
+        None,
+        description="The name of the secret to use for the build job.",
+        alias="secret-name",
+    )
+    secret_key: Optional[str] = Field(
+        None,
+        description="The key of the secret to use for the build job.",
+        alias="secret-key",
+    )
+    kaniko_image: Optional[str] = Field(
+        "gcr.io/kaniko-project/executor:latest",
+        description="The image to use for the kaniko executor.",
+        alias="kaniko-image",
+    )
+
+    @validator("build_context_store")  # type: ignore
+    @classmethod
+    def validate_build_context_store(
+        cls, build_context_store: Optional[str]
+    ) -> Optional[str]:
+        """Validate that the build context store is a valid container registry URI."""
+        if build_context_store is None:
+            return None
+        for regex in [
+            S3_URI_RE,
+            GCS_URI_RE,
+            AZURE_BLOB_REGEX,
+        ]:
+            if regex.match(build_context_store):
+                return build_context_store
+        raise ValueError(
+            "Invalid build context store. Build context store must be a URI for an "
+            "S3 bucket, GCS bucket, or Azure blob."
+        )
+
+    @root_validator(pre=True)  # type: ignore
+    @classmethod
+    def validate_docker(cls, values: dict) -> dict:
+        """Right now there are no required fields for docker builds."""
+        return values
+
+    @validator("destination")  # type: ignore
+    @classmethod
+    def validate_destination(cls, destination: Optional[str]) -> Optional[str]:
+        """Validate that the destination is a valid container registry URI."""
+        if destination is None:
+            return None
+        return validate_registry_uri(destination)
+
+
+class AgentConfig(BaseModel):
+    """Configuration for the Launch agent."""
+
+    queues: List[str] = Field(
+        default=[],
+        description="The queues to use for this agent.",
+    )
+    entity: Optional[str] = Field(
+        description="The W&B entity to use for this agent.",
+    )
+    max_jobs: Optional[int] = Field(
+        1,
+        description="The maximum number of jobs to run concurrently.",
+    )
+    max_schedulers: Optional[int] = Field(
+        1,
+        description="The maximum number of sweep schedulers to run concurrently.",
+    )
+    secure_mode: Optional[bool] = Field(
+        False,
+        description="Whether to use secure mode for this agent. If True, the "
+        "agent will reject runs that attempt to override the entrypoint or image.",
+    )
+    registry: Optional[RegistryConfig] = Field(
+        None,
+        description="The registry to use.",
+    )
+    environment: Optional[EnvironmentConfig] = Field(
+        None,
+        description="The environment to use.",
+    )
+    builder: Optional[BuilderConfig] = Field(
+        None,
+        description="The builder to use.",
+    )
+    verbosity: Optional[int] = Field(
+        0,
+        description="How verbose to print, 0 = default, 1 = verbose, 2 = very verbose",
+    )
+    stopped_run_timeout: Optional[int] = Field(
+        60,
+        description="How many seconds to wait after receiving the stop command before forcibly cancelling a run.",
+    )
+
+    class Config:
+        extra = "forbid"
+
+
+def validate_registry_uri(uri: str) -> str:
+    """Validate that the registry URI is a valid container registry URI.
+
+    The URI should resolve to an image name in a container registry. The recognized
+    formats are for ECR, ACR, and GCP Artifact Registry. If the URI does not match
+    any of these formats, a warning is printed indicating the registry type is not
+    recognized and the agent can't guarantee that images can be pushed.
+
+    If the format is recognized but does not resolve to an image name, an
+    error is raised. For example, if the URI is an ECR URI but does not include
+    an image name or includes a tag as well as an image name, an error is raised.
+    """
+    tag_msg = (
+        "Destination for built images may not include a tag, but the URI provided "
+        "includes the suffix '{tag}'. Please remove the tag and try again. The agent "
+        "will automatically tag each image with a unique hash of the source code."
+    )
+    if uri.startswith("https://"):
+        uri = uri[8:]
+
+    match = GCP_ARTIFACT_REGISTRY_URI_REGEX.match(uri)
+    if match:
+        if match.group("tag"):
+            raise ValueError(tag_msg.format(tag=match.group("tag")))
+        if not match.group("image_name"):
+            raise ValueError(
+                "An image name must be specified in the URI for a GCP Artifact Registry. "
+                "Please provide a uri with the format "
+                "'https://<region>-docker.pkg.dev/<project>/<repository>/<image>'."
+            )
+        return uri
+
+    match = AZURE_CONTAINER_REGISTRY_URI_REGEX.match(uri)
+    if match:
+        if match.group("tag"):
+            raise ValueError(tag_msg.format(tag=match.group("tag")))
+        if not match.group("repository"):
+            raise ValueError(
+                "A repository name must be specified in the URI for an "
+                "Azure Container Registry. Please provide a uri with the format "
+                "'https://<registry-name>.azurecr.io/<repository>'."
+            )
+        return uri
+
+    match = ELASTIC_CONTAINER_REGISTRY_URI_REGEX.match(uri)
+    if match:
+        if match.group("tag"):
+            raise ValueError(tag_msg.format(tag=match.group("tag")))
+        if not match.group("repository"):
+            raise ValueError(
+                "A repository name must be specified in the URI for an "
+                "Elastic Container Registry. Please provide a uri with the format "
+                "'https://<account-id>.dkr.ecr.<region>.amazonaws.com/<repository>'."
+            )
+        return uri
+
+    wandb.termwarn(
+        f"Unable to recognize registry type in URI {uri}. You are responsible "
+        "for ensuring the agent can push images to this registry."
+    )
+    return uri

parrot/lib/python3.10/site-packages/wandb/sdk/launch/agent/job_status_tracker.py

@@ -0,0 +1,53 @@
+import logging
+from dataclasses import dataclass
+from typing import Optional
+
+from wandb.apis.internal import Api
+from wandb.errors import CommError
+from wandb.sdk.launch._project_spec import LaunchProject
+
+from ..runner.abstract import AbstractRun
+from ..utils import event_loop_thread_exec
+from .run_queue_item_file_saver import RunQueueItemFileSaver
+
+_logger = logging.getLogger(__name__)
+
+
+@dataclass
+class JobAndRunStatusTracker:
+    run_queue_item_id: str
+    queue: str
+    saver: RunQueueItemFileSaver
+    run_id: Optional[str] = None
+    project: Optional[str] = None
+    entity: Optional[str] = None
+    run: Optional[AbstractRun] = None
+    failed_to_start: bool = False
+    completed_status: Optional[str] = None
+    is_scheduler: bool = False
+    err_stage: str = "agent"
+
+    @property
+    def job_completed(self) -> bool:
+        return self.failed_to_start or self.completed_status is not None
+
+    def update_run_info(self, launch_project: LaunchProject) -> None:
+        self.run_id = launch_project.run_id
+        self.project = launch_project.target_project
+        self.entity = launch_project.target_entity
+
+    def set_err_stage(self, stage: str) -> None:
+        self.err_stage = stage
+
+    async def check_wandb_run_stopped(self, api: Api) -> bool:
+        assert (
+            self.run_id is not None
+            and self.project is not None
+            and self.entity is not None
+        ), "Job tracker does not contain run info. Update with run info before checking if run stopped"
+        check_stop = event_loop_thread_exec(api.api.check_stop_requested)
+        try:
+            return bool(await check_stop(self.project, self.entity, self.run_id))
+        except CommError as e:
+            _logger.error(f"CommError when checking if wandb run stopped: {e}")
+        return False

parrot/lib/python3.10/site-packages/wandb/sdk/launch/agent/run_queue_item_file_saver.py

@@ -0,0 +1,45 @@
+"""Implementation of the run queue item file saver class."""
+
+import os
+import sys
+from typing import List, Optional
+
+import wandb
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+FileSubtypes = Literal["warning", "error"]
+
+
+class RunQueueItemFileSaver:
+    def __init__(
+        self,
+        agent_run: Optional["wandb.sdk.wandb_run.Run"],
+        run_queue_item_id: str,
+    ):
+        self.run_queue_item_id = run_queue_item_id
+        self.run = agent_run
+
+    def save_contents(
+        self, contents: str, fname: str, file_sub_type: FileSubtypes
+    ) -> Optional[List[str]]:
+        if not isinstance(self.run, wandb.sdk.wandb_run.Run):
+            wandb.termwarn("Not saving file contents because agent has no run")
+            return None
+        root_dir = self.run._settings.files_dir
+        saved_run_path = os.path.join(self.run_queue_item_id, file_sub_type, fname)
+        local_path = os.path.join(root_dir, saved_run_path)
+        os.makedirs(os.path.dirname(local_path), exist_ok=True)
+        with open(local_path, "w") as f:
+            f.write(contents)
+        res = self.run.save(local_path, base_path=root_dir, policy="now")
+        if isinstance(res, list):
+            return [saved_run_path]
+        else:
+            wandb.termwarn(
+                f"Failed to save files for run queue item: {self.run_queue_item_id}"
+            )
+            return None

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

@@ -0,0 +1,528 @@
+import json
+import logging
+import os
+import re
+import sys
+import tempfile
+from typing import Any, Dict, List, Optional, Tuple
+
+import wandb
+from wandb.apis.internal import Api
+from wandb.sdk.artifacts.artifact import Artifact
+from wandb.sdk.internal.job_builder import JobBuilder
+from wandb.sdk.launch.git_reference import GitReference
+from wandb.sdk.launch.utils import (
+    _is_git_uri,
+    get_current_python_version,
+    get_entrypoint_file,
+)
+from wandb.sdk.lib import filesystem
+from wandb.util import make_artifact_name_safe
+
+logging.basicConfig(stream=sys.stdout, level=logging.INFO)
+_logger = logging.getLogger("wandb")
+
+
+CODE_ARTIFACT_EXCLUDE_PATHS = ["wandb", ".git"]
+
+
+def create_job(
+    path: str,
+    job_type: str,
+    entity: Optional[str] = None,
+    project: Optional[str] = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    aliases: Optional[List[str]] = None,
+    runtime: Optional[str] = None,
+    entrypoint: Optional[str] = None,
+    git_hash: Optional[str] = None,
+    build_context: Optional[str] = None,
+    dockerfile: Optional[str] = None,
+) -> Optional[Artifact]:
+    """Create a job from a path, not as the output of a run.
+
+    Arguments:
+        path (str): Path to the job directory.
+        job_type (str): Type of the job. One of "git", "code", or "image".
+        entity (Optional[str]): Entity to create the job under.
+        project (Optional[str]): Project to create the job under.
+        name (Optional[str]): Name of the job.
+        description (Optional[str]): Description of the job.
+        aliases (Optional[List[str]]): Aliases for the job.
+        runtime (Optional[str]): Python runtime of the job, like 3.9.
+        entrypoint (Optional[str]): Entrypoint of the job. If build_context is
+            provided, path is relative to build_context.
+        git_hash (Optional[str]): Git hash of a specific commit, when using git type jobs.
+        build_context (Optional[str]): Path to the build context, when using image type jobs.
+        dockerfile (Optional[str]): Path to the Dockerfile, when using image type jobs.
+            If build_context is provided, path is relative to build_context.
+
+    Returns:
+        Optional[Artifact]: The artifact created by the job, the action (for printing), and job aliases.
+                            None if job creation failed.
+
+    Example:
+        ```python
+        artifact_job = wandb.create_job(
+            job_type="code",
+            path=".",
+            entity="wandb",
+            project="jobs",
+            name="my-train-job",
+            description="My training job",
+            aliases=["train"],
+            runtime="3.9",
+            entrypoint="train.py",
+        )
+        # then run the newly created job
+        artifact_job.call()
+        ```
+    """
+    api = Api()
+
+    artifact_job, _action, _aliases = _create_job(
+        api,
+        job_type,
+        path,
+        entity,
+        project,
+        name,
+        description,
+        aliases,
+        runtime,
+        entrypoint,
+        git_hash,
+        build_context,
+        dockerfile,
+    )
+
+    return artifact_job
+
+
+def _create_job(
+    api: Api,
+    job_type: str,
+    path: str,
+    entity: Optional[str] = None,
+    project: Optional[str] = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    aliases: Optional[List[str]] = None,
+    runtime: Optional[str] = None,
+    entrypoint: Optional[str] = None,
+    git_hash: Optional[str] = None,
+    build_context: Optional[str] = None,
+    dockerfile: Optional[str] = None,
+    base_image: Optional[str] = None,
+) -> Tuple[Optional[Artifact], str, List[str]]:
+    wandb.termlog(f"Creating launch job of type: {job_type}...")
+
+    if name and name != make_artifact_name_safe(name):
+        wandb.termerror(
+            f"Artifact names may only contain alphanumeric characters, dashes, underscores, and dots. Did you mean: {make_artifact_name_safe(name)}"
+        )
+        return None, "", []
+
+    if runtime is not None:
+        if not re.match(r"^3\.\d+$", runtime):
+            wandb.termerror(
+                f"Runtime (-r, --runtime) must be a minor version of Python 3, "
+                f"e.g. 3.9 or 3.10, received {runtime}"
+            )
+            return None, "", []
+    aliases = aliases or []
+    tempdir = tempfile.TemporaryDirectory()
+    try:
+        metadata, requirements = _make_metadata_for_partial_job(
+            job_type=job_type,
+            tempdir=tempdir,
+            git_hash=git_hash,
+            runtime=runtime,
+            path=path,
+            entrypoint=entrypoint,
+        )
+        if not metadata:
+            return None, "", []
+    except Exception as e:
+        wandb.termerror(f"Error creating job: {e}")
+        return None, "", []
+
+    _dump_metadata_and_requirements(
+        metadata=metadata,
+        tmp_path=tempdir.name,
+        requirements=requirements,
+    )
+
+    try:
+        # init hidden wandb run with job building disabled (handled manually)
+        run = wandb.init(
+            dir=tempdir.name,
+            settings={"silent": True, "disable_job_creation": True},
+            entity=entity,
+            project=project,
+            job_type="cli_create_job",
+        )
+    except Exception:
+        # Error printed by wandb.init
+        return None, "", []
+
+    job_builder = _configure_job_builder_for_partial(tempdir.name, job_source=job_type)
+    if job_type == "code":
+        assert entrypoint is not None
+        job_name = _make_code_artifact(
+            api=api,
+            job_builder=job_builder,
+            path=path,
+            entrypoint=entrypoint,
+            run=run,  # type: ignore
+            entity=entity,
+            project=project,
+            name=name,
+        )
+        if not job_name:
+            return None, "", []
+        name = job_name
+
+    # build job artifact, loads wandb-metadata and creates wandb-job.json here
+    artifact = job_builder.build(
+        api.api,
+        dockerfile=dockerfile,
+        build_context=build_context,
+        base_image=base_image,
+    )
+    if not artifact:
+        wandb.termerror("JobBuilder failed to build a job")
+        _logger.debug("Failed to build job, check job source and metadata")
+        return None, "", []
+
+    if not name:
+        name = artifact.name
+
+    aliases += job_builder._aliases
+    if "latest" not in aliases:
+        aliases += ["latest"]
+
+    res, _ = api.create_artifact(
+        artifact_type_name="job",
+        artifact_collection_name=name,
+        digest=artifact.digest,
+        client_id=artifact._client_id,
+        sequence_client_id=artifact._sequence_client_id,
+        entity_name=entity,
+        project_name=project,
+        run_name=run.id,  # type: ignore # run will be deleted after creation
+        description=description,
+        metadata={"_partial": True},
+        is_user_created=True,
+        aliases=[{"artifactCollectionName": name, "alias": a} for a in aliases],
+    )
+    action = "No changes detected for"
+    if not res.get("artifactSequence", {}).get("latestArtifact"):
+        # When there is no latestArtifact, we are creating new
+        action = "Created"
+    elif res.get("state") == "PENDING":
+        # updating an existing artifafct, state is pending awaiting call to
+        # log_artifact to upload and finalize artifact. If not pending, digest
+        # is the same as latestArtifact, so no changes detected
+        action = "Updated"
+
+    run.log_artifact(artifact, aliases=aliases)  # type: ignore
+    artifact.wait()
+    run.finish()  # type: ignore
+
+    # fetch, then delete hidden run
+    _run = wandb.Api().run(f"{entity}/{project}/{run.id}")  # type: ignore
+    _run.delete()
+
+    return artifact, action, aliases
+
+
+def _make_metadata_for_partial_job(
+    job_type: str,
+    tempdir: tempfile.TemporaryDirectory,
+    git_hash: Optional[str],
+    runtime: Optional[str],
+    path: str,
+    entrypoint: Optional[str],
+) -> Tuple[Optional[Dict[str, Any]], Optional[List[str]]]:
+    """Create metadata for partial jobs, return metadata and requirements."""
+    metadata = {}
+    if job_type == "git":
+        assert entrypoint is not None
+        repo_metadata = _create_repo_metadata(
+            path=path,
+            tempdir=tempdir.name,
+            entrypoint=entrypoint,
+            git_hash=git_hash,
+            runtime=runtime,
+        )
+        if not repo_metadata:
+            tempdir.cleanup()  # otherwise git can pollute
+            return None, None
+        metadata.update(repo_metadata)
+        return metadata, None
+
+    if job_type == "code":
+        assert entrypoint is not None
+        artifact_metadata, requirements = _create_artifact_metadata(
+            path=path, entrypoint=entrypoint, runtime=runtime
+        )
+        if not artifact_metadata:
+            return None, None
+        metadata.update(artifact_metadata)
+        return metadata, requirements
+
+    if job_type == "image":
+        if runtime:
+            wandb.termwarn(
+                "Setting runtime is not supported for image jobs, ignoring runtime"
+            )
+        # TODO(gst): support entrypoint for image based jobs
+        if entrypoint:
+            wandb.termwarn(
+                "Setting an entrypoint is not currently supported for image jobs, ignoring entrypoint argument"
+            )
+        metadata.update({"python": runtime or "", "docker": path})
+        return metadata, None
+
+    wandb.termerror(f"Invalid job type: {job_type}")
+    return None, None
+
+
+def _maybe_warn_python_no_executable(entrypoint: str):
+    entrypoint_list = entrypoint.split(" ")
+    if len(entrypoint_list) == 1 and entrypoint_list[0].endswith(".py"):
+        wandb.termwarn(
+            f"Entrypoint {entrypoint} is a python file without an executable, you may want to use `python {entrypoint}` as the entrypoint instead."
+        )
+
+
+def _create_repo_metadata(
+    path: str,
+    tempdir: str,
+    entrypoint: str,
+    git_hash: Optional[str] = None,
+    runtime: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    # Make sure the entrypoint doesn't contain any backward path traversal
+    if entrypoint and ".." in entrypoint:
+        wandb.termerror("Entrypoint cannot contain backward path traversal")
+        return None
+
+    _maybe_warn_python_no_executable(entrypoint)
+
+    if not _is_git_uri(path):
+        wandb.termerror("Path must be a git URI")
+        return None
+
+    ref = GitReference(path, git_hash)
+    if not ref:
+        wandb.termerror("Could not parse git URI")
+        return None
+
+    ref.fetch(tempdir)
+
+    commit = ref.commit_hash
+    if not commit:
+        if not ref.commit_hash:
+            wandb.termerror("Could not find git commit hash")
+            return None
+        commit = ref.commit_hash
+
+    local_dir = os.path.join(tempdir, ref.path or "")
+    python_version = runtime
+    if not python_version:
+        if os.path.exists(os.path.join(local_dir, "runtime.txt")):
+            with open(os.path.join(local_dir, "runtime.txt")) as f:
+                python_version = f.read().strip()
+        elif os.path.exists(os.path.join(local_dir, ".python-version")):
+            with open(os.path.join(local_dir, ".python-version")) as f:
+                python_version = f.read().strip().splitlines()[0]
+        else:
+            python_version, _ = get_current_python_version()
+
+    python_version = _clean_python_version(python_version)
+
+    metadata = {
+        "git": {
+            "commit": commit,
+            "remote": ref.url,
+        },
+        "entrypoint": entrypoint.split(" "),
+        "python": python_version,  # used to build container
+        "notebook": False,  # partial jobs from notebooks not supported
+    }
+
+    return metadata
+
+
+def _create_artifact_metadata(
+    path: str, entrypoint: str, runtime: Optional[str] = None
+) -> Tuple[Optional[Dict[str, Any]], Optional[List[str]]]:
+    if not os.path.isdir(path):
+        wandb.termerror("Path must be a valid file or directory")
+        return {}, []
+
+    _maybe_warn_python_no_executable(entrypoint)
+
+    entrypoint_list = entrypoint.split(" ")
+    entrypoint_file = get_entrypoint_file(entrypoint_list)
+
+    # read local requirements.txt and dump to temp dir for builder
+    requirements = []
+    depspath = os.path.join(path, "requirements.txt")
+    if os.path.exists(depspath):
+        with open(depspath) as f:
+            requirements = f.read().splitlines()
+
+    if not any(["wandb" in r for r in requirements]):
+        wandb.termwarn("wandb is not present in requirements.txt.")
+
+    if runtime:
+        python_version = _clean_python_version(runtime)
+    else:
+        python_version, _ = get_current_python_version()
+        python_version = _clean_python_version(python_version)
+
+    metadata = {
+        "python": python_version,
+        "codePath": entrypoint_file,
+        "entrypoint": entrypoint_list,
+    }
+    return metadata, requirements
+
+
+def _configure_job_builder_for_partial(tmpdir: str, job_source: str) -> JobBuilder:
+    """Configure job builder with temp dir and job source."""
+    # adjust git source to repo
+    if job_source == "git":
+        job_source = "repo"
+
+    # adjust code source to artifact
+    if job_source == "code":
+        job_source = "artifact"
+
+    settings = wandb.Settings()
+    settings.update({"files_dir": tmpdir, "job_source": job_source})
+    job_builder = JobBuilder(
+        settings=settings,  # type: ignore
+        verbose=True,
+    )
+    job_builder._partial = True
+    # never allow notebook runs
+    job_builder._is_notebook_run = False
+    # set run inputs and outputs to empty dicts
+    job_builder.set_config({})
+    job_builder.set_summary({})
+    return job_builder
+
+
+def _make_code_artifact(
+    api: Api,
+    job_builder: JobBuilder,
+    run: "wandb.sdk.wandb_run.Run",
+    path: str,
+    entrypoint: str,
+    entity: Optional[str],
+    project: Optional[str],
+    name: Optional[str],
+) -> Optional[str]:
+    """Helper for creating and logging code artifacts.
+
+    Returns the name of the eventual job.
+    """
+    entrypoint_list = entrypoint.split(" ")
+    # We no longer require the entrypoint to end in an existing file. But we
+    # need something to use as the default job artifact name. In the future we
+    # may require the user to provide a job name explicitly when calling
+    # wandb job create.
+    entrypoint_file = entrypoint_list[-1]
+    artifact_name = _make_code_artifact_name(os.path.join(path, entrypoint_file), name)
+    code_artifact = wandb.Artifact(
+        name=artifact_name,
+        type="code",
+        description="Code artifact for job",
+    )
+
+    try:
+        code_artifact.add_dir(path)
+    except Exception as e:
+        if os.path.islink(path):
+            wandb.termerror(
+                "Symlinks are not supported for code artifact jobs, please copy the code into a directory and try again"
+            )
+        wandb.termerror(f"Error adding to code artifact: {e}")
+        return None
+
+    # Remove paths we don't want to include, if present
+    for item in CODE_ARTIFACT_EXCLUDE_PATHS:
+        try:
+            code_artifact.remove(item)
+        except FileNotFoundError:
+            pass
+
+    res, _ = api.create_artifact(
+        artifact_type_name="code",
+        artifact_collection_name=artifact_name,
+        digest=code_artifact.digest,
+        client_id=code_artifact._client_id,
+        sequence_client_id=code_artifact._sequence_client_id,
+        entity_name=entity,
+        project_name=project,
+        run_name=run.id,  # run will be deleted after creation
+        description="Code artifact for job",
+        metadata={"codePath": path, "entrypoint": entrypoint_file},
+        is_user_created=True,
+        aliases=[
+            {"artifactCollectionName": artifact_name, "alias": a} for a in ["latest"]
+        ],
+    )
+    run.log_artifact(code_artifact)
+    code_artifact.wait()
+    job_builder._handle_server_artifact(res, code_artifact)  # type: ignore
+
+    # code artifacts have "code" prefix, remove it and alias
+    if not name:
+        name = code_artifact.name.replace("code", "job").split(":")[0]
+
+    return name
+
+
+def _make_code_artifact_name(path: str, name: Optional[str]) -> str:
+    """Make a code artifact name from a path and user provided name."""
+    if name:
+        return f"code-{name}"
+
+    clean_path = path.replace("./", "")
+    if clean_path[0] == "/":
+        clean_path = clean_path[1:]
+    if clean_path[-1] == "/":
+        clean_path = clean_path[:-1]
+
+    path_name = f"code-{make_artifact_name_safe(clean_path)}"
+    return path_name
+
+
+def _dump_metadata_and_requirements(
+    tmp_path: str, metadata: Dict[str, Any], requirements: Optional[List[str]]
+) -> None:
+    """Dump manufactured metadata and requirements.txt.
+
+    File used by the job_builder to create a job from provided metadata.
+    """
+    filesystem.mkdir_exists_ok(tmp_path)
+    with open(os.path.join(tmp_path, "wandb-metadata.json"), "w") as f:
+        json.dump(metadata, f)
+
+    requirements = requirements or []
+    with open(os.path.join(tmp_path, "requirements.txt"), "w") as f:
+        f.write("\n".join(requirements))
+
+
+def _clean_python_version(python_version: str) -> str:
+    # remove micro if present
+    if python_version.count(".") > 1:
+        python_version = ".".join(python_version.split(".")[:2])
+        _logger.debug(f"micro python version stripped. Now: {python_version}")
+    return python_version

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

@@ -0,0 +1,29 @@
+"""Abstract base class for environments."""
+
+from abc import ABC, abstractmethod
+
+
+class AbstractEnvironment(ABC):
+    """Abstract base class for environments."""
+
+    region: str
+
+    @abstractmethod
+    async def verify(self) -> None:
+        """Verify that the environment is configured correctly."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def upload_file(self, source: str, destination: str) -> None:
+        """Upload a file from the local filesystem to storage in the environment."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def upload_dir(self, source: str, destination: str) -> None:
+        """Upload the contents of a directory from the local filesystem to the environment."""
+        raise NotImplementedError
+
+    @abstractmethod
+    async def verify_storage_uri(self, uri: str) -> None:
+        """Verify that the storage URI is configured correctly."""
+        raise NotImplementedError