wandb 0.19.9__py3-none-macosx_10_14_x86_64.whl → 0.19.11__py3-none-macosx_10_14_x86_64.whl

wandb/__init__.py

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

wandb/__init__.pyi

@@ -106,7 +106,7 @@ if TYPE_CHECKING:
     import wandb
     from wandb.plot import CustomChart
 
-__version__: str = "0.19.9"
+__version__: str = "0.19.11"
 
 run: Run | None
 config: wandb_config.Config
@@ -229,6 +229,7 @@ def init(
             "default",
             "return_previous",
             "finish_previous",
+            "create_new",
         ]
     ) = None,
     resume: bool | Literal["allow", "never", "must", "auto"] | None = None,
@@ -476,6 +477,7 @@ def login(
     force: Optional[bool] = None,
     timeout: Optional[int] = None,
     verify: bool = False,
+    referrer: Optional[str] = None,
 ) -> bool:
     """Set up W&B login credentials.
 
@@ -495,6 +497,7 @@ def login(
         force: (bool, optional) If true, will force a relogin.
         timeout: (int, optional) Number of seconds to wait for user input.
         verify: (bool) Verify the credentials with the W&B server.
+        referrer: (string, optional) The referrer to use in the URL login request.
 
     Returns:
         bool: if key is configured
@@ -1075,7 +1078,7 @@ def link_model(
     registered_model_name: str,
     name: str | None = None,
     aliases: list[str] | None = None,
-) -> None:
+) -> Artifact | None:
     """Log a model artifact version and link it to a registered model in the model registry.
 
     The linked model version will be visible in the UI for the specified registered model.
