wandb 0.15.9__py3-none-any.whl → 0.15.11__py3-none-any.whl

wandb/sdk/artifacts/artifact.py

@@ -1,16 +1,15 @@
 """Artifact class."""
 import concurrent.futures
 import contextlib
-import datetime
 import json
 import multiprocessing.dummy
 import os
-import platform
 import re
 import shutil
 import tempfile
 import time
 from copy import copy
+from datetime import datetime, timedelta
 from functools import partial
 from pathlib import PurePosixPath
 from typing import (
@@ -35,27 +34,30 @@ import requests
 import wandb
 from wandb import data_types, env, util
 from wandb.apis.normalize import normalize_exceptions
-from wandb.apis.public import ArtifactFiles, RetryingClient, Run
+from wandb.apis.public import ArtifactCollection, ArtifactFiles, RetryingClient, Run
 from wandb.data_types import WBValue
 from wandb.errors.term import termerror, termlog, termwarn
+from wandb.sdk.artifacts.artifact_cache import artifact_cache
 from wandb.sdk.artifacts.artifact_download_logger import ArtifactDownloadLogger
 from wandb.sdk.artifacts.artifact_manifest import ArtifactManifest
 from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
 from wandb.sdk.artifacts.artifact_manifests.artifact_manifest_v1 import (
     ArtifactManifestV1,
 )
-from wandb.sdk.artifacts.artifact_saver import get_staging_dir
 from wandb.sdk.artifacts.artifact_state import ArtifactState
-from wandb.sdk.artifacts.artifacts_cache import get_artifacts_cache
+from wandb.sdk.artifacts.artifact_ttl import ArtifactTTL
 from wandb.sdk.artifacts.exceptions import (
     ArtifactFinalizedError,
     ArtifactNotLoggedError,
     WaitTimeoutError,
 )
+from wandb.sdk.artifacts.staging import get_staging_dir
 from wandb.sdk.artifacts.storage_layout import StorageLayout
-from wandb.sdk.artifacts.storage_policies.wandb_storage_policy import WandbStoragePolicy
+from wandb.sdk.artifacts.storage_policies import WANDB_STORAGE_POLICY
+from wandb.sdk.artifacts.storage_policy import StoragePolicy
 from wandb.sdk.data_types._dtypes import Type as WBType
 from wandb.sdk.data_types._dtypes import TypeRegistry
+from wandb.sdk.internal.internal_api import Api as InternalApi
 from wandb.sdk.internal.thread_local_settings import _thread_local_api_settings
 from wandb.sdk.lib import filesystem, retry, runid, telemetry
 from wandb.sdk.lib.hashutil import B64MD5, b64_to_hex_id, md5_file_b64
@@ -108,39 +110,6 @@ class Artifact:
     """
 
     _TMP_DIR = tempfile.TemporaryDirectory("wandb-artifacts")
-    _GQL_FRAGMENT = """
-      fragment ArtifactFragment on Artifact {
-          id
-          artifactSequence {
-              project {
-                  entityName
-                  name
-              }
-              name
-          }
-          versionIndex
-          artifactType {
-              name
-          }
-          description
-          metadata
-          aliases {
-              artifactCollection {
-                  project {
-                      entityName
-                      name
-                  }
-                  name
-              }
-              alias
-          }
-          state
-          commitHash
-          fileCount
-          createdAt
-          updatedAt
-      }
-    """
 
     def __init__(
         self,
@@ -166,15 +135,12 @@ class Artifact:
 
         # Internal.
         self._client: Optional[RetryingClient] = None
-        storage_layout = (
-            StorageLayout.V1 if env.get_use_v1_artifacts() else StorageLayout.V2
-        )
-        self._storage_policy = WandbStoragePolicy(
-            config={
-                "storageLayout": storage_layout,
-                #  TODO: storage region
-            }
-        )
+
+        storage_policy_cls = StoragePolicy.lookup_by_name(WANDB_STORAGE_POLICY)
+        layout = StorageLayout.V1 if env.get_use_v1_artifacts() else StorageLayout.V2
+        policy_config = {"storageLayout": layout}
+        self._storage_policy = storage_policy_cls.from_config(config=policy_config)
+
         self._tmp_dir: Optional[tempfile.TemporaryDirectory] = None
         self._added_objs: Dict[
             int, Tuple[data_types.WBValue, ArtifactManifestEntry]
@@ -200,6 +166,9 @@ class Artifact:
         self._type: str = type
         self._description: Optional[str] = description
         self._metadata: dict = self._normalize_metadata(metadata)
+        self._ttl_duration_seconds: Optional[int] = None
+        self._ttl_is_inherited: bool = True
+        self._ttl_changed: bool = False
         self._aliases: List[str] = []
         self._saved_aliases: List[str] = []
         self._distributed_id: Optional[str] = None
@@ -214,15 +183,16 @@ class Artifact:
         self._created_at: Optional[str] = None
         self._updated_at: Optional[str] = None
         self._final: bool = False
+
         # Cache.
-        get_artifacts_cache().store_client_artifact(self)
+        artifact_cache[self._client_id] = self
 
     def __repr__(self) -> str:
         return f"<Artifact {self.id or self.name}>"
 
     @classmethod
     def _from_id(cls, artifact_id: str, client: RetryingClient) -> Optional["Artifact"]:
-        artifact = get_artifacts_cache().get_artifact(artifact_id)
+        artifact = artifact_cache.get(artifact_id)
         if artifact is not None:
             return artifact
 
@@ -239,7 +209,7 @@ class Artifact:
                 }
             }
             """
-            + cls._GQL_FRAGMENT
+            + cls._get_gql_artifact_fragment()
         )
         response = client.execute(
             query,
@@ -271,7 +241,7 @@ class Artifact:
                 }
             }
             """
-            + cls._GQL_FRAGMENT
+            + cls._get_gql_artifact_fragment()
         )
         response = client.execute(
             query,
@@ -327,6 +297,12 @@ class Artifact:
         artifact.metadata = cls._normalize_metadata(
             json.loads(attrs["metadata"] or "{}")
         )
+        artifact._ttl_duration_seconds = artifact._ttl_duration_seconds_from_gql(
+            attrs.get("ttlDurationSeconds")
+        )
+        artifact._ttl_is_inherited = (
+            True if attrs.get("ttlIsInherited") is None else attrs["ttlIsInherited"]
+        )
         artifact._aliases = [
             alias for alias in aliases if not util.alias_is_version_index(alias)
         ]
@@ -342,7 +318,9 @@ class Artifact:
         artifact._updated_at = attrs["updatedAt"]
         artifact._final = True
         # Cache.
-        get_artifacts_cache().store_artifact(artifact)
+
+        assert artifact.id is not None
+        artifact_cache[artifact.id] = artifact
         return artifact
 
     def new_draft(self) -> "Artifact":
@@ -353,11 +331,22 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: if the artifact has not been logged
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "new_draft")
+        self._ensure_logged("new_draft")
 
+        # Name, _entity and _project are set to the *source* name/entity/project:
+        # if this artifact is saved it must be saved to the source sequence.
         artifact = Artifact(self.source_name.split(":")[0], self.type)
+        artifact._entity = self._source_entity
+        artifact._project = self._source_project
+        artifact._source_entity = self._source_entity
+        artifact._source_project = self._source_project
+
+        # This artifact's parent is the one we are making a draft from.
         artifact._base_id = self.id
+
+        # We can reuse the client, and copy over all the attributes that aren't
+        # version-dependent and don't depend on having been logged.
+        artifact._client = self._client
         artifact._description = self.description
         artifact._metadata = self.metadata
         artifact._manifest = ArtifactManifest.from_manifest_json(
@@ -370,7 +359,7 @@ class Artifact:
     @property
     def id(self) -> Optional[str]:
         """The artifact's ID."""
