wandb 0.15.3__py3-none-any.whl → 0.15.5__py3-none-any.whl

wandb/apis/public.py

@@ -15,20 +15,15 @@ import datetime
 import io
 import json
 import logging
-import multiprocessing.dummy  # this uses threads
 import os
 import platform
-import re
 import shutil
 import tempfile
 import time
 import urllib
-from collections import namedtuple
-from functools import partial
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Dict,
     List,
     Mapping,
@@ -45,21 +40,19 @@ import wandb
 from wandb import __version__, env, util
 from wandb.apis.internal import Api as InternalApi
 from wandb.apis.normalize import normalize_exceptions
-from wandb.data_types import WBValue
-from wandb.env import get_artifact_dir
 from wandb.errors import CommError
-from wandb.errors.term import termlog
 from wandb.sdk.data_types._dtypes import InvalidType, Type, TypeRegistry
-from wandb.sdk.interface import artifacts
+from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings
+from wandb.sdk.launch.errors import LaunchError
 from wandb.sdk.launch.utils import (
     LAUNCH_DEFAULT_PROJECT,
-    LaunchError,
     _fetch_git_repo,
     apply_patch,
+    convert_jupyter_notebook_to_script,
 )
-from wandb.sdk.lib import filesystem, ipython, retry, runid
+from wandb.sdk.lib import ipython, retry, runid
 from wandb.sdk.lib.gql_request import GraphQLSession
-from wandb.sdk.lib.hashutil import b64_to_hex_id, hex_to_b64_id, md5_file_b64
+from wandb.sdk.lib.paths import LogicalPath
 
 if TYPE_CHECKING:
     import wandb.apis.reports