@@ -1137,7 +1140,7 @@ def link_model(
         ValueError: if name has invalid special characters
 
     Returns:
-        None
+        The linked artifact if linking was successful, otherwise None.
     """
     ...
 

wandb/_pydantic/__init__.py

@@ -1,17 +1,19 @@
 """Internal utilities for working with pydantic."""
 
-from .base import Base, GQLBase, GQLId, SerializedToJson, Typename
-from .v1_compat import (
-    IS_PYDANTIC_V2,
-    AliasChoices,
-    computed_field,
-    field_validator,
-    model_validator,
+from .base import (
+    CompatBaseModel,
+    GQLBase,
+    GQLId,
+    SerializedToJson,
+    Typename,
+    ensure_json,
 )
+from .utils import IS_PYDANTIC_V2, from_json, pydantic_isinstance, to_json
+from .v1_compat import AliasChoices, computed_field, field_validator, model_validator
 
 __all__ = [
     "IS_PYDANTIC_V2",
-    "Base",
+    "CompatBaseModel",
     "GQLBase",
     "Typename",
     "GQLId",
@@ -20,4 +22,8 @@ __all__ = [
     "computed_field",
     "field_validator",
     "model_validator",
+    "pydantic_isinstance",
+    "to_json",
+    "from_json",
+    "ensure_json",
 ]

wandb/_pydantic/base.py

@@ -4,9 +4,10 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar
 
-from pydantic import BaseModel, ConfigDict, Field, Json
+from pydantic import BaseModel, ConfigDict, Field, Json, StrictStr
 from typing_extensions import Annotated, TypedDict, Unpack, override
 
+from .utils import IS_PYDANTIC_V2, to_json
 from .v1_compat import PydanticCompatMixin
 
 if TYPE_CHECKING:
@@ -36,17 +37,25 @@ MODEL_DUMP_DEFAULTS = ModelDumpKwargs(
 )
 
 
-# Base class for all generated classes/types.
+# v1-compatible base class for pydantic types.
+class CompatBaseModel(PydanticCompatMixin, BaseModel):
+    __doc__ = None  # Prevent subclasses from inheriting the BaseModel docstring
+
+
+# Base class for all GraphQL-generated types.
 # Omitted from docstring to avoid inclusion in generated docs.
-class Base(PydanticCompatMixin, BaseModel):
+class GQLBase(CompatBaseModel):
     model_config = ConfigDict(
-        populate_by_name=True,
+        populate_by_name=True,  # Discouraged in pydantic v2.11+, will be deprecated in v3
+        validate_by_name=True,  # Introduced in pydantic v2.11
+        validate_by_alias=True,  # Introduced in pydantic v2.11
+        serialize_by_alias=True,  # Introduced in pydantic v2.11
         validate_assignment=True,
         validate_default=True,
-        extra="forbid",
         use_attribute_docstrings=True,
         from_attributes=True,
         revalidate_instances="always",
+        protected_namespaces=(),  # Some GraphQL fields may begin with "model_"
     )
 
     @override
@@ -70,44 +79,50 @@ class Base(PydanticCompatMixin, BaseModel):
         return super().model_dump_json(indent=indent, **kwargs)
 
 
-# Base class with extra customization for GQL generated types.
-# Omitted from docstring to avoid inclusion in generated docs.
-class GQLBase(Base):
-    model_config = ConfigDict(
-        extra="ignore",
-        protected_namespaces=(),
-    )
-
-
 # ------------------------------------------------------------------------------
 # Reusable annotations for field types
 T = TypeVar("T")
 
-GQLId = Annotated[
-    str,
-    Field(repr=False, strict=True, frozen=True),
-]
+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, alias="__typename", frozen=True),
+    Field(repr=False, frozen=True, alias="__typename"),
 ]
 
 
-# FIXME: Restore, modify, or replace this later after ensuring pydantic v1 compatibility.
-# def validate_maybe_json(v: Any, handler: ValidatorFunctionWrapHandler) -> Any:
-#     """Wraps default Json[...] field validator to allow instantiation with an already-decoded value."""
-#     try:
-#         return handler(v)
-#     except ValidationError:
-#         # Try revalidating after properly jsonifying the value
-#         return handler(to_json(v, by_alias=True, round_trip=True))
-#
-#
-# SerializedToJson = Annotated[
-#     Json[T],
-#     # Allow lenient instantiation/validation: incoming data may already be deserialized.
-#     WrapValidator(validate_maybe_json),
-# ]
-
-SerializedToJson = Json[T]
+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/utils.py

@@ -0,0 +1,73 @@
+"""Internal utilities for working with Pydantic types and data."""
+
+from __future__ import annotations
+
+import json
+import sys
+from contextlib import suppress
+from typing import Any, Type
+
+import pydantic
+from pydantic import BaseModel, ValidationError
+from typing_extensions import TypeAlias
+
+PYTHON_VERSION = sys.version_info
+
+pydantic_major, *_ = pydantic.VERSION.split(".")
+IS_PYDANTIC_V2: bool = int(pydantic_major) >= 2
+
+
+BaseModelType: TypeAlias = Type[BaseModel]
+
+
+if IS_PYDANTIC_V2:
+    import pydantic_core  # pydantic_core is only installed by pydantic v2
+
+    def from_json(s: str) -> Any:
+        """Quickly deserialize a JSON string to a Python object."""
+        return pydantic_core.from_json(s)
+
+    def to_json(v: Any) -> str:
+        """Quickly serialize a (possibly Pydantic) object to a JSON string."""
+        return pydantic_core.to_json(v, by_alias=True, round_trip=True).decode("utf-8")
+
+    def pydantic_isinstance(
+        v: Any, classinfo: BaseModelType | tuple[BaseModelType, ...]
+    ) -> bool:
+        """Return True if the object could be parsed into the given Pydantic type.
+
+        This is like a more lenient version of `isinstance()` for use with Pydantic.
+        In Pydantic v2, should be fast since the underlying implementation is in Rust,
+        and it may be preferable over `try:...except ValidationError:...`.
+
+        See: https://docs.pydantic.dev/latest/api/pydantic_core/#pydantic_core.SchemaValidator.isinstance_python
+        """
+        if isinstance(classinfo, tuple):
+            return any(
+                cls.__pydantic_validator__.isinstance_python(v) for cls in classinfo
+            )
+        cls = classinfo
+        return cls.__pydantic_validator__.isinstance_python(v)
+
+else:
+    # Pydantic v1 fallback implementations.
+    # These may be noticeably slower, but their primary goal is to ensure
+    # compatibility with Pydantic v1 so long as we need to support it.
+
+    from pydantic.json import pydantic_encoder  # Only valid in pydantic v1
+
+    def from_json(s: str) -> Any:
+        return json.loads(s)
+
+    def to_json(v: Any) -> str:
+        return json.dumps(v, default=pydantic_encoder)
+
+    def pydantic_isinstance(
+        v: Any, classinfo: BaseModelType | tuple[BaseModelType, ...]
+    ) -> bool:
+        classes = classinfo if isinstance(classinfo, tuple) else (classinfo,)
+        for cls in classes:
+            with suppress(ValidationError):
+                cls.model_validate(v)
+                return True
+        return False

wandb/_pydantic/v1_compat.py

@@ -2,26 +2,29 @@
 
 from __future__ import annotations
 
-import sys
-from importlib.metadata import version
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    ClassVar,
-    Literal,
-    Mapping,
-    TypeVar,
-    overload,
-)
+import json
+from functools import lru_cache
+from inspect import signature
+from operator import attrgetter
+from typing import TYPE_CHECKING, Any, Callable, ClassVar, Literal, overload
 
 import pydantic
-from typing_extensions import ParamSpec
+
+from .utils import IS_PYDANTIC_V2, to_json
 
 if TYPE_CHECKING:
     from typing import Protocol
 
     class V1Model(Protocol):
+        # ------------------------------------------------------------------------------
+        # NOTE: These aren't part of the original v1 BaseModel spec, but were added as
+        # internal helpers and are (re-)declared here to satisfy mypy checks.
+        @classmethod
+        def _dump_json_vals(cls, values: dict, by_alias: bool) -> dict: ...
+
+        # ------------------------------------------------------------------------------
+        # These methods are part of the original v1 BaseModel spec.
+
         __config__: ClassVar[type]
         __fields__: ClassVar[dict[str, Any]]
         __fields_set__: set[str]
@@ -34,20 +37,10 @@ if TYPE_CHECKING:
         def parse_obj(cls, *args: Any, **kwargs: Any) -> V1Model: ...
         @classmethod
         def parse_raw(cls, *args: Any, **kwargs: Any) -> V1Model: ...
-        def dict(self, *args: Any, **kwargs: Any) -> dict[str, Any]: ...
-        def json(self, *args: Any, **kwargs: Any) -> str: ...
-        def copy(self, *args: Any, **kwargs: Any) -> V1Model: ...
-
 
-PYTHON_VERSION = sys.version_info
-
-pydantic_major_version, *_ = version(pydantic.__name__).split(".")
-IS_PYDANTIC_V2: bool = int(pydantic_major_version) >= 2
-
-
-ModelT = TypeVar("ModelT")
-RT = TypeVar("RT")
-P = ParamSpec("P")
+        def dict(self, **kwargs: Any) -> dict[str, Any]: ...
+        def json(self, **kwargs: Any) -> str: ...
+        def copy(self, **kwargs: Any) -> V1Model: ...
 
 
 # Maps {v2 -> v1} model config keys that were renamed in v2.
@@ -66,11 +59,17 @@ _V1_CONFIG_KEYS = {
 }
 
 
-def _convert_v2_config(v2_config: dict[str, Any]) -> dict[str, Any]:
-    """Return a copy of the v2 ConfigDict with renamed v1 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()}
 
 
+@lru_cache(maxsize=None)  # Reduce repeat introspection via `signature()`
+def allowed_arg_names(func: Callable) -> set[str]:
+    """Internal helper: Return the names of args accepted by the given function."""
+    return set(signature(func).parameters)
+
+
 # Pydantic BaseModels are defined with a custom metaclass, but its namespace
 # has changed between pydantic versions.
 #
