wandb 0.21.4__py3-none-win_amd64.whl → 0.22.1__py3-none-win_amd64.whl

wandb/apis/public/artifacts.py

@@ -51,12 +51,13 @@ from wandb.sdk.artifacts._generated import (
     ProjectArtifacts,
     ProjectArtifactType,
     ProjectArtifactTypes,
-    RunInputArtifactsProjectRunInputArtifacts,
-    RunOutputArtifactsProjectRunOutputArtifacts,
+    RunInputArtifactConnectionFragment,
+    RunOutputArtifactConnectionFragment,
 )
-from wandb.sdk.artifacts._graphql_fragments import omit_artifact_fields
+from wandb.sdk.artifacts._gqlutils import omit_artifact_fields
 from wandb.sdk.artifacts._validators import (
     SOURCE_ARTIFACT_COLLECTION_TYPE,
+    FullArtifactPath,
     validate_artifact_name,
     validate_artifact_type,
 )
@@ -715,7 +716,7 @@ class Artifacts(SizedPaginator["Artifact"]):
 
         self.QUERY = gql_compat(
             PROJECT_ARTIFACTS_GQL,
-            omit_fields=omit_artifact_fields(),
+            omit_fields=omit_artifact_fields(client),
             rename_fields=rename_fields,
         )
 
