wandb 0.19.8__py3-none-any.whl → 0.19.10__py3-none-any.whl

wandb/sdk/artifacts/_generated/project_artifacts.py

@@ -0,0 +1,42 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/artifacts/
+
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase, Typename
+
+from .fragments import ArtifactsFragment
+
+
+class ProjectArtifacts(GQLBase):
+    project: Optional[ProjectArtifactsProject]
+
+
+class ProjectArtifactsProject(GQLBase):
+    artifact_type: Optional[ProjectArtifactsProjectArtifactType] = Field(
+        alias="artifactType"
+    )
+
+
+class ProjectArtifactsProjectArtifactType(GQLBase):
+    artifact_collection: Optional[
+        ProjectArtifactsProjectArtifactTypeArtifactCollection
+    ] = Field(alias="artifactCollection")
+
+
+class ProjectArtifactsProjectArtifactTypeArtifactCollection(GQLBase):
+    typename__: Typename[
+        Literal["ArtifactCollection", "ArtifactPortfolio", "ArtifactSequence"]
+    ]
+    name: str
+    artifacts: Optional[ArtifactsFragment]
+
+
+ProjectArtifacts.model_rebuild()
+ProjectArtifactsProject.model_rebuild()
+ProjectArtifactsProjectArtifactType.model_rebuild()
+ProjectArtifactsProjectArtifactTypeArtifactCollection.model_rebuild()

wandb/sdk/artifacts/_generated/run_input_artifacts.py

@@ -0,0 +1,51 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/artifacts/
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase
+
+from .fragments import ArtifactFragment
+
+
+class RunInputArtifacts(GQLBase):
+    project: Optional[RunInputArtifactsProject]
+
+
+class RunInputArtifactsProject(GQLBase):
+    run: Optional[RunInputArtifactsProjectRun]
+
+
+class RunInputArtifactsProjectRun(GQLBase):
+    input_artifacts: Optional[RunInputArtifactsProjectRunInputArtifacts] = Field(
+        alias="inputArtifacts"
+    )
+
+
+class RunInputArtifactsProjectRunInputArtifacts(GQLBase):
+    total_count: int = Field(alias="totalCount")
+    edges: List[RunInputArtifactsProjectRunInputArtifactsEdges]
+    page_info: RunInputArtifactsProjectRunInputArtifactsPageInfo = Field(
+        alias="pageInfo"
+    )
+
+
+class RunInputArtifactsProjectRunInputArtifactsEdges(GQLBase):
+    node: Optional[ArtifactFragment]
+    cursor: str
+
+
+class RunInputArtifactsProjectRunInputArtifactsPageInfo(GQLBase):
+    end_cursor: Optional[str] = Field(alias="endCursor")
+    has_next_page: bool = Field(alias="hasNextPage")
+
+
+RunInputArtifacts.model_rebuild()
+RunInputArtifactsProject.model_rebuild()
+RunInputArtifactsProjectRun.model_rebuild()
+RunInputArtifactsProjectRunInputArtifacts.model_rebuild()
+RunInputArtifactsProjectRunInputArtifactsEdges.model_rebuild()

wandb/sdk/artifacts/_generated/run_output_artifacts.py

@@ -0,0 +1,51 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/artifacts/
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase
+
+from .fragments import ArtifactFragment
+
+
+class RunOutputArtifacts(GQLBase):
+    project: Optional[RunOutputArtifactsProject]
+
+
+class RunOutputArtifactsProject(GQLBase):
+    run: Optional[RunOutputArtifactsProjectRun]
+
+
+class RunOutputArtifactsProjectRun(GQLBase):
+    output_artifacts: Optional[RunOutputArtifactsProjectRunOutputArtifacts] = Field(
+        alias="outputArtifacts"
+    )
+
+
+class RunOutputArtifactsProjectRunOutputArtifacts(GQLBase):
+    total_count: int = Field(alias="totalCount")
+    edges: List[RunOutputArtifactsProjectRunOutputArtifactsEdges]
+    page_info: RunOutputArtifactsProjectRunOutputArtifactsPageInfo = Field(
+        alias="pageInfo"
+    )
+
+
+class RunOutputArtifactsProjectRunOutputArtifactsEdges(GQLBase):
+    node: Optional[ArtifactFragment]
+    cursor: str
+
+
+class RunOutputArtifactsProjectRunOutputArtifactsPageInfo(GQLBase):
+    end_cursor: Optional[str] = Field(alias="endCursor")
+    has_next_page: bool = Field(alias="hasNextPage")
+
+
+RunOutputArtifacts.model_rebuild()
+RunOutputArtifactsProject.model_rebuild()
+RunOutputArtifactsProjectRun.model_rebuild()
+RunOutputArtifactsProjectRunOutputArtifacts.model_rebuild()
+RunOutputArtifactsProjectRunOutputArtifactsEdges.model_rebuild()