@@ -144,41 +137,6 @@ fragment ArtifactTypesFragment on ArtifactTypeConnection {
 }
 """
 
-ARTIFACT_FRAGMENT = """
-fragment ArtifactFragment on Artifact {
-    id
-    digest
-    description
-    state
-    size
-    createdAt
-    updatedAt
-    labels
-    metadata
-    fileCount
-    versionIndex
-    aliases {
-        artifactCollectionName
-        alias
-    }
-    artifactSequence {
-        id
-        name
-    }
-    artifactType {
-        id
-        name
-        project {
-            name
-            entity {
-                name
-            }
-        }
-    }
-    commitHash
-}
-"""
-
 # TODO, factor out common file fragment
 ARTIFACT_FILES_FRAGMENT = """fragment ArtifactFilesFragment on Artifact {
     files(names: $fileNames, after: $fileCursor, first: $fileLimit) {
@@ -407,7 +365,7 @@ class Api:
         self.settings = InternalApi().settings()
         _overrides = overrides or {}
         self._api_key = api_key
-        if self.api_key is None:
+        if self.api_key is None and _thread_local_api_settings.cookies is None:
             wandb.login(host=_overrides.get("base_url"))
         self.settings.update(_overrides)
         if "username" in _overrides and "entity" not in _overrides:
@@ -424,15 +382,23 @@ class Api:
         self._reports = {}
         self._default_entity = None
         self._timeout = timeout if timeout is not None else self._HTTP_TIMEOUT
+        auth = None
+        if not _thread_local_api_settings.cookies:
+            auth = ("api", self.api_key)
         self._base_client = Client(
             transport=GraphQLSession(
-                headers={"User-Agent": self.user_agent, "Use-Admin-Privileges": "true"},
+                headers={
+                    "User-Agent": self.user_agent,
+                    "Use-Admin-Privileges": "true",
+                    **(_thread_local_api_settings.headers or {}),
+                },
                 use_json=True,
                 # this timeout won't apply when the DNS lookup fails. in that case, it will be 60s
                 # https://bugs.python.org/issue22889
                 timeout=self._timeout,
-                auth=("api", self.api_key),
+                auth=auth,
                 url="%s/graphql" % self.settings["base_url"],
+                cookies=_thread_local_api_settings.cookies,
             )
         )
         self._client = RetryingClient(self._base_client)
@@ -525,6 +491,9 @@ class Api:
 
     @property
     def api_key(self):
+        # just use thread local api key if it's set
+        if _thread_local_api_settings.api_key:
+            return _thread_local_api_settings.api_key
         if self._api_key is not None:
             return self._api_key
         auth = requests.utils.get_netrc_auth(self.settings["base_url"])
@@ -939,14 +908,13 @@ class Api:
 
     @normalize_exceptions
     def artifact(self, name, type=None):
-        """Return a single artifact by parsing path in the form `entity/project/run_id`.
+        """Return a single artifact by parsing path in the form `entity/project/name`.
 
         Arguments:
             name: (str) An artifact name. May be prefixed with entity/project. Valid names
                 can be in the following forms:
                     name:version
                     name:alias
-                    digest
             type: (str, optional) The type of artifact to fetch.
 
         Returns:
@@ -955,7 +923,9 @@ class Api:
         if name is None:
             raise ValueError("You must specify name= to fetch an artifact.")
         entity, project, artifact_name = self._parse_artifact_path(name)
-        artifact = Artifact(self.client, entity, project, artifact_name)
+        artifact = wandb.Artifact._from_name(
+            entity, project, artifact_name, self.client
+        )
         if type is not None and artifact.type != type:
             raise ValueError(
                 f"type {type} specified but this artifact is of type {artifact.type}"
@@ -966,6 +936,10 @@ class Api:
     def job(self, name, path=None):
         if name is None:
             raise ValueError("You must specify name= to fetch a job.")
+        elif name.count("/") != 2 or ":" not in name:
+            raise ValueError(
+                "Invalid job specification. A job must be of the form: <entity>/<project>/<job-name>:<alias-or-version>"
+            )
         return Job(self, name, path)
 
 
@@ -2036,7 +2010,7 @@ class Run(Attrs):
         root = os.path.abspath(root)
         name = os.path.relpath(path, root)
         with open(os.path.join(root, name), "rb") as f:
-            api.push({util.to_forward_slash_path(name): f})
+            api.push({LogicalPath(name): f})
         return Files(self.client, self, [name])[0]
 
     @normalize_exceptions
@@ -2166,10 +2140,10 @@ class Run(Attrs):
         )
         api.set_current_run_id(self.id)
 
-        if isinstance(artifact, Artifact):
+        if isinstance(artifact, wandb.Artifact) and not artifact.is_draft():
             api.use_artifact(artifact.id, use_as=use_as or artifact.name)
             return artifact
-        elif isinstance(artifact, wandb.Artifact):
+        elif isinstance(artifact, wandb.Artifact) and artifact.is_draft():
             raise ValueError(
                 "Only existing artifacts are accepted by this api. "
                 "Manually create one with `wandb artifacts put`"
@@ -2194,7 +2168,7 @@ class Run(Attrs):
         )
         api.set_current_run_id(self.id)
 
-        if isinstance(artifact, Artifact):
+        if isinstance(artifact, wandb.Artifact) and not artifact.is_draft():
             artifact_collection_name = artifact.name.split(":")[0]
             api.create_artifact(
                 artifact.type,
@@ -2203,7 +2177,7 @@ class Run(Attrs):
                 aliases=aliases,
             )
             return artifact
-        elif isinstance(artifact, wandb.Artifact):
+        elif isinstance(artifact, wandb.Artifact) and artifact.is_draft():
             raise ValueError(
                 "Only existing artifacts are accepted by this api. "
                 "Manually create one with `wandb artifacts put`"
@@ -3812,72 +3786,72 @@ class ProjectArtifactCollections(Paginator):
 
 
 class RunArtifacts(Paginator):
-    OUTPUT_QUERY = gql(
-        """
-        query RunOutputArtifacts(
-            $entity: String!, $project: String!, $runName: String!, $cursor: String, $perPage: Int,
-        ) {
-            project(name: $project, entityName: $entity) {
-                run(name: $runName) {
-                    outputArtifacts(after: $cursor, first: $perPage) {
-                        totalCount
-                        edges {
-                            node {
-                                ...ArtifactFragment
+    def __init__(
+        self, client: Client, run: "Run", mode="logged", per_page: Optional[int] = 50
+    ):
+        output_query = gql(
+            """
+            query RunOutputArtifacts(
+                $entity: String!, $project: String!, $runName: String!, $cursor: String, $perPage: Int,
+            ) {
+                project(name: $project, entityName: $entity) {
+                    run(name: $runName) {
+                        outputArtifacts(after: $cursor, first: $perPage) {
+                            totalCount
+                            edges {
+                                node {
+                                    ...ArtifactFragment
+                                }
+                                cursor
+                            }
+                            pageInfo {
+                                endCursor
+                                hasNextPage
                             }
-                            cursor
-                        }
-                        pageInfo {
-                            endCursor
-                            hasNextPage
                         }
                     }
                 }
             }
-        }
-        %s
-    """
-        % ARTIFACT_FRAGMENT
-    )
+            %s
+            """
+            % wandb.Artifact._GQL_FRAGMENT
+        )
 
-    INPUT_QUERY = gql(
-        """
-        query RunInputArtifacts(
-            $entity: String!, $project: String!, $runName: String!, $cursor: String, $perPage: Int,
-        ) {
-            project(name: $project, entityName: $entity) {
-                run(name: $runName) {
-                    inputArtifacts(after: $cursor, first: $perPage) {
-                        totalCount
-                        edges {
-                            node {
-                                ...ArtifactFragment
+        input_query = gql(
+            """
+            query RunInputArtifacts(
+                $entity: String!, $project: String!, $runName: String!, $cursor: String, $perPage: Int,
+            ) {
+                project(name: $project, entityName: $entity) {
+                    run(name: $runName) {
+                        inputArtifacts(after: $cursor, first: $perPage) {
+                            totalCount
+                            edges {
+                                node {
+                                    ...ArtifactFragment
+                                }
+                                cursor
+                            }
+                            pageInfo {
+                                endCursor
+                                hasNextPage
                             }
-                            cursor
-                        }
-                        pageInfo {
-                            endCursor
-                            hasNextPage
                         }
                     }
                 }
             }
-        }
-        %s
-    """
-        % ARTIFACT_FRAGMENT
-    )
+            %s
+            """
+            % wandb.Artifact._GQL_FRAGMENT
+        )
 
-    def __init__(
-        self, client: Client, run: "Run", mode="logged", per_page: Optional[int] = 50
-    ):
         self.run = run
         if mode == "logged":
             self.run_key = "outputArtifacts"
-            self.QUERY = self.OUTPUT_QUERY
+            self.QUERY = output_query
         elif mode == "used":
             self.run_key = "inputArtifacts"
-            self.QUERY = self.INPUT_QUERY
+            self.QUERY = input_query
         else:
             raise ValueError("mode must be logged or used")
 
@@ -3916,14 +3890,14 @@ class RunArtifacts(Paginator):
 
     def convert_objects(self):
         return [
-            Artifact(
-                self.client,
+            wandb.Artifact._from_attrs(
                 self.run.entity,
                 self.run.project,
                 "{}:v{}".format(
                     r["node"]["artifactSequence"]["name"], r["node"]["versionIndex"]
                 ),
                 r["node"],
+                self.client,
             )
             for r in self.last_response["project"]["run"][self.run_key]["edges"]
         ]
@@ -4109,1293 +4083,154 @@ class ArtifactCollection:
         return f"<ArtifactCollection {self.name} ({self.type})>"
 
 
-class _DownloadedArtifactEntry(artifacts.ArtifactManifestEntry):
+class ArtifactVersions(Paginator):
+    """An iterable collection of artifact versions associated with a project and optional filter.
+
+    This is generally used indirectly via the `Api`.artifact_versions method.
+    """
+
     def __init__(
         self,
-        entry: "artifacts.ArtifactManifestEntry",
-        parent_artifact: "Artifact",
+        client: Client,
+        entity: str,
+        project: str,
+        collection_name: str,
+        type: str,
+        filters: Optional[Mapping[str, Any]] = None,
+        order: Optional[str] = None,
+        per_page: int = 50,
     ):
-        super().__init__(
-            path=entry.path,
-            digest=entry.digest,
-            ref=entry.ref,
-            birth_artifact_id=entry.birth_artifact_id,
-            size=entry.size,
-            extra=entry.extra,
-            local_path=entry.local_path,
+        self.entity = entity
+        self.collection_name = collection_name
+        self.type = type
+        self.project = project
+        self.filters = {"state": "COMMITTED"} if filters is None else filters
+        self.order = order
+        variables = {
+            "project": self.project,
+            "entity": self.entity,
+            "order": self.order,
+            "type": self.type,
+            "collection": self.collection_name,
+            "filters": json.dumps(self.filters),
+        }
+        self.QUERY = gql(
+            """
+            query Artifacts($project: String!, $entity: String!, $type: String!, $collection: String!, $cursor: String, $perPage: Int = 50, $order: String, $filters: JSONString) {{
+                project(name: $project, entityName: $entity) {{
+                    artifactType(name: $type) {{
+                        artifactCollection: {}(name: $collection) {{
+                            name
+                            artifacts(filters: $filters, after: $cursor, first: $perPage, order: $order) {{
+                                totalCount
+                                edges {{
+                                    node {{
+                                        ...ArtifactFragment
+                                    }}
+                                    version
+                                    cursor
+                                }}
+                                pageInfo {{
+                                    endCursor
+                                    hasNextPage
+                                }}
+                            }}
+                        }}
+                    }}
+                }}
+            }}
+            {}
+            """.format(
+                artifact_collection_edge_name(
+                    server_supports_artifact_collections_gql_edges(client)
+                ),
+                wandb.Artifact._GQL_FRAGMENT,
+            )
         )
-        self._parent_artifact = parent_artifact
+        super().__init__(client, variables, per_page)
 
     @property
-    def name(self):
-        # TODO(hugh): add telemetry to see if anyone is still using this.
-        wandb.termwarn("ArtifactManifestEntry.name is deprecated, use .path instead")
-        return self.path
-
-    def parent_artifact(self):
-        return self._parent_artifact
-
-    def copy(self, cache_path, target_path):
-        raise NotImplementedError()
-
-    def download(self, root=None):
-        root = root or self._parent_artifact._default_root()
-        dest_path = os.path.join(root, self.path)
-
-        self._parent_artifact._add_download_root(root)
-        manifest = self._parent_artifact._load_manifest()
-
-        # Skip checking the cache (and possibly downloading) if the file already exists
-        # and has the digest we're expecting.
-        entry = manifest.entries[self.path]
-        if os.path.exists(dest_path) and entry.digest == md5_file_b64(dest_path):
-            return dest_path
+    def length(self):
+        if self.last_response:
+            return self.last_response["project"]["artifactType"]["artifactCollection"][
+                "artifacts"
+            ]["totalCount"]
+        else:
+            return None
 
-        if self.ref is not None:
-            cache_path = manifest.storage_policy.load_reference(entry, local=True)
+    @property
+    def more(self):
+        if self.last_response:
+            return self.last_response["project"]["artifactType"]["artifactCollection"][
+                "artifacts"
+            ]["pageInfo"]["hasNextPage"]
         else:
-            cache_path = manifest.storage_policy.load_file(self._parent_artifact, entry)
+            return True
 
-        return filesystem.copy_or_overwrite_changed(cache_path, dest_path)
+    @property
+    def cursor(self):
+        if self.last_response:
+            return self.last_response["project"]["artifactType"]["artifactCollection"][
+                "artifacts"
+            ]["edges"][-1]["cursor"]
+        else:
+            return None
 
-    def ref_target(self):
-        manifest = self._parent_artifact._load_manifest()
-        if self.ref is not None:
-            return manifest.storage_policy.load_reference(
-                manifest.entries[self.path],
-                local=False,
+    def convert_objects(self):
+        if self.last_response["project"]["artifactType"]["artifactCollection"] is None:
+            return []
+        return [
+            wandb.Artifact._from_attrs(
+                self.entity,
+                self.project,
+                self.collection_name + ":" + a["version"],
+                a["node"],
+                self.client,
             )
-        raise ValueError("Only reference entries support ref_target().")
-
-    def ref_url(self):
-        return (
-            "wandb-artifact://"
-            + b64_to_hex_id(self._parent_artifact.id)
-            + "/"
-            + self.path
-        )
-
-
-class _ArtifactDownloadLogger:
-    def __init__(
-        self,
-        nfiles: int,
-        clock_for_testing: Callable[[], float] = time.monotonic,
-        termlog_for_testing=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()
-
-
-class Artifact(artifacts.Artifact):
-    """A wandb Artifact.
-
-    An artifact that has been logged, including all its attributes, links to the runs
-    that use it, and a link to the run that logged it.
-
-    Examples:
-        Basic usage
-        ```
-        api = wandb.Api()
-        artifact = api.artifact('project/artifact:alias')
-
-        # Get information about the artifact...
-        artifact.digest
-        artifact.aliases
-        ```
-
-        Updating an artifact
-        ```
-        artifact = api.artifact('project/artifact:alias')
-
-        # Update the description
-        artifact.description = 'My new description'
-
-        # Selectively update metadata keys
-        artifact.metadata["oldKey"] = "new value"
-
-        # Replace the metadata entirely
-        artifact.metadata = {"newKey": "new value"}
-
-        # Add an alias
-        artifact.aliases.append('best')
-
-        # Remove an alias
-        artifact.aliases.remove('latest')
-
-        # Completely replace the aliases
-        artifact.aliases = ['replaced']
-
-        # Persist all artifact modifications
-        artifact.save()
-        ```
-
-        Artifact graph traversal
-        ```
-        artifact = api.artifact('project/artifact:alias')
-
-        # Walk up and down the graph from an artifact:
-        producer_run = artifact.logged_by()
-        consumer_runs = artifact.used_by()
-
-        # Walk up and down the graph from a run:
-        logged_artifacts = run.logged_artifacts()
-        used_artifacts = run.used_artifacts()
-        ```
+            for a in self.last_response["project"]["artifactType"][
+                "artifactCollection"
+            ]["artifacts"]["edges"]
+        ]
 
-        Deleting an artifact
-        ```
-        artifact = api.artifact('project/artifact:alias')
-        artifact.delete()
-        ```
-    """
 
+class ArtifactFiles(Paginator):
     QUERY = gql(
         """
-        query ArtifactWithCurrentManifest(
-            $id: ID!,
+        query ArtifactFiles(
+            $entityName: String!,
+            $projectName: String!,
+            $artifactTypeName: String!,
+            $artifactName: String!
+            $fileNames: [String!],
+            $fileCursor: String,
+            $fileLimit: Int = 50
         ) {
-            artifact(id: $id) {
-                currentManifest {
-                    id
-                    file {
-                        id
-                        directUrl
+            project(name: $projectName, entityName: $entityName) {
+                artifactType(name: $artifactTypeName) {
+                    artifact(name: $artifactName) {
+                        ...ArtifactFilesFragment
                     }
                 }
-                ...ArtifactFragment
             }
         }
         %s
     """
-        % ARTIFACT_FRAGMENT
-    )
-
-    @classmethod
-    def from_id(cls, artifact_id: str, client: Client):
-        artifact = artifacts.get_artifacts_cache().get_artifact(artifact_id)
-        if artifact is not None:
-            return artifact
-        response: Mapping[str, Any] = client.execute(
-            Artifact.QUERY,
-            variable_values={"id": artifact_id},
-        )
-
-        name = None
-        if response.get("artifact") is not None:
-            if response["artifact"].get("aliases") is not None:
-                aliases = response["artifact"]["aliases"]
-                name = ":".join(
-                    [aliases[0]["artifactCollectionName"], aliases[0]["alias"]]
-                )
-                if len(aliases) > 1:
-                    for alias in aliases:
-                        if alias["alias"] != "latest":
-                            name = ":".join(
-                                [alias["artifactCollectionName"], alias["alias"]]
-                            )
-                            break
-
-            p = response.get("artifact", {}).get("artifactType", {}).get("project", {})
-            project = p.get("name")  # defaults to None
-            entity = p.get("entity", {}).get("name")
-
-            artifact = cls(
-                client=client,
-                entity=entity,
-                project=project,
-                name=name,
-                attrs=response["artifact"],
-            )
-            index_file_url = response["artifact"]["currentManifest"]["file"][
-                "directUrl"
-            ]
-            with requests.get(index_file_url) as req:
-                req.raise_for_status()
-                artifact._manifest = artifacts.ArtifactManifest.from_manifest_json(
-                    json.loads(util.ensure_text(req.content))
-                )
-
-            artifact._load_dependent_manifests()
-
-            return artifact
-
-    def __init__(self, client, entity, project, name, attrs=None):
-        self.client = client
-        self._entity = entity
-        self._project = project
-        self._artifact_name = name
-        self._artifact_collection_name = name.split(":")[0]
-        self._attrs = attrs
-        if self._attrs is None:
-            self._load()
-
-        # The entity and project above are taken from the passed-in artifact version path
-        # so if the user is pulling an artifact version from an artifact portfolio, the entity/project
-        # of that portfolio may be different than the birth entity/project of the artifact version.
-        self._birth_project = (
-            self._attrs.get("artifactType", {}).get("project", {}).get("name")
-        )
-        self._birth_entity = (
-            self._attrs.get("artifactType", {})
-            .get("project", {})
-            .get("entity", {})
-            .get("name")
-        )
-        self._metadata = json.loads(self._attrs.get("metadata") or "{}")
-        self._description = self._attrs.get("description", None)
-        self._sequence_name = self._attrs["artifactSequence"]["name"]
-        self._sequence_version_index = self._attrs.get("versionIndex", None)
-        # We will only show aliases under the Collection this artifact version is fetched from
-        # _aliases will be a mutable copy on which the user can append or remove aliases
-        self._aliases = [
-            a["alias"]
-            for a in self._attrs["aliases"]
-            if not re.match(r"^v\d+$", a["alias"])
-            and a["artifactCollectionName"] == self._artifact_collection_name
-        ]
-        self._frozen_aliases = [a for a in self._aliases]
-        self._manifest = None
-        self._is_downloaded = False
-        self._dependent_artifacts = []
-        self._download_roots = set()
-        artifacts.get_artifacts_cache().store_artifact(self)
-
-    @property
-    def id(self):
-        return self._attrs["id"]
-
-    @property
-    def file_count(self):
-        return self._attrs["fileCount"]
-
-    @property
-    def source_version(self):
-        """The artifact's version index under its parent artifact collection.
-
-        A string with the format "v{number}".
-        """
-        return f"v{self._sequence_version_index}"
-
-    @property
-    def version(self):
-        """The artifact's version index under the given artifact collection.
-
-        A string with the format "v{number}".
-        """
-        for a in self._attrs["aliases"]:
-            if a[
-                "artifactCollectionName"
-            ] == self._artifact_collection_name and util.alias_is_version_index(
-                a["alias"]
-            ):
-                return a["alias"]
-        return None
-
-    @property
-    def entity(self):
-        return self._entity
-
-    @property
-    def project(self):
-        return self._project
-
-    @property
-    def metadata(self):
-        return self._metadata
-
-    @metadata.setter
-    def metadata(self, metadata):
-        self._metadata = metadata
-
-    @property
-    def manifest(self):
-        return self._load_manifest()
-
-    @property
-    def digest(self):
-        return self._attrs["digest"]
-
-    @property
-    def state(self):
-        return self._attrs["state"]
-
-    @property
-    def size(self):
-        return self._attrs["size"]
-
-    @property
-    def created_at(self):
-        """The time at which the artifact was created."""
-        return self._attrs["createdAt"]
-
-    @property
-    def updated_at(self):
-        """The time at which the artifact was last updated."""
-        return self._attrs["updatedAt"] or self._attrs["createdAt"]
-
-    @property
-    def description(self):
-        return self._description
-
-    @description.setter
-    def description(self, desc):
-        self._description = desc
-
-    @property
-    def type(self):
-        return self._attrs["artifactType"]["name"]
-
-    @property
-    def commit_hash(self):
-        return self._attrs.get("commitHash", "")
-
-    @property
-    def name(self):
-        if self._sequence_version_index is None:
-            return self.digest
-        return f"{self._sequence_name}:v{self._sequence_version_index}"
-
-    @property
-    def aliases(self):
-        """The aliases associated with this artifact.
-
-        Returns:
-            List[str]: The aliases associated with this artifact.
-
-        """
-        return self._aliases
-
-    @aliases.setter
-    def aliases(self, aliases):
-        for alias in aliases:
-            if any(char in alias for char in ["/", ":"]):
-                raise ValueError(
-                    'Invalid alias "%s", slashes and colons are disallowed' % alias
-                )
-        self._aliases = aliases
-
-    @staticmethod
-    def expected_type(client, name, entity_name, project_name):
-        """Returns the expected type for a given artifact name and project."""
-        query = gql(
-            """
-        query ArtifactType(
-            $entityName: String,
-            $projectName: String,
-            $name: String!
-        ) {
-            project(name: $projectName, entityName: $entityName) {
-                artifact(name: $name) {
-                    artifactType {
-                        name
-                    }
-                }
-            }
-        }
-        """
-        )
-        if ":" not in name:
-            name += ":latest"
-
-        response = client.execute(
-            query,
-            variable_values={
-                "entityName": entity_name,
-                "projectName": project_name,
-                "name": name,
-            },
-        )
-
-        project = response.get("project")
-        if project is not None:
-            artifact = project.get("artifact")
-            if artifact is not None:
-                artifact_type = artifact.get("artifactType")
-                if artifact_type is not None:
-                    return artifact_type.get("name")
-
-        return None
-
-    @property
-    def _use_as(self):
-        return self._attrs.get("_use_as")
-
-    @_use_as.setter
-    def _use_as(self, use_as):
-        self._attrs["_use_as"] = use_as
-        return use_as
-
-    @normalize_exceptions
-    def link(self, target_path: str, aliases=None):
-        if ":" in target_path:
-            raise ValueError(
-                f"target_path {target_path} cannot contain `:` because it is not an alias."
-            )
-
-        portfolio, project, entity = util._parse_entity_project_item(target_path)
-        aliases = util._resolve_aliases(aliases)
-
-        EmptyRunProps = namedtuple("Empty", "entity project")
-        r = wandb.run if wandb.run else EmptyRunProps(entity=None, project=None)
-        entity = entity or r.entity or self.entity
-        project = project or r.project or self.project
-
-        mutation = gql(
-            """
-            mutation LinkArtifact($artifactID: ID!, $artifactPortfolioName: String!, $entityName: String!, $projectName: String!, $aliases: [ArtifactAliasInput!]) {
-    linkArtifact(input: {artifactID: $artifactID, artifactPortfolioName: $artifactPortfolioName,
-        entityName: $entityName,
-        projectName: $projectName,
-        aliases: $aliases
-    }) {
-            versionIndex
-    }
-}
-        """
-        )
-        self.client.execute(
-            mutation,
-            variable_values={
-                "artifactID": self.id,
-                "artifactPortfolioName": portfolio,
-                "entityName": entity,
-                "projectName": project,
-                "aliases": [
-                    {"alias": alias, "artifactCollectionName": portfolio}
-                    for alias in aliases
-                ],
-            },
-        )
-        return True
-
-    @normalize_exceptions
-    def delete(self, delete_aliases=False):
-        """Delete an artifact and its files.
-
-        Examples:
-            Delete all the "model" artifacts a run has logged:
-            ```
-            runs = api.runs(path="my_entity/my_project")
-            for run in runs:
-                for artifact in run.logged_artifacts():
-                    if artifact.type == "model":
-                        artifact.delete(delete_aliases=True)
-            ```
-
-        Arguments:
-            delete_aliases: (bool) If true, deletes all aliases associated with the artifact.
-                Otherwise, this raises an exception if the artifact has existing aliases.
-        """
-        mutation = gql(
-            """
-        mutation DeleteArtifact($artifactID: ID!, $deleteAliases: Boolean) {
-            deleteArtifact(input: {
-                artifactID: $artifactID
-                deleteAliases: $deleteAliases
-            }) {
-                artifact {
-                    id
-                }
-            }
-        }
-        """
-        )
-        self.client.execute(
-            mutation,
-            variable_values={
-                "artifactID": self.id,
-                "deleteAliases": delete_aliases,
-            },
-        )
-        return True
-
-    def new_file(self, name, mode=None):
-        raise ValueError("Cannot add files to an artifact once it has been saved")
-
-    def add_file(self, local_path, name=None, is_tmp=False):
-        raise ValueError("Cannot add files to an artifact once it has been saved")
-
-    def add_dir(self, path, name=None):
-        raise ValueError("Cannot add files to an artifact once it has been saved")
-
-    def add_reference(self, uri, name=None, checksum=True, max_objects=None):
-        raise ValueError("Cannot add files to an artifact once it has been saved")
-
-    def add(self, obj, name):
-        raise ValueError("Cannot add files to an artifact once it has been saved")
-
-    def _add_download_root(self, dir_path):
-        """Make `dir_path` a root directory for this artifact."""
-        self._download_roots.add(os.path.abspath(dir_path))
-
-    def _is_download_root(self, dir_path):
-        """Determine if `dir_path` is a root directory for this artifact."""
-        return dir_path in self._download_roots
-
-    def _local_path_to_name(self, file_path):
-        """Convert a local file path to a path entry in the artifact."""
-        abs_file_path = os.path.abspath(file_path)
-        abs_file_parts = abs_file_path.split(os.sep)
-        for i in range(len(abs_file_parts) + 1):
-            if self._is_download_root(os.path.join(os.sep, *abs_file_parts[:i])):
-                return os.path.join(*abs_file_parts[i:])
-        return None
-
-    def _get_obj_entry(self, name):
-        """Return an object entry by name, handling any type suffixes.
-
-        When objects are added with `.add(obj, name)`, the name is typically changed to
-        include the suffix of the object type when serializing to JSON. So we need to be
-        able to resolve a name, without tasking the user with appending .THING.json.
-        This method returns an entry if it exists by a suffixed name.
-
-        Args:
-            name: (str) name used when adding
-        """
-        self._load_manifest()
-
-        type_mapping = WBValue.type_mapping()
-        for artifact_type_str in type_mapping:
-            wb_class = type_mapping[artifact_type_str]
-            wandb_file_name = wb_class.with_suffix(name)
-            entry = self._manifest.entries.get(wandb_file_name)
-            if entry is not None:
-                return entry, wb_class
-        return None, None
-
-    def get_path(self, name):
-        manifest = self._load_manifest()
-        entry = manifest.entries.get(name) or self._get_obj_entry(name)[0]
-        if entry is None:
-            raise KeyError("Path not contained in artifact: %s" % name)
-
-        return _DownloadedArtifactEntry(entry, self)
-
-    def get(self, name):
-        entry, wb_class = self._get_obj_entry(name)
-        if entry is not None:
-            # If the entry is a reference from another artifact, then get it directly from that artifact
-            if self._manifest_entry_is_artifact_reference(entry):
-                artifact = self._get_ref_artifact_from_entry(entry)
-                return artifact.get(util.uri_from_path(entry.ref))
-
-            # Special case for wandb.Table. This is intended to be a short term optimization.
-            # Since tables are likely to download many other assets in artifact(s), we eagerly download
-            # the artifact using the parallelized `artifact.download`. In the future, we should refactor
-            # the deserialization pattern such that this special case is not needed.
-            if wb_class == wandb.Table:
-                self.download(recursive=True)
-
-            # Get the ArtifactManifestEntry
-            item = self.get_path(entry.path)
-            item_path = item.download()
-
-            # Load the object from the JSON blob
-            result = None
-            json_obj = {}
-            with open(item_path) as file:
-                json_obj = json.load(file)
-            result = wb_class.from_json(json_obj, self)
-            result._set_artifact_source(self, name)
-            return result
-
-    def download(self, root=None, recursive=False):
-        dirpath = root or self._default_root()
-        self._add_download_root(dirpath)
-        manifest = self._load_manifest()
-        nfiles = len(manifest.entries)
-        size = sum(e.size for e in manifest.entries.values())
-        log = False
-        if nfiles > 5000 or size > 50 * 1024 * 1024:
-            log = True
-            termlog(
-                "Downloading large artifact {}, {:.2f}MB. {} files... ".format(
-                    self._artifact_name, size / (1024 * 1024), nfiles
-                ),
-            )
-            start_time = datetime.datetime.now()
-
-        # Force all the files to download into the same directory.
-        # Download in parallel
-        import multiprocessing.dummy  # this uses threads
-
-        download_logger = _ArtifactDownloadLogger(nfiles=nfiles)
-
-        pool = multiprocessing.dummy.Pool(32)
-        pool.map(
-            partial(self._download_file, root=dirpath, download_logger=download_logger),
-            manifest.entries,
-        )
-        if recursive:
-            pool.map(lambda artifact: artifact.download(), self._dependent_artifacts)
-        pool.close()
-        pool.join()
-
-        self._is_downloaded = True
-
-        if log:
-            now = datetime.datetime.now()
-            delta = abs((now - start_time).total_seconds())
-            hours = int(delta // 3600)
-            minutes = int((delta - hours * 3600) // 60)
-            seconds = delta - hours * 3600 - minutes * 60
-            termlog(
-                f"Done. {hours}:{minutes}:{seconds:.1f}",
-                prefix=False,
-            )
-        return dirpath
-
-    def checkout(self, root=None):
-        dirpath = root or self._default_root(include_version=False)
-
-        for root, _, files in os.walk(dirpath):
-            for file in files:
-                full_path = os.path.join(root, file)
-                artifact_path = util.to_forward_slash_path(
-                    os.path.relpath(full_path, start=dirpath)
-                )
-                try:
-                    self.get_path(artifact_path)
-                except KeyError:
-                    # File is not part of the artifact, remove it.
-                    os.remove(full_path)
-
-        return self.download(root=dirpath)
-
-    def verify(self, root=None):
-        dirpath = root or self._default_root()
-        manifest = self._load_manifest()
-        ref_count = 0
-
-        for root, _, files in os.walk(dirpath):
-            for file in files:
-                full_path = os.path.join(root, file)
-                artifact_path = util.to_forward_slash_path(
-                    os.path.relpath(full_path, start=dirpath)
-                )
-                try:
-                    self.get_path(artifact_path)
-                except KeyError:
-                    raise ValueError(
-                        "Found file {} which is not a member of artifact {}".format(
-                            full_path, self.name
-                        )
-                    )
-
-        for entry in manifest.entries.values():
-            if entry.ref is None:
-                if md5_file_b64(os.path.join(dirpath, entry.path)) != entry.digest:
-                    raise ValueError("Digest mismatch for file: %s" % entry.path)
-            else:
-                ref_count += 1
-        if ref_count > 0:
-            print("Warning: skipped verification of %s refs" % ref_count)
-
-    def file(self, root=None):
-        """Download a single file artifact to dir specified by the root.
-
-        Arguments:
-            root: (str, optional) The root directory in which to place the file. Defaults to './artifacts/self.name/'.
-
-        Returns:
-            (str): The full path of the downloaded file.
-        """
-        if root is None:
-            root = os.path.join(".", "artifacts", self.name)
-
-        manifest = self._load_manifest()
-        nfiles = len(manifest.entries)
-        if nfiles > 1:
-            raise ValueError(
-                "This artifact contains more than one file, call `.download()` to get all files or call "
-                '.get_path("filename").download()'
-            )
-
-        return self._download_file(list(manifest.entries)[0], root=root)
-
-    def _download_file(
-        self, name, root, download_logger: Optional[_ArtifactDownloadLogger] = None
-    ):
-        # download file into cache and copy to target dir
-        downloaded_path = self.get_path(name).download(root)
-        if download_logger is not None:
-            download_logger.notify_downloaded()
-        return downloaded_path
-
-    def _default_root(self, include_version=True):
-        name = self.name if include_version else self._sequence_name
-        root = os.path.join(get_artifact_dir(), name)
-        if platform.system() == "Windows":
-            head, tail = os.path.splitdrive(root)
-            root = head + tail.replace(":", "-")
-        return root
-
-    def json_encode(self):
-        return util.artifact_to_json(self)
-
-    @normalize_exceptions
-    def save(self):
-        """Persists artifact changes to the wandb backend."""
-        mutation = gql(
-            """
-        mutation updateArtifact(
-            $artifactID: ID!,
-            $description: String,
-            $metadata: JSONString,
-            $aliases: [ArtifactAliasInput!]
-        ) {
-            updateArtifact(input: {
-                artifactID: $artifactID,
-                description: $description,
-                metadata: $metadata,
-                aliases: $aliases
-            }) {
-                artifact {
-                    id
-                }
-            }
-        }
-        """
-        )
-        introspect_query = gql(
-            """
-            query ProbeServerAddAliasesInput {
-               AddAliasesInputInfoType: __type(name: "AddAliasesInput") {
-                   name
-                   inputFields {
-                       name
-                   }
-                }
-            }
-            """
-        )
-        res = self.client.execute(introspect_query)
-        valid = res.get("AddAliasesInputInfoType")
-        aliases = None
-        if not valid:
-            # If valid, wandb backend version >= 0.13.0.
-            # This means we can safely remove aliases from this updateArtifact request since we'll be calling
-            # the alias endpoints below in _save_alias_changes.
-            # If not valid, wandb backend version < 0.13.0. This requires aliases to be sent in updateArtifact.
-            aliases = [
-                {
-                    "artifactCollectionName": self._artifact_collection_name,
-                    "alias": alias,
-                }
-                for alias in self._aliases
-            ]
-
-        self.client.execute(
-            mutation,
-            variable_values={
-                "artifactID": self.id,
-                "description": self.description,
-                "metadata": util.json_dumps_safer(self.metadata),
-                "aliases": aliases,
-            },
-        )
-        # Save locally modified aliases
-        self._save_alias_changes()
-        return True
-
-    def wait(self):
-        return self
-
-    @normalize_exceptions
-    def _save_alias_changes(self):
-        """Persist alias changes on this artifact to the wandb backend.
-
-        Called by artifact.save().
-        """
-        aliases_to_add = set(self._aliases) - set(self._frozen_aliases)
-        aliases_to_remove = set(self._frozen_aliases) - set(self._aliases)
-
-        # Introspect
-        introspect_query = gql(
-            """
-            query ProbeServerAddAliasesInput {
-               AddAliasesInputInfoType: __type(name: "AddAliasesInput") {
-                   name
-                   inputFields {
-                       name
-                   }
-                }
-            }
-            """
-        )
-        res = self.client.execute(introspect_query)
-        valid = res.get("AddAliasesInputInfoType")
-        if not valid:
-            return
-
-        if len(aliases_to_add) > 0:
-            add_mutation = gql(
-                """
-            mutation addAliases(
-                $artifactID: ID!,
-                $aliases: [ArtifactCollectionAliasInput!]!,
-            ) {
-                addAliases(
-                    input: {
-                        artifactID: $artifactID,
-                        aliases: $aliases,
-                    }
-                ) {
-                    success
-                }
-            }
-            """
-            )
-            self.client.execute(
-                add_mutation,
-                variable_values={
-                    "artifactID": self.id,
-                    "aliases": [
-                        {
-                            "artifactCollectionName": self._artifact_collection_name,
-                            "alias": alias,
-                            "entityName": self._entity,
-                            "projectName": self._project,
-                        }
-                        for alias in aliases_to_add
-                    ],
-                },
-            )
-
-        if len(aliases_to_remove) > 0:
-            delete_mutation = gql(
-                """
-            mutation deleteAliases(
-                $artifactID: ID!,
-                $aliases: [ArtifactCollectionAliasInput!]!,
-            ) {
-                deleteAliases(
-                    input: {
-                        artifactID: $artifactID,
-                        aliases: $aliases,
-                    }
-                ) {
-                    success
-                }
-            }
-            """
-            )
-            self.client.execute(
-                delete_mutation,
-                variable_values={
-                    "artifactID": self.id,
-                    "aliases": [
-                        {
-                            "artifactCollectionName": self._artifact_collection_name,
-                            "alias": alias,
-                            "entityName": self._entity,
-                            "projectName": self._project,
-                        }
-                        for alias in aliases_to_remove
-                    ],
-                },
-            )
-
-        # reset local state
-        self._frozen_aliases = self._aliases
-        return True
-
-    # TODO: not yet public, but we probably want something like this.
-    def _list(self):
-        manifest = self._load_manifest()
-        return manifest.entries.keys()
-
-    def __repr__(self):
-        return f"<Artifact {self.id}>"
-
-    def _load(self):
-        query = gql(
-            """
-        query Artifact(
-            $entityName: String,
-            $projectName: String,
-            $name: String!
-        ) {
-            project(name: $projectName, entityName: $entityName) {
-                artifact(name: $name) {
-                    ...ArtifactFragment
-                }
-            }
-        }
-        %s
-        """
-            % ARTIFACT_FRAGMENT
-        )
-        response = None
-        try:
-            response = self.client.execute(
-                query,
-                variable_values={
-                    "entityName": self.entity,
-                    "projectName": self.project,
-                    "name": self._artifact_name,
-                },
-            )
-        except Exception:
-            # we check for this after doing the call, since the backend supports raw digest lookups
-            # which don't include ":" and are 32 characters long
-            if ":" not in self._artifact_name and len(self._artifact_name) != 32:
-                raise ValueError(
-                    'Attempted to fetch artifact without alias (e.g. "<artifact_name>:v3" or "<artifact_name>:latest")'
-                )
-        if (
-            response is None
-            or response.get("project") is None
-            or response["project"].get("artifact") is None
-        ):
-            raise ValueError(
-                f'Project {self.entity}/{self.project} does not contain artifact: "{self._artifact_name}"'
-            )
-        self._attrs = response["project"]["artifact"]
-        return self._attrs
-
-    def files(self, names=None, per_page=50):
-        """Iterate over all files stored in this artifact.
-
-        Arguments:
-            names: (list of str, optional) The filename paths relative to the
-                root of the artifact you wish to list.
-            per_page: (int, default 50) The number of files to return per request
-
-        Returns:
-            (`ArtifactFiles`): An iterator containing `File` objects
-        """
-        return ArtifactFiles(self.client, self, names, per_page)
-
-    def _load_manifest(self):
-        if self._manifest is None:
-            query = gql(
-                """
-            query ArtifactManifest(
-                $entityName: String!,
-                $projectName: String!,
-                $name: String!
-            ) {
-                project(name: $projectName, entityName: $entityName) {
-                    artifact(name: $name) {
-                        currentManifest {
-                            id
-                            file {
-                                id
-                                directUrl
-                            }
-                        }
-                    }
-                }
-            }
-            """
-            )
-            response = self.client.execute(
-                query,
-                variable_values={
-                    "entityName": self.entity,
-                    "projectName": self.project,
-                    "name": self._artifact_name,
-                },
-            )
-
-            index_file_url = response["project"]["artifact"]["currentManifest"]["file"][
-                "directUrl"
-            ]
-            with requests.get(index_file_url) as req:
-                req.raise_for_status()
-                self._manifest = artifacts.ArtifactManifest.from_manifest_json(
-                    json.loads(util.ensure_text(req.content))
-                )
-
-            self._load_dependent_manifests()
-
-        return self._manifest
-
-    def _load_dependent_manifests(self):
-        """Interrogate entries and ensure we have loaded their manifests."""
-        # Make sure dependencies are avail
-        for entry_key in self._manifest.entries:
-            entry = self._manifest.entries[entry_key]
-            if self._manifest_entry_is_artifact_reference(entry):
-                dep_artifact = self._get_ref_artifact_from_entry(entry)
-                if dep_artifact not in self._dependent_artifacts:
-                    dep_artifact._load_manifest()
-                    self._dependent_artifacts.append(dep_artifact)
-
-    @staticmethod
-    def _manifest_entry_is_artifact_reference(entry):
-        """Determine if an ArtifactManifestEntry is an artifact reference."""
-        return (
-            entry.ref is not None
-            and urllib.parse.urlparse(entry.ref).scheme == "wandb-artifact"
-        )
-
-    def _get_ref_artifact_from_entry(self, entry):
-        """Helper function returns the referenced artifact from an entry."""
-        artifact_id = util.host_from_path(entry.ref)
-        return Artifact.from_id(hex_to_b64_id(artifact_id), self.client)
-
-    def used_by(self):
-        """Retrieve the runs which use this artifact directly.
-
-        Returns:
-            [Run]: a list of Run objects which use this artifact
-        """
-        query = gql(
-            """
-            query ArtifactUsedBy(
-                $id: ID!,
-                $before: String,
-                $after: String,
-                $first: Int,
-                $last: Int
-            ) {
-                artifact(id: $id) {
-                    usedBy(before: $before, after: $after, first: $first, last: $last) {
-                        edges {
-                            node {
-                                name
-                                project {
-                                    name
-                                    entityName
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        """
-        )
-        response = self.client.execute(
-            query,
-            variable_values={"id": self.id},
-        )
-        # yes, "name" is actually id
-        runs = [
-            Run(
-                self.client,
-                edge["node"]["project"]["entityName"],
-                edge["node"]["project"]["name"],
-                edge["node"]["name"],
-            )
-            for edge in response.get("artifact", {}).get("usedBy", {}).get("edges", [])
-        ]
-        return runs
-
-    def logged_by(self):
-        """Retrieve the run which logged this artifact.
-
-        Returns:
-            Run: Run object which logged this artifact
-        """
-        query = gql(
-            """
-            query ArtifactCreatedBy(
-                $id: ID!
-            ) {
-                artifact(id: $id) {
-                    createdBy {
-                        ... on Run {
-                            name
-                            project {
-                                name
-                                entityName
-                            }
-                        }
-                    }
-                }
-            }
-        """
-        )
-        response = self.client.execute(
-            query,
-            variable_values={"id": self.id},
-        )
-        run_obj = response.get("artifact", {}).get("createdBy", {})
-        if run_obj is not None:
-            return Run(
-                self.client,
-                run_obj["project"]["entityName"],
-                run_obj["project"]["name"],
-                run_obj["name"],
-            )
-
-
-class ArtifactVersions(Paginator):
-    """An iterable collection of artifact versions associated with a project and optional filter.
-
-    This is generally used indirectly via the `Api`.artifact_versions method.
-    """
-
-    def __init__(
-        self,
-        client: Client,
-        entity: str,
-        project: str,
-        collection_name: str,
-        type: str,
-        filters: Optional[Mapping[str, Any]] = None,
-        order: Optional[str] = None,
-        per_page: int = 50,
-    ):
-        self.entity = entity
-        self.collection_name = collection_name
-        self.type = type
-        self.project = project
-        self.filters = {"state": "COMMITTED"} if filters is None else filters
-        self.order = order
-        variables = {
-            "project": self.project,
-            "entity": self.entity,
-            "order": self.order,
-            "type": self.type,
-            "collection": self.collection_name,
-            "filters": json.dumps(self.filters),
-        }
-        self.QUERY = gql(
-            """
-            query Artifacts($project: String!, $entity: String!, $type: String!, $collection: String!, $cursor: String, $perPage: Int = 50, $order: String, $filters: JSONString) {{
-                project(name: $project, entityName: $entity) {{
-                    artifactType(name: $type) {{
-                        artifactCollection: {}(name: $collection) {{
-                            name
-                            artifacts(filters: $filters, after: $cursor, first: $perPage, order: $order) {{
-                                totalCount
-                                edges {{
-                                    node {{
-                                        ...ArtifactFragment
-                                    }}
-                                    version
-                                    cursor
-                                }}
-                                pageInfo {{
-                                    endCursor
-                                    hasNextPage
-                                }}
-                            }}
-                        }}
-                    }}
-                }}
-            }}
-            {}
-            """.format(
-                artifact_collection_edge_name(
-                    server_supports_artifact_collections_gql_edges(client)
-                ),
-                ARTIFACT_FRAGMENT,
-            )
-        )
-        super().__init__(client, variables, per_page)
-
-    @property
-    def length(self):
-        if self.last_response:
-            return self.last_response["project"]["artifactType"]["artifactCollection"][
-                "artifacts"
-            ]["totalCount"]
-        else:
-            return None
-
-    @property
-    def more(self):
-        if self.last_response:
-            return self.last_response["project"]["artifactType"]["artifactCollection"][
-                "artifacts"
-            ]["pageInfo"]["hasNextPage"]
-        else:
-            return True
-
-    @property
-    def cursor(self):
-        if self.last_response:
-            return self.last_response["project"]["artifactType"]["artifactCollection"][
-                "artifacts"
-            ]["edges"][-1]["cursor"]
-        else:
-            return None
-
-    def convert_objects(self):
-        if self.last_response["project"]["artifactType"]["artifactCollection"] is None:
-            return []
-        return [
-            Artifact(
-                self.client,
-                self.entity,
-                self.project,
-                self.collection_name + ":" + a["version"],
-                a["node"],
-            )
-            for a in self.last_response["project"]["artifactType"][
-                "artifactCollection"
-            ]["artifacts"]["edges"]
-        ]
-
-
-class ArtifactFiles(Paginator):
-    QUERY = gql(
-        """
-        query ArtifactFiles(
-            $entityName: String!,
-            $projectName: String!,
-            $artifactTypeName: String!,
-            $artifactName: String!
-            $fileNames: [String!],
-            $fileCursor: String,
-            $fileLimit: Int = 50
-        ) {
-            project(name: $projectName, entityName: $entityName) {
-                artifactType(name: $artifactTypeName) {
-                    artifact(name: $artifactName) {
-                        ...ArtifactFilesFragment
-                    }
-                }
-            }
-        }
-        %s
-    """
-        % ARTIFACT_FILES_FRAGMENT
+        % ARTIFACT_FILES_FRAGMENT
     )
 
     def __init__(
         self,
         client: Client,
-        artifact: Artifact,
+        artifact: "wandb.Artifact",
         names: Optional[Sequence[str]] = None,
         per_page: int = 50,
     ):
         self.artifact = artifact
         variables = {
-            "entityName": artifact._birth_entity,
-            "projectName": artifact._birth_project,
+            "entityName": artifact.source_entity,
+            "projectName": artifact.source_project,
             "artifactTypeName": artifact.type,
-            "artifactName": artifact.name,
+            "artifactName": artifact.source_name,
             "fileNames": names,
         }
         # The server must advertise at least SDK 0.12.21
@@ -5452,6 +4287,7 @@ class Job:
     _entity: str
     _project: str
     _entrypoint: List[str]
+    _notebook_job: bool
 
     def __init__(self, api: Api, name, path: Optional[str] = None) -> None:
         try:
@@ -5468,22 +4304,25 @@ class Job:
         self._entity = api.default_entity
 
         with open(os.path.join(self._fpath, "wandb-job.json")) as f:
-            self._source_info: Mapping[str, Any] = json.load(f)
-        self._entrypoint = self._source_info.get("source", {}).get("entrypoint")
-        self._args = self._source_info.get("source", {}).get("args")
+            self._job_info: Mapping[str, Any] = json.load(f)
+        source_info = self._job_info.get("source", {})
+        # only use notebook job if entrypoint not set and notebook is set
+        self._notebook_job = source_info.get("notebook", False)
+        self._entrypoint = source_info.get("entrypoint")
+        self._args = source_info.get("args")
         self._requirements_file = os.path.join(self._fpath, "requirements.frozen.txt")
         self._input_types = TypeRegistry.type_from_dict(
-            self._source_info.get("input_types")
+            self._job_info.get("input_types")
         )
         self._output_types = TypeRegistry.type_from_dict(
-            self._source_info.get("output_types")
+            self._job_info.get("output_types")
         )
 
-        if self._source_info.get("source_type") == "artifact":
+        if self._job_info.get("source_type") == "artifact":
             self._set_configure_launch_project(self._configure_launch_project_artifact)
-        if self._source_info.get("source_type") == "repo":
+        if self._job_info.get("source_type") == "repo":
             self._set_configure_launch_project(self._configure_launch_project_repo)
-        if self._source_info.get("source_type") == "image":
+        if self._job_info.get("source_type") == "image":
             self._set_configure_launch_project(self._configure_launch_project_container)
 
     @property
@@ -5493,8 +4332,26 @@ class Job:
     def _set_configure_launch_project(self, func):
         self.configure_launch_project = func
 
+    def _get_code_artifact(self, artifact_string):
+        artifact_string, base_url, is_id = util.parse_artifact_string(artifact_string)
+        if is_id:
+            code_artifact = wandb.Artifact._from_id(artifact_string, self._api._client)
+        else:
+            code_artifact = self._api.artifact(name=artifact_string, type="code")
+        if code_artifact is None:
+            raise LaunchError("No code artifact found")
+        return code_artifact
+
+    def _configure_launch_project_notebook(self, launch_project):
+        new_fname = convert_jupyter_notebook_to_script(
+            self._entrypoint[-1], launch_project.project_dir
+        )
+        new_entrypoint = self._entrypoint
+        new_entrypoint[-1] = new_fname
+        launch_project.add_entry_point(new_entrypoint)
+
     def _configure_launch_project_repo(self, launch_project):
-        git_info = self._source_info.get("source", {}).get("git", {})
+        git_info = self._job_info.get("source", {}).get("git", {})
         _fetch_git_repo(
             launch_project.project_dir,
             git_info["remote"],
@@ -5504,27 +4361,30 @@ class Job:
             with open(os.path.join(self._fpath, "diff.patch")) as f:
                 apply_patch(f.read(), launch_project.project_dir)
         shutil.copy(self._requirements_file, launch_project.project_dir)
-        launch_project.add_entry_point(self._entrypoint)
-        launch_project.python_version = self._source_info.get("runtime")
+        launch_project.python_version = self._job_info.get("runtime")
+        if self._notebook_job:
+            self._configure_launch_project_notebook(launch_project)
+        else:
+            launch_project.add_entry_point(self._entrypoint)
 
     def _configure_launch_project_artifact(self, launch_project):
-        artifact_string = self._source_info.get("source", {}).get("artifact")
+        artifact_string = self._job_info.get("source", {}).get("artifact")
         if artifact_string is None:
             raise LaunchError(f"Job {self.name} had no source artifact")
-        artifact_string, base_url, is_id = util.parse_artifact_string(artifact_string)
-        if is_id:
-            code_artifact = Artifact.from_id(artifact_string, self._api._client)
-        else:
-            code_artifact = self._api.artifact(name=artifact_string, type="code")
-        if code_artifact is None:
-            raise LaunchError("No code artifact found")
-        code_artifact.download(launch_project.project_dir)
+
+        code_artifact = self._get_code_artifact(artifact_string)
+        launch_project.python_version = self._job_info.get("runtime")
         shutil.copy(self._requirements_file, launch_project.project_dir)
-        launch_project.add_entry_point(self._entrypoint)
-        launch_project.python_version = self._source_info.get("runtime")
+
+        code_artifact.download(launch_project.project_dir)
+
+        if self._notebook_job:
+            self._configure_launch_project_notebook(launch_project)
+        else:
+            launch_project.add_entry_point(self._entrypoint)
 
     def _configure_launch_project_container(self, launch_project):
-        launch_project.docker_image = self._source_info.get("source", {}).get("image")
+        launch_project.docker_image = self._job_info.get("source", {}).get("image")
         if launch_project.docker_image is None:
             raise LaunchError(
                 "Job had malformed source dictionary without an image key"
@@ -5550,7 +4410,7 @@ class Job:
         run_config = {}
         for key, item in config.items():
             if util._is_artifact_object(item):
-                if isinstance(item, wandb.Artifact) and item.id is None:
+                if isinstance(item, wandb.Artifact) and item.is_draft():
                     raise ValueError("Cannot queue jobs with unlogged artifacts")
                 run_config[key] = util.artifact_to_json(item)