Add files using upload-large-folder tool

.gitattributes

@@ -147,3 +147,4 @@ parrot/lib/python3.10/site-packages/wandb/vendor/pygments/lexers/__pycache__/_ph
 parrot/lib/python3.10/site-packages/aiohttp/_http_writer.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libquadmath.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/pyarrow/_dataset_parquet.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text

parrot/lib/python3.10/ensurepip/_bundled/setuptools-65.5.0-py3-none-any.whl

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

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

@@ -0,0 +1,43 @@
+"""Artifact download logger."""
+
+import multiprocessing.dummy
+import time
+from typing import Callable
+
+from wandb.errors.term import termlog
+
+
+class ArtifactDownloadLogger:
+    def __init__(
+        self,
+        nfiles: int,
+        clock_for_testing: Callable[[], float] = time.monotonic,
+        termlog_for_testing: Callable[..., None] = termlog,
+    ) -> None:
+        self._nfiles = nfiles
+        self._clock = clock_for_testing
+        self._termlog = termlog_for_testing
+
+        self._n_files_downloaded = 0
+        self._spinner_index = 0
+        self._last_log_time = self._clock()
+        self._lock = multiprocessing.dummy.Lock()
+
+    def notify_downloaded(self) -> None:
+        with self._lock:
+            self._n_files_downloaded += 1
+            if self._n_files_downloaded == self._nfiles:
+                self._termlog(
+                    f"  {self._nfiles} of {self._nfiles} files downloaded.  ",
+                    # ^ trailing spaces to wipe out ellipsis from previous logs
+                    newline=True,
+                )
+                self._last_log_time = self._clock()
+            elif self._clock() - self._last_log_time > 0.1:
+                self._spinner_index += 1
+                spinner = r"-\|/"[self._spinner_index % 4]
+                self._termlog(
+                    f"{spinner} {self._n_files_downloaded} of {self._nfiles} files downloaded...\r",
+                    newline=False,
+                )
+                self._last_log_time = self._clock()

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

@@ -0,0 +1,72 @@
+"""Artifact manifest."""
+
+from typing import TYPE_CHECKING, Dict, List, Mapping, Optional
+
+from wandb.sdk.internal.internal_api import Api as InternalApi
+from wandb.sdk.lib.hashutil import HexMD5
+
+if TYPE_CHECKING:
+    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+    from wandb.sdk.artifacts.storage_policy import StoragePolicy
+
+
+class ArtifactManifest:
+    entries: Dict[str, "ArtifactManifestEntry"]
+
+    @classmethod
+    def from_manifest_json(
+        cls, manifest_json: Dict, api: Optional[InternalApi] = None
+    ) -> "ArtifactManifest":
+        if "version" not in manifest_json:
+            raise ValueError("Invalid manifest format. Must contain version field.")
+        version = manifest_json["version"]
+        for sub in cls.__subclasses__():
+            if sub.version() == version:
+                return sub.from_manifest_json(manifest_json, api=api)
+        raise ValueError("Invalid manifest version.")
+
+    @classmethod
+    def version(cls) -> int:
+        raise NotImplementedError
+
+    def __init__(
+        self,
+        storage_policy: "StoragePolicy",
+        entries: Optional[Mapping[str, "ArtifactManifestEntry"]] = None,
+    ) -> None:
+        self.storage_policy = storage_policy
+        self.entries = dict(entries) if entries else {}
+
+    def __len__(self) -> int:
+        return len(self.entries)
+
+    def to_manifest_json(self) -> Dict:
+        raise NotImplementedError
+
+    def digest(self) -> HexMD5:
+        raise NotImplementedError
+
+    def add_entry(self, entry: "ArtifactManifestEntry") -> None:
+        if (
+            entry.path in self.entries
+            and entry.digest != self.entries[entry.path].digest
+        ):
+            raise ValueError("Cannot add the same path twice: {}".format(entry.path))
+        self.entries[entry.path] = entry
+
+    def remove_entry(self, entry: "ArtifactManifestEntry") -> None:
+        if entry.path not in self.entries:
+            raise FileNotFoundError(f"Cannot remove missing entry: '{entry.path}'")
+        del self.entries[entry.path]
+
+    def get_entry_by_path(self, path: str) -> Optional["ArtifactManifestEntry"]:
+        return self.entries.get(path)
+
+    def get_entries_in_directory(self, directory: str) -> List["ArtifactManifestEntry"]:
+        return [
+            self.entries[entry_key]
+            for entry_key in self.entries
+            if entry_key.startswith(
+                directory + "/"
+            )  # entries use forward slash even for windows
+        ]

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

