wandb 0.19.9__py3-none-win_amd64.whl → 0.19.10__py3-none-win_amd64.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.10"
 
 
 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.10"
 
 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

wandb/_pydantic/__init__.py

@@ -1,16 +1,20 @@
 """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 (
+    Base,
+    CompatBaseModel,
+    GQLBase,
+    GQLId,
+    SerializedToJson,
+    Typename,
+    ensure_json,
 )
+from .utils import IS_PYDANTIC_V2, pydantic_isinstance, to_json
+from .v1_compat import AliasChoices, computed_field, field_validator, model_validator
 
 __all__ = [
     "IS_PYDANTIC_V2",
+    "CompatBaseModel",
     "Base",
     "GQLBase",
     "Typename",
@@ -20,4 +24,7 @@ __all__ = [
     "computed_field",
     "field_validator",
     "model_validator",
+    "pydantic_isinstance",
+    "to_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,9 +37,14 @@ MODEL_DUMP_DEFAULTS = ModelDumpKwargs(
 )
 
 
+# v1-compatible base class for pydantic types.
+class CompatBaseModel(PydanticCompatMixin, BaseModel):
+    __doc__ = None  # Prevent subclasses from inheriting the BaseModel docstring
+
+
 # Base class for all generated classes/types.
 # Omitted from docstring to avoid inclusion in generated docs.
-class Base(PydanticCompatMixin, BaseModel):
+class Base(CompatBaseModel):
     model_config = ConfigDict(
         populate_by_name=True,
         validate_assignment=True,
@@ -83,17 +89,48 @@ class GQLBase(Base):
 # Reusable annotations for field types
 T = TypeVar("T")
 
-GQLId = Annotated[
-    str,
-    Field(repr=False, strict=True, frozen=True),
-]
+if IS_PYDANTIC_V2:
+    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"),
 ]
 
 
+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
+
+    SerializedToJson = Annotated[
+        Json[T],
+        # Allow lenient instantiation/validation: incoming data may already be deserialized.
+        BeforeValidator(ensure_json),
+    ]
+else:
+    SerializedToJson = Json[T]  # type: ignore[misc]
+
 # 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."""
@@ -109,5 +146,3 @@ Typename = Annotated[
 #     # Allow lenient instantiation/validation: incoming data may already be deserialized.
 #     WrapValidator(validate_maybe_json),
 # ]
-
-SerializedToJson = Json[T]

wandb/_pydantic/utils.py

@@ -0,0 +1,66 @@
+"""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 to_json(v: Any) -> str:
+        """Serialize a Python 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 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__
 
 
 # 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)
+        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]:

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,

wandb/apis/public/api.py

@@ -15,7 +15,7 @@ import json
 import logging
 import os
 import urllib
-from typing import Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional
 
 import requests
 from wandb_gql import Client, gql
@@ -32,15 +32,19 @@ from wandb.apis.public.utils import (
     fetch_org_from_settings_or_entity,
     parse_org_from_registry_path,
 )
+from wandb.proto.wandb_deprecated import Deprecated
 from wandb.proto.wandb_internal_pb2 import ServerFeature
 from wandb.sdk.artifacts._validators import is_artifact_registry_project
 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.launch.utils import LAUNCH_DEFAULT_PROJECT
 from wandb.sdk.lib import retry, runid
-from wandb.sdk.lib.deprecate import Deprecated, deprecate
+from wandb.sdk.lib.deprecate import deprecate
 from wandb.sdk.lib.gql_request import GraphQLSession
 
+if TYPE_CHECKING:
+    from wandb.automations import Integration, SlackIntegration, WebhookIntegration
+
 logger = logging.getLogger(__name__)
 
 
@@ -1517,3 +1521,111 @@ class Api:
             self.settings, self.default_entity
         )
         return Registries(self.client, organization, filter)
+
+    def integrations(
+        self,
+        entity: Optional[str] = None,
+        *,
+        per_page: int = 50,
+    ) -> Iterator["Integration"]:
+        """Return an iterator of all integrations for an entity.
+
+        Args:
+            entity (str, optional): The entity (e.g. team name) for which to
+                fetch integrations.  If not provided, the user's default entity
+                will be used.
+            per_page (int, optional): Number of integrations to fetch per page.
+                Defaults to 50.
+
+        Yields:
+            Iterator[SlackIntegration | WebhookIntegration]: An iterator of any supported integrations.
+        """
+        from wandb.apis.public.integrations import Integrations
+
+        entity = entity or self.default_entity
+        params = {"entityName": entity, "includeWebhook": True, "includeSlack": True}
+        return Integrations(client=self.client, variables=params, per_page=per_page)
+
+    def webhook_integrations(
+        self, entity: Optional[str] = None, *, per_page: int = 50
+    ) -> Iterator["WebhookIntegration"]:
+        """Return an iterator of webhook integrations for an entity.
+
+        Args:
+            entity (str, optional): The entity (e.g. team name) for which to
+                fetch integrations.  If not provided, the user's default entity
+                will be used.
+            per_page (int, optional): Number of integrations to fetch per page.
+                Defaults to 50.
+
+        Yields:
+            Iterator[WebhookIntegration]: An iterator of webhook integrations.
+
+        Examples:
+            Get all registered webhook integrations for the team "my-team":
+            ```python
+            import wandb
+
+            api = wandb.Api()
+            webhook_integrations = api.webhook_integrations(entity="my-team")
+            ```
+
+            Find only webhook integrations that post requests to "https://my-fake-url.com":
+            ```python
+            webhook_integrations = api.webhook_integrations(entity="my-team")
+            my_webhooks = [
+                ig
+                for ig in webhook_integrations
+                if ig.url_endpoint.startswith("https://my-fake-url.com")
+            ]
+            ```
+        """
+        from wandb.apis.public.integrations import WebhookIntegrations
+
+        entity = entity or self.default_entity
+        params = {"entityName": entity, "includeWebhook": True}
+        return WebhookIntegrations(
+            client=self.client, variables=params, per_page=per_page
+        )
+
+    def slack_integrations(
+        self, entity: Optional[str] = None, *, per_page: int = 50
+    ) -> Iterator["SlackIntegration"]:
+        """Return an iterator of Slack integrations for an entity.
+
+        Args:
+            entity (str, optional): The entity (e.g. team name) for which to
+                fetch integrations.  If not provided, the user's default entity
+                will be used.
+            per_page (int, optional): Number of integrations to fetch per page.
+                Defaults to 50.
+
+        Yields:
+            Iterator[SlackIntegration]: An iterator of Slack integrations.
+
+        Examples:
+            Get all registered Slack integrations for the team "my-team":
+            ```python
+            import wandb
+
+            api = wandb.Api()
+            slack_integrations = api.slack_integrations(entity="my-team")
+            ```
+
+            Find only Slack integrations that post to channel names starting with "team-alerts-":
+            ```python
+            slack_integrations = api.slack_integrations(entity="my-team")
+            team_alert_integrations = [
+                ig
+                for ig in slack_integrations
+                if ig.channel_name.startswith("team-alerts-")
+            ]
+            ```
+        """
+        from wandb.apis.public.integrations import SlackIntegrations
+
+        entity = entity or self.default_entity
+        params = {"entityName": entity, "includeSlack": True}
+        return SlackIntegrations(
+            client=self.client, variables=params, per_page=per_page
+        )