-        if self._state == ArtifactState.PENDING:
+        if self.is_draft():
             return None
         assert self._id is not None
         return self._id
@@ -378,16 +367,14 @@ class Artifact:
     @property
     def entity(self) -> str:
         """The name of the entity of the secondary (portfolio) artifact collection."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "entity")
+        self._ensure_logged("entity")
         assert self._entity is not None
         return self._entity
 
     @property
     def project(self) -> str:
         """The name of the project of the secondary (portfolio) artifact collection."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "project")
+        self._ensure_logged("project")
         assert self._project is not None
         return self._project
 
@@ -408,24 +395,34 @@ class Artifact:
     @property
     def version(self) -> str:
         """The artifact's version in its secondary (portfolio) collection."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "version")
+        self._ensure_logged("version")
         assert self._version is not None
         return self._version
 
+    @property
+    def collection(self) -> ArtifactCollection:
+        """The collection this artifact was retrieved from.
+
+        If this artifact was retrieved from a portfolio / linked collection, that
+        collection will be returned rather than the source sequence.
+        """
+        self._ensure_logged("collection")
+        base_name = self.name.split(":")[0]
+        return ArtifactCollection(
+            self._client, self.entity, self.project, base_name, self.type
+        )
+
     @property
     def source_entity(self) -> str:
         """The name of the entity of the primary (sequence) artifact collection."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "source_entity")