wandb/sdk/artifacts/_generated/update_artifact_portfolio.py

@@ -0,0 +1,35 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/artifacts/
+
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase, GQLId, Typename
+
+
+class UpdateArtifactPortfolio(GQLBase):
+    update_artifact_portfolio: Optional[
+        UpdateArtifactPortfolioUpdateArtifactPortfolio
+    ] = Field(alias="updateArtifactPortfolio")
+
+
+class UpdateArtifactPortfolioUpdateArtifactPortfolio(GQLBase):
+    artifact_collection: UpdateArtifactPortfolioUpdateArtifactPortfolioArtifactCollection = Field(
+        alias="artifactCollection"
+    )
+
+
+class UpdateArtifactPortfolioUpdateArtifactPortfolioArtifactCollection(GQLBase):
+    typename__: Typename[
+        Literal["ArtifactCollection", "ArtifactPortfolio", "ArtifactSequence"]
+    ]
+    id: GQLId
+    name: str
+    description: Optional[str]
+
+
+UpdateArtifactPortfolio.model_rebuild()
+UpdateArtifactPortfolioUpdateArtifactPortfolio.model_rebuild()

wandb/sdk/artifacts/_generated/update_artifact_sequence.py

@@ -0,0 +1,35 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/artifacts/
+
+from __future__ import annotations
+
+from typing import Literal, Optional
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase, GQLId, Typename
+
+
+class UpdateArtifactSequence(GQLBase):
+    update_artifact_sequence: Optional[UpdateArtifactSequenceUpdateArtifactSequence] = (
+        Field(alias="updateArtifactSequence")
+    )
+
+
+class UpdateArtifactSequenceUpdateArtifactSequence(GQLBase):
+    artifact_collection: UpdateArtifactSequenceUpdateArtifactSequenceArtifactCollection = Field(
+        alias="artifactCollection"
+    )
+
+
+class UpdateArtifactSequenceUpdateArtifactSequenceArtifactCollection(GQLBase):
+    typename__: Typename[
+        Literal["ArtifactCollection", "ArtifactPortfolio", "ArtifactSequence"]
+    ]
+    id: GQLId
+    name: str
+    description: Optional[str]
+
+
+UpdateArtifactSequence.model_rebuild()
+UpdateArtifactSequenceUpdateArtifactSequence.model_rebuild()

wandb/sdk/artifacts/_graphql_fragments.py

@@ -1,64 +1,57 @@
+from __future__ import annotations
+
+from textwrap import dedent
+
+from wandb_graphql.language.printer import print_ast
+
+from wandb.apis.public.utils import gql_compat
 from wandb.sdk.internal.internal_api import Api as InternalApi
 
-ARTIFACTS_TYPES_FRAGMENT = """
-fragment ArtifactTypesFragment on ArtifactTypeConnection {
-    edges {
-         node {
-             id
-             name
-             description
-             createdAt
-         }
-         cursor
+OMITTABLE_ARTIFACT_FIELDS = frozenset(
+    {
+        "ttlDurationSeconds",
+        "ttlIsInherited",
+        "aliases",
+        "tags",
+        "historyStep",
     }
-    pageInfo {
-        endCursor
-        hasNextPage
-    }
-}
-"""
+)
 