@@ -87,28 +86,22 @@ class V1MixinMetaclass(PydanticModelMetaclass):
         namespace: dict[str, Any],
         **kwargs: Any,
     ):
-        # Converts a `model_config` dict in a V2 class definition, e.g.:
-        #
-        #     class MyModel(BaseModel):
+        # In the class definition, convert the model config, if any:
+        #     # BEFORE
+        #     class MyModel(BaseModel):  # v2 model with `ConfigDict`
         #         model_config = ConfigDict(populate_by_name=True)
         #
-        # ...to a `Config` class in a V1 class definition, e.g.:
-        #
-        #     class MyModel(BaseModel):
+        #     # AFTER
+        #     class MyModel(BaseModel):  # v1 model with inner `Config` class
         #         class Config:
         #             allow_population_by_field_name = True
-        #
         if config_dict := namespace.pop("model_config", None):
-            namespace["Config"] = type("Config", (), _convert_v2_config(config_dict))
+            namespace["Config"] = type("Config", (), convert_v2_config(config_dict))
         return super().__new__(cls, name, bases, namespace, **kwargs)
 
-    # note: workarounds to patch "class properties" aren't consistent between python
-    # versions, so this will have to do until changes are needed.
-    if not ((3, 9) <= PYTHON_VERSION < (3, 13)):
-
-        @property
-        def model_fields(self) -> dict[str, Any]:
-            return self.__fields__
+    @property
+    def model_fields(self) -> dict[str, Any]:
+        return self.__fields__  # type: ignore[deprecated]
 
 
 # Mixin to ensure compatibility of Pydantic models if Pydantic v1 is detected.
@@ -118,6 +111,23 @@ class V1MixinMetaclass(PydanticModelMetaclass):
 # Whenever possible, users should strongly prefer upgrading to Pydantic v2 to
 # ensure full compatibility.
 class V1Mixin(metaclass=V1MixinMetaclass):