+        self._ensure_logged("source_entity")
         assert self._source_entity is not None
         return self._source_entity
 
     @property
     def source_project(self) -> str:
         """The name of the project of the primary (sequence) artifact collection."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "source_project")
+        self._ensure_logged("source_project")
         assert self._source_project is not None
         return self._source_project
 
@@ -449,11 +446,19 @@ class Artifact:
 
         A string with the format "v{number}".
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "source_version")
+        self._ensure_logged("source_version")
         assert self._source_version is not None
         return self._source_version
 
+    @property
+    def source_collection(self) -> ArtifactCollection:
+        """The artifact's primary (sequence) collection."""
+        self._ensure_logged("source_collection")
+        base_name = self.source_name.split(":")[0]
+        return ArtifactCollection(
+            self._client, self.source_entity, self.source_project, base_name, self.type
+        )
+
     @property
     def type(self) -> str:
         """The artifact's type."""
@@ -501,21 +506,69 @@ class Artifact:
         """
         self._metadata = self._normalize_metadata(metadata)
 
+    @property
+    def ttl(self) -> Union[timedelta, None]:
+        """Time To Live (TTL).
+
+        The artifact will be deleted shortly after TTL since its creation.
+        None means the artifact will never expire.
+        If TTL is not set on an artifact, it will inherit the default for its collection.
+
+        Raises:
+            ArtifactNotLoggedError: Unable to fetch inherited TTL if the artifact has not been logged or saved
+        """
+        if self._ttl_is_inherited and (self.is_draft() or self._ttl_changed):
+            raise ArtifactNotLoggedError(self, "ttl")
+        if self._ttl_duration_seconds is None:
+            return None
+        return timedelta(seconds=self._ttl_duration_seconds)
+
+    @ttl.setter
+    def ttl(self, ttl: Union[timedelta, ArtifactTTL, None]) -> None:
+        """Time To Live (TTL).
+
+        The artifact will be deleted shortly after TTL since its creation. None means the artifact will never expire.
+        If TTL is not set on an artifact, it will inherit the default TTL rules for its collection.
+
+        Arguments:
+            ttl: How long the artifact will remain active from its creation.
+                - Timedelta must be positive.
+                - `None` means the artifact will never expire.
+                - wandb.ArtifactTTL.INHERIT will set the TTL to go back to the default and inherit from collection rules.
+        """
+        if self.type == "wandb-history":
+            raise ValueError("Cannot set artifact TTL for type wandb-history")
+
+        self._ttl_changed = True
+        if isinstance(ttl, ArtifactTTL):
+            if ttl == ArtifactTTL.INHERIT:
+                self._ttl_is_inherited = True
+            else:
+                raise ValueError(f"Unhandled ArtifactTTL enum {ttl}")
+        else:
+            self._ttl_is_inherited = False
+            if ttl is None:
+                self._ttl_duration_seconds = None
+            else:
+                if ttl.total_seconds() <= 0:
+                    raise ValueError(
+                        f"Artifact TTL Duration has to be positive. ttl: {ttl.total_seconds()}"
+                    )
+                self._ttl_duration_seconds = int(ttl.total_seconds())
+
     @property
     def aliases(self) -> List[str]:
         """The aliases associated with this artifact.
 
         The list is mutable and calling `save()` will persist all alias changes.
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "aliases")
+        self._ensure_logged("aliases")
         return self._aliases
 
     @aliases.setter
     def aliases(self, aliases: List[str]) -> None:
         """Set the aliases associated with this artifact."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "aliases")
+        self._ensure_logged("aliases")
 
         if any(char in alias for alias in aliases for char in ["/", ":"]):
             raise ValueError(
@@ -609,32 +662,28 @@ class Artifact:
     @property
     def commit_hash(self) -> str:
         """The hash returned when this artifact was committed."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "commit_hash")