-ARTIFACT_FILES_FRAGMENT = """fragment ArtifactFilesFragment on Artifact {
-    files(names: $fileNames, after: $fileCursor, first: $fileLimit) {
-        edges {
-            node {
-                id
-                name: displayName
-                url
-                sizeBytes
-                storagePath
-                mimetype
-                updatedAt
-                digest
-                md5
-                directUrl
-            }
-            cursor
-        }
-        pageInfo {
-            endCursor
-            hasNextPage
-        }
-    }
-}"""
+
+def omit_artifact_fields(api: InternalApi) -> set[str]:
+    """Return names of Artifact fields to remove from GraphQL requests (for server compatibility)."""
+    allowed_fields = set(api.server_artifact_introspection())
+    return set(OMITTABLE_ARTIFACT_FIELDS - allowed_fields)
 
 
 def _gql_artifact_fragment(include_aliases: bool = True) -> str:
     """Return a GraphQL query fragment with all parseable Artifact attributes."""
-    allowed_fields = set(InternalApi().server_artifact_introspection())
-
-    supports_ttl = "ttlIsInherited" in allowed_fields
-    supports_tags = "tags" in allowed_fields
+    omit_fields = omit_artifact_fields(api=InternalApi())
 
-    ttl_duration_seconds = "ttlDurationSeconds" if supports_ttl else ""
-    ttl_is_inherited = "ttlIsInherited" if supports_ttl else ""
+    # Respect the `include_aliases` flag
+    if not include_aliases:
+        omit_fields.add("aliases")
 
