wandb 0.19.10__py3-none-musllinux_1_2_aarch64.whl → 0.19.11__py3-none-musllinux_1_2_aarch64.whl

wandb/apis/public/artifacts.py

@@ -59,6 +59,10 @@ from wandb.sdk.artifacts._generated import (
     RunOutputArtifactsProjectRunOutputArtifacts,
 )
 from wandb.sdk.artifacts._graphql_fragments import omit_artifact_fields
+from wandb.sdk.artifacts._validators import (
+    SOURCE_ARTIFACT_COLLECTION_TYPE,
+    validate_artifact_name,
+)
 from wandb.sdk.internal.internal_api import Api as InternalApi
 from wandb.sdk.lib import deprecate
 
@@ -286,16 +290,20 @@ class ArtifactCollection:
         type: str,
         organization: Optional[str] = None,
         attrs: Optional[Mapping[str, Any]] = None,
+        is_sequence: Optional[bool] = None,
     ):
         self.client = client
         self.entity = entity
         self.project = project
-        self._name = name
+        self._name = validate_artifact_name(name)
         self._saved_name = name
         self._type = type
         self._saved_type = type
         self._attrs = attrs
-        if self._attrs is None:
+        if is_sequence is not None:
+            self._is_sequence = is_sequence
+        is_loaded = attrs is not None and is_sequence is not None
+        if not is_loaded:
             self.load()
         self._aliases = [a["node"]["alias"] for a in self._attrs["aliases"]["edges"]]
         self._description = self._attrs["description"]
@@ -358,7 +366,7 @@ class ArtifactCollection:
         sequence = type_.artifact_sequence
         self._is_sequence = (
             sequence is not None
-        ) and sequence.typename__ == "ArtifactSequence"
+        ) and sequence.typename__ == SOURCE_ARTIFACT_COLLECTION_TYPE
 
         if self._attrs is None:
             self._attrs = collection.model_dump(exclude_unset=True)
@@ -430,8 +438,8 @@ class ArtifactCollection:
         return self._name
 
     @name.setter
-    def name(self, name: List[str]) -> None:
-        self._name = name
+    def name(self, name: str) -> None:
+        self._name = validate_artifact_name(name)
 
     @property
     def type(self):

wandb/apis/public/automations.py

@@ -64,6 +64,6 @@ class Automations(Paginator["Automation"]):
 
         page = self.last_response
         return [
-            Automation.model_validate_json(obj.model_dump_json())
+            Automation.model_validate(obj)
             for obj in chain.from_iterable(edge.node.triggers for edge in page.edges)
         ]

wandb/apis/public/integrations.py

@@ -59,7 +59,7 @@ class Integrations(Paginator["Integration"]):
             raise ValueError("Unexpected response data") from e
 
     def convert_objects(self) -> Iterable[Integration]:
-        """Parse the page data into a list of Integrations."""
+        """Parse the page data into a list of integrations."""
         from wandb.automations.integrations import _IntegrationEdge
 
         page = self.last_response
@@ -81,7 +81,7 @@ class WebhookIntegrations(Paginator["WebhookIntegration"]):
 
     @property
     def more(self) -> bool:
-        """Whether there are more Integrations to fetch."""
+        """Whether there are more webhook integrations to fetch."""
         if self.last_response is None:
             return True
         return self.last_response.page_info.has_next_page
@@ -112,11 +112,17 @@ class WebhookIntegrations(Paginator["WebhookIntegration"]):
             raise ValueError("Unexpected response data") from e
 
     def convert_objects(self) -> Iterable[WebhookIntegration]:
-        """Parse the page data into a list of Integrations."""
+        """Parse the page data into a list of webhook integrations."""
         from wandb.automations import WebhookIntegration
 
-        page = self.last_response
-        return [WebhookIntegration.model_validate(edge.node) for edge in page.edges]
+        typename = "GenericWebhookIntegration"
+        return [
+            # Filter on typename__ needed because the GQL response still
+            # includes all integration types
+            WebhookIntegration.model_validate(node)
+            for edge in self.last_response.edges
+            if (node := edge.node) and (node.typename__ == typename)
+        ]
 
 
 class SlackIntegrations(Paginator["SlackIntegration"]):
@@ -132,7 +138,7 @@ class SlackIntegrations(Paginator["SlackIntegration"]):
 
     @property
     def more(self) -> bool:
-        """Whether there are more Integrations to fetch."""
+        """Whether there are more Slack integrations to fetch."""
         if self.last_response is None:
             return True
         return self.last_response.page_info.has_next_page
