wandb 0.21.2__py3-none-macosx_12_0_arm64.whl → 0.21.4__py3-none-macosx_12_0_arm64.whl

wandb/__init__.py

@@ -10,7 +10,7 @@ For reference documentation, see https://docs.wandb.com/ref/python.
 """
 from __future__ import annotations
 
-__version__ = "0.21.2"
+__version__ = "0.21.4"
 
 
 from wandb.errors import Error

wandb/__init__.pyi

@@ -107,7 +107,7 @@ if TYPE_CHECKING:
     import wandb
     from wandb.plot import CustomChart
 
-__version__: str = "0.21.2"
+__version__: str = "0.21.4"
 
 run: Run | None
 config: wandb_config.Config

wandb/_analytics.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from functools import wraps
+from typing import Callable, Final, TypeVar
+from uuid import UUID, uuid4
+
+from typing_extensions import ParamSpec
+
+from wandb._strutils import nameof
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+# Header keys for tracking the calling function
+X_WANDB_PYTHON_FUNC: Final[str] = "X-Wandb-Python-Func"
+X_WANDB_PYTHON_CALL_ID: Final[str] = "X-Wandb-Python-Call-Id"
+
+
+@dataclass(frozen=True)
+class TrackedFuncInfo:
+    func: str
+    """The fully qualified namespace of the tracked function."""
+
+    call_id: UUID = field(default_factory=uuid4)
+    """A unique identifier assigned to each invocation."""
+
+    def to_headers(self) -> dict[str, str]:
+        return {
+            X_WANDB_PYTHON_FUNC: self.func,
+            X_WANDB_PYTHON_CALL_ID: str(self.call_id),
+        }
+
+
+_current_func: ContextVar[TrackedFuncInfo] = ContextVar("_current_func")
+"""An internal, threadsafe context variable to hold the current function being tracked."""
+
+
+def tracked(func: Callable[P, R]) -> Callable[P, R]:
+    """A decorator to inject the calling function name into any GraphQL request headers.
+
+    If a tracked function calls another tracked function, only the outermost function in
+    the call stack will be tracked.
+    """
+    func_namespace = f"{func.__module__}.{nameof(func)}"
+
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        # Don't override the current tracked function if it's already set
+        if tracked_func():
+            return func(*args, **kwargs)
+
+        token = _current_func.set(TrackedFuncInfo(func=func_namespace))
+        try:
+            return func(*args, **kwargs)
+        finally:
+            _current_func.reset(token)
+
+    return wrapper
+
+
+def tracked_func() -> TrackedFuncInfo | None:
+    """Returns info on the current tracked function, if any, otherwise None."""
+    return _current_func.get(None)

wandb/_iterutils.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
+from collections.abc import Hashable
 from typing import TYPE_CHECKING, Any, Iterable, TypeVar, Union, overload
 
 if TYPE_CHECKING:
     T = TypeVar("T")
+    HashableT = TypeVar("HashableT", bound=Hashable)
     ClassInfo = Union[type[T], tuple[type[T], ...]]
 
 
@@ -22,6 +24,12 @@ def always_list(obj: Any, base_type: Any = (str, bytes)) -> list[T]:
     return [obj] if isinstance(obj, base_type) else list(obj)
 
 
+def unique_list(iterable: Iterable[HashableT]) -> list[HashableT]:
+    """Return a deduplicated list of items from the given iterable, preserving order."""
+    # Trick for O(1) uniqueness check that maintains order
+    return list(dict.fromkeys(iterable))
+
+
 def one(
     iterable: Iterable[T],
     too_short: type[Exception] | Exception | None = None,

wandb/_pydantic/__init__.py

@@ -1,15 +1,15 @@
 """Internal utilities for working with pydantic."""
 
-from .base import (
-    CompatBaseModel,
-    GQLBase,
-    GQLId,
-    SerializedToJson,
-    Typename,
-    ensure_json,
-)
+from .base import CompatBaseModel, GQLBase
+from .field_types import GQLId, Typename
 from .utils import IS_PYDANTIC_V2, from_json, gql_typename, pydantic_isinstance, to_json
-from .v1_compat import AliasChoices, computed_field, field_validator, model_validator
+from .v1_compat import (
+    AliasChoices,
+    computed_field,
+    field_validator,
+    model_validator,
+    to_camel,
+)
 
 __all__ = [
     "IS_PYDANTIC_V2",
@@ -17,14 +17,13 @@ __all__ = [
     "GQLBase",
     "Typename",
     "GQLId",
-    "SerializedToJson",
     "AliasChoices",
     "computed_field",
     "field_validator",
     "model_validator",
     "pydantic_isinstance",
+    "to_camel",
     "to_json",
     "from_json",
-    "ensure_json",
     "gql_typename",
 ]

wandb/_pydantic/base.py

@@ -2,12 +2,11 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar
+from typing import TYPE_CHECKING, Any, Callable, Literal
 
-from pydantic import BaseModel, ConfigDict, Field, Json, StrictStr
-from typing_extensions import Annotated, TypedDict, Unpack, override
+from pydantic import BaseModel, ConfigDict
+from typing_extensions import TypedDict, Unpack, override
 
-from .utils import IS_PYDANTIC_V2, to_json
 from .v1_compat import PydanticCompatMixin
 
 if TYPE_CHECKING:
@@ -77,52 +76,3 @@ class GQLBase(CompatBaseModel):
     ) -> str:
         kwargs = {**MODEL_DUMP_DEFAULTS, **kwargs}
         return super().model_dump_json(indent=indent, **kwargs)
-
-
-# ------------------------------------------------------------------------------
-# Reusable annotations for field types
-T = TypeVar("T")
-
-if IS_PYDANTIC_V2 or TYPE_CHECKING:
-    GQLId = Annotated[
-        StrictStr,
-        Field(repr=False, frozen=True),
-    ]
-else:
-    # FIXME: Find a way to fix this for pydantic v1, which doesn't like when
-    # `Field(...)` used in the field assignment AND `Annotated[...]`.
-    # This is a problem for codegen, which can currently outputs e.g.
-    #
-    #   class MyModel(GQLBase):
-    #       my_id: GQLId = Field(alias="myID")
-    #
-    GQLId = StrictStr  # type: ignore[misc]
-
-Typename = Annotated[
-    T,
-    Field(repr=False, frozen=True, alias="__typename"),
-]
-
-
-def ensure_json(v: Any) -> Any:
-    """In case the incoming value isn't serialized JSON, reserialize it.
-
-    This lets us use `Json[...]` fields with values that are already deserialized.
-    """
-    # NOTE: Assumes that the deserialized type is not itself a string.
-    # Revisit this if we need to support deserialized types that are str/bytes.
-    return v if isinstance(v, (str, bytes)) else to_json(v)
-
-
-if IS_PYDANTIC_V2 or TYPE_CHECKING:
-    from pydantic import BeforeValidator, PlainSerializer
-
-    SerializedToJson = Annotated[
-        Json[T],
-        # Allow lenient instantiation/validation: incoming data may already be deserialized.
-        BeforeValidator(ensure_json),
-        PlainSerializer(to_json),
-    ]
-else:
-    # FIXME: Restore, modify, or replace this later after ensuring pydantic v1 compatibility.
-    SerializedToJson = Json[T]  # type: ignore[misc]

wandb/_pydantic/field_types.py

@@ -0,0 +1,29 @@
+"""Reusable field types and annotations for pydantic fields."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, TypeVar
+
+from pydantic import Field, StrictStr
+from typing_extensions import Annotated
+
+from .utils import IS_PYDANTIC_V2
+
+T = TypeVar("T")
+
+
+#: GraphQL `__typename` fields
+Typename = Annotated[T, Field(repr=False, frozen=True, alias="__typename")]
+
+
+if IS_PYDANTIC_V2 or TYPE_CHECKING:
+    GQLId = Annotated[StrictStr, Field(repr=False, frozen=True)]
+
+else:
+    # FIXME: Find a way to fix this for pydantic v1, which doesn't like when
+    # `Field(...)` used in the field assignment AND `Annotated[...]`.
+    # This is a problem for codegen, which can currently output e.g.
+    #
+    #   class MyModel(GQLBase):
+    #       my_id: GQLId = Field(alias="myID")
+    GQLId = StrictStr  # type: ignore[misc]