-    tags = "tags {name}" if supports_tags else ""
-
-    # The goal is to move all artifact aliases fetches to the membership level in the future
-    # but this is a quick fix to unblock the registry work
-    aliases = (
-        """aliases {
+    artifact_fragment_str = dedent(
+        """\
+        fragment ArtifactFragment on Artifact {
+            id
+            artifactSequence {
+                project {
+                    entityName
+                    name
+                }
+                name
+            }
+            versionIndex
+            artifactType {
+                name
+            }
+            description
+            metadata
+            ttlDurationSeconds
+            ttlIsInherited
+            aliases {
                 artifactCollection {
                     project {
                         entityName
@@ -67,43 +60,25 @@ def _gql_artifact_fragment(include_aliases: bool = True) -> str:
                     name
                 }
                 alias
-            }"""
-        if include_aliases
-        else ""
-    )
-
-    return f"""
-        fragment ArtifactFragment on Artifact {{
-            id
-            artifactSequence {{
-                project {{
-                    entityName
-                    name
-                }}
-                name
-            }}
-            versionIndex
-            artifactType {{
+            }
+            tags {
                 name
-            }}
-            description
-            metadata
-            {ttl_duration_seconds}
-            {ttl_is_inherited}
-            {aliases}
-            {tags}
+            }
+            historyStep
             state
-            currentManifest {{
-                file {{
+            currentManifest {
+                file {
                     directUrl
-                }}
-            }}
+                }
+            }
             commitHash
             fileCount
             createdAt
             updatedAt
-        }}
-    """
+        }"""
+    )
+    compat_doc = gql_compat(artifact_fragment_str, omit_fields=omit_fields)
+    return print_ast(compat_doc)
 
 
 def _gql_registry_fragment() -> str:

wandb/sdk/artifacts/_validators.py

@@ -22,6 +22,7 @@ if TYPE_CHECKING:
 
 
 REGISTRY_PREFIX: Final[str] = "wandb-registry-"
+MAX_ARTIFACT_METADATA_KEYS: Final[int] = 100
 
 
 # For mypy checks

wandb/sdk/artifacts/artifact.py

@@ -19,18 +19,7 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from functools import partial
 from pathlib import PurePosixPath
-from typing import (
-    IO,
-    Any,
-    Dict,
-    Iterator,
-    Literal,
-    Optional,
-    Sequence,
-    Type,
-    cast,
-    final,
-)
+from typing import IO, Any, Dict, Iterator, Literal, Sequence, Type, cast, final
 from urllib.parse import quote, urljoin, urlparse
 
 import requests
@@ -42,6 +31,8 @@ from wandb.apis.public import ArtifactCollection, ArtifactFiles, RetryingClient,
 from wandb.data_types import WBValue
 from wandb.errors.term import termerror, termlog, termwarn
 from wandb.proto import wandb_internal_pb2 as pb
+from wandb.proto.wandb_deprecated import Deprecated
+from wandb.sdk import wandb_setup
 from wandb.sdk.artifacts._graphql_fragments import _gql_artifact_fragment
 from wandb.sdk.artifacts._validators import (
     ensure_logged,
@@ -70,7 +61,7 @@ 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.deprecate import Deprecated, deprecate
+from wandb.sdk.lib.deprecate import deprecate
 from wandb.sdk.lib.hashutil import B64MD5, b64_to_hex_id, md5_file_b64
 from wandb.sdk.lib.paths import FilePathStr, LogicalPath, StrPath, URIStr
 from wandb.sdk.lib.runid import generate_id
@@ -200,6 +191,7 @@ class Artifact:
         self._created_at: str | None = None
         self._updated_at: str | None = None
         self._final: bool = False
+        self._history_step: int | None = None
 
         # Cache.
         artifact_instance_cache[self._client_id] = self
@@ -302,7 +294,7 @@ class Artifact:
         name: str,
         attrs: dict[str, Any],
         client: RetryingClient,
-        aliases: Optional[list[str]] = None,
+        aliases: list[str] | None = None,
     ) -> Artifact:
         # Placeholder is required to skip validation.
         artifact = cls("placeholder", type="placeholder")
@@ -320,7 +312,7 @@ class Artifact:
         return artifact
 
     def _assign_attrs(
-        self, attrs: dict[str, Any], aliases: Optional[list[str]] = None
+        self, attrs: dict[str, Any], aliases: list[str] | None = None
     ) -> None:
         """Update this Artifact's attributes using the server response."""
         self._id = attrs["id"]
@@ -420,6 +412,7 @@ class Artifact:
         self._file_count = attrs["fileCount"]
         self._created_at = attrs["createdAt"]
         self._updated_at = attrs["updatedAt"]
+        self._history_step = attrs.get("historyStep", None)
 
     @ensure_logged
     def new_draft(self) -> Artifact:
@@ -897,6 +890,26 @@ class Artifact:
         assert self._created_at is not None
         return self._updated_at or self._created_at
 
+    @property
+    @ensure_logged
+    def history_step(self) -> int | None:
+        """The nearest step at which history metrics were logged for the source run of the artifact.
+
+        Examples:
+            ```python
+            run = artifact.logged_by()
+            if run and (artifact.history_step is not None):
+                history = run.sample_history(
+                    min_step=artifact.history_step,
+                    max_step=artifact.history_step + 1,
+                    keys=["my_metric"],
+                )
+            ```
+        """
+        if self._history_step is None:
+            return None
+        return max(0, self._history_step - 1)
+
     # State management.
 
     def finalize(self) -> None:
@@ -942,7 +955,12 @@ class Artifact:
             with telemetry.context() as tel:
                 tel.feature.artifact_incremental = True
 
-        if wandb.run is None:
+        singleton = wandb_setup._setup(start_service=False)
+
+        if run := singleton.most_recent_active_run:
+            # TODO: Deprecate and encourage explicit log_artifact().
+            run.log_artifact(self)
+        else:
             if settings is None:
                 settings = wandb.Settings(silent="true")
             with wandb.init(  # type: ignore
@@ -957,8 +975,6 @@ class Artifact:
                     with telemetry.context(run=run) as tel:
                         tel.feature.artifact_incremental = True
                 run.log_artifact(self)
-        else:
-            wandb.run.log_artifact(self)
 
     def _set_save_handle(
         self,
@@ -1782,15 +1798,10 @@ class Artifact:
 
         Raises:
             ArtifactNotLoggedError: If the artifact is not logged.
-            RuntimeError: If the artifact is attempted to be downloaded in offline mode.
         """
         root = FilePathStr(str(root or self._default_root()))
         self._add_download_root(root)
 
-        # TODO: we need a better way to check for offline mode across the app, as this is an anti-pattern
-        if env.is_offline() or util._is_offline():
-            raise RuntimeError("Cannot download artifacts in offline mode.")
-
         # TODO: download artifacts using core when implemented
         # if is_require_core():
         #     return self._download_using_core(
@@ -1817,6 +1828,7 @@ class Artifact:
 
         from wandb.sdk.backend.backend import Backend
 
+        # TODO: Create a special stream instead of relying on an existing run.
         if wandb.run is None:
             wl = wandb.setup()
 
@@ -1962,33 +1974,78 @@ class Artifact:
         retryable_exceptions=(requests.RequestException),
     )
     def _fetch_file_urls(self, cursor: str | None, per_page: int | None = 5000) -> Any:
-        query = gql(
-            """
-            query ArtifactFileURLs($id: ID!, $cursor: String, $perPage: Int) {
-                artifact(id: $id) {
-                    files(after: $cursor, first: $perPage) {
-                        pageInfo {
-                            hasNextPage
-                            endCursor
+        if InternalApi()._check_server_feature_with_fallback(
+            pb.ServerFeature.ARTIFACT_COLLECTION_MEMBERSHIP_FILES  # type: ignore
+        ):
+            query = gql(
+                """
+                query ArtifactCollectionMembershipFileURLs($entityName: String!, $projectName: String!, \
+                        $artifactName: String!, $artifactVersionIndex: String!, $cursor: String, $perPage: Int) {
+                    project(name: $projectName, entityName: $entityName) {
+                        artifactCollection(name: $artifactName) {
+                            artifactMembership(aliasName: $artifactVersionIndex) {
+                                files(after: $cursor, first: $perPage) {
+                                    pageInfo {
+                                        hasNextPage
+                                        endCursor
+                                    }
+                                    edges {
+                                        node {
+                                            name
+                                            directUrl
+                                        }
+                                    }
+                                }
+                            }
                         }
-                        edges {
-                            node {
-                                name
-                                directUrl
+                    }
+                }
+                """
+            )
+            assert self._client is not None
+            response = self._client.execute(
+                query,
+                variable_values={
+                    "entityName": self.entity,
+                    "projectName": self.project,
+                    "artifactName": self.name.split(":")[0],
+                    "artifactVersionIndex": self.version,
+                    "cursor": cursor,
+                    "perPage": per_page,
+                },
+                timeout=60,
+            )
+            return response["project"]["artifactCollection"]["artifactMembership"][
+                "files"
+            ]
+        else:
+            query = gql(
+                """
+                query ArtifactFileURLs($id: ID!, $cursor: String, $perPage: Int) {
+                    artifact(id: $id) {
+                        files(after: $cursor, first: $perPage) {
+                            pageInfo {
+                                hasNextPage
+                                endCursor
+                            }
+                            edges {
+                                node {
+                                    name
+                                    directUrl
+                                }
                             }
                         }
                     }
                 }
-            }
-            """
-        )
-        assert self._client is not None
-        response = self._client.execute(
-            query,
-            variable_values={"id": self.id, "cursor": cursor, "perPage": per_page},
-            timeout=60,
-        )
-        return response["artifact"]["files"]
+                """
+            )
+            assert self._client is not None
+            response = self._client.execute(
+                query,
+                variable_values={"id": self.id, "cursor": cursor, "perPage": per_page},
+                timeout=60,
+            )
+            return response["artifact"]["files"]
 
     @ensure_logged
     def checkout(self, root: str | None = None) -> str:
@@ -2193,16 +2250,20 @@ class Artifact:
         Raises:
             ArtifactNotLoggedError: If the artifact is not logged.
         """
-        if wandb.run is None:
-            with wandb.init(  # type: ignore
+        singleton = wandb_setup._setup(start_service=False)
+
+        if run := singleton.most_recent_active_run:
+            # TODO: Deprecate and encourage explicit link_artifact().
+            run.link_artifact(self, target_path, aliases)
+
+        else:
+            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)
 
     @ensure_logged
     def unlink(self) -> None:

wandb/sdk/artifacts/artifact_manifest_entry.py

@@ -9,8 +9,9 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 from urllib.parse import urlparse
 
+from wandb.proto.wandb_deprecated import Deprecated
 from wandb.sdk.lib import filesystem
-from wandb.sdk.lib.deprecate import Deprecated, deprecate
+from wandb.sdk.lib.deprecate import deprecate
 from wandb.sdk.lib.hashutil import (
     B64MD5,
     ETag,