+        self._ensure_logged("commit_hash")
         assert self._commit_hash is not None
         return self._commit_hash
 
     @property
     def file_count(self) -> int:
         """The number of files (including references)."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "file_count")
+        self._ensure_logged("file_count")
         assert self._file_count is not None
         return self._file_count
 
     @property
     def created_at(self) -> str:
         """The time at which the artifact was created."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "created_at")
+        self._ensure_logged("created_at")
         assert self._created_at is not None
         return self._created_at
 
     @property
     def updated_at(self) -> str:
         """The time at which the artifact was last updated."""
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "created_at")
+        self._ensure_logged("updated_at")
         assert self._created_at is not None
         return self._updated_at or self._created_at
 
@@ -651,6 +700,10 @@ class Artifact:
         if self._final:
             raise ArtifactFinalizedError(artifact=self)
 
+    def _ensure_logged(self, attr: Optional[str] = None) -> None:
+        if self.is_draft():
+            raise ArtifactNotLoggedError(self, attr)
+
     def is_draft(self) -> bool:
         """Whether the artifact is a draft, i.e. it hasn't been saved yet."""
         return self._state == ArtifactState.PENDING
@@ -684,7 +737,12 @@ class Artifact:
         if wandb.run is None:
             if settings is None:
                 settings = wandb.Settings(silent="true")
-            with wandb.init(project=project, job_type="auto", settings=settings) as run:
+            with wandb.init(
+                entity=self._source_entity,
+                project=project or self._source_project,
+                job_type="auto",
+                settings=settings,
+            ) as run:
                 # redoing this here because in this branch we know we didn't
                 # have the run at the beginning of the method
                 if self._incremental:
@@ -706,7 +764,7 @@ class Artifact:
         Arguments:
             timeout: Wait up to this long.
         """
-        if self._state == ArtifactState.PENDING:
+        if self.is_draft():
             if self._save_future is None:
                 raise ArtifactNotLoggedError(self, "wait")
             result = self._save_future.get(timeout)
@@ -721,8 +779,7 @@ class Artifact:
         return self
 
     def _populate_after_save(self, artifact_id: str) -> None:
-        query = gql(
-            """
+        query_template = """
             query ArtifactByIDShort($id: ID!) {
                 artifact(id: $id) {
                     artifactSequence {
@@ -733,6 +790,8 @@ class Artifact:
                         name
                     }
                     versionIndex
+                    ttlDurationSeconds
+                    ttlIsInherited
                     aliases {
                         artifactCollection {
                             project {
@@ -755,8 +814,16 @@ class Artifact:
                     updatedAt
                 }
             }
-            """
-        )
+        """
+
+        fields = InternalApi().server_artifact_introspection()
+        if "ttlIsInherited" not in fields:
+            query_template = query_template.replace("ttlDurationSeconds", "").replace(
+                "ttlIsInherited",
+                "",
+            )
+        query = gql(query_template)
+
         assert self._client is not None
         response = self._client.execute(
             query,
@@ -776,6 +843,13 @@ class Artifact:
         self._source_project = self._project
         self._source_name = self._name
         self._source_version = self._version
+        self._ttl_duration_seconds = self._ttl_duration_seconds_from_gql(
+            attrs.get("ttlDurationSeconds")
+        )
+        self._ttl_is_inherited = (
+            True if attrs.get("ttlIsInherited") is None else attrs["ttlIsInherited"]
+        )
+        self._ttl_changed = False  # Reset after saving artifact
         self._aliases = [
             alias["alias"]
             for alias in attrs["aliases"]
@@ -884,12 +958,12 @@ class Artifact:
                 for alias in self._aliases
             ]
 
-        mutation = gql(
-            """
+        mutation_template = """
             mutation updateArtifact(
                 $artifactID: ID!,
                 $description: String,
                 $metadata: JSONString,
+                _TTL_DURATION_SECONDS_TYPE_
                 $aliases: [ArtifactAliasInput!]
             ) {
                 updateArtifact(
@@ -897,26 +971,68 @@ class Artifact:
                         artifactID: $artifactID,
                         description: $description,
                         metadata: $metadata,
+                        _TTL_DURATION_SECONDS_VALUE_
                         aliases: $aliases
                     }
                 ) {
                     artifact {
                         id
+                        _TTL_DURATION_SECONDS_FIELDS_
                     }
                 }
             }
-            """
-        )
+        """
+        fields = InternalApi().server_artifact_introspection()
+        if "ttlIsInherited" in fields:
+            mutation_template = (
+                mutation_template.replace(
+                    "_TTL_DURATION_SECONDS_TYPE_", "$ttlDurationSeconds: Int64,"
+                )
+                .replace(
+                    "_TTL_DURATION_SECONDS_VALUE_",
+                    "ttlDurationSeconds: $ttlDurationSeconds,",
+                )
+                .replace(
+                    "_TTL_DURATION_SECONDS_FIELDS_", "ttlDurationSeconds ttlIsInherited"
+                )
+            )
+        else:
+            if self._ttl_changed:
+                termwarn(
+                    "Server not compatible with setting Artifact TTLs, please upgrade the server to use Artifact TTL"
+                )
+            mutation_template = (
+                mutation_template.replace("_TTL_DURATION_SECONDS_TYPE_", "")
+                .replace(
+                    "_TTL_DURATION_SECONDS_VALUE_",
+                    "",
+                )
+                .replace("_TTL_DURATION_SECONDS_FIELDS_", "")
+            )
+        mutation = gql(mutation_template)
         assert self._client is not None
-        self._client.execute(
+
+        ttl_duration_input = self._ttl_duration_seconds_to_gql()
+        response = self._client.execute(
             mutation,
             variable_values={
                 "artifactID": self.id,
                 "description": self.description,
                 "metadata": util.json_dumps_safer(self.metadata),
+                "ttlDurationSeconds": ttl_duration_input,
                 "aliases": aliases,
             },
         )
+        attrs = response["updateArtifact"]["artifact"]
+
+        # Update ttl_duration_seconds based on updateArtifact
+        self._ttl_duration_seconds = self._ttl_duration_seconds_from_gql(
+            attrs.get("ttlDurationSeconds")
+        )
+        self._ttl_is_inherited = (
+            True if attrs.get("ttlIsInherited") is None else attrs["ttlIsInherited"]
+        )
+        self._ttl_changed = False  # Reset after updating artifact
 
     # Adding, removing, getting entries.
 
@@ -1424,8 +1540,7 @@ class Artifact:
                 path.download()
             ```
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "get_path")
+        self._ensure_logged("get_path")
 
         name = LogicalPath(name)
         entry = self.manifest.entries.get(name) or self._get_obj_entry(name)[0]
@@ -1461,8 +1576,7 @@ class Artifact:
                 table = artifact.get("my_table")
             ```
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "get")
+        self._ensure_logged("get")
 
         entry, wb_class = self._get_obj_entry(name)
         if entry is None or wb_class is None:
@@ -1470,9 +1584,11 @@ class Artifact:
 
         # If the entry is a reference from another artifact, then get it directly from
         # that artifact.
-        if entry._is_artifact_reference():
+        referenced_id = entry._referenced_artifact_id()
+        if referenced_id:
             assert self._client is not None
-            artifact = entry._get_referenced_artifact(self._client)
+            artifact = self._from_id(referenced_id, client=self._client)
+            assert artifact is not None
             return artifact.get(util.uri_from_path(entry.ref))
 
         # Special case for wandb.Table. This is intended to be a short term
@@ -1565,8 +1681,7 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: if the artifact has not been logged
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "download")
+        self._ensure_logged("download")
 
         root = root or self._default_root()
         self._add_download_root(root)
@@ -1581,7 +1696,7 @@ class Artifact:
                     self.name, size / (1024 * 1024), nfiles
                 ),
             )
-            start_time = datetime.datetime.now()
+            start_time = datetime.now()
         download_logger = ArtifactDownloadLogger(nfiles=nfiles)
 
         def _download_entry(
@@ -1615,7 +1730,8 @@ class Artifact:
             has_next_page = True
             cursor = None
             while has_next_page:
-                attrs = self._fetch_file_urls(cursor)
+                fetch_url_batch_size = env.get_artifact_fetch_file_url_batch_size()
+                attrs = self._fetch_file_urls(cursor, fetch_url_batch_size)
                 has_next_page = attrs["pageInfo"]["hasNextPage"]
                 cursor = attrs["pageInfo"]["endCursor"]
                 for edge in attrs["edges"]:
@@ -1623,7 +1739,7 @@ class Artifact:
                     entry._download_url = edge["node"]["directUrl"]
                     active_futures.add(executor.submit(download_entry, entry))
                 # Wait for download threads to catch up.
-                max_backlog = 5000
+                max_backlog = fetch_url_batch_size
                 if len(active_futures) > max_backlog:
                     for future in concurrent.futures.as_completed(active_futures):
                         future.result()  # check for errors
@@ -1639,7 +1755,7 @@ class Artifact:
                 dependent_artifact.download()
 
         if log:
-            now = datetime.datetime.now()
+            now = datetime.now()
             delta = abs((now - start_time).total_seconds())
             hours = int(delta // 3600)
             minutes = int((delta - hours * 3600) // 60)
@@ -1651,15 +1767,17 @@ class Artifact:
         return FilePathStr(root)
 
     @retry.retriable(
-        retry_timedelta=datetime.timedelta(minutes=3),
+        retry_timedelta=timedelta(minutes=3),
         retryable_exceptions=(requests.RequestException),
     )
-    def _fetch_file_urls(self, cursor: Optional[str]) -> Any:
+    def _fetch_file_urls(
+        self, cursor: Optional[str], per_page: Optional[int] = 5000
+    ) -> Any:
         query = gql(
             """