+    # Internal compat helpers
+    @classmethod
+    def _dump_json_vals(cls, values: dict[str, Any], by_alias: bool) -> dict[str, Any]:
+        """Reserialize values from `Json`-typed fields after dumping the model to dict."""
+        # Get the expected keys (after `.model_dump()`) for `Json`-typed fields.
+        # Note: In v1, `Json` fields have `ModelField.parse_json == True`
+        json_fields = (f for f in cls.__fields__.values() if f.parse_json)  # type: ignore[deprecated]
+        get_key = attrgetter("alias" if by_alias else "name")
+        json_field_keys = set(map(get_key, json_fields))
+
+        return {
+            # Only serialize `Json` fields with non-null values.
+            k: to_json(v) if ((v is not None) and (k in json_field_keys)) else v
+            for k, v in values.items()
+        }
+
+    # ------------------------------------------------------------------------------
     @classmethod
     def __try_update_forward_refs__(cls: type[V1Model], **localns: Any) -> None:
         if hasattr(sup := super(), "__try_update_forward_refs__"):
@@ -139,23 +149,35 @@ class V1Mixin(metaclass=V1MixinMetaclass):
     def model_validate_json(cls, *args: Any, **kwargs: Any) -> V1Model:
         return cls.parse_raw(*args, **kwargs)
 
-    def model_dump(self: V1Model, *args: Any, **kwargs: Any) -> dict[str, Any]:
-        return self.dict(*args, **kwargs)
+    def model_dump(self: V1Model, **kwargs: Any) -> dict[str, Any]:
+        # Pass only kwargs that are allowed in the V1 method.
+        allowed_keys = allowed_arg_names(self.dict) & kwargs.keys()
+        dict_ = self.dict(**{k: kwargs[k] for k in allowed_keys})
+
+        # Ugly hack: Try to serialize `Json` fields correctly when `round_trip=True` in pydantic v1
+        if kwargs.get("round_trip", False):
+            by_alias: bool = kwargs.get("by_alias", False)
+            return self._dump_json_vals(dict_, by_alias=by_alias)
+
+        return dict_
 
-    def model_dump_json(self: V1Model, *args: Any, **kwargs: Any) -> str:
-        return self.json(*args, **kwargs)
+    def model_dump_json(self: V1Model, **kwargs: Any) -> str:
+        # Pass only kwargs that are allowed in the V1 method.
+        allowed_keys = allowed_arg_names(self.json) & kwargs.keys()
+        json_ = self.json(**{k: kwargs[k] for k in allowed_keys})
 
-    def model_copy(self: V1Model, *args: Any, **kwargs: Any) -> V1Model:
-        return self.copy(*args, **kwargs)
+        # Ugly hack: Try to serialize `Json` fields correctly when `round_trip=True` in pydantic v1
+        if kwargs.get("round_trip", False):
+            by_alias: bool = kwargs.get("by_alias", False)
+            dict_ = json.loads(json_)
+            return json.dumps(self._dump_json_vals(dict_, by_alias=by_alias))
 
-    # workarounds to patch "class properties" aren't consistent between python
-    # versions, so this will have to do until changes are needed.
-    if (3, 9) <= PYTHON_VERSION < (3, 13):
+        return json_
 
-        @classmethod  # type: ignore[misc]
-        @property
-        def model_fields(cls: type[V1Model]) -> Mapping[str, Any]:
-            return cls.__fields__
+    def model_copy(self: V1Model, **kwargs: Any) -> V1Model:
+        # Pass only kwargs that are allowed in the V1 method.
+        allowed_keys = allowed_arg_names(self.copy) & kwargs.keys()
+        return self.copy(**{k: kwargs[k] for k in allowed_keys})
 
     @property
     def model_fields_set(self: V1Model) -> set[str]:
@@ -191,7 +213,7 @@ else:
         check_fields: bool | None = None,
         **_: Any,
     ) -> Callable:
-        return pydantic.validator(
+        return pydantic.validator(  # type: ignore[deprecated]
             field,
             *fields,
             pre=(mode == "before"),

wandb/apis/public/__init__.py

@@ -1,7 +1,5 @@
 from wandb.apis.public.api import Api, RetryingClient, requests
 from wandb.apis.public.artifacts import (
-    ARTIFACT_FILES_FRAGMENT,
-    ARTIFACTS_TYPES_FRAGMENT,
     ArtifactCollection,
     ArtifactCollections,
     ArtifactFiles,
@@ -10,8 +8,10 @@ from wandb.apis.public.artifacts import (
     ArtifactTypes,
     RunArtifacts,
 )
+from wandb.apis.public.automations import Automations
 from wandb.apis.public.files import FILE_FRAGMENT, File, Files
 from wandb.apis.public.history import HistoryScan, SampledHistoryScan
+from wandb.apis.public.integrations import SlackIntegrations, WebhookIntegrations
 from wandb.apis.public.jobs import (
     Job,
     QueuedRun,