@@ -0,0 +1,267 @@
+"""Artifact saver."""
+
+import concurrent.futures
+import json
+import os
+import sys
+import tempfile
+from typing import TYPE_CHECKING, Awaitable, Dict, Optional, Sequence
+
+import wandb
+import wandb.filesync.step_prepare
+from wandb import util
+from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
+from wandb.sdk.lib.hashutil import B64MD5, b64_to_hex_id, md5_file_b64
+from wandb.sdk.lib.paths import URIStr
+
+if TYPE_CHECKING:
+    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+    from wandb.sdk.internal.file_pusher import FilePusher
+    from wandb.sdk.internal.internal_api import Api as InternalApi
+    from wandb.sdk.internal.progress import ProgressFn
+
+    if sys.version_info >= (3, 8):
+        from typing import Protocol
+    else:
+        from typing_extensions import Protocol
+
+    class SaveFn(Protocol):
+        def __call__(
+            self, entry: "ArtifactManifestEntry", progress_callback: "ProgressFn"
+        ) -> bool:
+            pass
+
+    class SaveFnAsync(Protocol):
+        def __call__(
+            self, entry: "ArtifactManifestEntry", progress_callback: "ProgressFn"
+        ) -> Awaitable[bool]:
+            pass
+
+
+class ArtifactSaver:
+    _server_artifact: Optional[Dict]  # TODO better define this dict
+
+    def __init__(
+        self,
+        api: "InternalApi",
+        digest: str,
+        manifest_json: Dict,
+        file_pusher: "FilePusher",
+        is_user_created: bool = False,
+    ) -> None:
+        self._api = api
+        self._file_pusher = file_pusher
+        self._digest = digest
+        self._manifest = ArtifactManifest.from_manifest_json(
+            manifest_json,
+            api=self._api,
+        )
+        self._is_user_created = is_user_created
+        self._server_artifact = None
+
+    def save(
+        self,
+        type: str,
+        name: str,
+        client_id: str,
+        sequence_client_id: str,
+        distributed_id: Optional[str] = None,
+        finalize: bool = True,
+        metadata: Optional[Dict] = None,
+        ttl_duration_seconds: Optional[int] = None,
+        description: Optional[str] = None,
+        aliases: Optional[Sequence[str]] = None,
+        tags: Optional[Sequence[str]] = None,
+        use_after_commit: bool = False,
+        incremental: bool = False,
+        history_step: Optional[int] = None,
+        base_id: Optional[str] = None,
+    ) -> Optional[Dict]:
+        return self._save_internal(
+            type,
+            name,
+            client_id,
+            sequence_client_id,
+            distributed_id,
+            finalize,
+            metadata,
+            ttl_duration_seconds,
+            description,
+            aliases,
+            tags,
+            use_after_commit,
+            incremental,
+            history_step,
+            base_id,
+        )
+
+    def _save_internal(
+        self,
+        type: str,
+        name: str,
+        client_id: str,
+        sequence_client_id: str,
+        distributed_id: Optional[str] = None,
+        finalize: bool = True,
+        metadata: Optional[Dict] = None,
+        ttl_duration_seconds: Optional[int] = None,
+        description: Optional[str] = None,
+        aliases: Optional[Sequence[str]] = None,
+        tags: Optional[Sequence[str]] = None,
+        use_after_commit: bool = False,
+        incremental: bool = False,
+        history_step: Optional[int] = None,
+        base_id: Optional[str] = None,
+    ) -> Optional[Dict]:
+        alias_specs = []
+        for alias in aliases or []:
+            alias_specs.append({"artifactCollectionName": name, "alias": alias})
+
+        tag_specs = [{"tagName": tag} for tag in tags or []]
+
+        """Returns the server artifact."""
+        self._server_artifact, latest = self._api.create_artifact(
+            type,
+            name,
+            self._digest,
+            metadata=metadata,
+            ttl_duration_seconds=ttl_duration_seconds,
+            aliases=alias_specs,
+            tags=tag_specs,
+            description=description,
+            is_user_created=self._is_user_created,
+            distributed_id=distributed_id,
+            client_id=client_id,
+            sequence_client_id=sequence_client_id,
+            history_step=history_step,
+        )
+
+        assert self._server_artifact is not None  # mypy optionality unwrapper
+        artifact_id = self._server_artifact["id"]
+        if base_id is None and latest:
+            base_id = latest["id"]
+        if self._server_artifact["state"] == "COMMITTED":
+            if use_after_commit:
+                self._api.use_artifact(artifact_id)
+            return self._server_artifact
+        if (
+            self._server_artifact["state"] != "PENDING"
+            # For old servers, see https://github.com/wandb/wandb/pull/6190
+            and self._server_artifact["state"] != "DELETED"
+        ):
+            raise Exception(
+                'Unknown artifact state "{}"'.format(self._server_artifact["state"])
+            )
+
+        manifest_type = "FULL"
+        manifest_filename = "wandb_manifest.json"
+        if incremental:
+            manifest_type = "INCREMENTAL"
+            manifest_filename = "wandb_manifest.incremental.json"
+        elif distributed_id:
+            manifest_type = "PATCH"
+            manifest_filename = "wandb_manifest.patch.json"
+        artifact_manifest_id, _ = self._api.create_artifact_manifest(
+            manifest_filename,
+            "",
+            artifact_id,
+            base_artifact_id=base_id,
+            include_upload=False,
+            type=manifest_type,
+        )
+
+        step_prepare = wandb.filesync.step_prepare.StepPrepare(
+            self._api, 0.1, 0.01, 1000
+        )  # TODO: params
+        step_prepare.start()
+
+        # Upload Artifact "L1" files, the actual artifact contents
+        self._file_pusher.store_manifest_files(
+            self._manifest,
+            artifact_id,
+            lambda entry, progress_callback: self._manifest.storage_policy.store_file(
+                artifact_id,
+                artifact_manifest_id,
+                entry,
+                step_prepare,
+                progress_callback=progress_callback,
+            ),
+        )
+
+        def before_commit() -> None:
+            self._resolve_client_id_manifest_references()
+            with tempfile.NamedTemporaryFile("w+", suffix=".json", delete=False) as fp:
+                path = os.path.abspath(fp.name)
+                json.dump(self._manifest.to_manifest_json(), fp, indent=4)
+            digest = md5_file_b64(path)
+            if distributed_id or incremental:
+                # If we're in the distributed flow, we want to update the
+                # patch manifest we created with our finalized digest.
+                _, resp = self._api.update_artifact_manifest(
+                    artifact_manifest_id,
+                    digest=digest,
+                )
+            else:
+                # In the regular flow, we can recreate the full manifest with the
+                # updated digest.
+                #
+                # NOTE: We do this for backwards compatibility with older backends
+                # that don't support the 'updateArtifactManifest' API.
+                _, resp = self._api.create_artifact_manifest(
+                    manifest_filename,
+                    digest,
+                    artifact_id,
+                    base_artifact_id=base_id,
+                )
+
+            # We're duplicating the file upload logic a little, which isn't great.
+            upload_url = resp["uploadUrl"]
+            upload_headers = resp["uploadHeaders"]
+            extra_headers = {}
+            for upload_header in upload_headers:
+                key, val = upload_header.split(":", 1)
+                extra_headers[key] = val
+            with open(path, "rb") as fp2:
+                self._api.upload_file_retry(
+                    upload_url,
+                    fp2,
+                    extra_headers=extra_headers,
+                )
+
+        commit_result: concurrent.futures.Future[None] = concurrent.futures.Future()
+
+        # This will queue the commit. It will only happen after all the file uploads are done
+        self._file_pusher.commit_artifact(
+            artifact_id,
+            finalize=finalize,
+            before_commit=before_commit,
+            result_future=commit_result,
+        )
+
+        # Block until all artifact files are uploaded and the
+        # artifact is committed.
+        try:
+            commit_result.result()
+        finally:
+            step_prepare.shutdown()
+
+        if finalize and use_after_commit:
+            self._api.use_artifact(artifact_id)
+
+        return self._server_artifact
+
+    def _resolve_client_id_manifest_references(self) -> None:
+        for entry_path in self._manifest.entries:
+            entry = self._manifest.entries[entry_path]
+            if entry.ref is not None:
+                if entry.ref.startswith("wandb-client-artifact:"):
+                    client_id = util.host_from_path(entry.ref)
+                    artifact_file_path = util.uri_from_path(entry.ref)
+                    artifact_id = self._api._resolve_client_id(client_id)
+                    if artifact_id is None:
+                        raise RuntimeError(f"Could not resolve client id {client_id}")
+                    entry.ref = URIStr(
+                        "wandb-artifact://{}/{}".format(
+                            b64_to_hex_id(B64MD5(artifact_id)), artifact_file_path
+                        )
+                    )

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