-            query ArtifactFileURLs($id: ID!, $cursor: String) {
+            query ArtifactFileURLs($id: ID!, $cursor: String, $perPage: Int) {
                 artifact(id: $id) {
-                    files(after: $cursor, first: 5000) {
+                    files(after: $cursor, first: $perPage) {
                         pageInfo {
                             hasNextPage
                             endCursor
@@ -1678,7 +1796,7 @@ class Artifact:
         assert self._client is not None
         response = self._client.execute(
             query,
-            variable_values={"id": self.id, "cursor": cursor},
+            variable_values={"id": self.id, "cursor": cursor, "perPage": per_page},
             timeout=60,
         )
         return response["artifact"]["files"]
@@ -1698,8 +1816,7 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: if the artifact has not been logged
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "checkout")
+        self._ensure_logged("checkout")
 
         root = root or self._default_root(include_version=False)
 
@@ -1731,8 +1848,7 @@ class Artifact:
             ArtifactNotLoggedError: if the artifact has not been logged
             ValueError: If the verification fails.
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "verify")
+        self._ensure_logged("verify")
 
         root = root or self._default_root()
 
@@ -1773,8 +1889,7 @@ class Artifact:
             ArtifactNotLoggedError: if the artifact has not been logged
             ValueError: if the artifact contains more than one file
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "file")
+        self._ensure_logged("file")
 
         if root is None:
             root = os.path.join(".", "artifacts", self.name)
@@ -1803,18 +1918,17 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: if the artifact has not been logged
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "files")
-
+        self._ensure_logged("files")
         return ArtifactFiles(self._client, self, names, per_page)
 
-    def _default_root(self, include_version: bool = True) -> str:
+    def _default_root(self, include_version: bool = True) -> FilePathStr:
         name = self.source_name if include_version else self.source_name.split(":")[0]
         root = os.path.join(env.get_artifact_dir(), name)
-        if platform.system() == "Windows":
-            head, tail = os.path.splitdrive(root)
-            root = head + tail.replace(":", "-")
-        return root
+        # In case we're on a system where the artifact dir has a name corresponding to
+        # an unexpected filesystem, we'll check for alternate roots. If one exists we'll
+        # use that, otherwise we'll fall back to the system-preferred path.
+        path = filesystem.check_exists(root) or filesystem.system_preferred_path(root)
+        return FilePathStr(str(path))
 
     def _add_download_root(self, dir_path: str) -> None:
         self._download_roots.add(os.path.abspath(dir_path))
@@ -1851,8 +1965,7 @@ class Artifact:
                         artifact.delete(delete_aliases=True)
             ```
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "delete")
+        self._ensure_logged("delete")
         self._delete(delete_aliases)
 
     @normalize_exceptions
@@ -1880,6 +1993,7 @@ class Artifact:
             },
         )
 
+    @normalize_exceptions
     def link(self, target_path: str, aliases: Optional[List[str]] = None) -> None:
         """Link this artifact to a portfolio (a promoted collection of artifacts).
 
@@ -1892,63 +2006,16 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: if the artifact has not been logged
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "link")
-        self._link(target_path, aliases)
-
-    @normalize_exceptions
-    def _link(self, target_path: str, aliases: Optional[List[str]] = None) -> None:
-        if ":" in target_path:
-            raise ValueError(
-                f"target_path {target_path} cannot contain `:` because it is not an "
-                f"alias."
-            )
-
-        portfolio, project, entity = util._parse_entity_project_item(target_path)
-        aliases = util._resolve_aliases(aliases)
-
-        run_entity = wandb.run.entity if wandb.run else None
-        run_project = wandb.run.project if wandb.run else None
-        entity = entity or run_entity or self.entity
-        project = project or run_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
-                }
-            }
-            """
-        )
-        assert self._client is not None
-        self._client.execute(
-            mutation,
-            variable_values={
-                "artifactID": self.id,
-                "artifactPortfolioName": portfolio,
-                "entityName": entity,
-                "projectName": project,
-                "aliases": [
-                    {"alias": alias, "artifactCollectionName": portfolio}
-                    for alias in aliases
-                ],
-            },
-        )
+        if wandb.run is None:
+            with wandb.init(
+                entity=self._source_entity,
+                project=self._source_project,
+                job_type="auto",
+                settings=wandb.Settings(silent="true"),
+            ) as run:
+                run.link_artifact(self, target_path, aliases)
+        else:
+            wandb.run.link_artifact(self, target_path, aliases)
 
     def used_by(self) -> List[Run]:
         """Get a list of the runs that have used this artifact.
@@ -1956,8 +2023,7 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: if the artifact has not been logged
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "used_by")
+        self._ensure_logged("used_by")
 
         query = gql(
             """
@@ -2001,8 +2067,7 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: if the artifact has not been logged
         """
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "logged_by")
+        self._ensure_logged("logged_by")
 
         query = gql(
             """
@@ -2039,8 +2104,7 @@ class Artifact:
         )
 
     def json_encode(self) -> Dict[str, Any]:
-        if self._state == ArtifactState.PENDING:
-            raise ArtifactNotLoggedError(self, "json_encode")
+        self._ensure_logged("json_encode")
         return util.artifact_to_json(self)
 
     @staticmethod
@@ -2097,11 +2161,79 @@ class Artifact:
                 json.loads(util.ensure_text(request.content))
             )
         for entry in self.manifest.entries.values():
-            if entry._is_artifact_reference():
+            referenced_id = entry._referenced_artifact_id()
+            if referenced_id:
                 assert self._client is not None
-                dep_artifact = entry._get_referenced_artifact(self._client)
+                dep_artifact = self._from_id(referenced_id, client=self._client)
+                assert dep_artifact is not None
                 self._dependent_artifacts.add(dep_artifact)
 
+    @staticmethod
+    def _get_gql_artifact_fragment() -> str:
+        fields = InternalApi().server_artifact_introspection()
+        fragment = """
+            fragment ArtifactFragment on Artifact {
+                id
+                artifactSequence {
+                    project {
+                        entityName
+                        name
+                    }
+                    name
+                }
+                versionIndex
+                artifactType {
+                    name
+                }
+                description
+                metadata
+                ttlDurationSeconds
+                ttlIsInherited
+                aliases {
+                    artifactCollection {
+                        project {
+                            entityName
+                            name
+                        }
+                        name
+                    }
+                    alias
+                }
+                state
+                commitHash
+                fileCount
+                createdAt
+                updatedAt
+            }
+        """
+        if "ttlIsInherited" not in fields:
+            return fragment.replace("ttlDurationSeconds", "").replace(
+                "ttlIsInherited", ""
+            )
+        return fragment
+
+    def _ttl_duration_seconds_to_gql(self) -> Optional[int]:
+        # Set artifact ttl value to ttl_duration_seconds if the user set a value
+        # otherwise use ttl_status to indicate the backend INHERIT(-1) or DISABLED(-2) when the TTL is None
+        # When ttl_change = None its a no op since nothing changed
+        INHERIT = -1  # noqa: N806
+        DISABLED = -2  # noqa: N806
+
+        if not self._ttl_changed:
+            return None
+        if self._ttl_is_inherited:
+            return INHERIT
+        return self._ttl_duration_seconds or DISABLED
+
+    def _ttl_duration_seconds_from_gql(
+        self, gql_ttl_duration_seconds: Optional[int]
+    ) -> Optional[int]:
+        # If gql_ttl_duration_seconds is not positive, its indicating that TTL is DISABLED(-2)
+        # gql_ttl_duration_seconds only returns None if the server is not compatible with setting Artifact TTLs
+        if gql_ttl_duration_seconds and gql_ttl_duration_seconds > 0:
+            return gql_ttl_duration_seconds
+        return None
+
 
 class _ArtifactVersionType(WBType):
     name = "artifactVersion"