wandb/_pydantic/v1_compat.py

@@ -61,7 +61,12 @@ _V1_CONFIG_KEYS = {
 
 def convert_v2_config(v2_config: dict[str, Any]) -> dict[str, Any]:
     """Internal helper: Return a copy of the v2 ConfigDict with renamed v1 keys."""
-    return {_V1_CONFIG_KEYS.get(k, k): v for k, v in v2_config.items()}
+    return {
+        # Convert v2 config keys to v1 keys
+        **{_V1_CONFIG_KEYS.get(k, k): v for k, v in v2_config.items()},
+        # This is a v1-only config key. In v2, it no longer exists and is effectively always True.
+        "underscore_attrs_are_private": True,
+    }
 
 
 @lru_cache(maxsize=None)  # Reduce repeat introspection via `signature()`
@@ -87,12 +92,10 @@ class V1MixinMetaclass(PydanticModelMetaclass):
         **kwargs: Any,
     ):
         # In the class definition, convert the model config, if any:
-        #     # BEFORE
-        #     class MyModel(BaseModel):  # v2 model with `ConfigDict`
+        #     class MyModel(BaseModel):  # BEFORE (v2)
         #         model_config = ConfigDict(populate_by_name=True)
         #
-        #     # AFTER
-        #     class MyModel(BaseModel):  # v1 model with inner `Config` class
+        #     class MyModel(BaseModel):  # AFTER (v1)
         #         class Config:
         #             allow_population_by_field_name = True
         if config_dict := namespace.pop("model_config", None):