@@ -160,9 +166,15 @@ class SlackIntegrations(Paginator["SlackIntegration"]):
         except (LookupError, AttributeError, ValidationError) as e:
             raise ValueError("Unexpected response data") from e
 
-    def convert_objects(self) -> list[SlackIntegration]:
-        """Parse the page data into a list of Integrations."""
+    def convert_objects(self) -> Iterable[SlackIntegration]:
+        """Parse the page data into a list of Slack integrations."""
         from wandb.automations import SlackIntegration
 
-        page = self.last_response
-        return [SlackIntegration.model_validate(edge.node) for edge in page.edges]
+        typename = "SlackIntegration"
+        return [
+            # Filter on typename__ needed because the GQL response still
+            # includes all integration types
+            SlackIntegration.model_validate(node)
+            for edge in self.last_response.edges
+            if (node := edge.node) and (node.typename__ == typename)
+        ]

wandb/apis/public/registries/_freezable_list.py

@@ -0,0 +1,179 @@
+from itertools import chain
+from typing import (
+    Any,
+    Iterable,
+    Iterator,
+    List,
+    MutableSequence,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    final,
+    overload,
+)
+
+T = TypeVar("T")
+
+
+@final
+class FreezableList(MutableSequence[T]):
+    """A list-like container type that only allows adding new items.
+
+    It tracks "saved" (immutable) and "draft" (mutable) items.
+    Items can be added, inserted, and removed while in draft state, but once frozen,
+    they become immutable. Unlike a set, duplicate items are allowed in the draft
+    state but duplicates already present in the saved state cannot be added.
+    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 append(self, value: T) -> None:
+        """Append an item to the draft list. No duplicates are allowed."""
+        if (value in self._frozen) or (value in self._draft):
+            return
+        self._draft.append(value)
+
+    def remove(self, value: T) -> None:
+        """Remove the first occurrence of value from the draft list."""
+        if value in self._frozen:
+            raise ValueError(f"Cannot remove item from frozen list: {value!r}")
+        self._draft.remove(value)
+
+    def freeze(self) -> None:
+        """Freeze any draft items by adding them to the saved tuple."""
+        # Filter out duplicates already in saved before extending
+        new_items = tuple(item for item in self._draft if item not in self._frozen)
+        self._frozen = self._frozen + new_items
+        self._draft.clear()
+
+    def __eq__(self, value: object) -> bool:
+        if not isinstance(value, Sequence):
+            return NotImplemented
+        return list(self) == list(value)
+
+    def __contains__(self, value: Any) -> bool:
+        return value in self._frozen or value in self._draft
+
+    def __len__(self) -> int:
+        return len(self._frozen) + len(self._draft)
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(chain(self._frozen, self._draft))
+
+    @overload
+    def __getitem__(self, index: int) -> T: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> Sequence[T]: ...
+
+    def __getitem__(self, index: Union[int, slice]) -> Union[T, Sequence[T]]:
+        return [*self._frozen, *self._draft][index]
+
+    @overload
+    def __setitem__(self, index: int, value: T) -> None: ...
+
+    @overload
+    def __setitem__(self, index: slice, value: Iterable[T]) -> None: ...
+
+    def __setitem__(
+        self, index: Union[int, slice], value: Union[T, Iterable[T]]
+    ) -> None:
+        if isinstance(index, slice):
+            # Setting slices might affect saved items, disallow for simplicity
+            raise TypeError(
+                f"{type(self).__name__!r} does not support slice assignment"
+            )
+        else:
+            if value in self._frozen or value in self._draft:
+                return
+
+            # The frozen items are sequentially first and protected from changes
+            len_frozen = len(self._frozen)
+            size = len(self)
+
+            if (index >= size) or (index < -size):
+                raise IndexError("Index out of range")
+
+            draft_index = (index % size) - len_frozen
+            if draft_index < 0:
+                raise ValueError(f"Cannot assign to saved item at index {index!r}")
+            self._draft[draft_index] = value
+
+    @overload
+    def __delitem__(self, index: int) -> None: ...
+
+    @overload
+    def __delitem__(self, index: slice) -> None: ...
+
+    def __delitem__(self, index: Union[int, slice]) -> None:
+        if isinstance(index, slice):
+            raise TypeError(f"{type(self).__name__!r} does not support slice deletion")
+        else:
+            # The frozen items are sequentially first and protected from changes
+            len_frozen = len(self._frozen)
+            size = len(self)
+
+            if (index >= size) or (index < -size):
+                raise IndexError("Index out of range")
+
+            draft_index = (index % size) - len_frozen
+            if draft_index < 0:
+                raise ValueError(f"Cannot delete saved item at index {index!r}")
+            del self._draft[draft_index]
+
+    def insert(self, index: int, value: T) -> None:
+        """Insert item before index.
+
+        Insertion is only allowed at indices corresponding to the draft portion
+        of the list (i.e., index >= len(frozen_items)). Negative indices are
+        interpreted relative to the combined length of frozen and draft items.
+        """
+        if value in self._frozen or value in self._draft:
+            # Silently ignore duplicates, similar to append
+            return
+
+        # The frozen items are sequentially first and protected from changes
+        len_frozen = len(self._frozen)
+        size = len(self)
+
+        # Follow the behavior of `list.insert()` when the index is out of bounds.
+        # - negative out-of-bounds index: prepend.  Will only work if the frozen items are empty.
+        if index < -size and not self._frozen:
+            return self._draft.insert(0, value)
+
+        # - positive out-of-bounds index: append.
+        if index >= size:
+            return self._draft.append(value)
+
+        # - in-bounds index: insert only if into the draft portion.
+        draft_index = (index % size) - len_frozen
+        if draft_index < 0:
+            raise IndexError(
+                f"Cannot insert into the frozen list (index < {len_frozen})"
+            )
+        return self._draft.insert(draft_index, value)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(frozen={list(self._frozen)!r}, draft={list(self._draft)!r})"
+
+    @property
+    def draft(self) -> Tuple[T, ...]:
+        """A read-only, tuple copy of the current draft items."""
+        return tuple(self._draft)
+
+
+class AddOnlyArtifactTypesList(FreezableList[str]):
+    def remove(self, value: str) -> None:
+        try:
+            super().remove(value)
+        except ValueError:
+            raise ValueError(
+                f"Cannot remove artifact type: {value!r} that has been saved to the registry"
+            )
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(saved={list(self._frozen)!r}, draft={list(self._draft)!r})"

wandb/apis/public/{registries.py → registries/registries_search.py}

@@ -1,7 +1,7 @@
-"""Public API: registries."""
+"""Public API: registries search."""
 
 import json
-from typing import TYPE_CHECKING, Any, Dict, Mapping, Optional, Sequence
+from typing import TYPE_CHECKING, Any, Dict, Optional
 
 if TYPE_CHECKING:
     from wandb_gql import Client
@@ -11,11 +11,11 @@ from wandb_gql import gql
 import wandb
 from wandb.apis.paginator import Paginator
 from wandb.apis.public.artifacts import ArtifactCollection
+from wandb.apis.public.registries.utils import _ensure_registry_prefix_on_names
 from wandb.sdk.artifacts._graphql_fragments import (
     _gql_artifact_fragment,
     _gql_registry_fragment,
 )
-from wandb.sdk.artifacts._validators import REGISTRY_PREFIX
 
 
 class Registries(Paginator):
@@ -63,7 +63,7 @@ class Registries(Paginator):
         super().__init__(client, variables, per_page)
 
     def __bool__(self):
-        return len(self) > 0 or len(self.objects) > 0
+        return bool(self.objects)
 
     def __next__(self):
         # Implement custom next since its possible to load empty pages because of auth
@@ -128,6 +128,8 @@ class Registries(Paginator):
                 f"Organization '{self.organization}' not found. Please verify the organization name is correct"
             )
 
+        from wandb.apis.public.registries.registry import Registry
+
         return [
             Registry(
                 self.client,
@@ -142,86 +144,6 @@ class Registries(Paginator):
         ]
 
 
-class Registry:
-    """A single registry in the Registry."""
-
-    def __init__(
-        self,
-        client: "Client",
-        organization: str,
-        entity: str,
-        full_name: str,
-        attrs: Dict[str, Any],
-    ):
-        self.client = client
-        self._full_name = full_name
-        self._name = full_name.replace(REGISTRY_PREFIX, "")
-        self._entity = entity
-        self._organization = organization
-        self._description = attrs.get("description", "")
-        self._allow_all_artifact_types = attrs.get(
-            "allowAllArtifactTypesInRegistry", False
-        )
-        self._artifact_types = [
-            t["node"]["name"] for t in attrs.get("artifactTypes", {}).get("edges", [])
-        ]
-        self._id = attrs.get("id", "")
-        self._created_at = attrs.get("createdAt", "")
-        self._updated_at = attrs.get("updatedAt", "")
-
-    @property
-    def full_name(self):
-        return self._full_name
-
-    @property
-    def name(self):
-        return self._name
-
-    @property
-    def entity(self):
-        return self._entity
-
-    @property
-    def organization(self):
-        return self._organization
-
-    @property
-    def description(self):
-        return self._description
-
-    @property
-    def allow_all_artifact_types(self):
-        return self._allow_all_artifact_types
-
-    @property
-    def artifact_types(self):
-        return self._artifact_types
-
-    @property
-    def created_at(self):
-        return self._created_at
-
-    @property
-    def updated_at(self):
-        return self._updated_at
-
-    @property
-    def path(self):
-        return [self.entity, self.name]
-
-    def collections(self, filter: Optional[Dict[str, Any]] = None):
-        registry_filter = {
-            "name": self.full_name,
-        }
-        return Collections(self.client, self.organization, registry_filter, filter)
-
-    def versions(self, filter: Optional[Dict[str, Any]] = None):
-        registry_filter = {
-            "name": self.full_name,
-        }
-        return Versions(self.client, self.organization, registry_filter, None, filter)
-
-
 class Collections(Paginator):
     """Iterator that returns Artifact collections in the Registry."""
 
@@ -303,12 +225,12 @@ class Collections(Paginator):
         self.collection_filter = collection_filter or {}
 
         variables = {
-            "registryFilter": json.dumps(self.registry_filter)
-            if self.registry_filter
-            else None,
-            "collectionFilter": json.dumps(self.collection_filter)
-            if self.collection_filter
-            else None,
+            "registryFilter": (
+                json.dumps(self.registry_filter) if self.registry_filter else None
+            ),
+            "collectionFilter": (
+                json.dumps(self.collection_filter) if self.collection_filter else None
+            ),
             "organization": self.organization,
             "collectionTypes": ["PORTFOLIO"],
             "perPage": per_page,
@@ -383,6 +305,7 @@ class Collections(Paginator):
                 r["node"]["defaultArtifactType"]["name"],
                 self.organization,
                 r["node"],
+                is_sequence=False,
             )
             for r in self.last_response["organization"]["orgEntity"][
                 "artifactCollections"
@@ -460,15 +383,15 @@ class Versions(Paginator):
         )
 
         variables = {
-            "registryFilter": json.dumps(self.registry_filter)
-            if self.registry_filter
-            else None,
-            "collectionFilter": json.dumps(self.collection_filter)
-            if self.collection_filter
-            else None,
-            "artifactFilter": json.dumps(self.artifact_filter)
-            if self.artifact_filter
-            else None,
+            "registryFilter": (
+                json.dumps(self.registry_filter) if self.registry_filter else None
+            ),
+            "collectionFilter": (
+                json.dumps(self.collection_filter) if self.collection_filter else None
+            ),
+            "artifactFilter": (
+                json.dumps(self.artifact_filter) if self.artifact_filter else None
+            ),
             "organization": self.organization,
         }
 
@@ -541,33 +464,3 @@ class Versions(Paginator):
             ]["edges"]
         )
         return artifacts
-
-
-def _ensure_registry_prefix_on_names(query, in_name=False):
-    """Traverse the filter to prepend the `name` key value with the registry prefix unless the value is a regex.
-
-    - in_name: True if we are under a "name" key (or propagating from one).
-
-    EX: {"name": "model"} -> {"name": "wandb-registry-model"}
-    """
-    if isinstance((txt := query), str):
-        if in_name:
-            return txt if txt.startswith(REGISTRY_PREFIX) else f"{REGISTRY_PREFIX}{txt}"
-        return txt
-    if isinstance((dct := query), Mapping):
-        new_dict = {}
-        for key, obj in dct.items():
-            if key == "name":
-                new_dict[key] = _ensure_registry_prefix_on_names(obj, in_name=True)
-            elif key == "$regex":
-                # For regex operator, we skip transformation of its value.
-                new_dict[key] = obj
-            else:
-                # For any other key, propagate the in_name and skip_transform flags as-is.
-                new_dict[key] = _ensure_registry_prefix_on_names(obj, in_name=in_name)
-        return new_dict
-    if isinstance((objs := query), Sequence):
-        return list(
-            map(lambda x: _ensure_registry_prefix_on_names(x, in_name=in_name), objs)
-        )
-    return query