@@ -778,10 +779,12 @@ class Artifacts(SizedPaginator["Artifact"]):
         artifact_edges = (edge for edge in self.last_response.edges if edge.node)
         artifacts = (
             wandb.Artifact._from_attrs(
-                entity=self.entity,
-                project=self.project,
-                name=f"{self.collection_name}:{edge.version}",
-                attrs=edge.node.model_dump(exclude_unset=True),
+                path=FullArtifactPath(
+                    prefix=self.entity,
+                    project=self.project,
+                    name=f"{self.collection_name}:{edge.version}",
+                ),
+                attrs=edge.node,
                 client=self.client,
             )
             for edge in artifact_edges
@@ -797,14 +800,12 @@ class RunArtifacts(SizedPaginator["Artifact"]):
     """
 
     last_response: (
-        RunOutputArtifactsProjectRunOutputArtifacts
-        | RunInputArtifactsProjectRunInputArtifacts
+        RunOutputArtifactConnectionFragment | RunInputArtifactConnectionFragment
     )
 
     #: The pydantic model used to parse the (inner part of the) raw response.
     _response_cls: type[
-        RunOutputArtifactsProjectRunOutputArtifacts
-        | RunInputArtifactsProjectRunInputArtifacts
+        RunOutputArtifactConnectionFragment | RunInputArtifactConnectionFragment
     ]
 
     def __init__(
@@ -819,15 +820,15 @@ class RunArtifacts(SizedPaginator["Artifact"]):
         if mode == "logged":
             self.run_key = "outputArtifacts"
             self.QUERY = gql_compat(
-                RUN_OUTPUT_ARTIFACTS_GQL, omit_fields=omit_artifact_fields()
+                RUN_OUTPUT_ARTIFACTS_GQL, omit_fields=omit_artifact_fields(client)
             )
-            self._response_cls = RunOutputArtifactsProjectRunOutputArtifacts
+            self._response_cls = RunOutputArtifactConnectionFragment
         elif mode == "used":
             self.run_key = "inputArtifacts"
             self.QUERY = gql_compat(
-                RUN_INPUT_ARTIFACTS_GQL, omit_fields=omit_artifact_fields()
+                RUN_INPUT_ARTIFACTS_GQL, omit_fields=omit_artifact_fields(client)
             )
-            self._response_cls = RunInputArtifactsProjectRunInputArtifacts
+            self._response_cls = RunInputArtifactConnectionFragment
         else:
             raise ValueError("mode must be logged or used")
 
@@ -886,10 +887,12 @@ class RunArtifacts(SizedPaginator["Artifact"]):
 
         return [
             wandb.Artifact._from_attrs(
-                entity=proj.entity_name,
-                project=proj.name,
-                name=f"{artifact_seq.name}:v{node.version_index}",
-                attrs=node.model_dump(exclude_unset=True),
+                path=FullArtifactPath(
+                    prefix=proj.entity_name,
+                    project=proj.name,
+                    name=f"{artifact_seq.name}:v{node.version_index}",
+                ),
+                attrs=node,
                 client=self.client,
             )
             for edge in self.last_response.edges

wandb/apis/public/const.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import datetime
 
 # Only retry requests for 20 seconds in the public api

wandb/apis/public/files.py

@@ -49,7 +49,7 @@ from wandb.apis.paginator import SizedPaginator
 from wandb.apis.public import utils
 from wandb.apis.public.api import Api, RetryingClient
 from wandb.apis.public.const import RETRY_TIMEDELTA
-from wandb.apis.public.runs import Run
+from wandb.apis.public.runs import Run, _server_provides_internal_id_for_project
 from wandb.sdk.lib import retry
 
 FILE_FRAGMENT = """fragment RunFilesFragment on Run {
@@ -103,21 +103,24 @@ class Files(SizedPaginator["File"]):
     ```
     """
 
-    QUERY = gql(
-        """
-        query RunFiles($project: String!, $entity: String!, $name: String!, $fileCursor: String,
-            $fileLimit: Int = 50, $fileNames: [String] = [], $upload: Boolean = false, $pattern: String) {{
-            project(name: $project, entityName: $entity) {{
-                internalId
-                run(name: $name) {{
-                    fileCount
-                    ...RunFilesFragment
+    def _get_query(self):
+        """Generate query dynamically based on server capabilities."""
+        with_internal_id = _server_provides_internal_id_for_project(self.client)
+        return gql(
+            f"""
+            query RunFiles($project: String!, $entity: String!, $name: String!, $fileCursor: String,
+                $fileLimit: Int = 50, $fileNames: [String] = [], $upload: Boolean = false, $pattern: String) {{
+                project(name: $project, entityName: $entity) {{
+                    {"internalId" if with_internal_id else ""}
+                    run(name: $name) {{
+                        fileCount
+                        ...RunFilesFragment
+                    }}
                 }}
             }}
-        }}
-        {}
-        """.format(FILE_FRAGMENT)
-    )
+            {FILE_FRAGMENT}
+            """
+        )
 
     def __init__(
         self,
@@ -133,15 +136,15 @@ class Files(SizedPaginator["File"]):
         Files are retrieved in pages from the W&B server as needed.
 
         Args:
-        client: The run object that contains the files
-        run: The run object that contains the files
-        names (list, optional): A list of file names to filter the files
-        per_page (int, optional): The number of files to fetch per page
-        upload (bool, optional): If `True`, fetch the upload URL for each file
-        pattern (str, optional): Pattern to match when returning files from W&B
-            This pattern uses mySQL's LIKE syntax,
-            so matching all files that end with .json would be "%.json".
-            If both names and pattern are provided, a ValueError will be raised.
+            client: The run object that contains the files
+            run: The run object that contains the files
+            names (list, optional): A list of file names to filter the files
+            per_page (int, optional): The number of files to fetch per page
+            upload (bool, optional): If `True`, fetch the upload URL for each file
+            pattern (str, optional): Pattern to match when returning files from W&B
+                This pattern uses mySQL's LIKE syntax,
+                so matching all files that end with .json would be "%.json".
+                If both names and pattern are provided, a ValueError will be raised.
         """
         if names and pattern:
             raise ValueError(
@@ -160,6 +163,12 @@ class Files(SizedPaginator["File"]):
         }
         super().__init__(client, variables, per_page)
 
+    def _update_response(self) -> None:
+        """Fetch and store the response data for the next page using dynamic query."""
+        self.last_response = self.client.execute(
+            self._get_query(), variable_values=self.variables
+        )
+
     @property
     def _length(self):
         """
@@ -244,7 +253,7 @@ class File(Attrs):
         attrs (dict): A dictionary of attributes that define the file
         run: The run object that contains the file
 
-    <!-- lazydoc-ignore-class: internal -->
+    <!-- lazydoc-ignore-init: internal -->
     """
 
     def __init__(self, client, attrs, run=None):

wandb/apis/public/history.py

@@ -9,6 +9,8 @@ Note:
     both complete and sampled access to metrics logged during training runs.
 """
 
+from __future__ import annotations
+
 import json
 
 from wandb_gql import gql

wandb/apis/public/jobs.py

@@ -4,11 +4,13 @@ This module provides classes for managing W&B jobs, queued runs, and run
 queues.
 """
 
+from __future__ import annotations
+
 import json
 import os
 import shutil
 import time
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Literal, Mapping
 
 from wandb_gql import gql
 
@@ -37,11 +39,11 @@ class Job:
     _output_types: Type
     _entity: str
     _project: str
-    _entrypoint: List[str]
+    _entrypoint: list[str]
     _notebook_job: bool
     _partial: bool
 
-    def __init__(self, api: "Api", name, path: Optional[str] = None) -> None:
+    def __init__(self, api: Api, name, path: str | None = None) -> None:
         try:
             self._job_artifact = api._artifact(name, type="job")
         except CommError:
@@ -166,7 +168,7 @@ class Job:
         if self._entrypoint:
             launch_project.set_job_entry_point(self._entrypoint)
 
-    def set_entrypoint(self, entrypoint: List[str]):
+    def set_entrypoint(self, entrypoint: list[str]):
         """Set the entrypoint for the job."""
         self._entrypoint = entrypoint
 
@@ -307,7 +309,7 @@ class QueuedRun:
         )
 
     @normalize_exceptions
-    def _get_run_queue_item_legacy(self) -> Dict:
+    def _get_run_queue_item_legacy(self) -> dict:
         query = gql(
             """
             query GetRunQueueItem($projectName: String!, $entityName: String!, $runQueue: String!) {
@@ -490,13 +492,13 @@ class RunQueue:
 
     def __init__(
         self,
-        client: "RetryingClient",
+        client: RetryingClient,
         name: str,
         entity: str,
-        prioritization_mode: Optional[RunQueuePrioritizationMode] = None,
-        _access: Optional[RunQueueAccessType] = None,
-        _default_resource_config_id: Optional[int] = None,
-        _default_resource_config: Optional[dict] = None,
+        prioritization_mode: RunQueuePrioritizationMode | None = None,
+        _access: RunQueueAccessType | None = None,
+        _default_resource_config_id: int | None = None,
+        _default_resource_config: dict | None = None,
     ) -> None:
         self._name: str = name
         self._client = client
@@ -538,7 +540,7 @@ class RunQueue:
         return self._access
 
     @property
-    def external_links(self) -> Dict[str, str]:
+    def external_links(self) -> dict[str, str]:
         """External resource links for the queue."""
         if self._external_links is None:
             self._get_metadata()
@@ -579,7 +581,7 @@ class RunQueue:
         return self._id
 
     @property
-    def items(self) -> List[QueuedRun]:
+    def items(self) -> list[QueuedRun]:
         """Up to the first 100 queued runs. Modifying this list will not modify the queue or any enqueued items!"""
         # TODO(np): Add a paginated interface
         if self._items is None:
@@ -716,12 +718,12 @@ class RunQueue:
     def create(
         cls,
         name: str,
-        resource: "RunQueueResourceType",
-        entity: Optional[str] = None,
-        prioritization_mode: Optional["RunQueuePrioritizationMode"] = None,
-        config: Optional[dict] = None,
-        template_variables: Optional[dict] = None,
-    ) -> "RunQueue":
+        resource: RunQueueResourceType,
+        entity: str | None = None,
+        prioritization_mode: RunQueuePrioritizationMode | None = None,
+        config: dict | None = None,
+        template_variables: dict | None = None,
+    ) -> RunQueue:
         """Create a RunQueue.
 
         Args:

wandb/apis/public/projects.py

@@ -31,6 +31,8 @@ Note:
     with a new project name.
 """
 
+from __future__ import annotations
+
 from requests import HTTPError
 from wandb_gql import gql
 
@@ -100,7 +102,7 @@ class Projects(Paginator["Project"]):
         client: RetryingClient,
         entity: str,
         per_page: int = 50,
-    ) -> "Projects":
+    ) -> Projects:
         """An iterable collection of `Project` objects.
 
         Args:
@@ -187,7 +189,7 @@ class Project(Attrs):
         entity: str,
         project: str,
         attrs: dict,
-    ) -> "Project":
+    ) -> Project:
         """A single project associated with an entity.
 
         Args:

wandb/apis/public/query_generator.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class QueryGenerator:
     """QueryGenerator is a helper object to write filters for runs.
 

wandb/apis/public/registries/__init__.py

@@ -0,0 +1,7 @@
+__all__ = [
+    "Registry",  # doc:exclude
+    "Registries",  # doc:exclude
+]
+
+from .registries_search import Registries
+from .registry import Registry

wandb/apis/public/registries/_freezable_list.py

@@ -1,14 +1,13 @@
+from __future__ import annotations
+
 from itertools import chain
 from typing import (
     Any,
     Iterable,
     Iterator,
-    List,
     MutableSequence,
     Sequence,
-    Tuple,
     TypeVar,
-    Union,
     final,
     overload,
 )
@@ -29,9 +28,9 @@ class FreezableList(MutableSequence[T]):
     Any initial items passed to the constructor are saved.
     """
 
-    def __init__(self, iterable: Union[Iterable[T], None] = None, /) -> None:
-        self._frozen: Tuple[T, ...] = tuple(iterable or ())
-        self._draft: List[T] = []
+    def __init__(self, iterable: Iterable[T] | None = None, /) -> None:
+        self._frozen: tuple[T, ...] = tuple(iterable or ())
+        self._draft: list[T] = []
 
     def append(self, value: T) -> None:
         """Append an item to the draft list. No duplicates are allowed."""
@@ -72,7 +71,7 @@ class FreezableList(MutableSequence[T]):
     @overload
     def __getitem__(self, index: slice) -> Sequence[T]: ...
 
-    def __getitem__(self, index: Union[int, slice]) -> Union[T, Sequence[T]]:
+    def __getitem__(self, index: int | slice) -> T | Sequence[T]:
         return [*self._frozen, *self._draft][index]
 
     @overload
@@ -81,9 +80,7 @@ class FreezableList(MutableSequence[T]):
     @overload
     def __setitem__(self, index: slice, value: Iterable[T]) -> None: ...
 
-    def __setitem__(
-        self, index: Union[int, slice], value: Union[T, Iterable[T]]
-    ) -> None:
+    def __setitem__(self, index: int | slice, value: T | Iterable[T]) -> None:
         if isinstance(index, slice):
             # Setting slices might affect saved items, disallow for simplicity
             raise TypeError(f"{nameof(type(self))!r} does not support slice assignment")
@@ -109,7 +106,7 @@ class FreezableList(MutableSequence[T]):
     @overload
     def __delitem__(self, index: slice) -> None: ...
 
-    def __delitem__(self, index: Union[int, slice]) -> None:
+    def __delitem__(self, index: int | slice) -> None:
         if isinstance(index, slice):
             raise TypeError(f"{nameof(type(self))!r} does not support slice deletion")
         else:
@@ -161,7 +158,7 @@ class FreezableList(MutableSequence[T]):
         return f"{nameof(type(self))}(frozen={list(self._frozen)!r}, draft={list(self._draft)!r})"
 
     @property
-    def draft(self) -> Tuple[T, ...]:
+    def draft(self) -> tuple[T, ...]:
         """A read-only, tuple copy of the current draft items."""
         return tuple(self._draft)
 

wandb/apis/public/registries/registries_search.py

@@ -24,8 +24,8 @@ from wandb.sdk.artifacts._generated import (
     RegistryVersions,
     RegistryVersionsPage,
 )
-from wandb.sdk.artifacts._graphql_fragments import omit_artifact_fields
-from wandb.sdk.artifacts._validators import remove_registry_prefix
+from wandb.sdk.artifacts._gqlutils import omit_artifact_fields
+from wandb.sdk.artifacts._validators import FullArtifactPath, remove_registry_prefix
 
 from ._utils import ensure_registry_prefix_on_names
 
@@ -270,7 +270,7 @@ class Versions(Paginator["Artifact"]):
         self.artifact_filter = artifact_filter or {}
 
         self.QUERY = gql_compat(
-            REGISTRY_VERSIONS_GQL, omit_fields=omit_artifact_fields()
+            REGISTRY_VERSIONS_GQL, omit_fields=omit_artifact_fields(client)
         )
 
         variables = {
@@ -335,9 +335,11 @@ class Versions(Paginator["Artifact"]):
         nodes = (e.node for e in self.last_response.edges)
         return [
             Artifact._from_attrs(
-                entity=project.entity.name,
-                project=project.name,
-                name=f"{collection.name}:v{node.version_index}",
+                path=FullArtifactPath(
+                    prefix=project.entity.name,
+                    project=project.name,
+                    name=f"{collection.name}:v{node.version_index}",
+                ),
                 attrs=artifact,
                 client=self.client,
                 aliases=[alias.alias for alias in node.aliases],

wandb/apis/public/registries/registry.py

@@ -1,4 +1,6 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
 
 from wandb_gql import gql
 
@@ -35,11 +37,11 @@ class Registry:
 
     def __init__(
         self,
-        client: "Client",
+        client: Client,
         organization: str,
         entity: str,
         name: str,
-        attrs: Optional[Dict[str, Any]] = None,
+        attrs: dict[str, Any] | None = None,
     ):
         self.client = client
         self._name = name
@@ -49,7 +51,7 @@ class Registry:
         if attrs is not None:
             self._update_attributes(attrs)
 
-    def _update_attributes(self, attrs: Dict[str, Any]) -> None:
+    def _update_attributes(self, attrs: dict[str, Any]) -> None:
         """Helper method to update instance attributes from a dictionary."""
         self._id = attrs.get("id", "")
         if self._id is None:
@@ -127,14 +129,17 @@ class Registry:
             Previously saved artifact types cannot be removed.
 
         Example:
-            ```python
-            registry.artifact_types.append("model")
-            registry.save()  # once saved, the artifact type `model` cannot be removed
-            registry.artifact_types.append("accidentally_added")
-            registry.artifact_types.remove(
-                "accidentally_added"
-            )  # Types can only be removed if it has not been saved yet
-            ```
+        ```python
+        import wandb
+
+        registry = wandb.Api().create_registry()
+        registry.artifact_types.append("model")
+        registry.save()  # once saved, the artifact type `model` cannot be removed
+        registry.artifact_types.append("accidentally_added")
+        registry.artifact_types.remove(
+            "accidentally_added"
+        )  # Types can only be removed if it has not been saved yet
+        ```
         """
         return self._artifact_types
 
@@ -179,7 +184,7 @@ class Registry:
         self._visibility = value
 
     @tracked
-    def collections(self, filter: Optional[Dict[str, Any]] = None) -> Collections:
+    def collections(self, filter: dict[str, Any] | None = None) -> Collections:
         """Returns the collections belonging to the registry."""
         registry_filter = {
             "name": self.full_name,
@@ -187,7 +192,7 @@ class Registry:
         return Collections(self.client, self.organization, registry_filter, filter)
 
     @tracked
-    def versions(self, filter: Optional[Dict[str, Any]] = None) -> Versions:
+    def versions(self, filter: dict[str, Any] | None = None) -> Versions:
         """Returns the versions belonging to the registry."""
         registry_filter = {
             "name": self.full_name,
@@ -198,12 +203,12 @@ class Registry:
     @tracked
     def create(
         cls,
-        client: "Client",
+        client: Client,
         organization: str,
         name: str,
         visibility: Literal["organization", "restricted"],
-        description: Optional[str] = None,
-        artifact_types: Optional[List[str]] = None,
+        description: str | None = None,
+        artifact_types: list[str] | None = None,
     ):
         """Create a new registry.
 

wandb/apis/public/reports.py

@@ -4,6 +4,8 @@ This module provides classes for interacting with W&B reports and
 managing report-related data.
 """
 
+from __future__ import annotations
+
 import ast
 import json
 import re