@@ -197,24 +200,41 @@ PydanticCompatMixin: type = V2Mixin if IS_PYDANTIC_V2 else V1Mixin
 # Decorators and other pydantic helpers
 # ----------------------------------------------------------------------------
 if IS_PYDANTIC_V2:
+    from pydantic import alias_generators
+
+    # https://docs.pydantic.dev/latest/api/config/#pydantic.alias_generators.to_camel
+    to_camel = alias_generators.to_camel  # e.g. "foo_bar" -> "fooBar"
+
+    # https://docs.pydantic.dev/latest/api/functional_validators/#pydantic.functional_validators.field_validator
     field_validator = pydantic.field_validator
+
+    # https://docs.pydantic.dev/latest/api/functional_validators/#pydantic.functional_validators.model_validator
     model_validator = pydantic.model_validator
-    AliasChoices = pydantic.AliasChoices
+
+    # https://docs.pydantic.dev/latest/api/fields/#pydantic.fields.computed_field
     computed_field = pydantic.computed_field
 
+    # https://docs.pydantic.dev/latest/api/aliases/#pydantic.aliases.AliasChoices
+    AliasChoices = pydantic.AliasChoices
+
 else:
-    # Redefines `@field_validator` with a v2-like signature
-    # to call `@validator` from v1 instead.
+    from pydantic.utils import to_lower_camel
+
+    V2ValidatorMode = Literal["before", "after", "wrap", "plain"]
+
+    # NOTE:
+    # - `to_lower_camel` in v1 is the equivalent of `to_camel` in v2 (i.e. to lowerCamelCase)
+    # - `to_camel` in v1 is the equivalent of `to_pascal` in v2 (i.e. to UpperCamelCase)
+    to_camel = to_lower_camel
+
+    # Lets us use `@field_validator` from v2, while calling `@validator` from v1 if needed.
     def field_validator(
-        field: str,
-        /,
         *fields: str,
-        mode: Literal["before", "after", "wrap", "plain"] = "after",
+        mode: V2ValidatorMode = "after",
         check_fields: bool | None = None,
         **_: Any,
     ) -> Callable:
         return pydantic.validator(  # type: ignore[deprecated]
-            field,
             *fields,
             pre=(mode == "before"),
             always=True,
@@ -222,31 +242,28 @@ else:
             allow_reuse=True,
         )
 
-    # Redefines `@model_validator` with a v2-like signature
-    # to call `@root_validator` from v1 instead.
-    def model_validator(
-        *,
-        mode: Literal["before", "after", "wrap", "plain"],
-        **_: Any,
-    ) -> Callable:
+    # Lets us use `@model_validator` from v2, while calling `@root_validator` from v1 if needed.
+    def model_validator(*, mode: V2ValidatorMode, **_: Any) -> Callable:
         if mode == "after":
-            # Patch the behavior for `@model_validator(mode="after")` in v1.  This is
-            # necessarily complicated because:
-            # - `@model_validator(mode="after")` decorates an instance method in pydantic v2
-            # - `@root_validator(pre=False)` always decorates a classmethod in pydantic v1
+
             def _decorator(v2_method: Callable) -> Any:
+                # Patch the behavior for `@model_validator(mode="after")` in v1.
+                #
+                # This is necessarily complicated because:
+                # - `@model_validator(mode="after")` always decorates an instance method in v2,
+                #   i.e. the decorated function has `self` as the first arg.
+                # - `@root_validator(pre=False)` always decorates a classmethod in v1,
+                #   i.e. the decorated function has `cls` as the first arg.
+
                 def v1_method(
                     cls: type[V1Model], values: dict[str, Any]
                 ) -> dict[str, Any]:
-                    # Note: Since this is an "after" validator, the values should already be
-                    # validated, so `.construct()` in v1 (`.model_construct()` in v2)
-                    # should create a valid object to pass to the **original** decorated instance method.
-                    validated = v2_method(cls.construct(**values))
+                    # values should already be validated in an "after" validator, so use `construct()`
+                    # to instantiate without (re-)validating.
+                    v_self = v2_method(cls.construct(**values))
 
                     # Pydantic v1 expects the validator to return a dict of {field_name -> value}
-                    return {
-                        name: getattr(validated, name) for name in validated.__fields__
-                    }
+                    return {f: getattr(v_self, f) for f in v_self.__fields__}
 
                 return pydantic.root_validator(pre=False, allow_reuse=True)(  # type: ignore[call-overload]
                     classmethod(v1_method)

wandb/_strutils.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def removeprefix(s: str, prefix: str) -> str:
+    """Removes a prefix from a string.
+
+    This roughly backports the built-in `str.removeprefix` function from Python 3.9+.
+    Once Python 3.8 support is dropped, just replace this with `str.removeprefix`.
+    """
+    return s[len(prefix) :] if s.startswith(prefix) else s
+
+
+def removesuffix(s: str, suffix: str) -> str:
+    """Removes a suffix from a string.
+
+    This roughly backports the built-in `str.removesuffix` function from Python 3.9+.
+    Once Python 3.8 support is dropped, just replace this with `str.removesuffix`.
+    """
+    return s[: -len(suffix)] if s.endswith(suffix) else s
+
+
+def ensureprefix(s: str, prefix: str) -> str:
+    """Ensures the string has the given prefix prepended."""
+    return s if s.startswith(prefix) else f"{prefix}{s}"
+
+
+def ensuresuffix(s: str, suffix: str) -> str:
+    """Ensures the string has the given suffix appended."""
+    return s if s.endswith(suffix) else f"{s}{suffix}"
+
+
+def nameof(obj: Any, full: bool = True) -> str:
+    """Internal convenience helper that returns the object's `__name__` or `__qualname__`.
+
+    If `full` is True, attempt to return the object's `__qualname__` attribute,
+    falling back on the `__name__` attribute.
+    """
+    return getattr(obj, "__qualname__", obj.__name__) if full else obj.__name__

wandb/apis/public/api.py

@@ -36,7 +36,9 @@ from wandb_gql.client import RetryError
 
 import wandb
 from wandb import env, util
+from wandb._analytics import tracked
 from wandb._iterutils import one
+from wandb._strutils import nameof
 from wandb.apis import public
 from wandb.apis.normalize import normalize_exceptions
 from wandb.apis.public.const import RETRY_TIMEDELTA
@@ -1730,6 +1732,7 @@ class Api:
 
         return True
 
+    @tracked
     def registries(
         self,
         organization: Optional[str] = None,
@@ -1797,6 +1800,7 @@ class Api:
         )
         return Registries(self.client, organization, filter)
 
+    @tracked
     def registry(self, name: str, organization: Optional[str] = None) -> Registry:
         """Return a registry given a registry name.
 
@@ -1836,6 +1840,7 @@ class Api:
         registry.load()
         return registry
 
+    @tracked
     def create_registry(
         self,
         name: str,
@@ -1910,6 +1915,7 @@ class Api:
             artifact_types,
         )
 
+    @tracked
     def integrations(
         self,
         entity: Optional[str] = None,
@@ -1933,6 +1939,7 @@ class Api:
         params = {"entityName": entity or self.default_entity}
         return Integrations(client=self.client, variables=params, per_page=per_page)
 
+    @tracked
     def webhook_integrations(
         self, entity: Optional[str] = None, *, per_page: int = 50
     ) -> Iterator["WebhookIntegration"]:
@@ -1976,6 +1983,7 @@ class Api:
             client=self.client, variables=params, per_page=per_page
         )
 
+    @tracked
     def slack_integrations(
         self, *, entity: Optional[str] = None, per_page: int = 50
     ) -> Iterator["SlackIntegration"]:
@@ -2079,10 +2087,10 @@ class Api:
         # Note: we can't currently define this as a constant outside the method
         # and still keep it nearby in this module, because it relies on pydantic v2-only imports
         fragment_names: dict[ActionType, str] = {
-            ActionType.NO_OP: NoOpActionFields.__name__,
-            ActionType.QUEUE_JOB: QueueJobActionFields.__name__,
-            ActionType.NOTIFICATION: NotificationActionFields.__name__,
-            ActionType.GENERIC_WEBHOOK: GenericWebhookActionFields.__name__,
+            ActionType.NO_OP: nameof(NoOpActionFields),
+            ActionType.QUEUE_JOB: nameof(QueueJobActionFields),
+            ActionType.NOTIFICATION: nameof(NotificationActionFields),
+            ActionType.GENERIC_WEBHOOK: nameof(GenericWebhookActionFields),
         }
 
         return set(
@@ -2092,6 +2100,7 @@ class Api:
             and (name := fragment_names.get(action))
         )
 
+    @tracked
     def automation(
         self,
         name: str,
@@ -2129,6 +2138,7 @@ class Api:
             too_long=ValueError("Multiple automations found"),
         )
 
+    @tracked
     def automations(
         self,
         entity: Optional[str] = None,
@@ -2186,6 +2196,7 @@ class Api:
         yield from iterator
 
     @normalize_exceptions
+    @tracked
     def create_automation(
         self,
         obj: "NewAutomation",
@@ -2293,6 +2304,7 @@ class Api:
         return Automation.model_validate(result.trigger)
 
     @normalize_exceptions
+    @tracked
     def update_automation(
         self,
         obj: "Automation",
@@ -2415,6 +2427,7 @@ class Api:
         return Automation.model_validate(result.trigger)
 
     @normalize_exceptions
+    @tracked
     def delete_automation(self, obj: Union["Automation", str]) -> Literal[True]:
         """Delete an automation.
 

wandb/apis/public/artifacts.py

@@ -15,6 +15,7 @@ from typing_extensions import override
 from wandb_gql import Client, gql
 
 import wandb
+from wandb._strutils import nameof
 from wandb.apis import public
 from wandb.apis.normalize import normalize_exceptions
 from wandb.apis.paginator import Paginator, SizedPaginator
@@ -104,7 +105,7 @@ class ArtifactTypes(Paginator["ArtifactType"]):
 
         # Extract the inner `*Connection` result for faster/easier access.
         if not ((proj := result.project) and (conn := proj.artifact_types)):
-            raise ValueError(f"Unable to parse {type(self).__name__!r} response data")
+            raise ValueError(f"Unable to parse {nameof(type(self))!r} response data")
 
         self.last_response = ArtifactTypesFragment.model_validate(conn)
 
@@ -305,7 +306,7 @@ class ArtifactCollections(SizedPaginator["ArtifactCollection"]):
             and (type_ := proj.artifact_type)
             and (conn := type_.artifact_collections)
         ):