@@ -0,0 +1,25 @@
+"""Manages artifact file staging.
+
+Artifact files are copied to the staging area as soon as they are added to an artifact
+in order to avoid file changes corrupting the artifact. Once the upload is complete, the
+file should be moved to the artifact cache.
+"""
+
+import os
+
+from wandb import env
+from wandb.sdk.lib.filesystem import mkdir_exists_ok
+from wandb.sdk.lib.paths import FilePathStr
+
+
+def get_staging_dir() -> FilePathStr:
+    path = os.path.join(env.get_data_dir(), "artifacts", "staging")
+    try:
+        mkdir_exists_ok(path)
+    except OSError as e:
+        raise PermissionError(
+            f"Unable to write staging files to {path}. To fix this problem, please set "
+            f"{env.DATA_DIR} to a directory where you have the necessary write access."
+        ) from e
+
+    return FilePathStr(os.path.abspath(os.path.expanduser(path)))

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

@@ -0,0 +1,60 @@
+"""Storage handler."""
+
+from typing import TYPE_CHECKING, Optional, Sequence, Union
+
+from wandb.sdk.lib.paths import FilePathStr, URIStr
+
+if TYPE_CHECKING:
+    from urllib.parse import ParseResult
+
+    from wandb.sdk.artifacts.artifact import Artifact
+    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+
+DEFAULT_MAX_OBJECTS = 10**7
+
+
+class StorageHandler:
+    def can_handle(self, parsed_url: "ParseResult") -> bool:
+        """Checks whether this handler can handle the given url.
+
+        Returns:
+            Whether this handler can handle the given url.
+        """
+        raise NotImplementedError
+
+    def load_path(
+        self,
+        manifest_entry: "ArtifactManifestEntry",
+        local: bool = False,
+    ) -> Union[URIStr, FilePathStr]:
+        """Load a file or directory given the corresponding index entry.
+
+        Args:
+            manifest_entry: The index entry to load
+            local: Whether to load the file locally or not
+
+        Returns:
+            A path to the file represented by `index_entry`
+        """
+        raise NotImplementedError
+
+    def store_path(
+        self,
+        artifact: "Artifact",
+        path: Union[URIStr, FilePathStr],
+        name: Optional[str] = None,
+        checksum: bool = True,
+        max_objects: Optional[int] = None,
+    ) -> Sequence["ArtifactManifestEntry"]:
+        """Store the file or directory at the given path to the specified artifact.
+
+        Args:
+            path: The path to store
+            name: If specified, the logical name that should map to `path`
+            checksum: Whether to compute the checksum of the file
+            max_objects: The maximum number of objects to store
+
+        Returns:
+            A list of manifest entries to store within the artifact
+        """
+        raise NotImplementedError

