Add files using upload-large-folder tool

.gitattributes

@@ -142,3 +142,6 @@ parrot/lib/python3.10/site-packages/wandb/vendor/pynvml/__pycache__/pynvml.cpyth
 parrot/lib/python3.10/site-packages/cv2/qt/fonts/DejaVuSans-BoldOblique.ttf filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/pyarrow/_fs.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/cv2/qt/fonts/DejaVuSans-Bold.ttf filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libreadline.a filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/wandb/vendor/pygments/lexers/__pycache__/_php_builtins.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/aiohttp/_http_writer.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

parrot/lib/libreadline.a

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34edb0aaf24f86fa37e869bb46389534179d560e141a744b15d854497148663a
+size 749782

parrot/lib/python3.10/site-packages/aiohttp/_http_writer.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5436569093dd69cf0f00b018a9189d08fb2ddd45b65049de429719f1540fa777
+size 459376

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

@@ -0,0 +1,4 @@
+#
+NOTIFY_PROCESS = 1
+NOTIFY_SHUTDOWN = 2
+NOTIFY_REQUEST = 3

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

@@ -0,0 +1,996 @@
+"""Interface base class - Used to send messages to the internal process.
+
+InterfaceBase: The abstract class
+InterfaceShared: Common routines for socket and queue based implementations
+InterfaceQueue: Use multiprocessing queues to send and receive messages
+InterfaceSock: Use socket to send and receive messages
+InterfaceRelay: Responses are routed to a relay queue (not matching uuids)
+
+"""
+
+import gzip
+import logging
+import os
+import sys
+import time
+from abc import abstractmethod
+from pathlib import Path
+from secrets import token_hex
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    NewType,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from wandb import termwarn
+from wandb.proto import wandb_internal_pb2 as pb
+from wandb.proto import wandb_telemetry_pb2 as tpb
+from wandb.sdk.artifacts.artifact import Artifact
+from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
+from wandb.sdk.artifacts.staging import get_staging_dir
+from wandb.sdk.lib import json_util as json
+from wandb.util import (
+    WandBJSONEncoderOld,
+    get_h5_typename,
+    json_dumps_safer,
+    json_dumps_safer_history,
+    json_friendly,
+    json_friendly_val,
+    maybe_compress_summary,
+)
+
+from ..data_types.utils import history_dict_to_json, val_to_json
+from ..lib.mailbox import MailboxHandle
+from . import summary_record as sr
+from .message_future import MessageFuture
+
+MANIFEST_FILE_SIZE_THRESHOLD = 100_000
+
+GlobStr = NewType("GlobStr", str)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, TypedDict
+else:
+    from typing_extensions import Literal, TypedDict
+
+PolicyName = Literal["now", "live", "end"]
+
+
+class FilesDict(TypedDict):
+    files: Iterable[Tuple[GlobStr, PolicyName]]
+
+
+if TYPE_CHECKING:
+    from ..wandb_run import Run
+
+
+logger = logging.getLogger("wandb")
+
+
+def file_policy_to_enum(policy: "PolicyName") -> "pb.FilesItem.PolicyType.V":
+    if policy == "now":
+        enum = pb.FilesItem.PolicyType.NOW
+    elif policy == "end":
+        enum = pb.FilesItem.PolicyType.END
+    elif policy == "live":
+        enum = pb.FilesItem.PolicyType.LIVE
+    return enum
+
+
+def file_enum_to_policy(enum: "pb.FilesItem.PolicyType.V") -> "PolicyName":
+    if enum == pb.FilesItem.PolicyType.NOW:
+        policy: PolicyName = "now"
+    elif enum == pb.FilesItem.PolicyType.END:
+        policy = "end"
+    elif enum == pb.FilesItem.PolicyType.LIVE:
+        policy = "live"
+    return policy
+
+
+class InterfaceBase:
+    _run: Optional["Run"]
+    _drop: bool
+
+    def __init__(self) -> None:
+        self._run = None
+        self._drop = False
+
+    def _hack_set_run(self, run: "Run") -> None:
+        self._run = run
+        current_pid = os.getpid()
+        self._run._set_iface_pid(current_pid)
+
+    def publish_header(self) -> None:
+        header = pb.HeaderRecord()
+        self._publish_header(header)
+
+    @abstractmethod
+    def _publish_header(self, header: pb.HeaderRecord) -> None:
+        raise NotImplementedError
+
+    def deliver_status(self) -> MailboxHandle:
+        return self._deliver_status(pb.StatusRequest())
+
+    @abstractmethod
+    def _deliver_status(
+        self,
+        status: pb.StatusRequest,
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    def _make_config(
+        self,
+        data: Optional[dict] = None,
+        key: Optional[Union[Tuple[str, ...], str]] = None,
+        val: Optional[Any] = None,
+        obj: Optional[pb.ConfigRecord] = None,
+    ) -> pb.ConfigRecord:
+        config = obj or pb.ConfigRecord()
+        if data:
+            for k, v in data.items():
+                update = config.update.add()
+                update.key = k
+                update.value_json = json_dumps_safer(json_friendly(v)[0])
+        if key:
+            update = config.update.add()
+            if isinstance(key, tuple):
+                for k in key:
+                    update.nested_key.append(k)
+            else:
+                update.key = key
+            update.value_json = json_dumps_safer(json_friendly(val)[0])
+        return config
+
+    def _make_run(self, run: "Run") -> pb.RunRecord:
+        proto_run = pb.RunRecord()
+        run._make_proto_run(proto_run)
+        if run._settings.host:
+            proto_run.host = run._settings.host
+        if run._config is not None:
+            config_dict = run._config._as_dict()  # type: ignore
+            self._make_config(data=config_dict, obj=proto_run.config)
+        if run._telemetry_obj:
+            proto_run.telemetry.MergeFrom(run._telemetry_obj)
+        return proto_run
+
+    def publish_run(self, run: "Run") -> None:
+        run_record = self._make_run(run)
+        self._publish_run(run_record)
+
+    @abstractmethod
+    def _publish_run(self, run: pb.RunRecord) -> None:
+        raise NotImplementedError
+
+    def publish_cancel(self, cancel_slot: str) -> None:
+        cancel = pb.CancelRequest(cancel_slot=cancel_slot)
+        self._publish_cancel(cancel)
+
+    @abstractmethod
+    def _publish_cancel(self, cancel: pb.CancelRequest) -> None:
+        raise NotImplementedError
+
+    def publish_config(
+        self,
+        data: Optional[dict] = None,
+        key: Optional[Union[Tuple[str, ...], str]] = None,
+        val: Optional[Any] = None,
+    ) -> None:
+        cfg = self._make_config(data=data, key=key, val=val)
+
+        self._publish_config(cfg)
+
+    @abstractmethod
+    def _publish_config(self, cfg: pb.ConfigRecord) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _publish_metric(self, metric: pb.MetricRecord) -> None:
+        raise NotImplementedError
+
+    def _make_summary_from_dict(self, summary_dict: dict) -> pb.SummaryRecord:
+        summary = pb.SummaryRecord()
+        for k, v in summary_dict.items():
+            update = summary.update.add()
+            update.key = k
+            update.value_json = json.dumps(v)
+        return summary
+
+    def _summary_encode(self, value: Any, path_from_root: str) -> dict:
+        """Normalize, compress, and encode sub-objects for backend storage.
+
+        value: Object to encode.
+        path_from_root: `str` dot separated string from the top-level summary to the
+            current `value`.
+
+        Returns:
+            A new tree of dict's with large objects replaced with dictionaries
+            with "_type" entries that say which type the original data was.
+        """
+        # Constructs a new `dict` tree in `json_value` that discards and/or
+        # encodes objects that aren't JSON serializable.
+
+        if isinstance(value, dict):
+            json_value = {}
+            for key, value in value.items():  # noqa: B020
+                json_value[key] = self._summary_encode(
+                    value, path_from_root + "." + key
+                )
+            return json_value
+        else:
+            friendly_value, converted = json_friendly(
+                val_to_json(self._run, path_from_root, value, namespace="summary")
+            )
+            json_value, compressed = maybe_compress_summary(
+                friendly_value, get_h5_typename(value)
+            )
+            if compressed:
+                # TODO(jhr): impleement me
+                pass
+                # self.write_h5(path_from_root, friendly_value)
+
+            return json_value
+
+    def _make_summary(self, summary_record: sr.SummaryRecord) -> pb.SummaryRecord:
+        pb_summary_record = pb.SummaryRecord()
+
+        for item in summary_record.update:
+            pb_summary_item = pb_summary_record.update.add()
+            key_length = len(item.key)
+
+            assert key_length > 0
+
+            if key_length > 1:
+                pb_summary_item.nested_key.extend(item.key)
+            else:
+                pb_summary_item.key = item.key[0]
+
+            path_from_root = ".".join(item.key)
+            json_value = self._summary_encode(item.value, path_from_root)
+            json_value, _ = json_friendly(json_value)  # type: ignore
+
+            pb_summary_item.value_json = json.dumps(
+                json_value,
+                cls=WandBJSONEncoderOld,
+            )
+
+        for item in summary_record.remove:
+            pb_summary_item = pb_summary_record.remove.add()
+            key_length = len(item.key)
+
+            assert key_length > 0
+
+            if key_length > 1:
+                pb_summary_item.nested_key.extend(item.key)
+            else:
+                pb_summary_item.key = item.key[0]
+
+        return pb_summary_record
+
+    def publish_summary(self, summary_record: sr.SummaryRecord) -> None:
+        pb_summary_record = self._make_summary(summary_record)
+        self._publish_summary(pb_summary_record)
+
+    @abstractmethod
+    def _publish_summary(self, summary: pb.SummaryRecord) -> None:
+        raise NotImplementedError
+
+    def _make_files(self, files_dict: "FilesDict") -> pb.FilesRecord:
+        files = pb.FilesRecord()
+        for path, policy in files_dict["files"]:
+            f = files.files.add()
+            f.path = path
+            f.policy = file_policy_to_enum(policy)
+        return files
+
+    def publish_files(self, files_dict: "FilesDict") -> None:
+        files = self._make_files(files_dict)
+        self._publish_files(files)
+
+    @abstractmethod
+    def _publish_files(self, files: pb.FilesRecord) -> None:
+        raise NotImplementedError
+
+    def publish_python_packages(self, working_set) -> None:
+        python_packages = pb.PythonPackagesRequest()
+        for pkg in working_set:
+            python_packages.package.add(name=pkg.key, version=pkg.version)
+        self._publish_python_packages(python_packages)
+
+    @abstractmethod
+    def _publish_python_packages(
+        self, python_packages: pb.PythonPackagesRequest
+    ) -> None:
+        raise NotImplementedError
+
+    def _make_artifact(self, artifact: "Artifact") -> pb.ArtifactRecord:
+        proto_artifact = pb.ArtifactRecord()
+        proto_artifact.type = artifact.type
+        proto_artifact.name = artifact.name
+        proto_artifact.client_id = artifact._client_id
+        proto_artifact.sequence_client_id = artifact._sequence_client_id
+        proto_artifact.digest = artifact.digest
+        if artifact.distributed_id:
+            proto_artifact.distributed_id = artifact.distributed_id
+        if artifact.description:
+            proto_artifact.description = artifact.description
+        if artifact.metadata:
+            proto_artifact.metadata = json.dumps(json_friendly_val(artifact.metadata))
+        if artifact._base_id:
+            proto_artifact.base_id = artifact._base_id
+
+        ttl_duration_input = artifact._ttl_duration_seconds_to_gql()
+        if ttl_duration_input:
+            proto_artifact.ttl_duration_seconds = ttl_duration_input
+        proto_artifact.incremental_beta1 = artifact.incremental
+        self._make_artifact_manifest(artifact.manifest, obj=proto_artifact.manifest)
+        return proto_artifact
+
+    def _make_artifact_manifest(
+        self,
+        artifact_manifest: ArtifactManifest,
+        obj: Optional[pb.ArtifactManifest] = None,
+    ) -> pb.ArtifactManifest:
+        proto_manifest = obj or pb.ArtifactManifest()
+        proto_manifest.version = artifact_manifest.version()
+        proto_manifest.storage_policy = artifact_manifest.storage_policy.name()
+
+        # Very large manifests need to be written to file to avoid protobuf size limits.
+        if len(artifact_manifest) > MANIFEST_FILE_SIZE_THRESHOLD:
+            path = self._write_artifact_manifest_file(artifact_manifest)
+            proto_manifest.manifest_file_path = path
+            return proto_manifest
+
+        for k, v in artifact_manifest.storage_policy.config().items() or {}.items():
+            cfg = proto_manifest.storage_policy_config.add()
+            cfg.key = k
+            cfg.value_json = json.dumps(v)
+
+        for entry in sorted(artifact_manifest.entries.values(), key=lambda k: k.path):
+            proto_entry = proto_manifest.contents.add()
+            proto_entry.path = entry.path
+            proto_entry.digest = entry.digest
+            if entry.size:
+                proto_entry.size = entry.size
+            if entry.birth_artifact_id:
+                proto_entry.birth_artifact_id = entry.birth_artifact_id
+            if entry.ref:
+                proto_entry.ref = entry.ref
+            if entry.local_path:
+                proto_entry.local_path = entry.local_path
+            proto_entry.skip_cache = entry.skip_cache
+            for k, v in entry.extra.items():
+                proto_extra = proto_entry.extra.add()
+                proto_extra.key = k
+                proto_extra.value_json = json.dumps(v)
+        return proto_manifest
+
+    def _write_artifact_manifest_file(self, manifest: ArtifactManifest) -> str:
+        manifest_dir = Path(get_staging_dir()) / "artifact_manifests"
+        manifest_dir.mkdir(parents=True, exist_ok=True)
+        # It would be simpler to use `manifest.to_json()`, but that gets very slow for
+        # large manifests since it encodes the whole thing as a single JSON object.
+        filename = f"{time.time()}_{token_hex(8)}.manifest_contents.jl.gz"
+        manifest_file_path = manifest_dir / filename
+        with gzip.open(manifest_file_path, mode="wt", compresslevel=1) as f:
+            for entry in manifest.entries.values():
+                f.write(f"{json.dumps(entry.to_json())}\n")
+        return str(manifest_file_path)
+
+    def deliver_link_artifact(
+        self,
+        run: "Run",
+        artifact: "Artifact",
+        portfolio_name: str,
+        aliases: Iterable[str],
+        entity: Optional[str] = None,
+        project: Optional[str] = None,
+    ) -> MailboxHandle:
+        link_artifact = pb.LinkArtifactRequest()
+        if artifact.is_draft():
+            link_artifact.client_id = artifact._client_id
+        else:
+            link_artifact.server_id = artifact.id if artifact.id else ""
+        link_artifact.portfolio_name = portfolio_name
+        link_artifact.portfolio_entity = entity or run.entity
+        link_artifact.portfolio_project = project or run.project
+        link_artifact.portfolio_aliases.extend(aliases)
+
+        return self._deliver_link_artifact(link_artifact)
+
+    @abstractmethod
+    def _deliver_link_artifact(
+        self, link_artifact: pb.LinkArtifactRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    @staticmethod
+    def _make_partial_source_str(
+        source: Any, job_info: Dict[str, Any], metadata: Dict[str, Any]
+    ) -> str:
+        """Construct use_artifact.partial.source_info.source as str."""
+        source_type = job_info.get("source_type", "").strip()
+        if source_type == "artifact":
+            info_source = job_info.get("source", {})
+            source.artifact.artifact = info_source.get("artifact", "")
+            source.artifact.entrypoint.extend(info_source.get("entrypoint", []))
+            source.artifact.notebook = info_source.get("notebook", False)
+            build_context = info_source.get("build_context")
+            if build_context:
+                source.artifact.build_context = build_context
+            dockerfile = info_source.get("dockerfile")
+            if dockerfile:
+                source.artifact.dockerfile = dockerfile
+        elif source_type == "repo":
+            source.git.git_info.remote = metadata.get("git", {}).get("remote", "")
+            source.git.git_info.commit = metadata.get("git", {}).get("commit", "")
+            source.git.entrypoint.extend(metadata.get("entrypoint", []))
+            source.git.notebook = metadata.get("notebook", False)
+            build_context = metadata.get("build_context")
+            if build_context:
+                source.git.build_context = build_context
+            dockerfile = metadata.get("dockerfile")
+            if dockerfile:
+                source.git.dockerfile = dockerfile
+        elif source_type == "image":
+            source.image.image = metadata.get("docker", "")
+        else:
+            raise ValueError("Invalid source type")
+
+        source_str: str = source.SerializeToString()
+        return source_str
+
+    def _make_proto_use_artifact(
+        self,
+        use_artifact: pb.UseArtifactRecord,
+        job_name: str,
+        job_info: Dict[str, Any],
+        metadata: Dict[str, Any],
+    ) -> pb.UseArtifactRecord:
+        use_artifact.partial.job_name = job_name
+        use_artifact.partial.source_info._version = job_info.get("_version", "")
+        use_artifact.partial.source_info.source_type = job_info.get("source_type", "")
+        use_artifact.partial.source_info.runtime = job_info.get("runtime", "")
+
+        src_str = self._make_partial_source_str(
+            source=use_artifact.partial.source_info.source,
+            job_info=job_info,
+            metadata=metadata,
+        )
+        use_artifact.partial.source_info.source.ParseFromString(src_str)  # type: ignore[arg-type]
+
+        return use_artifact
+
+    def publish_use_artifact(
+        self,
+        artifact: "Artifact",
+    ) -> None:
+        assert artifact.id is not None, "Artifact must have an id"
+
+        use_artifact = pb.UseArtifactRecord(
+            id=artifact.id,
+            type=artifact.type,
+            name=artifact.name,
+        )
+
+        # TODO(gst): move to internal process
+        if "_partial" in artifact.metadata:
+            # Download source info from logged partial job artifact
+            job_info = {}
+            try:
+                path = artifact.get_entry("wandb-job.json").download()
+                with open(path) as f:
+                    job_info = json.load(f)
+
+            except Exception as e:
+                logger.warning(
+                    f"Failed to download partial job info from artifact {artifact}, : {e}"
+                )
+                termwarn(
+                    f"Failed to download partial job info from artifact {artifact}, : {e}"
+                )
+                return
+
+            try:
+                use_artifact = self._make_proto_use_artifact(
+                    use_artifact=use_artifact,
+                    job_name=artifact.name,
+                    job_info=job_info,
+                    metadata=artifact.metadata,
+                )
+            except Exception as e:
+                logger.warning(f"Failed to construct use artifact proto: {e}")
+                termwarn(f"Failed to construct use artifact proto: {e}")
+                return
+
+        self._publish_use_artifact(use_artifact)
+
+    @abstractmethod
+    def _publish_use_artifact(self, proto_artifact: pb.UseArtifactRecord) -> None:
+        raise NotImplementedError
+
+    def communicate_artifact(
+        self,
+        run: "Run",
+        artifact: "Artifact",
+        aliases: Iterable[str],
+        tags: Optional[Iterable[str]] = None,
+        history_step: Optional[int] = None,
+        is_user_created: bool = False,
+        use_after_commit: bool = False,
+        finalize: bool = True,
+    ) -> MessageFuture:
+        proto_run = self._make_run(run)
+        proto_artifact = self._make_artifact(artifact)
+        proto_artifact.run_id = proto_run.run_id
+        proto_artifact.project = proto_run.project
+        proto_artifact.entity = proto_run.entity
+        proto_artifact.user_created = is_user_created
+        proto_artifact.use_after_commit = use_after_commit
+        proto_artifact.finalize = finalize
+
+        proto_artifact.aliases.extend(aliases or [])
+        proto_artifact.tags.extend(tags or [])
+
+        log_artifact = pb.LogArtifactRequest()
+        log_artifact.artifact.CopyFrom(proto_artifact)
+        if history_step is not None:
+            log_artifact.history_step = history_step
+        log_artifact.staging_dir = get_staging_dir()
+        resp = self._communicate_artifact(log_artifact)
+        return resp
+
+    @abstractmethod
+    def _communicate_artifact(
+        self, log_artifact: pb.LogArtifactRequest
+    ) -> MessageFuture:
+        raise NotImplementedError
+
+    def deliver_download_artifact(
+        self,
+        artifact_id: str,
+        download_root: str,
+        allow_missing_references: bool,
+        skip_cache: bool,
+        path_prefix: Optional[str],
+    ) -> MailboxHandle:
+        download_artifact = pb.DownloadArtifactRequest()
+        download_artifact.artifact_id = artifact_id
+        download_artifact.download_root = download_root
+        download_artifact.allow_missing_references = allow_missing_references
+        download_artifact.skip_cache = skip_cache
+        download_artifact.path_prefix = path_prefix or ""
+        resp = self._deliver_download_artifact(download_artifact)
+        return resp
+
+    @abstractmethod
+    def _deliver_download_artifact(
+        self, download_artifact: pb.DownloadArtifactRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    def publish_artifact(
+        self,
+        run: "Run",
+        artifact: "Artifact",
+        aliases: Iterable[str],
+        tags: Optional[Iterable[str]] = None,
+        is_user_created: bool = False,
+        use_after_commit: bool = False,
+        finalize: bool = True,
+    ) -> None:
+        proto_run = self._make_run(run)
+        proto_artifact = self._make_artifact(artifact)
+        proto_artifact.run_id = proto_run.run_id
+        proto_artifact.project = proto_run.project
+        proto_artifact.entity = proto_run.entity
+        proto_artifact.user_created = is_user_created
+        proto_artifact.use_after_commit = use_after_commit
+        proto_artifact.finalize = finalize
+        proto_artifact.aliases.extend(aliases or [])
+        proto_artifact.tags.extend(tags or [])
+        self._publish_artifact(proto_artifact)
+
+    @abstractmethod
+    def _publish_artifact(self, proto_artifact: pb.ArtifactRecord) -> None:
+        raise NotImplementedError
+
+    def publish_tbdata(self, log_dir: str, save: bool, root_logdir: str = "") -> None:
+        tbrecord = pb.TBRecord()
+        tbrecord.log_dir = log_dir
+        tbrecord.save = save
+        tbrecord.root_dir = root_logdir
+        self._publish_tbdata(tbrecord)
+
+    @abstractmethod
+    def _publish_tbdata(self, tbrecord: pb.TBRecord) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _publish_telemetry(self, telem: tpb.TelemetryRecord) -> None:
+        raise NotImplementedError
+
+    def publish_partial_history(
+        self,
+        data: dict,
+        user_step: int,
+        step: Optional[int] = None,
+        flush: Optional[bool] = None,
+        publish_step: bool = True,
+        run: Optional["Run"] = None,
+    ) -> None:
+        run = run or self._run
+
+        data = history_dict_to_json(run, data, step=user_step, ignore_copy_err=True)
+        data.pop("_step", None)
+
+        # add timestamp to the history request, if not already present
+        # the timestamp might come from the tensorboard log logic
+        if "_timestamp" not in data:
+            data["_timestamp"] = time.time()
+
+        partial_history = pb.PartialHistoryRequest()
+        for k, v in data.items():
+            item = partial_history.item.add()
+            item.key = k
+            item.value_json = json_dumps_safer_history(v)
+
+        if publish_step and step is not None:
+            partial_history.step.num = step
+        if flush is not None:
+            partial_history.action.flush = flush
+        self._publish_partial_history(partial_history)
+
+    @abstractmethod
+    def _publish_partial_history(self, history: pb.PartialHistoryRequest) -> None:
+        raise NotImplementedError
+
+    def publish_history(
+        self,
+        data: dict,
+        step: Optional[int] = None,
+        run: Optional["Run"] = None,
+        publish_step: bool = True,
+    ) -> None:
+        run = run or self._run
+        data = history_dict_to_json(run, data, step=step)
+        history = pb.HistoryRecord()
+        if publish_step:
+            assert step is not None
+            history.step.num = step
+        data.pop("_step", None)
+        for k, v in data.items():
+            item = history.item.add()
+            item.key = k
+            item.value_json = json_dumps_safer_history(v)
+        self._publish_history(history)
+
+    @abstractmethod
+    def _publish_history(self, history: pb.HistoryRecord) -> None:
+        raise NotImplementedError
+
+    def publish_preempting(self) -> None:
+        preempt_rec = pb.RunPreemptingRecord()
+        self._publish_preempting(preempt_rec)
+
+    @abstractmethod
+    def _publish_preempting(self, preempt_rec: pb.RunPreemptingRecord) -> None:
+        raise NotImplementedError
+
+    def publish_output(self, name: str, data: str) -> None:
+        # from vendor.protobuf import google3.protobuf.timestamp
+        # ts = timestamp.Timestamp()
+        # ts.GetCurrentTime()
+        # now = datetime.now()
+        if name == "stdout":
+            otype = pb.OutputRecord.OutputType.STDOUT
+        elif name == "stderr":
+            otype = pb.OutputRecord.OutputType.STDERR
+        else:
+            # TODO(jhr): throw error?
+            print("unknown type")
+        o = pb.OutputRecord(output_type=otype, line=data)
+        o.timestamp.GetCurrentTime()
+        self._publish_output(o)
+
+    @abstractmethod
+    def _publish_output(self, outdata: pb.OutputRecord) -> None:
+        raise NotImplementedError
+
+    def publish_output_raw(self, name: str, data: str) -> None:
+        # from vendor.protobuf import google3.protobuf.timestamp
+        # ts = timestamp.Timestamp()
+        # ts.GetCurrentTime()
+        # now = datetime.now()
+        if name == "stdout":
+            otype = pb.OutputRawRecord.OutputType.STDOUT
+        elif name == "stderr":
+            otype = pb.OutputRawRecord.OutputType.STDERR
+        else:
+            # TODO(jhr): throw error?
+            print("unknown type")
+        o = pb.OutputRawRecord(output_type=otype, line=data)
+        o.timestamp.GetCurrentTime()
+        self._publish_output_raw(o)
+
+    @abstractmethod
+    def _publish_output_raw(self, outdata: pb.OutputRawRecord) -> None:
+        raise NotImplementedError
+
+    def publish_pause(self) -> None:
+        pause = pb.PauseRequest()
+        self._publish_pause(pause)
+
+    @abstractmethod
+    def _publish_pause(self, pause: pb.PauseRequest) -> None:
+        raise NotImplementedError
+
+    def publish_resume(self) -> None:
+        resume = pb.ResumeRequest()
+        self._publish_resume(resume)
+
+    @abstractmethod
+    def _publish_resume(self, resume: pb.ResumeRequest) -> None:
+        raise NotImplementedError
+
+    def publish_alert(
+        self, title: str, text: str, level: str, wait_duration: int
+    ) -> None:
+        proto_alert = pb.AlertRecord()
+        proto_alert.title = title
+        proto_alert.text = text
+        proto_alert.level = level
+        proto_alert.wait_duration = wait_duration
+        self._publish_alert(proto_alert)
+
+    @abstractmethod
+    def _publish_alert(self, alert: pb.AlertRecord) -> None:
+        raise NotImplementedError
+
+    def _make_exit(self, exit_code: Optional[int]) -> pb.RunExitRecord:
+        exit = pb.RunExitRecord()
+        if exit_code is not None:
+            exit.exit_code = exit_code
+        return exit
+
+    def publish_exit(self, exit_code: Optional[int]) -> None:
+        exit_data = self._make_exit(exit_code)
+        self._publish_exit(exit_data)
+
+    @abstractmethod
+    def _publish_exit(self, exit_data: pb.RunExitRecord) -> None:
+        raise NotImplementedError
+
+    def publish_keepalive(self) -> None:
+        keepalive = pb.KeepaliveRequest()
+        self._publish_keepalive(keepalive)
+
+    @abstractmethod
+    def _publish_keepalive(self, keepalive: pb.KeepaliveRequest) -> None:
+        raise NotImplementedError
+
+    def publish_job_input(
+        self,
+        include_paths: List[List[str]],
+        exclude_paths: List[List[str]],
+        input_schema: Optional[dict],
+        run_config: bool = False,
+        file_path: str = "",
+    ):
+        """Publishes a request to add inputs to the job.
+
+        If run_config is True, the wandb.config will be added as a job input.
+        If file_path is provided, the file at file_path will be added as a job
+        input.
+
+        The paths provided as arguments are sequences of dictionary keys that
+        specify a path within the wandb.config. If a path is included, the
+        corresponding field will be treated as a job input. If a path is
+        excluded, the corresponding field will not be treated as a job input.
+
+        Args:
+            include_paths: paths within config to include as job inputs.
+            exclude_paths: paths within config to exclude as job inputs.
+            input_schema: A JSON Schema describing which attributes will be
+                editable from the Launch drawer.
+            run_config: bool indicating whether wandb.config is the input source.
+            file_path: path to file to include as a job input.
+        """
+        if run_config and file_path:
+            raise ValueError(
+                "run_config and file_path are mutually exclusive arguments."
+            )
+        request = pb.JobInputRequest()
+        include_records = [pb.JobInputPath(path=path) for path in include_paths]
+        exclude_records = [pb.JobInputPath(path=path) for path in exclude_paths]
+        request.include_paths.extend(include_records)
+        request.exclude_paths.extend(exclude_records)
+        source = pb.JobInputSource(
+            run_config=pb.JobInputSource.RunConfigSource(),
+        )
+        if run_config:
+            source.run_config.CopyFrom(pb.JobInputSource.RunConfigSource())
+        else:
+            source.file.CopyFrom(
+                pb.JobInputSource.ConfigFileSource(path=file_path),
+            )
+        request.input_source.CopyFrom(source)
+        if input_schema:
+            request.input_schema = json_dumps_safer(input_schema)
+
+        return self._publish_job_input(request)
+
+    @abstractmethod
+    def _publish_job_input(self, request: pb.JobInputRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    def join(self) -> None:
+        # Drop indicates that the internal process has already been shutdown
+        if self._drop:
+            return
+        _ = self._communicate_shutdown()
+
+    @abstractmethod
+    def _communicate_shutdown(self) -> None:
+        raise NotImplementedError
+
+    def deliver_run(self, run: "Run") -> MailboxHandle:
+        run_record = self._make_run(run)
+        return self._deliver_run(run_record)
+
+    def deliver_sync(
+        self,
+        start_offset: int,
+        final_offset: int,
+        entity: Optional[str] = None,
+        project: Optional[str] = None,
+        run_id: Optional[str] = None,
+        skip_output_raw: Optional[bool] = None,
+    ) -> MailboxHandle:
+        sync = pb.SyncRequest(
+            start_offset=start_offset,
+            final_offset=final_offset,
+        )
+        if entity:
+            sync.overwrite.entity = entity
+        if project:
+            sync.overwrite.project = project
+        if run_id:
+            sync.overwrite.run_id = run_id
+        if skip_output_raw:
+            sync.skip.output_raw = skip_output_raw
+        return self._deliver_sync(sync)
+
+    @abstractmethod
+    def _deliver_sync(self, sync: pb.SyncRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _deliver_run(self, run: pb.RunRecord) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_run_start(self, run_pb: pb.RunRecord) -> MailboxHandle:
+        run_start = pb.RunStartRequest()
+        run_start.run.CopyFrom(run_pb)
+        return self._deliver_run_start(run_start)
+
+    @abstractmethod
+    def _deliver_run_start(self, run_start: pb.RunStartRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_attach(self, attach_id: str) -> MailboxHandle:
+        attach = pb.AttachRequest(attach_id=attach_id)
+        return self._deliver_attach(attach)
+
+    @abstractmethod
+    def _deliver_attach(self, status: pb.AttachRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_check_version(
+        self, current_version: Optional[str] = None
+    ) -> MailboxHandle:
+        check_version = pb.CheckVersionRequest()
+        if current_version:
+            check_version.current_version = current_version
+        return self._deliver_check_version(check_version)
+
+    @abstractmethod
+    def _deliver_check_version(
+        self, check_version: pb.CheckVersionRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_stop_status(self) -> MailboxHandle:
+        status = pb.StopStatusRequest()
+        return self._deliver_stop_status(status)
+
+    @abstractmethod
+    def _deliver_stop_status(self, status: pb.StopStatusRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_network_status(self) -> MailboxHandle:
+        status = pb.NetworkStatusRequest()
+        return self._deliver_network_status(status)
+
+    @abstractmethod
+    def _deliver_network_status(self, status: pb.NetworkStatusRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_internal_messages(self) -> MailboxHandle:
+        internal_message = pb.InternalMessagesRequest()
+        return self._deliver_internal_messages(internal_message)
+
+    @abstractmethod
+    def _deliver_internal_messages(
+        self, internal_message: pb.InternalMessagesRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_get_summary(self) -> MailboxHandle:
+        get_summary = pb.GetSummaryRequest()
+        return self._deliver_get_summary(get_summary)
+
+    @abstractmethod
+    def _deliver_get_summary(self, get_summary: pb.GetSummaryRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_get_system_metrics(self) -> MailboxHandle:
+        get_summary = pb.GetSystemMetricsRequest()
+        return self._deliver_get_system_metrics(get_summary)
+
+    @abstractmethod
+    def _deliver_get_system_metrics(
+        self, get_summary: pb.GetSystemMetricsRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_exit(self, exit_code: Optional[int]) -> MailboxHandle:
+        exit_data = self._make_exit(exit_code)
+        return self._deliver_exit(exit_data)
+
+    @abstractmethod
+    def _deliver_exit(self, exit_data: pb.RunExitRecord) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_poll_exit(self) -> MailboxHandle:
+        poll_exit = pb.PollExitRequest()
+        return self._deliver_poll_exit(poll_exit)
+
+    @abstractmethod
+    def _deliver_poll_exit(self, poll_exit: pb.PollExitRequest) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_request_server_info(self) -> MailboxHandle:
+        server_info = pb.ServerInfoRequest()
+        return self._deliver_request_server_info(server_info)
+
+    @abstractmethod
+    def _deliver_request_server_info(
+        self, server_info: pb.ServerInfoRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_request_sampled_history(self) -> MailboxHandle:
+        sampled_history = pb.SampledHistoryRequest()
+        return self._deliver_request_sampled_history(sampled_history)
+
+    @abstractmethod
+    def _deliver_request_sampled_history(
+        self, sampled_history: pb.SampledHistoryRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError
+
+    def deliver_request_run_status(self) -> MailboxHandle:
+        run_status = pb.RunStatusRequest()
+        return self._deliver_request_run_status(run_status)
+
+    @abstractmethod
+    def _deliver_request_run_status(
+        self, run_status: pb.RunStatusRequest
+    ) -> MailboxHandle:
+        raise NotImplementedError

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

@@ -0,0 +1,59 @@
+"""InterfaceQueue - Derived from InterfaceShared using queues to send to internal thread.
+
+See interface.py for how interface classes relate to each other.
+
+"""
+
+import logging
+from multiprocessing.process import BaseProcess
+from typing import TYPE_CHECKING, Optional
+
+from ..lib import tracelog
+from ..lib.mailbox import Mailbox
+from .interface_shared import InterfaceShared
+from .router_queue import MessageQueueRouter
+
+if TYPE_CHECKING:
+    from queue import Queue
+
+    from wandb.proto import wandb_internal_pb2 as pb
+
+
+logger = logging.getLogger("wandb")
+
+
+class InterfaceQueue(InterfaceShared):
+    record_q: Optional["Queue[pb.Record]"]
+    result_q: Optional["Queue[pb.Result]"]
+    _mailbox: Optional[Mailbox]
+
+    def __init__(
+        self,
+        record_q: Optional["Queue[pb.Record]"] = None,
+        result_q: Optional["Queue[pb.Result]"] = None,
+        process: Optional[BaseProcess] = None,
+        process_check: bool = True,
+        mailbox: Optional[Mailbox] = None,
+    ) -> None:
+        self.record_q = record_q
+        self.result_q = result_q
+        if self.record_q:
+            tracelog.annotate_queue(self.record_q, "record_q")
+        if self.result_q:
+            tracelog.annotate_queue(self.result_q, "result_q")
+        super().__init__(process=process, process_check=process_check, mailbox=mailbox)
+
+    def _init_router(self) -> None:
+        if self.record_q and self.result_q:
+            self._router = MessageQueueRouter(
+                self.record_q, self.result_q, mailbox=self._mailbox
+            )
+
+    def _publish(self, record: "pb.Record", local: Optional[bool] = None) -> None:
+        if self._process_check and self._process and not self._process.is_alive():
+            raise Exception("The wandb backend process has shutdown")
+        if local:
+            record.control.local = local
+        if self.record_q:
+            tracelog.log_message_queue(record, self.record_q)
+            self.record_q.put(record)

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

@@ -0,0 +1,53 @@
+"""InterfaceRelay - Derived from InterfaceQueue using RelayRouter to preserve uuid req/resp.
+
+See interface.py for how interface classes relate to each other.
+
+"""
+
+import logging
+from multiprocessing.process import BaseProcess
+from typing import TYPE_CHECKING, Optional
+
+from wandb.proto import wandb_internal_pb2 as pb
+
+from ..lib.mailbox import Mailbox
+from .interface_queue import InterfaceQueue
+from .router_relay import MessageRelayRouter
+
+if TYPE_CHECKING:
+    from queue import Queue
+
+
+logger = logging.getLogger("wandb")
+
+
+class InterfaceRelay(InterfaceQueue):
+    _mailbox: Mailbox
+    relay_q: Optional["Queue[pb.Result]"]
+
+    def __init__(
+        self,
+        mailbox: Mailbox,
+        record_q: Optional["Queue[pb.Record]"] = None,
+        result_q: Optional["Queue[pb.Result]"] = None,
+        relay_q: Optional["Queue[pb.Result]"] = None,
+        process: Optional[BaseProcess] = None,
+        process_check: bool = True,
+    ) -> None:
+        self.relay_q = relay_q
+        super().__init__(
+            record_q=record_q,
+            result_q=result_q,
+            process=process,
+            process_check=process_check,
+            mailbox=mailbox,
+        )
+
+    def _init_router(self) -> None:
+        if self.record_q and self.result_q and self.relay_q:
+            self._router = MessageRelayRouter(
+                request_queue=self.record_q,
+                response_queue=self.result_q,
+                relay_queue=self.relay_q,
+                mailbox=self._mailbox,
+            )

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

@@ -0,0 +1,549 @@
+"""InterfaceShared - Derived from InterfaceBase - shared with InterfaceQueue and InterfaceSock.
+
+See interface.py for how interface classes relate to each other.
+
+"""
+
+import logging
+import time
+from abc import abstractmethod
+from multiprocessing.process import BaseProcess
+from typing import Any, Optional, cast
+
+import wandb
+from wandb.proto import wandb_internal_pb2 as pb
+from wandb.proto import wandb_telemetry_pb2 as tpb
+from wandb.util import json_dumps_safer, json_friendly
+
+from ..lib.mailbox import Mailbox, MailboxHandle
+from .interface import InterfaceBase
+from .message_future import MessageFuture
+from .router import MessageRouter
+
+logger = logging.getLogger("wandb")
+
+
+class InterfaceShared(InterfaceBase):
+    process: Optional[BaseProcess]
+    _process_check: bool
+    _router: Optional[MessageRouter]
+    _mailbox: Optional[Mailbox]
+    _transport_success_timestamp: float
+    _transport_failed: bool
+
+    def __init__(
+        self,
+        process: Optional[BaseProcess] = None,
+        process_check: bool = True,
+        mailbox: Optional[Any] = None,
+    ) -> None:
+        super().__init__()
+        self._transport_success_timestamp = time.monotonic()
+        self._transport_failed = False
+        self._process = process
+        self._router = None
+        self._process_check = process_check
+        self._mailbox = mailbox
+        self._init_router()
+
+    @abstractmethod
+    def _init_router(self) -> None:
+        raise NotImplementedError
+
+    @property
+    def transport_failed(self) -> bool:
+        return self._transport_failed
+
+    @property
+    def transport_success_timestamp(self) -> float:
+        return self._transport_success_timestamp
+
+    def _transport_mark_failed(self) -> None:
+        self._transport_failed = True
+
+    def _transport_mark_success(self) -> None:
+        self._transport_success_timestamp = time.monotonic()
+
+    def _publish_output(self, outdata: pb.OutputRecord) -> None:
+        rec = pb.Record()
+        rec.output.CopyFrom(outdata)
+        self._publish(rec)
+
+    def _publish_cancel(self, cancel: pb.CancelRequest) -> None:
+        rec = self._make_request(cancel=cancel)
+        self._publish(rec)
+
+    def _publish_output_raw(self, outdata: pb.OutputRawRecord) -> None:
+        rec = pb.Record()
+        rec.output_raw.CopyFrom(outdata)
+        self._publish(rec)
+
+    def _publish_tbdata(self, tbrecord: pb.TBRecord) -> None:
+        rec = self._make_record(tbrecord=tbrecord)
+        self._publish(rec)
+
+    def _publish_partial_history(
+        self, partial_history: pb.PartialHistoryRequest
+    ) -> None:
+        rec = self._make_request(partial_history=partial_history)
+        self._publish(rec)
+
+    def _publish_history(self, history: pb.HistoryRecord) -> None:
+        rec = self._make_record(history=history)
+        self._publish(rec)
+
+    def _publish_preempting(self, preempt_rec: pb.RunPreemptingRecord) -> None:
+        rec = self._make_record(preempting=preempt_rec)
+        self._publish(rec)
+
+    def _publish_telemetry(self, telem: tpb.TelemetryRecord) -> None:
+        rec = self._make_record(telemetry=telem)
+        self._publish(rec)
+
+    def _publish_job_input(self, job_input: pb.JobInputRequest) -> MailboxHandle:
+        record = self._make_request(job_input=job_input)
+        return self._deliver_record(record)
+
+    def _make_stats(self, stats_dict: dict) -> pb.StatsRecord:
+        stats = pb.StatsRecord()
+        stats.stats_type = pb.StatsRecord.StatsType.SYSTEM
+        stats.timestamp.GetCurrentTime()  # todo: fix this, this is wrong :)
+        for k, v in stats_dict.items():
+            item = stats.item.add()
+            item.key = k
+            item.value_json = json_dumps_safer(json_friendly(v)[0])
+        return stats
+
+    def _make_login(self, api_key: Optional[str] = None) -> pb.LoginRequest:
+        login = pb.LoginRequest()
+        if api_key:
+            login.api_key = api_key
+        return login
+
+    def _make_request(  # noqa: C901
+        self,
+        login: Optional[pb.LoginRequest] = None,
+        get_summary: Optional[pb.GetSummaryRequest] = None,
+        pause: Optional[pb.PauseRequest] = None,
+        resume: Optional[pb.ResumeRequest] = None,
+        status: Optional[pb.StatusRequest] = None,
+        stop_status: Optional[pb.StopStatusRequest] = None,
+        internal_messages: Optional[pb.InternalMessagesRequest] = None,
+        network_status: Optional[pb.NetworkStatusRequest] = None,
+        poll_exit: Optional[pb.PollExitRequest] = None,
+        partial_history: Optional[pb.PartialHistoryRequest] = None,
+        sampled_history: Optional[pb.SampledHistoryRequest] = None,
+        run_start: Optional[pb.RunStartRequest] = None,
+        check_version: Optional[pb.CheckVersionRequest] = None,
+        log_artifact: Optional[pb.LogArtifactRequest] = None,
+        download_artifact: Optional[pb.DownloadArtifactRequest] = None,
+        link_artifact: Optional[pb.LinkArtifactRequest] = None,
+        defer: Optional[pb.DeferRequest] = None,
+        attach: Optional[pb.AttachRequest] = None,
+        server_info: Optional[pb.ServerInfoRequest] = None,
+        keepalive: Optional[pb.KeepaliveRequest] = None,
+        run_status: Optional[pb.RunStatusRequest] = None,
+        sender_mark: Optional[pb.SenderMarkRequest] = None,
+        sender_read: Optional[pb.SenderReadRequest] = None,
+        sync: Optional[pb.SyncRequest] = None,
+        status_report: Optional[pb.StatusReportRequest] = None,
+        cancel: Optional[pb.CancelRequest] = None,
+        summary_record: Optional[pb.SummaryRecordRequest] = None,
+        telemetry_record: Optional[pb.TelemetryRecordRequest] = None,
+        get_system_metrics: Optional[pb.GetSystemMetricsRequest] = None,
+        python_packages: Optional[pb.PythonPackagesRequest] = None,
+        job_input: Optional[pb.JobInputRequest] = None,
+    ) -> pb.Record:
+        request = pb.Request()
+        if login:
+            request.login.CopyFrom(login)
+        elif get_summary:
+            request.get_summary.CopyFrom(get_summary)
+        elif pause:
+            request.pause.CopyFrom(pause)
+        elif resume:
+            request.resume.CopyFrom(resume)
+        elif status:
+            request.status.CopyFrom(status)
+        elif stop_status:
+            request.stop_status.CopyFrom(stop_status)
+        elif internal_messages:
+            request.internal_messages.CopyFrom(internal_messages)
+        elif network_status:
+            request.network_status.CopyFrom(network_status)
+        elif poll_exit:
+            request.poll_exit.CopyFrom(poll_exit)
+        elif partial_history:
+            request.partial_history.CopyFrom(partial_history)
+        elif sampled_history:
+            request.sampled_history.CopyFrom(sampled_history)
+        elif run_start:
+            request.run_start.CopyFrom(run_start)
+        elif check_version:
+            request.check_version.CopyFrom(check_version)
+        elif log_artifact:
+            request.log_artifact.CopyFrom(log_artifact)
+        elif download_artifact:
+            request.download_artifact.CopyFrom(download_artifact)
+        elif link_artifact:
+            request.link_artifact.CopyFrom(link_artifact)
+        elif defer:
+            request.defer.CopyFrom(defer)
+        elif attach:
+            request.attach.CopyFrom(attach)
+        elif server_info:
+            request.server_info.CopyFrom(server_info)
+        elif keepalive:
+            request.keepalive.CopyFrom(keepalive)
+        elif run_status:
+            request.run_status.CopyFrom(run_status)
+        elif sender_mark:
+            request.sender_mark.CopyFrom(sender_mark)
+        elif sender_read:
+            request.sender_read.CopyFrom(sender_read)
+        elif cancel:
+            request.cancel.CopyFrom(cancel)
+        elif status_report:
+            request.status_report.CopyFrom(status_report)
+        elif summary_record:
+            request.summary_record.CopyFrom(summary_record)
+        elif telemetry_record:
+            request.telemetry_record.CopyFrom(telemetry_record)
+        elif get_system_metrics:
+            request.get_system_metrics.CopyFrom(get_system_metrics)
+        elif sync:
+            request.sync.CopyFrom(sync)
+        elif python_packages:
+            request.python_packages.CopyFrom(python_packages)
+        elif job_input:
+            request.job_input.CopyFrom(job_input)
+        else:
+            raise Exception("Invalid request")
+        record = self._make_record(request=request)
+        # All requests do not get persisted
+        record.control.local = True
+        if status_report:
+            record.control.flow_control = True
+        return record
+
+    def _make_record(  # noqa: C901
+        self,
+        run: Optional[pb.RunRecord] = None,
+        config: Optional[pb.ConfigRecord] = None,
+        files: Optional[pb.FilesRecord] = None,
+        summary: Optional[pb.SummaryRecord] = None,
+        history: Optional[pb.HistoryRecord] = None,
+        stats: Optional[pb.StatsRecord] = None,
+        exit: Optional[pb.RunExitRecord] = None,
+        artifact: Optional[pb.ArtifactRecord] = None,
+        tbrecord: Optional[pb.TBRecord] = None,
+        alert: Optional[pb.AlertRecord] = None,
+        final: Optional[pb.FinalRecord] = None,
+        metric: Optional[pb.MetricRecord] = None,
+        header: Optional[pb.HeaderRecord] = None,
+        footer: Optional[pb.FooterRecord] = None,
+        request: Optional[pb.Request] = None,
+        telemetry: Optional[tpb.TelemetryRecord] = None,
+        preempting: Optional[pb.RunPreemptingRecord] = None,
+        use_artifact: Optional[pb.UseArtifactRecord] = None,
+        output: Optional[pb.OutputRecord] = None,
+        output_raw: Optional[pb.OutputRawRecord] = None,
+    ) -> pb.Record:
+        record = pb.Record()
+        if run:
+            record.run.CopyFrom(run)
+        elif config:
+            record.config.CopyFrom(config)
+        elif summary:
+            record.summary.CopyFrom(summary)
+        elif history:
+            record.history.CopyFrom(history)
+        elif files:
+            record.files.CopyFrom(files)
+        elif stats:
+            record.stats.CopyFrom(stats)
+        elif exit:
+            record.exit.CopyFrom(exit)
+        elif artifact:
+            record.artifact.CopyFrom(artifact)
+        elif tbrecord:
+            record.tbrecord.CopyFrom(tbrecord)
+        elif alert:
+            record.alert.CopyFrom(alert)
+        elif final:
+            record.final.CopyFrom(final)
+        elif header:
+            record.header.CopyFrom(header)
+        elif footer:
+            record.footer.CopyFrom(footer)
+        elif request:
+            record.request.CopyFrom(request)
+        elif telemetry:
+            record.telemetry.CopyFrom(telemetry)
+        elif metric:
+            record.metric.CopyFrom(metric)
+        elif preempting:
+            record.preempting.CopyFrom(preempting)
+        elif use_artifact:
+            record.use_artifact.CopyFrom(use_artifact)
+        elif output:
+            record.output.CopyFrom(output)
+        elif output_raw:
+            record.output_raw.CopyFrom(output_raw)
+        else:
+            raise Exception("Invalid record")
+        return record
+
+    @abstractmethod
+    def _publish(self, record: pb.Record, local: Optional[bool] = None) -> None:
+        raise NotImplementedError
+
+    def _communicate(
+        self, rec: pb.Record, timeout: Optional[int] = 30, local: Optional[bool] = None
+    ) -> Optional[pb.Result]:
+        return self._communicate_async(rec, local=local).get(timeout=timeout)
+
+    def _communicate_async(
+        self, rec: pb.Record, local: Optional[bool] = None
+    ) -> MessageFuture:
+        assert self._router
+        if self._process_check and self._process and not self._process.is_alive():
+            raise Exception("The wandb backend process has shutdown")
+        future = self._router.send_and_receive(rec, local=local)
+        return future
+
+    def communicate_login(
+        self, api_key: Optional[str] = None, timeout: Optional[int] = 15
+    ) -> pb.LoginResponse:
+        login = self._make_login(api_key)
+        rec = self._make_request(login=login)
+        result = self._communicate(rec, timeout=timeout)
+        if result is None:
+            # TODO: friendlier error message here
+            raise wandb.Error(
+                "Couldn't communicate with backend after {} seconds".format(timeout)
+            )
+        login_response = result.response.login_response
+        assert login_response
+        return login_response
+
+    def _publish_defer(self, state: "pb.DeferRequest.DeferState.V") -> None:
+        defer = pb.DeferRequest(state=state)
+        rec = self._make_request(defer=defer)
+        self._publish(rec, local=True)
+
+    def publish_defer(self, state: int = 0) -> None:
+        self._publish_defer(cast("pb.DeferRequest.DeferState.V", state))
+
+    def _publish_header(self, header: pb.HeaderRecord) -> None:
+        rec = self._make_record(header=header)
+        self._publish(rec)
+
+    def publish_footer(self) -> None:
+        footer = pb.FooterRecord()
+        rec = self._make_record(footer=footer)
+        self._publish(rec)
+
+    def publish_final(self) -> None:
+        final = pb.FinalRecord()
+        rec = self._make_record(final=final)
+        self._publish(rec)
+
+    def publish_login(self, api_key: Optional[str] = None) -> None:
+        login = self._make_login(api_key)
+        rec = self._make_request(login=login)
+        self._publish(rec)
+
+    def _publish_pause(self, pause: pb.PauseRequest) -> None:
+        rec = self._make_request(pause=pause)
+        self._publish(rec)
+
+    def _publish_resume(self, resume: pb.ResumeRequest) -> None:
+        rec = self._make_request(resume=resume)
+        self._publish(rec)
+
+    def _publish_run(self, run: pb.RunRecord) -> None:
+        rec = self._make_record(run=run)
+        self._publish(rec)
+
+    def _publish_config(self, cfg: pb.ConfigRecord) -> None:
+        rec = self._make_record(config=cfg)
+        self._publish(rec)
+
+    def _publish_summary(self, summary: pb.SummaryRecord) -> None:
+        rec = self._make_record(summary=summary)
+        self._publish(rec)
+
+    def _publish_metric(self, metric: pb.MetricRecord) -> None:
+        rec = self._make_record(metric=metric)
+        self._publish(rec)
+
+    def publish_stats(self, stats_dict: dict) -> None:
+        stats = self._make_stats(stats_dict)
+        rec = self._make_record(stats=stats)
+        self._publish(rec)
+
+    def _publish_python_packages(
+        self, python_packages: pb.PythonPackagesRequest
+    ) -> None:
+        rec = self._make_request(python_packages=python_packages)
+        self._publish(rec)
+
+    def _publish_files(self, files: pb.FilesRecord) -> None:
+        rec = self._make_record(files=files)
+        self._publish(rec)
+
+    def _publish_use_artifact(self, use_artifact: pb.UseArtifactRecord) -> Any:
+        rec = self._make_record(use_artifact=use_artifact)
+        self._publish(rec)
+
+    def _communicate_artifact(self, log_artifact: pb.LogArtifactRequest) -> Any:
+        rec = self._make_request(log_artifact=log_artifact)
+        return self._communicate_async(rec)
+
+    def _deliver_download_artifact(
+        self, download_artifact: pb.DownloadArtifactRequest
+    ) -> MailboxHandle:
+        rec = self._make_request(download_artifact=download_artifact)
+        return self._deliver_record(rec)
+
+    def _deliver_link_artifact(
+        self, link_artifact: pb.LinkArtifactRequest
+    ) -> MailboxHandle:
+        rec = self._make_request(link_artifact=link_artifact)
+        return self._deliver_record(rec)
+
+    def _publish_artifact(self, proto_artifact: pb.ArtifactRecord) -> None:
+        rec = self._make_record(artifact=proto_artifact)
+        self._publish(rec)
+
+    def _publish_alert(self, proto_alert: pb.AlertRecord) -> None:
+        rec = self._make_record(alert=proto_alert)
+        self._publish(rec)
+
+    def _deliver_status(
+        self,
+        status: pb.StatusRequest,
+    ) -> MailboxHandle:
+        req = self._make_request(status=status)
+        return self._deliver_record(req)
+
+    def _publish_exit(self, exit_data: pb.RunExitRecord) -> None:
+        rec = self._make_record(exit=exit_data)
+        self._publish(rec)
+
+    def _publish_keepalive(self, keepalive: pb.KeepaliveRequest) -> None:
+        record = self._make_request(keepalive=keepalive)
+        self._publish(record)
+
+    def _communicate_shutdown(self) -> None:
+        # shutdown
+        request = pb.Request(shutdown=pb.ShutdownRequest())
+        record = self._make_record(request=request)
+        _ = self._communicate(record)
+
+    def _get_mailbox(self) -> Mailbox:
+        mailbox = self._mailbox
+        assert mailbox
+        return mailbox
+
+    def _deliver_record(self, record: pb.Record) -> MailboxHandle:
+        mailbox = self._get_mailbox()
+        handle = mailbox._deliver_record(record, interface=self)
+        return handle
+
+    def _deliver_run(self, run: pb.RunRecord) -> MailboxHandle:
+        record = self._make_record(run=run)
+        return self._deliver_record(record)
+
+    def _deliver_sync(self, sync: pb.SyncRequest) -> MailboxHandle:
+        record = self._make_request(sync=sync)
+        return self._deliver_record(record)
+
+    def _deliver_run_start(self, run_start: pb.RunStartRequest) -> MailboxHandle:
+        record = self._make_request(run_start=run_start)
+        return self._deliver_record(record)
+
+    def _deliver_get_summary(self, get_summary: pb.GetSummaryRequest) -> MailboxHandle:
+        record = self._make_request(get_summary=get_summary)
+        return self._deliver_record(record)
+
+    def _deliver_get_system_metrics(
+        self, get_system_metrics: pb.GetSystemMetricsRequest
+    ) -> MailboxHandle:
+        record = self._make_request(get_system_metrics=get_system_metrics)
+        return self._deliver_record(record)
+
+    def _deliver_exit(self, exit_data: pb.RunExitRecord) -> MailboxHandle:
+        record = self._make_record(exit=exit_data)
+        return self._deliver_record(record)
+
+    def _deliver_poll_exit(self, poll_exit: pb.PollExitRequest) -> MailboxHandle:
+        record = self._make_request(poll_exit=poll_exit)
+        return self._deliver_record(record)
+
+    def _deliver_stop_status(self, stop_status: pb.StopStatusRequest) -> MailboxHandle:
+        record = self._make_request(stop_status=stop_status)
+        return self._deliver_record(record)
+
+    def _deliver_attach(self, attach: pb.AttachRequest) -> MailboxHandle:
+        record = self._make_request(attach=attach)
+        return self._deliver_record(record)
+
+    def _deliver_check_version(
+        self, check_version: pb.CheckVersionRequest
+    ) -> MailboxHandle:
+        record = self._make_request(check_version=check_version)
+        return self._deliver_record(record)
+
+    def _deliver_network_status(
+        self, network_status: pb.NetworkStatusRequest
+    ) -> MailboxHandle:
+        record = self._make_request(network_status=network_status)
+        return self._deliver_record(record)
+
+    def _deliver_internal_messages(
+        self, internal_message: pb.InternalMessagesRequest
+    ) -> MailboxHandle:
+        record = self._make_request(internal_messages=internal_message)
+        return self._deliver_record(record)
+
+    def _deliver_request_server_info(
+        self, server_info: pb.ServerInfoRequest
+    ) -> MailboxHandle:
+        record = self._make_request(server_info=server_info)
+        return self._deliver_record(record)
+
+    def _deliver_request_sampled_history(
+        self, sampled_history: pb.SampledHistoryRequest
+    ) -> MailboxHandle:
+        record = self._make_request(sampled_history=sampled_history)
+        return self._deliver_record(record)
+
+    def _deliver_request_run_status(
+        self, run_status: pb.RunStatusRequest
+    ) -> MailboxHandle:
+        record = self._make_request(run_status=run_status)
+        return self._deliver_record(record)
+
+    def _transport_keepalive_failed(self, keepalive_interval: int = 5) -> bool:
+        if self._transport_failed:
+            return True
+
+        now = time.monotonic()
+        if now < self._transport_success_timestamp + keepalive_interval:
+            return False
+
+        try:
+            self.publish_keepalive()
+        except Exception:
+            self._transport_mark_failed()
+        else:
+            self._transport_mark_success()
+        return self._transport_failed
+
+    def join(self) -> None:
+        super().join()
+
+        if self._router:
+            self._router.join()

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

@@ -0,0 +1,61 @@
+"""InterfaceSock - Derived from InterfaceShared using a socket to send to internal thread.
+
+See interface.py for how interface classes relate to each other.
+
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+from ..lib.mailbox import Mailbox
+from ..lib.sock_client import SockClient
+from .interface_shared import InterfaceShared
+from .message_future import MessageFuture
+from .router_sock import MessageSockRouter
+
+if TYPE_CHECKING:
+    from wandb.proto import wandb_internal_pb2 as pb
+
+    from ..wandb_run import Run
+
+
+logger = logging.getLogger("wandb")
+
+
+class InterfaceSock(InterfaceShared):
+    _stream_id: Optional[str]
+    _sock_client: SockClient
+    _mailbox: Mailbox
+
+    def __init__(self, sock_client: SockClient, mailbox: Mailbox) -> None:
+        # _sock_client is used when abstract method _init_router() is called by constructor
+        self._sock_client = sock_client
+        super().__init__(mailbox=mailbox)
+        self._process_check = False
+        self._stream_id = None
+
+    def _init_router(self) -> None:
+        self._router = MessageSockRouter(self._sock_client, mailbox=self._mailbox)
+
+    def _hack_set_run(self, run: "Run") -> None:
+        super()._hack_set_run(run)
+        assert run._run_id
+        self._stream_id = run._run_id
+
+    def _assign(self, record: Any) -> None:
+        assert self._stream_id
+        record._info.stream_id = self._stream_id
+
+    def _publish(self, record: "pb.Record", local: Optional[bool] = None) -> None:
+        self._assign(record)
+        self._sock_client.send_record_publish(record)
+
+    def _communicate_async(
+        self, rec: "pb.Record", local: Optional[bool] = None
+    ) -> MessageFuture:
+        self._assign(rec)
+        assert self._router
+        if self._process_check and self._process and not self._process.is_alive():
+            raise Exception("The wandb backend process has shutdown")
+        future = self._router.send_and_receive(rec, local=local)
+        return future

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

@@ -0,0 +1,27 @@
+"""MessageFuture - represents a message result of an asynchronous operation.
+
+Base class MessageFuture for MessageFutureObject and MessageFuturePoll
+
+"""
+
+import threading
+from abc import abstractmethod
+from typing import Optional
+
+from wandb.proto import wandb_internal_pb2 as pb
+
+
+class MessageFuture:
+    _object: Optional[pb.Result]
+
+    def __init__(self) -> None:
+        self._object = None
+        self._object_ready = threading.Event()
+
+    def _set_object(self, obj: pb.Result) -> None:
+        self._object = obj
+        self._object_ready.set()
+
+    @abstractmethod
+    def get(self, timeout: Optional[int] = None) -> Optional[pb.Result]:
+        raise NotImplementedError

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

@@ -0,0 +1,50 @@
+"""MessageFuturePoll - Derived from MessageFuture but implementing polling loop.
+
+MessageFuture represents a message result of an asynchronous operation.
+
+MessageFuturePoll implements a polling loop to periodically query for a
+completed async operation.
+
+"""
+
+import time
+from typing import Any, Optional
+
+from wandb.proto import wandb_internal_pb2 as pb
+
+from .message_future import MessageFuture
+
+
+class MessageFuturePoll(MessageFuture):
+    _fn: Any
+    _xid: str
+
+    def __init__(self, fn: Any, xid: str) -> None:
+        super().__init__()
+        self._fn = fn
+        self._xid = xid
+
+    def get(self, timeout: Optional[int] = None) -> Optional[pb.Result]:
+        self._poll(timeout=timeout)
+        if self._object_ready.is_set():
+            return self._object
+        return None
+
+    def _poll(self, timeout: Optional[int] = None) -> None:
+        if self._object_ready.is_set():
+            return
+        done = False
+        start_time = time.time()
+        sleep_time = 0.5
+        while not done:
+            result = self._fn(xid=self._xid)
+            if result:
+                self._set_object(result)
+                done = True
+                continue
+            now_time = time.time()
+            if timeout and start_time - now_time > timeout:
+                done = True
+                continue
+            time.sleep(sleep_time)
+            sleep_time = min(sleep_time * 2, 5)

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

@@ -0,0 +1,118 @@
+"""Router - handle message router (base class).
+
+Router to manage responses.
+
+"""
+
+import logging
+import threading
+import uuid
+from abc import abstractmethod
+from typing import TYPE_CHECKING, Dict, Optional
+
+from ..lib import mailbox, tracelog
+from .message_future import MessageFuture
+
+if TYPE_CHECKING:
+    from queue import Queue
+
+    from wandb.proto import wandb_internal_pb2 as pb
+
+
+logger = logging.getLogger("wandb")
+
+
+class MessageRouterClosedError(Exception):
+    """Router has been closed."""
+
+    pass
+
+
+class MessageFutureObject(MessageFuture):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def get(self, timeout: Optional[int] = None) -> Optional["pb.Result"]:
+        is_set = self._object_ready.wait(timeout)
+        if is_set and self._object:
+            return self._object
+        return None
+
+
+class MessageRouter:
+    _pending_reqs: Dict[str, MessageFutureObject]
+    _request_queue: "Queue[pb.Record]"
+    _response_queue: "Queue[pb.Result]"
+    _mailbox: Optional[mailbox.Mailbox]
+
+    def __init__(self, mailbox: Optional[mailbox.Mailbox] = None) -> None:
+        self._mailbox = mailbox
+        self._pending_reqs = {}
+        self._lock = threading.Lock()
+
+        self._join_event = threading.Event()
+        self._thread = threading.Thread(target=self.message_loop)
+        self._thread.name = "MsgRouterThr"
+        self._thread.daemon = True
+        self._thread.start()
+
+    @abstractmethod
+    def _read_message(self) -> Optional["pb.Result"]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _send_message(self, record: "pb.Record") -> None:
+        raise NotImplementedError
+
+    def message_loop(self) -> None:
+        while not self._join_event.is_set():
+            try:
+                msg = self._read_message()
+            except EOFError:
+                # On abnormal shutdown the queue will be destroyed underneath
+                # resulting in EOFError.  message_loop needs to exit..
+                logger.warning("EOFError seen in message_loop")
+                break
+            except MessageRouterClosedError:
+                logger.warning("message_loop has been closed")
+                break
+            if not msg:
+                continue
+            self._handle_msg_rcv(msg)
+
+    def send_and_receive(
+        self, rec: "pb.Record", local: Optional[bool] = None
+    ) -> MessageFuture:
+        rec.control.req_resp = True
+        if local:
+            rec.control.local = local
+        rec.uuid = uuid.uuid4().hex
+        future = MessageFutureObject()
+        with self._lock:
+            self._pending_reqs[rec.uuid] = future
+
+        self._send_message(rec)
+
+        return future
+
+    def join(self) -> None:
+        self._join_event.set()
+        self._thread.join()
+
+    def _handle_msg_rcv(self, msg: "pb.Result") -> None:
+        # deliver mailbox addressed messages to mailbox
+        if self._mailbox and msg.control.mailbox_slot:
+            self._mailbox.deliver(msg)
+            return
+        with self._lock:
+            future = self._pending_reqs.pop(msg.uuid, None)
+        if future is None:
+            # TODO (cvp): saw this in tests, seemed benign enough to ignore, but
+            # could point to other issues.
+            if msg.uuid != "":
+                tracelog.log_message_assert(msg)
+                logger.warning(
+                    "No listener found for msg with uuid %s (%s)", msg.uuid, msg
+                )
+            return
+        future._set_object(msg)

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

@@ -0,0 +1,44 @@
+"""Router - handle message router (queue).
+
+Router to manage responses from a queue.
+
+"""
+
+import queue
+from typing import TYPE_CHECKING, Optional
+
+from ..lib import tracelog
+from ..lib.mailbox import Mailbox
+from .router import MessageRouter
+
+if TYPE_CHECKING:
+    from queue import Queue
+
+    from wandb.proto import wandb_internal_pb2 as pb
+
+
+class MessageQueueRouter(MessageRouter):
+    _request_queue: "Queue[pb.Record]"
+    _response_queue: "Queue[pb.Result]"
+
+    def __init__(
+        self,
+        request_queue: "Queue[pb.Record]",
+        response_queue: "Queue[pb.Result]",
+        mailbox: Optional[Mailbox] = None,
+    ) -> None:
+        self._request_queue = request_queue
+        self._response_queue = response_queue
+        super().__init__(mailbox=mailbox)
+
+    def _read_message(self) -> Optional["pb.Result"]:
+        try:
+            msg = self._response_queue.get(timeout=1)
+        except queue.Empty:
+            return None
+        tracelog.log_message_dequeue(msg, self._response_queue)
+        return msg
+
+    def _send_message(self, record: "pb.Record") -> None:
+        tracelog.log_message_queue(record, self._request_queue)
+        self._request_queue.put(record)

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

@@ -0,0 +1,39 @@
+"""Router - handle message router (relay).
+
+Router to manage responses from a queue with relay.
+
+"""
+
+from typing import TYPE_CHECKING
+
+from ..lib import tracelog
+from ..lib.mailbox import Mailbox
+from .router_queue import MessageQueueRouter
+
+if TYPE_CHECKING:
+    from queue import Queue
+
+    from wandb.proto import wandb_internal_pb2 as pb
+
+
+class MessageRelayRouter(MessageQueueRouter):
+    _relay_queue: "Queue[pb.Result]"
+
+    def __init__(
+        self,
+        request_queue: "Queue[pb.Record]",
+        response_queue: "Queue[pb.Result]",
+        relay_queue: "Queue[pb.Result]",
+        mailbox: Mailbox,
+    ) -> None:
+        self._relay_queue = relay_queue
+        super().__init__(
+            request_queue=request_queue, response_queue=response_queue, mailbox=mailbox
+        )
+
+    def _handle_msg_rcv(self, msg: "pb.Result") -> None:
+        if msg.control.relay_id:
+            tracelog.log_message_queue(msg, self._relay_queue)
+            self._relay_queue.put(msg)
+            return
+        super()._handle_msg_rcv(msg)

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

@@ -0,0 +1,36 @@
+"""Router - handle message router (sock).
+
+Router to manage responses from a socket client.
+
+"""
+
+from typing import TYPE_CHECKING, Optional
+
+from ..lib.mailbox import Mailbox
+from ..lib.sock_client import SockClient, SockClientClosedError
+from .router import MessageRouter, MessageRouterClosedError
+
+if TYPE_CHECKING:
+    from wandb.proto import wandb_internal_pb2 as pb
+
+
+class MessageSockRouter(MessageRouter):
+    _sock_client: SockClient
+    _mailbox: Mailbox
+
+    def __init__(self, sock_client: SockClient, mailbox: Mailbox) -> None:
+        self._sock_client = sock_client
+        super().__init__(mailbox=mailbox)
+
+    def _read_message(self) -> Optional["pb.Result"]:
+        try:
+            resp = self._sock_client.read_server_response(timeout=1)
+        except SockClientClosedError:
+            raise MessageRouterClosedError
+        if not resp:
+            return None
+        msg = resp.result_communicate
+        return msg
+
+    def _send_message(self, record: "pb.Record") -> None:
+        self._sock_client.send_record_communicate(record)

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

@@ -0,0 +1,67 @@
+"""Summary Record.
+
+This module implements a summary record as an intermediate format before being converted
+to a protocol buffer.
+"""
+
+import typing as t
+
+
+class SummaryRecord:
+    """Encodes a diff -- analogous to the SummaryRecord protobuf message."""
+
+    update: t.List["SummaryItem"]
+    remove: t.List["SummaryItem"]
+
+    def __init__(self):
+        self.update = []
+        self.remove = []
+
+    def __str__(self):
+        s = "SummaryRecord:\n  Update:\n    "
+        s += "\n    ".join([str(item) for item in self.update])
+        s += "\n  Remove:\n    "
+        s += "\n    ".join([str(item) for item in self.remove])
+        s += "\n"
+        return s
+
+    __repr__ = __str__
+
+    def _add_next_parent(self, parent_key):
+        with_next_parent = SummaryRecord()
+        with_next_parent.update = [
+            item._add_next_parent(parent_key) for item in self.update
+        ]
+        with_next_parent.remove = [
+            item._add_next_parent(parent_key) for item in self.remove
+        ]
+
+        return with_next_parent
+
+
+class SummaryItem:
+    """Analogous to the SummaryItem protobuf message."""
+
+    key: t.Tuple[str]
+    value: t.Any
+
+    def __init__(self):
+        self.key = tuple()
+        self.value = None
+
+    def __str__(self):
+        return "SummaryItem: key: " + str(self.key) + " value: " + str(self.value)
+
+    __repr__ = __str__
+
+    def _add_next_parent(self, parent_key):
+        with_next_parent = SummaryItem()
+
+        key = self.key
+        if not isinstance(key, tuple):
+            key = (key,)
+
+        with_next_parent.key = (parent_key,) + self.key
+        with_next_parent.value = self.value
+
+        return with_next_parent

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

@@ -0,0 +1,297 @@
+"""leveldb log datastore.
+
+Format is described at:
+    https://github.com/google/leveldb/blob/master/doc/log_format.md
+
+block := record* trailer?
+record :=
+  checksum: uint32     // crc32c of type and data[] ; little-endian
+  length: uint16       // little-endian
+  type: uint8          // One of FULL, FIRST, MIDDLE, LAST
+  data: uint8[length]
+
+header :=
+  ident: char[4]
+  magic: uint16
+  version: uint8
+"""
+
+# TODO: possibly restructure code by porting the C++ or go implementation
+
+import logging
+import os
+import struct
+import zlib
+from typing import TYPE_CHECKING, Optional, Tuple
+
+import wandb
+
+if TYPE_CHECKING:
+    from typing import IO, Any
+
+    from wandb.proto.wandb_internal_pb2 import Record
+
+logger = logging.getLogger(__name__)
+
+LEVELDBLOG_HEADER_LEN = 7
+LEVELDBLOG_BLOCK_LEN = 32768
+LEVELDBLOG_DATA_LEN = LEVELDBLOG_BLOCK_LEN - LEVELDBLOG_HEADER_LEN
+
+LEVELDBLOG_FULL = 1
+LEVELDBLOG_FIRST = 2
+LEVELDBLOG_MIDDLE = 3
+LEVELDBLOG_LAST = 4
+
+LEVELDBLOG_HEADER_IDENT = ":W&B"
+LEVELDBLOG_HEADER_MAGIC = (
+    0xBEE1  # zlib.crc32(bytes("Weights & Biases", 'iso8859-1')) & 0xffff
+)
+LEVELDBLOG_HEADER_VERSION = 0
+
+try:
+    bytes("", "ascii")
+
+    def strtobytes(x):
+        """Strtobytes."""
+        return bytes(x, "iso8859-1")
+
+    # def bytestostr(x):
+    #     return str(x, 'iso8859-1')
+
+except Exception:
+    strtobytes = str
+    # bytestostr = str
+
+
+class DataStore:
+    _index: int
+    _flush_offset: int
+
+    def __init__(self) -> None:
+        self._opened_for_scan = False
+        self._fp: Optional[IO[Any]] = None
+        self._index = 0
+        self._flush_offset = 0
+        self._size_bytes = 0
+
+        self._crc = [0] * (LEVELDBLOG_LAST + 1)
+        for x in range(1, LEVELDBLOG_LAST + 1):
+            self._crc[x] = zlib.crc32(strtobytes(chr(x))) & 0xFFFFFFFF
+
+        assert (
+            wandb._assert_is_internal_process  # type: ignore
+        ), "DataStore can only be used in the internal process"
+
+    def open_for_write(self, fname: str) -> None:
+        self._fname = fname
+        logger.info("open: %s", fname)
+        open_flags = "xb"
+        self._fp = open(fname, open_flags)
+        self._write_header()
+
+    def open_for_append(self, fname):
+        # TODO: implement
+        self._fname = fname
+        logger.info("open: %s", fname)
+        self._fp = open(fname, "wb")
+        # do something with _index
+
+    def open_for_scan(self, fname):
+        self._fname = fname
+        logger.info("open for scan: %s", fname)
+        self._fp = open(fname, "r+b")
+        self._index = 0
+        self._size_bytes = os.stat(fname).st_size
+        self._opened_for_scan = True
+        self._read_header()
+
+    def seek(self, offset: int) -> None:
+        self._fp.seek(offset)  # type: ignore
+        self._index = offset
+
+    def get_offset(self) -> int:
+        offset = self._fp.tell()  # type: ignore
+        return offset
+
+    def in_last_block(self):
+        """Determine if we're in the last block to handle in-progress writes."""
+        return self._index > self._size_bytes - LEVELDBLOG_DATA_LEN
+
+    def scan_record(self):
+        assert self._opened_for_scan, "file not open for scanning"
+        # TODO(jhr): handle some assertions as file corruption issues
+        # assume we have enough room to read header, checked by caller?
+        header = self._fp.read(LEVELDBLOG_HEADER_LEN)
+        if len(header) == 0:
+            return None
+        assert (
+            len(header) == LEVELDBLOG_HEADER_LEN
+        ), "record header is {} bytes instead of the expected {}".format(
+            len(header), LEVELDBLOG_HEADER_LEN
+        )
+        fields = struct.unpack("<IHB", header)
+        checksum, dlength, dtype = fields
+        # check len, better fit in the block
+        self._index += LEVELDBLOG_HEADER_LEN
+        data = self._fp.read(dlength)
+        checksum_computed = zlib.crc32(data, self._crc[dtype]) & 0xFFFFFFFF
+        assert (
+            checksum == checksum_computed
+        ), "record checksum is invalid, data may be corrupt"
+        self._index += dlength
+        return dtype, data
+
+    def scan_data(self):
+        # TODO(jhr): handle some assertions as file corruption issues
+        # how much left in the block.  if less than header len, read as pad,
+        offset = self._index % LEVELDBLOG_BLOCK_LEN
+        space_left = LEVELDBLOG_BLOCK_LEN - offset
+        if space_left < LEVELDBLOG_HEADER_LEN:
+            pad_check = strtobytes("\x00" * space_left)
+            pad = self._fp.read(space_left)
+            # verify they are zero
+            assert pad == pad_check, "invalid padding"
+            self._index += space_left
+
+        record = self.scan_record()
+        if record is None:  # eof
+            return None
+        dtype, data = record
+        if dtype == LEVELDBLOG_FULL:
+            return data
+
+        assert (
+            dtype == LEVELDBLOG_FIRST
+        ), f"expected record to be type {LEVELDBLOG_FIRST} but found {dtype}"
+        while True:
+            offset = self._index % LEVELDBLOG_BLOCK_LEN
+            record = self.scan_record()
+            if record is None:  # eof
+                return None
+            dtype, new_data = record
+            if dtype == LEVELDBLOG_LAST:
+                data += new_data
+                break
+            assert (
+                dtype == LEVELDBLOG_MIDDLE
+            ), f"expected record to be type {LEVELDBLOG_MIDDLE} but found {dtype}"
+            data += new_data
+        return data
+
+    def _write_header(self):
+        data = struct.pack(
+            "<4sHB",
+            strtobytes(LEVELDBLOG_HEADER_IDENT),
+            LEVELDBLOG_HEADER_MAGIC,
+            LEVELDBLOG_HEADER_VERSION,
+        )
+        assert (
+            len(data) == LEVELDBLOG_HEADER_LEN
+        ), f"header size is {len(data)} bytes, expected {LEVELDBLOG_HEADER_LEN}"
+        self._fp.write(data)
+        self._index += len(data)
+
+    def _read_header(self):
+        header = self._fp.read(LEVELDBLOG_HEADER_LEN)
+        assert (
+            len(header) == LEVELDBLOG_HEADER_LEN
+        ), "header is {} bytes instead of the expected {}".format(
+            len(header), LEVELDBLOG_HEADER_LEN
+        )
+        ident, magic, version = struct.unpack("<4sHB", header)
+        if ident != strtobytes(LEVELDBLOG_HEADER_IDENT):
+            raise Exception("Invalid header")
+        if magic != LEVELDBLOG_HEADER_MAGIC:
+            raise Exception("Invalid header")
+        if version != LEVELDBLOG_HEADER_VERSION:
+            raise Exception("Invalid header")
+        self._index += len(header)
+
+    def _write_record(self, s, dtype=None):
+        """Write record that must fit into a block."""
+        # double check that there is enough space
+        # (this is a precondition to calling this method)
+        assert len(s) + LEVELDBLOG_HEADER_LEN <= (
+            LEVELDBLOG_BLOCK_LEN - self._index % LEVELDBLOG_BLOCK_LEN
+        ), "not enough space to write new records"
+
+        dlength = len(s)
+        dtype = dtype or LEVELDBLOG_FULL
+        # print("record: length={} type={}".format(dlength, dtype))
+        checksum = zlib.crc32(s, self._crc[dtype]) & 0xFFFFFFFF
+        # logger.info("write_record: index=%d len=%d dtype=%d",
+        #     self._index, dlength, dtype)
+        self._fp.write(struct.pack("<IHB", checksum, dlength, dtype))
+        if dlength:
+            self._fp.write(s)
+        self._index += LEVELDBLOG_HEADER_LEN + len(s)
+
+    def _write_data(self, s):
+        start_offset = self._index
+
+        offset = self._index % LEVELDBLOG_BLOCK_LEN
+        space_left = LEVELDBLOG_BLOCK_LEN - offset
+        data_used = 0
+        data_left = len(s)
+        # logger.info("write_data: index=%d offset=%d len=%d",
+        #     self._index, offset, data_left)
+        if space_left < LEVELDBLOG_HEADER_LEN:
+            pad = "\x00" * space_left
+            self._fp.write(strtobytes(pad))
+            self._index += space_left
+            offset = 0
+            space_left = LEVELDBLOG_BLOCK_LEN
+
+        # does it fit in first (possibly partial) block?
+        if data_left + LEVELDBLOG_HEADER_LEN <= space_left:
+            self._write_record(s)
+        else:
+            # write first record (we could still be in the middle of a block,
+            # but this write will end on a block boundary)
+            data_room = space_left - LEVELDBLOG_HEADER_LEN
+            self._write_record(s[:data_room], LEVELDBLOG_FIRST)
+            data_used += data_room
+            data_left -= data_room
+            assert data_left, "data_left should be non-zero"
+
+            # write middles (if any)
+            while data_left > LEVELDBLOG_DATA_LEN:
+                self._write_record(
+                    s[data_used : data_used + LEVELDBLOG_DATA_LEN],
+                    LEVELDBLOG_MIDDLE,
+                )
+                data_used += LEVELDBLOG_DATA_LEN
+                data_left -= LEVELDBLOG_DATA_LEN
+
+            # write last and flush the entire block to disk
+            self._write_record(s[data_used:], LEVELDBLOG_LAST)
+            self._fp.flush()
+            os.fsync(self._fp.fileno())
+            self._flush_offset = self._index
+
+        return start_offset, self._index, self._flush_offset
+
+    def ensure_flushed(self, off: int) -> None:
+        self._fp.flush()  # type: ignore
+
+    def write(self, obj: "Record") -> Tuple[int, int, int]:
+        """Write a protocol buffer.
+
+        Arguments:
+            obj: Protocol buffer to write.
+
+        Returns:
+            (start_offset, end_offset, flush_offset) if successful,
+            None otherwise
+
+        """
+        raw_size = obj.ByteSize()
+        s = obj.SerializeToString()
+        assert len(s) == raw_size, "invalid serialization"
+        ret = self._write_data(s)
+        return ret
+
+    def close(self) -> None:
+        if self._fp is not None:
+            logger.info("close: %s", self._fname)
+            self._fp.close()

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

@@ -0,0 +1,911 @@
+"""Handle Manager."""
+
+import json
+import logging
+import math
+import numbers
+import time
+from collections import defaultdict
+from queue import Queue
+from threading import Event
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    cast,
+)
+
+from wandb.proto.wandb_internal_pb2 import (
+    HistoryRecord,
+    InternalMessages,
+    MetricRecord,
+    Record,
+    Result,
+    RunRecord,
+    SampledHistoryItem,
+    SummaryItem,
+    SummaryRecord,
+    SummaryRecordRequest,
+    SystemMetricSample,
+    SystemMetricsBuffer,
+)
+
+from ..interface.interface_queue import InterfaceQueue
+from ..lib import handler_util, proto_util, tracelog, wburls
+from . import context, sample, tb_watcher
+from .settings_static import SettingsStatic
+from .system.system_monitor import SystemMonitor
+
+if TYPE_CHECKING:
+    from wandb.proto.wandb_internal_pb2 import MetricSummary
+
+
+SummaryDict = Dict[str, Any]
+
+logger = logging.getLogger(__name__)
+
+# Update (March 5, 2024): Since ~2020/2021, when constructing the summary
+# object, we had replaced the artifact path for media types with the latest
+# artifact path. The primary purpose of this was to support live updating of
+# media objects in the UI (since the default artifact path was fully qualified
+# and would not update). However, in March of 2024, a bug was discovered with
+# this approach which causes this path to be incorrect in cases where the media
+# object is logged to another artifact before being logged to the run. Setting
+# this to `False` disables this copy behavior. The impact is that users will
+# need to refresh to see updates. Ironically, this updating behavior is not
+# currently supported in the UI, so the impact of this change is minimal.
+REPLACE_SUMMARY_ART_PATH_WITH_LATEST = False
+
+
+def _dict_nested_set(target: Dict[str, Any], key_list: Sequence[str], v: Any) -> None:
+    # recurse down the dictionary structure:
+
+    for k in key_list[:-1]:
+        target.setdefault(k, {})
+        new_target = target.get(k)
+        if TYPE_CHECKING:
+            new_target = cast(Dict[str, Any], new_target)
+        target = new_target
+    # use the last element of the key to write the leaf:
+    target[key_list[-1]] = v
+
+
+class HandleManager:
+    _consolidated_summary: SummaryDict
+    _sampled_history: Dict[str, sample.UniformSampleAccumulator]
+    _partial_history: Dict[str, Any]
+    _run_proto: Optional[RunRecord]
+    _settings: SettingsStatic
+    _record_q: "Queue[Record]"
+    _result_q: "Queue[Result]"
+    _stopped: Event
+    _writer_q: "Queue[Record]"
+    _interface: InterfaceQueue
+    _system_monitor: Optional[SystemMonitor]
+    _tb_watcher: Optional[tb_watcher.TBWatcher]
+    _metric_defines: Dict[str, MetricRecord]
+    _metric_globs: Dict[str, MetricRecord]
+    _metric_track: Dict[Tuple[str, ...], float]
+    _metric_copy: Dict[Tuple[str, ...], Any]
+    _track_time: Optional[float]
+    _accumulate_time: float
+    _run_start_time: Optional[float]
+    _context_keeper: context.ContextKeeper
+
+    def __init__(
+        self,
+        settings: SettingsStatic,
+        record_q: "Queue[Record]",
+        result_q: "Queue[Result]",
+        stopped: Event,
+        writer_q: "Queue[Record]",
+        interface: InterfaceQueue,
+        context_keeper: context.ContextKeeper,
+    ) -> None:
+        self._settings = settings
+        self._record_q = record_q
+        self._result_q = result_q
+        self._stopped = stopped
+        self._writer_q = writer_q
+        self._interface = interface
+        self._context_keeper = context_keeper
+
+        self._tb_watcher = None
+        self._system_monitor = None
+        self._step = 0
+
+        self._track_time = None
+        self._accumulate_time = 0
+        self._run_start_time = None
+
+        # keep track of summary from key/val updates
+        self._consolidated_summary = dict()
+        self._sampled_history = defaultdict(sample.UniformSampleAccumulator)
+        self._run_proto = None
+        self._partial_history = dict()
+        self._metric_defines = defaultdict(MetricRecord)
+        self._metric_globs = defaultdict(MetricRecord)
+        self._metric_track = dict()
+        self._metric_copy = dict()
+        self._internal_messages = InternalMessages()
+
+        self._dropped_history = False
+
+    def __len__(self) -> int:
+        return self._record_q.qsize()
+
+    def handle(self, record: Record) -> None:
+        self._context_keeper.add_from_record(record)
+        record_type = record.WhichOneof("record_type")
+        assert record_type
+        handler_str = "handle_" + record_type
+        handler: Callable[[Record], None] = getattr(self, handler_str, None)  # type: ignore
+        assert handler, f"unknown handle: {handler_str}"  # type: ignore
+        handler(record)
+
+    def handle_request(self, record: Record) -> None:
+        request_type = record.request.WhichOneof("request_type")
+        assert request_type
+        handler_str = "handle_request_" + request_type
+        handler: Callable[[Record], None] = getattr(self, handler_str, None)  # type: ignore
+        if request_type != "network_status":
+            logger.debug(f"handle_request: {request_type}")
+        assert handler, f"unknown handle: {handler_str}"  # type: ignore
+        handler(record)
+
+    def _dispatch_record(self, record: Record, always_send: bool = False) -> None:
+        if always_send:
+            record.control.always_send = True
+        tracelog.log_message_queue(record, self._writer_q)
+        self._writer_q.put(record)
+
+    def _respond_result(self, result: Result) -> None:
+        tracelog.log_message_queue(result, self._result_q)
+        context_id = context.context_id_from_result(result)
+        self._context_keeper.release(context_id)
+        self._result_q.put(result)
+
+    def debounce(self) -> None:
+        pass
+
+    def handle_request_cancel(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_request_defer(self, record: Record) -> None:
+        defer = record.request.defer
+        state = defer.state
+
+        logger.info(f"handle defer: {state}")
+        # only handle flush tb (sender handles the rest)
+        if state == defer.FLUSH_STATS:
+            # TODO(jhr): this could block so we dont really want to call shutdown
+            # from handler thread
+            if self._system_monitor is not None:
+                self._system_monitor.finish()
+        elif state == defer.FLUSH_TB:
+            if self._tb_watcher:
+                # shutdown tensorboard workers so we get all metrics flushed
+                self._tb_watcher.finish()
+                self._tb_watcher = None
+        elif state == defer.FLUSH_PARTIAL_HISTORY:
+            self._flush_partial_history()
+        elif state == defer.FLUSH_SUM:
+            self._save_summary(self._consolidated_summary, flush=True)
+
+        # defer is used to drive the sender finish state machine
+        self._dispatch_record(record, always_send=True)
+
+    def handle_request_login(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_request_python_packages(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_run(self, record: Record) -> None:
+        if self._settings._offline:
+            self._run_proto = record.run
+            result = proto_util._result_from_record(record)
+            result.run_result.run.CopyFrom(record.run)
+            self._respond_result(result)
+        self._dispatch_record(record)
+
+    def handle_stats(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_config(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_output(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_output_raw(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_files(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_request_link_artifact(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_use_artifact(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_artifact(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_alert(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def _save_summary(self, summary_dict: SummaryDict, flush: bool = False) -> None:
+        summary = SummaryRecord()
+        for k, v in summary_dict.items():
+            update = summary.update.add()
+            update.key = k
+            update.value_json = json.dumps(v)
+        if flush:
+            record = Record(summary=summary)
+            self._dispatch_record(record)
+        elif not self._settings._offline:
+            # Send this summary update as a request since we aren't persisting every update
+            summary_record = SummaryRecordRequest(summary=summary)
+            request_record = self._interface._make_request(
+                summary_record=summary_record
+            )
+            self._dispatch_record(request_record)
+
+    def _save_history(
+        self,
+        history: HistoryRecord,
+    ) -> None:
+        for item in history.item:
+            # TODO(jhr) save nested keys?
+            k = item.key
+            v = json.loads(item.value_json)
+            if isinstance(v, numbers.Real):
+                self._sampled_history[k].add(v)
+
+    def _update_summary_metrics(
+        self,
+        s: "MetricSummary",
+        kl: List[str],
+        v: "numbers.Real",
+        float_v: float,
+        goal_max: Optional[bool],
+    ) -> bool:
+        updated = False
+        best_key: Optional[Tuple[str, ...]] = None
+        if s.none:
+            return False
+        if s.copy:
+            # non-key list copy already done in _update_summary
+            if len(kl) > 1:
+                _dict_nested_set(self._consolidated_summary, kl, v)
+                return True
+        if s.last:
+            last_key = tuple(kl + ["last"])
+            old_last = self._metric_track.get(last_key)
+            if old_last is None or float_v != old_last:
+                self._metric_track[last_key] = float_v
+                _dict_nested_set(self._consolidated_summary, last_key, v)
+                updated = True
+        if s.best:
+            best_key = tuple(kl + ["best"])
+        if s.max or best_key and goal_max:
+            max_key = tuple(kl + ["max"])
+            old_max = self._metric_track.get(max_key)
+            if old_max is None or float_v > old_max:
+                self._metric_track[max_key] = float_v
+                if s.max:
+                    _dict_nested_set(self._consolidated_summary, max_key, v)
+                    updated = True
+                if best_key:
+                    _dict_nested_set(self._consolidated_summary, best_key, v)
+                    updated = True
+        # defaulting to minimize if goal is not specified
+        if s.min or best_key and not goal_max:
+            min_key = tuple(kl + ["min"])
+            old_min = self._metric_track.get(min_key)
+            if old_min is None or float_v < old_min:
+                self._metric_track[min_key] = float_v
+                if s.min:
+                    _dict_nested_set(self._consolidated_summary, min_key, v)
+                    updated = True
+                if best_key:
+                    _dict_nested_set(self._consolidated_summary, best_key, v)
+                    updated = True
+        if s.mean:
+            tot_key = tuple(kl + ["tot"])
+            num_key = tuple(kl + ["num"])
+            avg_key = tuple(kl + ["mean"])
+            tot = self._metric_track.get(tot_key, 0.0)
+            num = self._metric_track.get(num_key, 0)
+            tot += float_v
+            num += 1
+            self._metric_track[tot_key] = tot
+            self._metric_track[num_key] = num
+            _dict_nested_set(self._consolidated_summary, avg_key, tot / num)
+            updated = True
+        return updated
+
+    def _update_summary_leaf(
+        self,
+        kl: List[str],
+        v: Any,
+        d: Optional[MetricRecord] = None,
+    ) -> bool:
+        has_summary = d and d.HasField("summary")
+        if len(kl) == 1:
+            copy_key = tuple(kl)
+            old_copy = self._metric_copy.get(copy_key)
+            if old_copy is None or v != old_copy:
+                self._metric_copy[copy_key] = v
+                # Store copy metric if not specified, or copy behavior
+                if not has_summary or (d and d.summary.copy):
+                    self._consolidated_summary[kl[0]] = v
+                    return True
+        if not d:
+            return False
+        if not has_summary:
+            return False
+        if not isinstance(v, numbers.Real):
+            return False
+        if math.isnan(v):
+            return False
+        float_v = float(v)
+        goal_max = None
+        if d.goal:
+            goal_max = d.goal == d.GOAL_MAXIMIZE
+        if self._update_summary_metrics(
+            d.summary, kl=kl, v=v, float_v=float_v, goal_max=goal_max
+        ):
+            return True
+        return False
+
+    def _update_summary_list(
+        self,
+        kl: List[str],
+        v: Any,
+        d: Optional[MetricRecord] = None,
+    ) -> bool:
+        metric_key = ".".join([k.replace(".", "\\.") for k in kl])
+        d = self._metric_defines.get(metric_key, d)
+        # if the dict has _type key, it's a wandb table object
+        if isinstance(v, dict) and not handler_util.metric_is_wandb_dict(v):
+            updated = False
+            for nk, nv in v.items():
+                if self._update_summary_list(kl=kl[:] + [nk], v=nv, d=d):
+                    updated = True
+            return updated
+        # If the dict is a media object, update the pointer to the latest alias
+        elif (
+            REPLACE_SUMMARY_ART_PATH_WITH_LATEST
+            and isinstance(v, dict)
+            and handler_util.metric_is_wandb_dict(v)
+        ):
+            if "_latest_artifact_path" in v and "artifact_path" in v:
+                # TODO: Make non-destructive?
+                v["artifact_path"] = v["_latest_artifact_path"]
+        updated = self._update_summary_leaf(kl=kl, v=v, d=d)
+        return updated
+
+    def _update_summary_media_objects(self, v: Dict[str, Any]) -> Dict[str, Any]:
+        # For now, non-recursive - just top level
+        for nk, nv in v.items():
+            if REPLACE_SUMMARY_ART_PATH_WITH_LATEST and (
+                isinstance(nv, dict)
+                and handler_util.metric_is_wandb_dict(nv)
+                and "_latest_artifact_path" in nv
+                and "artifact_path" in nv
+            ):
+                # TODO: Make non-destructive?
+                nv["artifact_path"] = nv["_latest_artifact_path"]
+                v[nk] = nv
+        return v
+
+    def _update_summary(self, history_dict: Dict[str, Any]) -> List[str]:
+        # keep old behavior fast path if no define metrics have been used
+        if not self._metric_defines:
+            history_dict = self._update_summary_media_objects(history_dict)
+            self._consolidated_summary.update(history_dict)
+            return list(history_dict.keys())
+        updated_keys = []
+        for k, v in history_dict.items():
+            if self._update_summary_list(kl=[k], v=v):
+                updated_keys.append(k)
+        return updated_keys
+
+    def _history_assign_step(
+        self,
+        history: HistoryRecord,
+        history_dict: Dict[str, Any],
+    ) -> None:
+        has_step = history.HasField("step")
+        item = history.item.add()
+        item.key = "_step"
+        if has_step:
+            step = history.step.num
+            history_dict["_step"] = step
+            item.value_json = json.dumps(step)
+            self._step = step + 1
+        else:
+            history_dict["_step"] = self._step
+            item.value_json = json.dumps(self._step)
+            self._step += 1
+
+    def _history_define_metric(self, hkey: str) -> Optional[MetricRecord]:
+        """Check for hkey match in glob metrics and return the defined metric."""
+        # Dont define metric for internal metrics
+        if hkey.startswith("_"):
+            return None
+        for k, mglob in self._metric_globs.items():
+            if k.endswith("*"):
+                if hkey.startswith(k[:-1]):
+                    m = MetricRecord()
+                    m.CopyFrom(mglob)
+                    m.ClearField("glob_name")
+                    m.options.defined = False
+                    m.name = hkey
+                    return m
+        return None
+
+    def _history_update_leaf(
+        self,
+        kl: List[str],
+        v: Any,
+        history_dict: Dict[str, Any],
+        update_history: Dict[str, Any],
+    ) -> None:
+        hkey = ".".join([k.replace(".", "\\.") for k in kl])
+        m = self._metric_defines.get(hkey)
+        if not m:
+            m = self._history_define_metric(hkey)
+            if not m:
+                return
+            mr = Record()
+            mr.metric.CopyFrom(m)
+            mr.control.local = True  # Dont store this, just send it
+            self._handle_defined_metric(mr)
+
+        if m.options.step_sync and m.step_metric:
+            if m.step_metric not in history_dict:
+                copy_key = tuple([m.step_metric])
+                step = self._metric_copy.get(copy_key)
+                if step is not None:
+                    update_history[m.step_metric] = step
+
+    def _history_update_list(
+        self,
+        kl: List[str],
+        v: Any,
+        history_dict: Dict[str, Any],
+        update_history: Dict[str, Any],
+    ) -> None:
+        if isinstance(v, dict):
+            for nk, nv in v.items():
+                self._history_update_list(
+                    kl=kl[:] + [nk],
+                    v=nv,
+                    history_dict=history_dict,
+                    update_history=update_history,
+                )
+            return
+        self._history_update_leaf(
+            kl=kl, v=v, history_dict=history_dict, update_history=update_history
+        )
+
+    def _history_update(
+        self,
+        history: HistoryRecord,
+        history_dict: Dict[str, Any],
+    ) -> None:
+        #  if syncing an old run, we can skip this logic
+        if history_dict.get("_step") is None:
+            self._history_assign_step(history, history_dict)
+
+        update_history: Dict[str, Any] = {}
+        # Look for metric matches
+        if self._metric_defines or self._metric_globs:
+            for hkey, hval in history_dict.items():
+                self._history_update_list([hkey], hval, history_dict, update_history)
+
+        if update_history:
+            history_dict.update(update_history)
+            for k, v in update_history.items():
+                item = history.item.add()
+                item.key = k
+                item.value_json = json.dumps(v)
+
+    def handle_history(self, record: Record) -> None:
+        history_dict = proto_util.dict_from_proto_list(record.history.item)
+
+        # Inject _runtime if it is not present
+        if history_dict is not None:
+            if "_runtime" not in history_dict:
+                self._history_assign_runtime(record.history, history_dict)
+
+        self._history_update(record.history, history_dict)
+        self._dispatch_record(record)
+        self._save_history(record.history)
+        # update summary from history
+        updated_keys = self._update_summary(history_dict)
+        if updated_keys:
+            updated_items = {k: self._consolidated_summary[k] for k in updated_keys}
+            self._save_summary(updated_items)
+
+    def _flush_partial_history(
+        self,
+        step: Optional[int] = None,
+    ) -> None:
+        if not self._partial_history:
+            return
+
+        history = HistoryRecord()
+        for k, v in self._partial_history.items():
+            item = history.item.add()
+            item.key = k
+            item.value_json = json.dumps(v)
+        if step is not None:
+            history.step.num = step
+        self.handle_history(Record(history=history))
+        self._partial_history = {}
+
+    def handle_request_sender_mark_report(self, record: Record) -> None:
+        self._dispatch_record(record, always_send=True)
+
+    def handle_request_status_report(self, record: Record) -> None:
+        self._dispatch_record(record, always_send=True)
+
+    def handle_request_partial_history(self, record: Record) -> None:
+        partial_history = record.request.partial_history
+
+        flush = None
+        if partial_history.HasField("action"):
+            flush = partial_history.action.flush
+
+        step = None
+        if partial_history.HasField("step"):
+            step = partial_history.step.num
+
+        history_dict = proto_util.dict_from_proto_list(partial_history.item)
+        if step is not None:
+            if step < self._step:
+                if not self._dropped_history:
+                    message = (
+                        "Step only supports monotonically increasing values, use define_metric to set a custom x "
+                        f"axis. For details see: {wburls.wburls.get('wandb_define_metric')}"
+                    )
+                    self._internal_messages.warning.append(message)
+                    self._dropped_history = True
+                message = (
+                    f"(User provided step: {step} is less than current step: {self._step}. "
+                    f"Dropping entry: {history_dict})."
+                )
+                self._internal_messages.warning.append(message)
+                return
+            elif step > self._step:
+                self._flush_partial_history()
+                self._step = step
+        elif flush is None:
+            flush = True
+
+        self._partial_history.update(history_dict)
+
+        if flush:
+            self._flush_partial_history(self._step)
+
+    def handle_summary(self, record: Record) -> None:
+        summary = record.summary
+        for item in summary.update:
+            if len(item.nested_key) > 0:
+                # we use either key or nested_key -- not both
+                assert item.key == ""
+                key = tuple(item.nested_key)
+            else:
+                # no counter-assertion here, because technically
+                # summary[""] is valid
+                key = (item.key,)
+
+            target = self._consolidated_summary
+
+            # recurse down the dictionary structure:
+            for prop in key[:-1]:
+                target = target[prop]
+
+            # use the last element of the key to write the leaf:
+            target[key[-1]] = json.loads(item.value_json)
+
+        for item in summary.remove:
+            if len(item.nested_key) > 0:
+                # we use either key or nested_key -- not both
+                assert item.key == ""
+                key = tuple(item.nested_key)
+            else:
+                # no counter-assertion here, because technically
+                # summary[""] is valid
+                key = (item.key,)
+
+            target = self._consolidated_summary
+
+            # recurse down the dictionary structure:
+            for prop in key[:-1]:
+                target = target[prop]
+
+            # use the last element of the key to erase the leaf:
+            del target[key[-1]]
+
+        self._save_summary(self._consolidated_summary)
+
+    def handle_exit(self, record: Record) -> None:
+        if self._track_time is not None:
+            self._accumulate_time += time.time() - self._track_time
+        record.exit.runtime = int(self._accumulate_time)
+        self._dispatch_record(record, always_send=True)
+
+    def handle_final(self, record: Record) -> None:
+        self._dispatch_record(record, always_send=True)
+
+    def handle_preempting(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_header(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_footer(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_request_check_version(self, record: Record) -> None:
+        if self._settings._offline:
+            result = proto_util._result_from_record(record)
+            self._respond_result(result)
+        else:
+            self._dispatch_record(record)
+
+    def handle_request_attach(self, record: Record) -> None:
+        result = proto_util._result_from_record(record)
+        attach_id = record.request.attach.attach_id
+        assert attach_id
+        assert self._run_proto
+        result.response.attach_response.run.CopyFrom(self._run_proto)
+        self._respond_result(result)
+
+    def handle_request_log_artifact(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_telemetry(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_request_run_start(self, record: Record) -> None:
+        run_start = record.request.run_start
+        assert run_start
+        assert run_start.run
+
+        self._run_proto = run_start.run
+
+        self._run_start_time = run_start.run.start_time.ToMicroseconds() / 1e6
+
+        self._track_time = time.time()
+        if run_start.run.resumed and run_start.run.runtime:
+            self._accumulate_time = run_start.run.runtime
+        else:
+            self._accumulate_time = 0
+
+        # system monitor
+        self._system_monitor = SystemMonitor(
+            self._settings,
+            self._interface,
+        )
+        if not self._settings._disable_stats:
+            self._system_monitor.start()
+        if not self._settings._disable_meta and not run_start.run.resumed:
+            self._system_monitor.probe(publish=True)
+
+        self._tb_watcher = tb_watcher.TBWatcher(
+            self._settings, interface=self._interface, run_proto=run_start.run
+        )
+
+        if run_start.run.resumed or run_start.run.forked:
+            self._step = run_start.run.starting_step
+        result = proto_util._result_from_record(record)
+        self._respond_result(result)
+
+    def handle_request_resume(self, record: Record) -> None:
+        if self._system_monitor is not None:
+            logger.info("starting system metrics thread")
+            self._system_monitor.start()
+
+        if self._track_time is not None:
+            self._accumulate_time += time.time() - self._track_time
+        self._track_time = time.time()
+
+    def handle_request_pause(self, record: Record) -> None:
+        if self._system_monitor is not None:
+            logger.info("stopping system metrics thread")
+            self._system_monitor.finish()
+        if self._track_time is not None:
+            self._accumulate_time += time.time() - self._track_time
+            self._track_time = None
+
+    def handle_request_poll_exit(self, record: Record) -> None:
+        self._dispatch_record(record, always_send=True)
+
+    def handle_request_stop_status(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_request_network_status(self, record: Record) -> None:
+        self._dispatch_record(record)
+
+    def handle_request_internal_messages(self, record: Record) -> None:
+        result = proto_util._result_from_record(record)
+        result.response.internal_messages_response.messages.CopyFrom(
+            self._internal_messages
+        )
+        self._internal_messages.Clear()
+        self._respond_result(result)
+
+    def handle_request_status(self, record: Record) -> None:
+        result = proto_util._result_from_record(record)
+        self._respond_result(result)
+
+    def handle_request_get_summary(self, record: Record) -> None:
+        result = proto_util._result_from_record(record)
+        for key, value in self._consolidated_summary.items():
+            item = SummaryItem()
+            item.key = key
+            item.value_json = json.dumps(value)
+            result.response.get_summary_response.item.append(item)
+        self._respond_result(result)
+
+    def handle_request_get_system_metrics(self, record: Record) -> None:
+        result = proto_util._result_from_record(record)
+        if self._system_monitor is None:
+            return
+
+        buffer = self._system_monitor.buffer
+        for key, samples in buffer.items():
+            buff = []
+            for s in samples:
+                sms = SystemMetricSample()
+                sms.timestamp.FromMicroseconds(int(s[0] * 1e6))
+                sms.value = s[1]
+                buff.append(sms)
+
+            result.response.get_system_metrics_response.system_metrics[key].CopyFrom(
+                SystemMetricsBuffer(record=buff)
+            )
+
+        self._respond_result(result)
+
+    def handle_tbrecord(self, record: Record) -> None:
+        logger.info("handling tbrecord: %s", record)
+        if self._tb_watcher:
+            tbrecord = record.tbrecord
+            self._tb_watcher.add(tbrecord.log_dir, tbrecord.save, tbrecord.root_dir)
+        self._dispatch_record(record)
+
+    def _handle_defined_metric(self, record: Record) -> None:
+        metric = record.metric
+        if metric._control.overwrite:
+            self._metric_defines[metric.name].CopyFrom(metric)
+        else:
+            self._metric_defines[metric.name].MergeFrom(metric)
+
+        # before dispatching, make sure step_metric is defined, if not define it and
+        # dispatch it locally first
+        metric = self._metric_defines[metric.name]
+        if metric.step_metric and metric.step_metric not in self._metric_defines:
+            m = MetricRecord(name=metric.step_metric)
+            self._metric_defines[metric.step_metric] = m
+            mr = Record()
+            mr.metric.CopyFrom(m)
+            mr.control.local = True  # Don't store this, just send it
+            self._dispatch_record(mr)
+
+        self._dispatch_record(record)
+
+    def _handle_glob_metric(self, record: Record) -> None:
+        metric = record.metric
+        if metric._control.overwrite:
+            self._metric_globs[metric.glob_name].CopyFrom(metric)
+        else:
+            self._metric_globs[metric.glob_name].MergeFrom(metric)
+        self._dispatch_record(record)
+
+    def handle_metric(self, record: Record) -> None:
+        """Handle MetricRecord.
+
+        Walkthrough of the life of a MetricRecord:
+
+        Metric defined:
+        - run.define_metric() parses arguments create wandb_metric.Metric
+        - build MetricRecord publish to interface
+        - handler (this function) keeps list of metrics published:
+          - self._metric_defines: Fully defined metrics
+          - self._metric_globs: metrics that have a wildcard
+        - dispatch writer and sender thread
+          - writer: records are saved to persistent store
+          - sender: fully defined metrics get mapped into metadata for UI
+
+        History logged:
+        - handle_history
+        - check if metric matches _metric_defines
+        - if not, check if metric matches _metric_globs
+        - if _metric globs match, generate defined metric and call _handle_metric
+
+        Args:
+            record (Record): Metric record to process
+        """
+        if record.metric.name:
+            self._handle_defined_metric(record)
+        elif record.metric.glob_name:
+            self._handle_glob_metric(record)
+
+    def handle_request_sampled_history(self, record: Record) -> None:
+        result = proto_util._result_from_record(record)
+        for key, sampled in self._sampled_history.items():
+            item = SampledHistoryItem()
+            item.key = key
+            values: Iterable[Any] = sampled.get()
+            if all(isinstance(i, numbers.Integral) for i in values):
+                try:
+                    item.values_int.extend(values)
+                except ValueError:
+                    # it is safe to ignore these as this is for display information
+                    pass
+            elif all(isinstance(i, numbers.Real) for i in values):
+                item.values_float.extend(values)
+            result.response.sampled_history_response.item.append(item)
+        self._respond_result(result)
+
+    def handle_request_server_info(self, record: Record) -> None:
+        self._dispatch_record(record, always_send=True)
+
+    def handle_request_keepalive(self, record: Record) -> None:
+        """Handle a keepalive request.
+
+        Keepalive is a noop, we just want to verify transport is alive.
+        """
+
+    def handle_request_run_status(self, record: Record) -> None:
+        self._dispatch_record(record, always_send=True)
+
+    def handle_request_shutdown(self, record: Record) -> None:
+        # TODO(jhr): should we drain things and stop new requests from coming in?
+        result = proto_util._result_from_record(record)
+        self._respond_result(result)
+        self._stopped.set()
+
+    def finish(self) -> None:
+        logger.info("shutting down handler")
+        if self._system_monitor is not None:
+            self._system_monitor.finish()
+        if self._tb_watcher:
+            self._tb_watcher.finish()
+        # self._context_keeper._debug_print_orphans()
+
+    def __next__(self) -> Record:
+        return self._record_q.get(block=True)
+
+    next = __next__
+
+    def _history_assign_runtime(
+        self,
+        history: HistoryRecord,
+        history_dict: Dict[str, Any],
+    ) -> None:
+        # _runtime calculation is meaningless if there is no _timestamp
+        if "_timestamp" not in history_dict:
+            return
+        # if it is offline sync, self._run_start_time is None
+        # in that case set it to the first tfevent timestamp
+        if self._run_start_time is None:
+            self._run_start_time = history_dict["_timestamp"]
+        history_dict["_runtime"] = history_dict["_timestamp"] - self._run_start_time
+        item = history.item.add()
+        item.key = "_runtime"
+        item.value_json = json.dumps(history_dict[item.key])

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

@@ -0,0 +1,629 @@
+"""job builder."""
+
+import json
+import logging
+import os
+import re
+import sys
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
+
+import wandb
+from wandb.sdk.artifacts.artifact import Artifact
+from wandb.sdk.data_types._dtypes import TypeRegistry
+from wandb.sdk.internal.internal_api import Api
+from wandb.sdk.lib.filenames import DIFF_FNAME, METADATA_FNAME, REQUIREMENTS_FNAME
+from wandb.util import make_artifact_name_safe
+
+from .settings_static import SettingsStatic
+
+if sys.version_info >= (3, 8):
+    from typing import Literal, TypedDict
+else:
+    from typing_extensions import Literal, TypedDict
+
+_logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from wandb.proto.wandb_internal_pb2 import ArtifactRecord
+
+FROZEN_REQUIREMENTS_FNAME = "requirements.frozen.txt"
+JOB_FNAME = "wandb-job.json"
+JOB_ARTIFACT_TYPE = "job"
+
+LOG_LEVEL = Literal["log", "warn", "error"]
+
+
+class Version:
+    def __init__(self, major: int, minor: int, patch: int):
+        self._major = major
+        self._minor = minor
+        self._patch = patch
+
+    def __repr__(self) -> str:
+        return f"{self._major}.{self._minor}.{self._patch}"
+
+    def __lt__(self, other: "Version") -> bool:
+        if self._major < other._major:
+            return True
+        elif self._major == other._major:
+            if self._minor < other._minor:
+                return True
+            elif self._minor == other._minor:
+                if self._patch < other._patch:
+                    return True
+        return False
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Version):
+            return NotImplemented
+        return (
+            self._major == other._major
+            and self._minor == other._minor
+            and self._patch == other._patch
+        )
+
+
+# Minimum supported wandb version for keys in the source dict of wandb-job.json
+SOURCE_KEYS_MIN_SUPPORTED_VERSION = {
+    "dockerfile": Version(0, 17, 0),
+    "build_context": Version(0, 17, 0),
+}
+
+
+class GitInfo(TypedDict):
+    remote: str
+    commit: str
+
+
+class GitSourceDict(TypedDict):
+    git: GitInfo
+    entrypoint: List[str]
+    notebook: bool
+    build_context: Optional[str]
+    dockerfile: Optional[str]
+
+
+class ArtifactSourceDict(TypedDict):
+    artifact: str
+    entrypoint: List[str]
+    notebook: bool
+    build_context: Optional[str]
+    dockerfile: Optional[str]
+
+
+class ImageSourceDict(TypedDict):
+    image: str
+
+
+class JobSourceDict(TypedDict, total=False):
+    _version: str
+    source_type: str
+    source: Union[GitSourceDict, ArtifactSourceDict, ImageSourceDict]
+    input_types: Dict[str, Any]
+    output_types: Dict[str, Any]
+    runtime: Optional[str]
+
+
+class ArtifactInfoForJob(TypedDict):
+    id: str
+    name: str
+
+
+def get_min_supported_for_source_dict(
+    source: Union[GitSourceDict, ArtifactSourceDict, ImageSourceDict],
+) -> Optional[Version]:
+    """Get the minimum supported wandb version the source dict of wandb-job.json."""
+    min_seen = None
+    for key in source:
+        new_ver = SOURCE_KEYS_MIN_SUPPORTED_VERSION.get(key)
+        if new_ver:
+            if min_seen is None or new_ver < min_seen:
+                min_seen = new_ver
+    return min_seen
+
+
+class JobArtifact(Artifact):
+    def __init__(self, name: str, *args: Any, **kwargs: Any):
+        super().__init__(name, "placeholder", *args, **kwargs)
+        self._type = JOB_ARTIFACT_TYPE  # Get around type restriction.
+
+
+class JobBuilder:
+    _settings: SettingsStatic
+    _metadatafile_path: Optional[str]
+    _requirements_path: Optional[str]
+    _config: Optional[Dict[str, Any]]
+    _summary: Optional[Dict[str, Any]]
+    _logged_code_artifact: Optional[ArtifactInfoForJob]
+    _disable: bool
+    _partial_source_id: Optional[str]  # Partial job source artifact id.
+    _aliases: List[str]
+    _job_seq_id: Optional[str]
+    _job_version_alias: Optional[str]
+    _is_notebook_run: bool
+    _verbose: bool
+
+    def __init__(self, settings: SettingsStatic, verbose: bool = False):
+        self._settings = settings
+        self._metadatafile_path = None
+        self._requirements_path = None
+        self._config = None
+        self._summary = None
+        self._logged_code_artifact = None
+        self._job_seq_id = None
+        self._job_version_alias = None
+        self._disable = settings.disable_job_creation
+        self._partial_source_id = None
+        self._aliases = []
+        self._source_type: Optional[Literal["repo", "artifact", "image"]] = (
+            settings.job_source  # type: ignore[assignment]
+        )
+        self._is_notebook_run = self._get_is_notebook_run()
+        self._verbose = verbose
+        self._partial = False
+
+    def set_config(self, config: Dict[str, Any]) -> None:
+        self._config = config
+
+    def set_summary(self, summary: Dict[str, Any]) -> None:
+        self._summary = summary
+
+    @property
+    def disable(self) -> bool:
+        return self._disable
+
+    @disable.setter
+    def disable(self, val: bool) -> None:
+        self._disable = val
+
+    @property
+    def input_types(self) -> Dict[str, Any]:
+        return TypeRegistry.type_of(self._config).to_json()
+
+    @property
+    def output_types(self) -> Dict[str, Any]:
+        return TypeRegistry.type_of(self._summary).to_json()
+
+    def set_partial_source_id(self, source_id: str) -> None:
+        self._partial_source_id = source_id
+
+    def _handle_server_artifact(
+        self, res: Optional[Dict], artifact: "ArtifactRecord"
+    ) -> None:
+        if artifact.type == "job" and res is not None:
+            try:
+                if res["artifactSequence"]["latestArtifact"] is None:
+                    self._job_version_alias = "v0"
+                elif res["artifactSequence"]["latestArtifact"]["id"] == res["id"]:
+                    self._job_version_alias = (
+                        f"v{res['artifactSequence']['latestArtifact']['versionIndex']}"
+                    )
+                else:
+                    self._job_version_alias = f"v{res['artifactSequence']['latestArtifact']['versionIndex'] + 1}"
+                self._job_seq_id = res["artifactSequence"]["id"]
+            except KeyError as e:
+                _logger.info(f"Malformed response from ArtifactSaver.save {e}")
+        if artifact.type == "code" and res is not None:
+            self._logged_code_artifact = ArtifactInfoForJob(
+                {
+                    "id": res["id"],
+                    "name": artifact.name,
+                }
+            )
+
+    def _build_repo_job_source(
+        self,
+        program_relpath: str,
+        metadata: Dict[str, Any],
+    ) -> Tuple[Optional[GitSourceDict], Optional[str]]:
+        git_info: Dict[str, str] = metadata.get("git", {})
+        remote = git_info.get("remote")
+        commit = git_info.get("commit")
+        root = metadata.get("root")
+        assert remote is not None
+        assert commit is not None
+        if self._is_notebook_run:
+            if not os.path.exists(
+                os.path.join(os.getcwd(), os.path.basename(program_relpath))
+            ):
+                return None, None
+
+            if root is None or self._settings._jupyter_root is None:
+                _logger.info("target path does not exist, exiting")
+                return None, None
+            assert self._settings._jupyter_root is not None
+            # git notebooks set the root to the git root,
+            # jupyter_root contains the path where the jupyter notebook was started
+            # program_relpath contains the path from jupyter_root to the file
+            # full program path here is actually the relpath from the program to the git root
+            full_program_path = os.path.join(
+                os.path.relpath(str(self._settings._jupyter_root), root),
+                program_relpath,
+            )
+            full_program_path = os.path.normpath(full_program_path)
+            # if the notebook server is started above the git repo need to clear all the ..s
+            if full_program_path.startswith(".."):
+                split_path = full_program_path.split("/")
+                count_dots = 0
+                for p in split_path:
+                    if p == "..":
+                        count_dots += 1
+                full_program_path = "/".join(split_path[2 * count_dots :])
+        else:
+            full_program_path = program_relpath
+
+        entrypoint = self._get_entrypoint(full_program_path, metadata)
+        # TODO: update executable to a method that supports pex
+        source: GitSourceDict = {
+            "git": {"remote": remote, "commit": commit},
+            "entrypoint": entrypoint,
+            "notebook": self._is_notebook_run,
+            "build_context": metadata.get("build_context"),
+            "dockerfile": metadata.get("dockerfile"),
+        }
+        name = self._make_job_name(f"{remote}_{program_relpath}")
+
+        return source, name
+
+    def _log_if_verbose(self, message: str, level: LOG_LEVEL) -> None:
+        log_func: Optional[Union[Callable[[Any], None], Callable[[Any], None]]] = None
+        if level == "log":
+            _logger.info(message)
+            log_func = wandb.termlog
+        elif level == "warn":
+            _logger.warning(message)
+            log_func = wandb.termwarn
+        elif level == "error":
+            _logger.error(message)
+            log_func = wandb.termerror
+
+        if self._verbose and log_func is not None:
+            log_func(message)
+
+    def _build_artifact_job_source(
+        self,
+        program_relpath: str,
+        metadata: Dict[str, Any],
+    ) -> Tuple[Optional[ArtifactSourceDict], Optional[str]]:
+        assert isinstance(self._logged_code_artifact, dict)
+        # TODO: should we just always exit early if the path doesn't exist?
+        if self._is_notebook_run and not self._is_colab_run():
+            full_program_relpath = os.path.relpath(program_relpath, os.getcwd())
+            # if the resolved path doesn't exist, then we shouldn't make a job because it will fail
+            if not os.path.exists(full_program_relpath):
+                # when users call log code in a notebook the code artifact starts
+                # at the directory the notebook is in instead of the jupyter core
+                if not os.path.exists(os.path.basename(program_relpath)):
+                    _logger.info("target path does not exist, exiting")
+                    self._log_if_verbose(
+                        "No program path found when generating artifact job source for a non-colab notebook run. See https://docs.wandb.ai/guides/launch/create-job",
+                        "warn",
+                    )
+                    return None, None
+                full_program_relpath = os.path.basename(program_relpath)
+        else:
+            full_program_relpath = program_relpath
+
+        entrypoint = self._get_entrypoint(full_program_relpath, metadata)
+        # TODO: update executable to a method that supports pex
+        source: ArtifactSourceDict = {
+            "entrypoint": entrypoint,
+            "notebook": self._is_notebook_run,
+            "artifact": f"wandb-artifact://_id/{self._logged_code_artifact['id']}",
+            "build_context": metadata.get("build_context"),
+            "dockerfile": metadata.get("dockerfile"),
+        }
+        name = self._make_job_name(self._logged_code_artifact["name"])
+
+        return source, name
+
+    def _build_image_job_source(
+        self, metadata: Dict[str, Any]
+    ) -> Tuple[ImageSourceDict, str]:
+        image_name = metadata.get("docker")
+        assert isinstance(image_name, str)
+
+        raw_image_name = image_name
+        if ":" in image_name:
+            tag = image_name.split(":")[-1]
+
+            # if tag looks properly formatted, assume its a tag
+            # regex: alphanumeric and "_" "-" "."
+            if re.fullmatch(r"([a-zA-Z0-9_\-\.]+)", tag):
+                raw_image_name = raw_image_name.replace(f":{tag}", "")
+                self._aliases += [tag]
+
+        source: ImageSourceDict = {
+            "image": image_name,
+        }
+        name = self._make_job_name(raw_image_name)
+
+        return source, name
+
+    def _make_job_name(self, input_str: str) -> str:
+        """Use job name from settings if provided, else use programmatic name."""
+        if self._settings.job_name:
+            return self._settings.job_name
+
+        return make_artifact_name_safe(f"job-{input_str}")
+
+    def _get_entrypoint(
+        self,
+        program_relpath: str,
+        metadata: Dict[str, Any],
+    ) -> List[str]:
+        # if building a partial job from CLI, overwrite entrypoint and notebook
+        # should already be in metadata from create_job
+        if self._partial:
+            if metadata.get("entrypoint"):
+                entrypoint: List[str] = metadata["entrypoint"]
+                return entrypoint
+        # job is being built from a run
+        entrypoint = [os.path.basename(sys.executable), program_relpath]
+
+        return entrypoint
+
+    def _get_is_notebook_run(self) -> bool:
+        return hasattr(self._settings, "_jupyter") and bool(self._settings._jupyter)
+
+    def _is_colab_run(self) -> bool:
+        return hasattr(self._settings, "_colab") and bool(self._settings._colab)
+
+    def _build_job_source(
+        self,
+        source_type: str,
+        program_relpath: Optional[str],
+        metadata: Dict[str, Any],
+    ) -> Tuple[
+        Union[GitSourceDict, ArtifactSourceDict, ImageSourceDict, None],
+        Optional[str],
+    ]:
+        """Construct a job source dict and name from the current run.
+
+        Arguments:
+            source_type (str): The type of source to build the job from. One of
+                "repo", "artifact", or "image".
+        """
+        source: Union[
+            GitSourceDict,
+            ArtifactSourceDict,
+            ImageSourceDict,
+            None,
+        ] = None
+
+        if source_type == "repo":
+            source, name = self._build_repo_job_source(
+                program_relpath or "",
+                metadata,
+            )
+        elif source_type == "artifact":
+            source, name = self._build_artifact_job_source(
+                program_relpath or "",
+                metadata,
+            )
+        elif source_type == "image" and self._has_image_job_ingredients(metadata):
+            source, name = self._build_image_job_source(metadata)
+        else:
+            source = None
+
+        if source is None:
+            if source_type:
+                self._log_if_verbose(
+                    f"Source type is set to '{source_type}' but some required information is missing "
+                    "from the environment. A job will not be created from this run. See "
+                    "https://docs.wandb.ai/guides/launch/create-job",
+                    "warn",
+                )
+            return None, None
+
+        return source, name
+
+    def build(
+        self,
+        api: Api,
+        build_context: Optional[str] = None,
+        dockerfile: Optional[str] = None,
+        base_image: Optional[str] = None,
+    ) -> Optional[Artifact]:
+        """Build a job artifact from the current run.
+
+        Arguments:
+            api (Api): The API object to use to create the job artifact.
+            build_context (Optional[str]): Path within the job source code to
+                the image build context. Saved as part of the job for future
+                builds.
+            dockerfile (Optional[str]): Path within the build context the
+                Dockerfile. Saved as part of the job for future builds.
+            base_image (Optional[str]): The base image used to run the job code.
+
+        Returns:
+            Optional[Artifact]: The job artifact if it was successfully built,
+            otherwise None.
+        """
+        _logger.info("Attempting to build job artifact")
+
+        # If a partial job was used, write the input/output types to the metadata
+        # rather than building a new job version.
+        if self._partial_source_id is not None:
+            new_metadata = {
+                "input_types": {"@wandb.config": self.input_types},
+                "output_types": self.output_types,
+            }
+            api.update_artifact_metadata(
+                self._partial_source_id,
+                new_metadata,
+            )
+            return None
+
+        if not os.path.exists(
+            os.path.join(self._settings.files_dir, REQUIREMENTS_FNAME)
+        ):
+            self._log_if_verbose(
+                "No requirements.txt found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                "warn",
+            )
+            return None
+        metadata = self._handle_metadata_file()
+        if metadata is None:
+            self._log_if_verbose(
+                f"Ensure read and write access to run files dir: {self._settings.files_dir}, control this via the WANDB_DIR env var. See https://docs.wandb.ai/guides/track/environment-variables",
+                "warn",
+            )
+            return None
+
+        runtime: Optional[str] = metadata.get("python")
+        # can't build a job without a python version
+        if runtime is None:
+            self._log_if_verbose(
+                "No python version found in metadata, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                "warn",
+            )
+            return None
+
+        input_types = TypeRegistry.type_of(self._config).to_json()
+        output_types = TypeRegistry.type_of(self._summary).to_json()
+
+        name: Optional[str] = None
+        source_info: Optional[JobSourceDict] = None
+
+        # configure job from environment
+        source_type = self._get_source_type(metadata)
+        if not source_type:
+            # if source_type is None, then we don't have enough information to build a job
+            # if the user intended to create a job, warn.
+            if (
+                self._settings.job_name
+                or self._settings.job_source
+                or self._source_type
+            ):
+                self._log_if_verbose(
+                    "No source type found, not creating job artifact", "warn"
+                )
+            return None
+
+        program_relpath = self._get_program_relpath(source_type, metadata)
+        if not self._partial and source_type != "image" and not program_relpath:
+            self._log_if_verbose(
+                "No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job",
+                "warn",
+            )
+            return None
+
+        source, name = self._build_job_source(
+            source_type,
+            program_relpath,
+            metadata,
+        )
+        if source is None:
+            return None
+
+        if build_context:
+            source["build_context"] = build_context  # type: ignore[typeddict-item]
+        if dockerfile:
+            source["dockerfile"] = dockerfile  # type: ignore[typeddict-item]
+        if base_image:
+            source["base_image"] = base_image  # type: ignore[typeddict-item]
+
+        # Pop any keys that are initialized to None. The current TypedDict
+        # system for source dicts requires all keys to be present, but we
+        # don't want to include keys that are None in the final dict.
+        for key in list(source.keys()):
+            if source[key] is None:  # type: ignore[literal-required]
+                source.pop(key)  # type: ignore[literal-require,misc]
+
+        source_info = {
+            "_version": str(get_min_supported_for_source_dict(source) or "v0"),
+            "source_type": source_type,
+            "source": source,
+            "input_types": input_types,
+            "output_types": output_types,
+            "runtime": runtime,
+        }
+
+        assert source_info is not None
+        assert name is not None
+
+        artifact = JobArtifact(name)
+
+        _logger.info("adding wandb-job metadata file")
+        with artifact.new_file("wandb-job.json") as f:
+            f.write(json.dumps(source_info, indent=4))
+
+        artifact.add_file(
+            os.path.join(self._settings.files_dir, REQUIREMENTS_FNAME),
+            name=FROZEN_REQUIREMENTS_FNAME,
+        )
+
+        if source_type == "repo":
+            # add diff
+            if os.path.exists(os.path.join(self._settings.files_dir, DIFF_FNAME)):
+                artifact.add_file(
+                    os.path.join(self._settings.files_dir, DIFF_FNAME),
+                    name=DIFF_FNAME,
+                )
+
+        return artifact
+
+    def _get_source_type(self, metadata: Dict[str, Any]) -> Optional[str]:
+        if self._source_type:
+            return self._source_type
+
+        if self._has_git_job_ingredients(metadata):
+            _logger.info("is repo sourced job")
+            return "repo"
+
+        if self._has_artifact_job_ingredients():
+            _logger.info("is artifact sourced job")
+            return "artifact"
+
+        if self._has_image_job_ingredients(metadata):
+            _logger.info("is image sourced job")
+            return "image"
+
+        _logger.info("no source found")
+        return None
+
+    def _get_program_relpath(
+        self, source_type: str, metadata: Dict[str, Any]
+    ) -> Optional[str]:
+        if self._is_notebook_run:
+            _logger.info("run is notebook based run")
+            program = metadata.get("program")
+
+            if not program:
+                self._log_if_verbose(
+                    "Notebook 'program' path not found in metadata. See https://docs.wandb.ai/guides/launch/create-job",
+                    "warn",
+                )
+
+            return program
+
+        if source_type == "artifact" or self._settings.job_source == "artifact":
+            # if the job is set to be an artifact, use relpath guaranteed
+            # to be correct. 'codePath' uses the root path when in git repo
+            # fallback to codePath if strictly local relpath not present
+            return metadata.get("codePathLocal") or metadata.get("codePath")
+
+        return metadata.get("codePath")
+
+    def _handle_metadata_file(
+        self,
+    ) -> Optional[Dict]:
+        if os.path.exists(os.path.join(self._settings.files_dir, METADATA_FNAME)):
+            with open(os.path.join(self._settings.files_dir, METADATA_FNAME)) as f:
+                metadata: Dict = json.load(f)
+            return metadata
+
+        return None
+
+    def _has_git_job_ingredients(self, metadata: Dict[str, Any]) -> bool:
+        git_info: Dict[str, str] = metadata.get("git", {})
+        if self._is_notebook_run and metadata.get("root") is None:
+            return False
+        return git_info.get("remote") is not None and git_info.get("commit") is not None
+
+    def _has_artifact_job_ingredients(self) -> bool:
+        return self._logged_code_artifact is not None
+
+    def _has_image_job_ingredients(self, metadata: Dict[str, Any]) -> bool:
+        return metadata.get("docker") is not None

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

@@ -0,0 +1,83 @@
+"""progress."""
+
+import os
+import sys
+from typing import IO, TYPE_CHECKING, Optional
+
+from wandb.errors import CommError
+
+if TYPE_CHECKING:
+    if sys.version_info >= (3, 8):
+        from typing import Protocol
+    else:
+        from typing_extensions import Protocol
+
+    class ProgressFn(Protocol):
+        def __call__(self, new_bytes: int, total_bytes: int) -> None:
+            pass
+
+
+class Progress:
+    """A helper class for displaying progress."""
+
+    ITER_BYTES = 1024 * 1024
+
+    def __init__(
+        self, file: IO[bytes], callback: Optional["ProgressFn"] = None
+    ) -> None:
+        self.file = file
+        if callback is None:
+
+            def callback_(new_bytes: int, total_bytes: int) -> None:
+                pass
+
+            callback = callback_
+
+        self.callback: ProgressFn = callback
+        self.bytes_read = 0
+        self.len = os.fstat(file.fileno()).st_size
+
+    def read(self, size=-1):
+        """Read bytes and call the callback."""
+        bites = self.file.read(size)
+        self.bytes_read += len(bites)
+        if not bites and self.bytes_read < self.len:
+            # Files shrinking during uploads causes request timeouts. Maybe
+            # we could avoid those by updating the self.len in real-time, but
+            # files getting truncated while uploading seems like something
+            # that shouldn't really be happening anyway.
+            raise CommError(
+                "File {} size shrank from {} to {} while it was being uploaded.".format(
+                    self.file.name, self.len, self.bytes_read
+                )
+            )
+        # Growing files are also likely to be bad, but our code didn't break
+        # on those in the past, so it's riskier to make that an error now.
+        self.callback(len(bites), self.bytes_read)
+        return bites
+
+    def rewind(self) -> None:
+        self.callback(-self.bytes_read, 0)
+        self.bytes_read = 0
+        self.file.seek(0)
+
+    def __getattr__(self, name):
+        """Fallback to the file object for attrs not defined here."""
+        if hasattr(self.file, name):
+            return getattr(self.file, name)
+        else:
+            raise AttributeError
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        bites = self.read(self.ITER_BYTES)
+        if len(bites) == 0:
+            raise StopIteration
+        return bites
+
+    def __len__(self):
+        return self.len
+
+    next = __next__

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

@@ -0,0 +1,18 @@
+import threading
+from typing import Dict, Optional
+
+
+# Context variable for setting API settings (api keys, etc.) for internal and public apis thread-locally
+# TODO: move this into actual settings
+class _ThreadLocalApiSettings(threading.local):
+    api_key: Optional[str]
+    cookies: Optional[Dict]
+    headers: Optional[Dict]
+
+    def __init__(self) -> None:
+        self.api_key = None
+        self.cookies = None
+        self.headers = None
+
+
+_thread_local_api_settings: _ThreadLocalApiSettings = _ThreadLocalApiSettings()

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

@@ -0,0 +1,113 @@
+from typing import Dict, Optional, Tuple
+
+import requests
+
+import wandb
+
+
+def _find_available(
+    current_version: str,
+) -> Optional[Tuple[str, bool, bool, bool, Optional[str]]]:
+    from wandb.util import parse_version
+
+    pypi_url = "https://pypi.org/pypi/wandb/json"
+
+    yanked_dict = {}
+    try:
+        # raise Exception("test")
+        async_requests_get = wandb.util.async_call(requests.get, timeout=5)
+        data, thread = async_requests_get(pypi_url, timeout=3)
+        if not data or isinstance(data, Exception):
+            return None
+        data = data.json()
+        latest_version = data["info"]["version"]
+        release_list = data["releases"].keys()
+        for version, fields in data["releases"].items():
+            for item in fields:
+                yanked = item.get("yanked")
+                yanked_reason = item.get("yanked_reason")
+                if yanked:
+                    yanked_dict[version] = yanked_reason
+    except Exception:
+        # Any issues whatsoever, just skip the latest version check.
+        return None
+
+    # Return if no update is available
+    pip_prerelease = False
+    deleted = False
+    yanked = False
+    yanked_reason = None
+    parsed_current_version = parse_version(current_version)
+
+    # Check if current version has been yanked or deleted
+    # NOTE: we will not return yanked or deleted if there is nothing to upgrade to
+    if current_version in release_list:
+        yanked = current_version in yanked_dict
+        yanked_reason = yanked_dict.get(current_version)
+    else:
+        deleted = True
+
+    # Check pre-releases
+    if parse_version(latest_version) <= parsed_current_version:
+        # pre-releases are not included in latest_version
+        # so if we are currently running a pre-release we check more
+        if not parsed_current_version.is_prerelease:
+            return None
+        # Candidates are pre-releases with the same base_version
+        release_list = map(parse_version, release_list)
+        release_list = filter(lambda v: v.is_prerelease, release_list)
+        release_list = filter(
+            lambda v: v.base_version == parsed_current_version.base_version,
+            release_list,
+        )
+        release_list = sorted(release_list)
+        if not release_list:
+            return None
+
+        parsed_latest_version = release_list[-1]
+        if parsed_latest_version <= parsed_current_version:
+            return None
+        latest_version = str(parsed_latest_version)
+        pip_prerelease = True
+
+    return latest_version, pip_prerelease, deleted, yanked, yanked_reason
+
+
+def check_available(current_version: str) -> Optional[Dict[str, Optional[str]]]:
+    package_info = _find_available(current_version)
+    if not package_info:
+        return None
+
+    wandb_module_name = "wandb"
+
+    latest_version, pip_prerelease, deleted, yanked, yanked_reason = package_info
+    upgrade_message = (
+        "{} version {} is available!  To upgrade, please run:\n"
+        " $ pip install {} --upgrade{}".format(
+            wandb_module_name,
+            latest_version,
+            wandb_module_name,
+            " --pre" if pip_prerelease else "",
+        )
+    )
+    delete_message = None
+    if deleted:
+        delete_message = "{} version {} has been retired!  Please upgrade.".format(
+            wandb_module_name,
+            current_version,
+        )
+    yank_message = None
+    if yanked:
+        reason_message = "({})  ".format(yanked_reason) if yanked_reason else ""
+        yank_message = "{} version {} has been recalled!  {}Please upgrade.".format(
+            wandb_module_name,
+            current_version,
+            reason_message,
+        )
+
+    # A new version is available!
+    return {
+        "upgrade_message": upgrade_message,
+        "yank_message": yank_message,
+        "delete_message": delete_message,
+    }