-            raise ValueError(f"Unable to parse {type(self).__name__!r} response data")
+            raise ValueError(f"Unable to parse {nameof(type(self))!r} response data")
 
         self.last_response = ArtifactCollectionsFragment.model_validate(conn)
 
@@ -732,7 +733,7 @@ class Artifacts(SizedPaginator["Artifact"]):
             and (collection := type_.artifact_collection)
             and (conn := collection.artifacts)
         ):
-            raise ValueError(f"Unable to parse {type(self).__name__!r} response data")
+            raise ValueError(f"Unable to parse {nameof(type(self))!r} response data")
 
         self.last_response = ArtifactsFragment.model_validate(conn)
 
@@ -959,7 +960,7 @@ class ArtifactFiles(SizedPaginator["public.File"]):
             conn = result.project.artifact_type.artifact.files
 
         if conn is None:
-            raise ValueError(f"Unable to parse {type(self).__name__!r} response data")
+            raise ValueError(f"Unable to parse {nameof(type(self))!r} response data")
 
         self.last_response = FilesFragment.model_validate(conn)
 

wandb/apis/public/automations.py

@@ -9,6 +9,7 @@ from pydantic import ValidationError
 from typing_extensions import override
 from wandb_graphql.language.ast import Document
 
+from wandb._strutils import nameof
 from wandb.apis.paginator import Paginator, _Client
 
 if TYPE_CHECKING:
@@ -34,7 +35,7 @@ class Automations(Paginator["Automation"]):
     ):
         super().__init__(client, variables, per_page=per_page)
         if _query is None:
-            raise RuntimeError(f"Query required for {type(self).__qualname__}")
+            raise RuntimeError(f"Query required for {nameof(type(self))}")
         self._query = _query
 
     @property

wandb/apis/public/registries/_freezable_list.py

@@ -13,6 +13,8 @@ from typing import (
     overload,
 )
 
+from wandb._strutils import nameof
+
 T = TypeVar("T")
 
 
@@ -84,9 +86,7 @@ class FreezableList(MutableSequence[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"
-            )
+            raise TypeError(f"{nameof(type(self))!r} does not support slice assignment")
         else:
             if value in self._frozen or value in self._draft:
                 return
@@ -111,7 +111,7 @@ class FreezableList(MutableSequence[T]):
 
     def __delitem__(self, index: Union[int, slice]) -> None:
         if isinstance(index, slice):
-            raise TypeError(f"{type(self).__name__!r} does not support slice deletion")
+            raise TypeError(f"{nameof(type(self))!r} does not support slice deletion")
         else:
             # The frozen items are sequentially first and protected from changes
             len_frozen = len(self._frozen)
@@ -158,7 +158,7 @@ class FreezableList(MutableSequence[T]):
         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})"
+        return f"{nameof(type(self))}(frozen={list(self._frozen)!r}, draft={list(self._draft)!r})"
 
     @property
     def draft(self) -> Tuple[T, ...]:
@@ -176,4 +176,4 @@ class AddOnlyArtifactTypesList(FreezableList[str]):
             )
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}(saved={list(self._frozen)!r}, draft={list(self._draft)!r})"
+        return f"{nameof(type(self))}(saved={list(self._frozen)!r}, draft={list(self._draft)!r})"

wandb/apis/public/registries/_utils.py

@@ -4,6 +4,7 @@ from enum import Enum
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Literal, Mapping, Sequence
 
+from wandb._strutils import ensureprefix
 from wandb.sdk.artifacts._validators import (
     REGISTRY_PREFIX,
     validate_artifact_types_list,
@@ -81,7 +82,7 @@ def ensure_registry_prefix_on_names(query: Any, in_name: bool = False) -> Any:
     """
     if isinstance((txt := query), str):
         if in_name:
-            return txt if txt.startswith(REGISTRY_PREFIX) else f"{REGISTRY_PREFIX}{txt}"
+            return ensureprefix(txt, REGISTRY_PREFIX)
         return txt
     if isinstance((dct := query), Mapping):
         new_dict = {}

wandb/apis/public/registries/registries_search.py

@@ -9,6 +9,7 @@ from pydantic import ValidationError
 from typing_extensions import override
 from wandb_gql import gql
 
+from wandb._analytics import tracked
 from wandb.apis.paginator import Paginator
 from wandb.apis.public.utils import gql_compat
 from wandb.sdk.artifacts._generated import (
@@ -69,6 +70,7 @@ class Registries(Paginator):
                 raise StopIteration
         return self.objects[self.index]
 
+    @tracked
     def collections(self, filter: dict[str, Any] | None = None) -> Collections:
         return Collections(
             client=self.client,
@@ -77,6 +79,7 @@ class Registries(Paginator):
             collection_filter=filter,
         )
 
+    @tracked
     def versions(self, filter: dict[str, Any] | None = None) -> Versions:
         return Versions(
             client=self.client,
@@ -177,6 +180,7 @@ class Collections(Paginator["ArtifactCollection"]):
                 raise StopIteration
         return self.objects[self.index]
 
+    @tracked
     def versions(self, filter: dict[str, Any] | None = None) -> Versions:
         return Versions(
             client=self.client,