parrot/lib/python3.10/site-packages/wandb/sdk/artifacts/storage_handlers/gcs_handler.py

@@ -0,0 +1,226 @@
+"""GCS storage handler."""
+
+import time
+from pathlib import PurePosixPath
+from typing import TYPE_CHECKING, Optional, Sequence, Tuple, Union
+from urllib.parse import ParseResult, urlparse
+
+from wandb import util
+from wandb.errors.term import termlog
+from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
+from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+from wandb.sdk.artifacts.storage_handler import DEFAULT_MAX_OBJECTS, StorageHandler
+from wandb.sdk.lib.hashutil import ETag
+from wandb.sdk.lib.paths import FilePathStr, StrPath, URIStr
+
+if TYPE_CHECKING:
+    import google.cloud.storage as gcs_module  # type: ignore
+
+    from wandb.sdk.artifacts.artifact import Artifact
+
+
+class _GCSIsADirectoryError(Exception):
+    """Raised when we try to download a GCS folder."""
+
+    pass
+
+
+class GCSHandler(StorageHandler):
+    _client: Optional["gcs_module.client.Client"]
+
+    def __init__(self, scheme: Optional[str] = None) -> None:
+        self._scheme = scheme or "gs"
+        self._client = None
+        self._cache = get_artifact_file_cache()
+
+    def can_handle(self, parsed_url: "ParseResult") -> bool:
+        return parsed_url.scheme == self._scheme
+
+    def init_gcs(self) -> "gcs_module.client.Client":
+        if self._client is not None:
+            return self._client
+        storage = util.get_module(
+            "google.cloud.storage",
+            required="gs:// references requires the google-cloud-storage library, run pip install wandb[gcp]",
+        )
+        self._client = storage.Client()
+        return self._client
+
+    def _parse_uri(self, uri: str) -> Tuple[str, str, Optional[str]]:
+        url = urlparse(uri)
+        bucket = url.netloc
+        key = url.path[1:]
+        version = url.fragment if url.fragment else None
+        return bucket, key, version
+
+    def load_path(
+        self,
+        manifest_entry: ArtifactManifestEntry,
+        local: bool = False,
+    ) -> Union[URIStr, FilePathStr]:
+        assert manifest_entry.ref is not None
+        if not local:
+            return manifest_entry.ref
+
+        path, hit, cache_open = self._cache.check_etag_obj_path(
+            url=URIStr(manifest_entry.ref),
+            etag=ETag(manifest_entry.digest),
+            size=manifest_entry.size if manifest_entry.size is not None else 0,
+        )
+        if hit:
+            return path
+
+        self.init_gcs()
+        assert self._client is not None  # mypy: unwraps optionality
+        assert manifest_entry.ref is not None
+        bucket, key, _ = self._parse_uri(manifest_entry.ref)
+        version = manifest_entry.extra.get("versionID")
+
+        if self._is_dir(manifest_entry):
+            raise _GCSIsADirectoryError(
+                f"Unable to download GCS folder {manifest_entry.ref!r}, skipping"
+            )
+
+        obj = None
+        # First attempt to get the generation specified, this will return None if versioning is not enabled
+        if version is not None:
+            obj = self._client.bucket(bucket).get_blob(key, generation=version)
+
+        if obj is None:
+            # Object versioning is disabled on the bucket, so just get
+            # the latest version and make sure the MD5 matches.
+            obj = self._client.bucket(bucket).get_blob(key)
+            if obj is None:
+                raise ValueError(
+                    f"Unable to download object {manifest_entry.ref} with generation {version}"
+                )
+            if obj.etag != manifest_entry.digest:
+                raise ValueError(
+                    f"Digest mismatch for object {manifest_entry.ref}: "
+                    f"expected {manifest_entry.digest} but found {obj.etag}"
+                )
+
+        with cache_open(mode="wb") as f:
+            obj.download_to_file(f)
+        return path
+
+    def store_path(
+        self,
+        artifact: "Artifact",
+        path: Union[URIStr, FilePathStr],
+        name: Optional[StrPath] = None,
+        checksum: bool = True,
+        max_objects: Optional[int] = None,
+    ) -> Sequence[ArtifactManifestEntry]:
+        self.init_gcs()
+        assert self._client is not None  # mypy: unwraps optionality
+
+        # After parsing any query params / fragments for additional context,
+        # such as version identifiers, pare down the path to just the bucket
+        # and key.
+        bucket, key, version = self._parse_uri(path)
+        path = URIStr(f"{self._scheme}://{bucket}/{key}")
+        max_objects = max_objects or DEFAULT_MAX_OBJECTS
+
+        if not checksum:
+            return [ArtifactManifestEntry(path=name or key, ref=path, digest=path)]
+
+        start_time = None
+        obj = self._client.bucket(bucket).get_blob(key, generation=version)
+        if obj is None and version is not None:
+            raise ValueError(f"Object does not exist: {path}#{version}")
+        multi = obj is None
+        if multi:
+            start_time = time.time()
+            termlog(
+                'Generating checksum for up to %i objects with prefix "%s"... '
+                % (max_objects, key),
+                newline=False,
+            )
+            objects = self._client.bucket(bucket).list_blobs(
+                prefix=key, max_results=max_objects
+            )
+        else:
+            objects = [obj]
+
+        entries = [
+            self._entry_from_obj(obj, path, name, prefix=key, multi=multi)
+            for obj in objects
+            if not obj.name.endswith("/")
+        ]
+        if start_time is not None:
+            termlog("Done. %.1fs" % (time.time() - start_time), prefix=False)
+        if len(entries) > max_objects:
+            raise ValueError(
+                "Exceeded %i objects tracked, pass max_objects to add_reference"
+                % max_objects
+            )
+        return entries
+
+    def _entry_from_obj(
+        self,
+        obj: "gcs_module.blob.Blob",
+        path: str,
+        name: Optional[StrPath] = None,
+        prefix: str = "",
+        multi: bool = False,
+    ) -> ArtifactManifestEntry:
+        """Create an ArtifactManifestEntry from a GCS object.
+
+        Arguments:
+            obj: The GCS object
+            path: The GCS-style path (e.g.: "gs://bucket/file.txt")
+            name: The user assigned name, or None if not specified
+            prefix: The prefix to add (will be the same as `path` for directories)
+            multi: Whether or not this is a multi-object add.
+        """
+        bucket, key, _ = self._parse_uri(path)
+
+        # Always use posix paths, since that's what S3 uses.
+        posix_key = PurePosixPath(obj.name)  # the bucket key
+        posix_path = PurePosixPath(bucket) / PurePosixPath(
+            key
+        )  # the path, with the scheme stripped
+        posix_prefix = PurePosixPath(prefix)  # the prefix, if adding a prefix
+        posix_name = PurePosixPath(name or "")
+        posix_ref = posix_path
+
+        if name is None:
+            # We're adding a directory (prefix), so calculate a relative path.
+            if str(posix_prefix) in str(posix_key) and posix_prefix != posix_key:
+                posix_name = posix_key.relative_to(posix_prefix)
+                posix_ref = posix_path / posix_name
+            else:
+                posix_name = PurePosixPath(posix_key.name)
+                posix_ref = posix_path
+        elif multi:
+            # We're adding a directory with a name override.
+            relpath = posix_key.relative_to(posix_prefix)
+            posix_name = posix_name / relpath
+            posix_ref = posix_path / relpath
+        return ArtifactManifestEntry(
+            path=posix_name,
+            ref=URIStr(f"{self._scheme}://{str(posix_ref)}"),
+            digest=obj.etag,
+            size=obj.size,
+            extra={"versionID": obj.generation},
+        )
+
+    def _is_dir(
+        self,
+        manifest_entry: ArtifactManifestEntry,
+    ) -> bool:
+        assert self._client is not None
+        assert manifest_entry.ref is not None
+        bucket, key, _ = self._parse_uri(manifest_entry.ref)
+        bucket_obj = self._client.bucket(bucket)
+        # A gcs bucket key should end with a forward slash on gcloud, but
+        # we save these refs without the forward slash in the manifest entry
+        # so we check the size and extension, make sure its not referring to
+        # an actual file with this reference, and that the ref with the slash
+        # exists on gcloud
+        return key.endswith("/") or (
+            not (manifest_entry.size or PurePosixPath(key).suffix)
+            and bucket_obj.get_blob(key) is None
+            and bucket_obj.get_blob(f"{key}/") is not None
+        )

parrot/lib/python3.10/site-packages/wandb/sdk/artifacts/storage_handlers/http_handler.py

@@ -0,0 +1,113 @@
+"""HTTP storage handler."""
+
+import os
+from typing import TYPE_CHECKING, Dict, Optional, Sequence, Tuple, Union
+from urllib.parse import ParseResult
+
+from wandb.sdk.artifacts.artifact_file_cache import get_artifact_file_cache
+from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+from wandb.sdk.artifacts.storage_handler import StorageHandler
+from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings
+from wandb.sdk.lib.hashutil import ETag
+from wandb.sdk.lib.paths import FilePathStr, StrPath, URIStr
+
+if TYPE_CHECKING:
+    import requests
+
+    from wandb.sdk.artifacts.artifact import Artifact
+
+
+class HTTPHandler(StorageHandler):
+    def __init__(
+        self, session: "requests.Session", scheme: Optional[str] = None
+    ) -> None:
+        self._scheme = scheme or "http"
+        self._cache = get_artifact_file_cache()
+        self._session = session
+
+    def can_handle(self, parsed_url: "ParseResult") -> bool:
+        return parsed_url.scheme == self._scheme
+
+    def load_path(
+        self,
+        manifest_entry: ArtifactManifestEntry,
+        local: bool = False,
+    ) -> Union[URIStr, FilePathStr]:
+        if not local:
+            assert manifest_entry.ref is not None
+            return manifest_entry.ref
+
+        assert manifest_entry.ref is not None
+
+        path, hit, cache_open = self._cache.check_etag_obj_path(
+            URIStr(manifest_entry.ref),
+            ETag(manifest_entry.digest),  # TODO(spencerpearson): unsafe cast
+            manifest_entry.size if manifest_entry.size is not None else 0,
+        )
+        if hit:
+            return path
+
+        response = self._session.get(
+            manifest_entry.ref,
+            stream=True,
+            cookies=_thread_local_api_settings.cookies,
+            headers=_thread_local_api_settings.headers,
+        )
+        response.raise_for_status()
+
+        digest: Optional[Union[ETag, FilePathStr, URIStr]]
+        digest, size, extra = self._entry_from_headers(response.headers)
+        digest = digest or manifest_entry.ref
+        if manifest_entry.digest != digest:
+            raise ValueError(
+                f"Digest mismatch for url {manifest_entry.ref}: expected {manifest_entry.digest} but found {digest}"
+            )
+
+        with cache_open(mode="wb") as file:
+            for data in response.iter_content(chunk_size=16 * 1024):
+                file.write(data)
+        return path
+
+    def store_path(
+        self,
+        artifact: "Artifact",
+        path: Union[URIStr, FilePathStr],
+        name: Optional[StrPath] = None,
+        checksum: bool = True,
+        max_objects: Optional[int] = None,
+    ) -> Sequence[ArtifactManifestEntry]:
+        name = name or os.path.basename(path)
+        if not checksum:
+            return [ArtifactManifestEntry(path=name, ref=path, digest=path)]
+
+        with self._session.get(
+            path,
+            stream=True,
+            cookies=_thread_local_api_settings.cookies,
+            headers=_thread_local_api_settings.headers,
+        ) as response:
+            response.raise_for_status()
+            digest: Optional[Union[ETag, FilePathStr, URIStr]]
+            digest, size, extra = self._entry_from_headers(response.headers)
+            digest = digest or path
+        return [
+            ArtifactManifestEntry(
+                path=name, ref=path, digest=digest, size=size, extra=extra
+            )
+        ]
+
+    def _entry_from_headers(
+        self, headers: "requests.structures.CaseInsensitiveDict"
+    ) -> Tuple[Optional[ETag], Optional[int], Dict[str, str]]:
+        response_headers = {k.lower(): v for k, v in headers.items()}
+        size = None
+        if response_headers.get("content-length", None):
+            size = int(response_headers["content-length"])
+
+        digest = response_headers.get("etag", None)
+        extra = {}
+        if digest:
+            extra["etag"] = digest
+        if digest and digest[:1] == '"' and digest[-1:] == '"':
+            digest = digest[1:-1]  # trim leading and trailing quotes around etag
+        return digest, size, extra

parrot/lib/python3.10/site-packages/wandb/sdk/artifacts/storage_handlers/multi_handler.py

@@ -0,0 +1,54 @@
+"""Multi storage handler."""
+
+from typing import TYPE_CHECKING, List, Optional, Sequence, Union
+from urllib.parse import urlparse
+
+from wandb.sdk.artifacts.storage_handler import StorageHandler
+from wandb.sdk.lib.paths import FilePathStr, URIStr
+
+if TYPE_CHECKING:
+    from wandb.sdk.artifacts.artifact import Artifact
+    from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+
+
+class MultiHandler(StorageHandler):
+    _handlers: List[StorageHandler]
+
+    def __init__(
+        self,
+        handlers: Optional[List[StorageHandler]] = None,
+        default_handler: Optional[StorageHandler] = None,
+    ) -> None:
+        self._handlers = handlers or []
+        self._default_handler = default_handler
+
+    def _get_handler(self, url: Union[FilePathStr, URIStr]) -> StorageHandler:
+        parsed_url = urlparse(url)
+        for handler in self._handlers:
+            if handler.can_handle(parsed_url):
+                return handler
+        if self._default_handler is not None:
+            return self._default_handler
+        raise ValueError('No storage handler registered for url "{}"'.format(str(url)))
+
+    def load_path(
+        self,
+        manifest_entry: "ArtifactManifestEntry",
+        local: bool = False,
+    ) -> Union[URIStr, FilePathStr]:
+        assert manifest_entry.ref is not None
+        handler = self._get_handler(manifest_entry.ref)
+        return handler.load_path(manifest_entry, local=local)
+
+    def store_path(
+        self,
+        artifact: "Artifact",
+        path: Union[URIStr, FilePathStr],
+        name: Optional[str] = None,
+        checksum: bool = True,
+        max_objects: Optional[int] = None,
+    ) -> Sequence["ArtifactManifestEntry"]:
+        handler = self._get_handler(path)
+        return handler.store_path(
+            artifact, path, name=name, checksum=checksum, max_objects=max_objects
+        )

parrot/lib/python3.10/site-packages/wandb/sdk/artifacts/storage_handlers/tracking_handler.py

@@ -0,0 +1,70 @@
+"""Tracking storage handler."""
+
+from typing import TYPE_CHECKING, Optional, Sequence, Union
+from urllib.parse import urlparse
+
+from wandb.errors.term import termwarn
+from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
+from wandb.sdk.artifacts.storage_handler import StorageHandler
+from wandb.sdk.lib.paths import FilePathStr, StrPath, URIStr
+
+if TYPE_CHECKING:
+    from urllib.parse import ParseResult
+
+    from wandb.sdk.artifacts.artifact import Artifact
+
+
+class TrackingHandler(StorageHandler):
+    def __init__(self, scheme: Optional[str] = None) -> None:
+        """Track paths with no modification or special processing.
+
+        Useful when paths being tracked are on file systems mounted at a standardized
+        location.
+
+        For example, if the data to track is located on an NFS share mounted on
+        `/data`, then it is sufficient to just track the paths.
+        """
+        self._scheme = scheme or ""
+
+    def can_handle(self, parsed_url: "ParseResult") -> bool:
+        return parsed_url.scheme == self._scheme
+
+    def load_path(
+        self,
+        manifest_entry: ArtifactManifestEntry,
+        local: bool = False,
+    ) -> Union[URIStr, FilePathStr]:
+        if local:
+            # Likely a user error. The tracking handler is
+            # oblivious to the underlying paths, so it has
+            # no way of actually loading it.
+            url = urlparse(manifest_entry.ref)
+            raise ValueError(
+                f"Cannot download file at path {str(manifest_entry.ref)}, scheme {str(url.scheme)} not recognized"
+            )
+        # TODO(spencerpearson): should this go through util.to_native_slash_path
+        # instead of just getting typecast?
+        return FilePathStr(manifest_entry.path)
+
+    def store_path(
+        self,
+        artifact: "Artifact",
+        path: Union[URIStr, FilePathStr],
+        name: Optional[StrPath] = None,
+        checksum: bool = True,
+        max_objects: Optional[int] = None,
+    ) -> Sequence[ArtifactManifestEntry]:
+        url = urlparse(path)
+        if name is None:
+            raise ValueError(
+                'You must pass name="<entry_name>" when tracking references with unknown schemes. ref: {}'.format(
+                    path
+                )
+            )
+        termwarn(
+            "Artifact references with unsupported schemes cannot be checksummed: {}".format(
+                path
+            )
+        )
+        name = name or url.path[1:]  # strip leading slash
+        return [ArtifactManifestEntry(path=name, ref=path, digest=path)]

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

@@ -0,0 +1,6 @@
+"""Storage layout."""
+
+
+class StorageLayout:
+    V1 = "V1"
+    V2 = "V2"