wandb 0.19.8__py3-none-macosx_11_0_arm64.whl → 0.19.9__py3-none-macosx_11_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.19.8"
+__version__ = "0.19.9"
 
 
 from wandb.errors import Error
@@ -18,6 +18,10 @@ from wandb.errors import Error
 # This needs to be early as other modules call it.
 from wandb.errors.term import termsetup, termlog, termerror, termwarn
 
+# Configure the logger as early as possible for consistent behavior.
+from wandb.sdk.lib import wb_logging as _wb_logging
+_wb_logging.configure_wandb_logger()
+
 from wandb import sdk as wandb_sdk
 
 import wandb

wandb/__init__.pyi

@@ -106,7 +106,7 @@ if TYPE_CHECKING:
     import wandb
     from wandb.plot import CustomChart
 
-__version__: str = "0.19.8"
+__version__: str = "0.19.9"
 
 run: Run | None
 config: wandb_config.Config
@@ -222,7 +222,15 @@ def init(
     mode: Literal["online", "offline", "disabled"] | None = None,
     force: bool | None = None,
     anonymous: Literal["never", "allow", "must"] | None = None,
-    reinit: bool | None = None,
+    reinit: (
+        bool
+        | Literal[
+            None,
+            "default",
+            "return_previous",
+            "finish_previous",
+        ]
+    ) = None,
     resume: bool | Literal["allow", "never", "must", "auto"] | None = None,
     resume_from: str | None = None,
     fork_from: str | None = None,
@@ -370,12 +378,8 @@ def init(
                 to view the charts and data in the UI.
             - `"must"`: Forces the run to be logged to an anonymous account, even
                 if the user is logged in.
-        reinit: Determines if multiple `wandb.init()` calls can start new runs
-            within the same process. By default (`False`), if an active run
-            exists, calling `wandb.init()` returns the existing run instead of
-            creating a new one. When `reinit=True`, the active run is finished
-            before a new run is initialized. In notebook environments, runs are
-            reinitialized by default unless `reinit` is explicitly set to `False`.
+        reinit: Shorthand for the "reinit" setting. Determines the behavior of
+            `wandb.init()` when a run is active.
         resume: Controls the behavior when resuming a run with the specified `id`.
             Available options are:
             - `"allow"`: If a run with the specified `id` exists, it will resume

wandb/_pydantic/__init__.py

@@ -0,0 +1,23 @@
+"""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,
+)
+
+__all__ = [
+    "IS_PYDANTIC_V2",
+    "Base",
+    "GQLBase",
+    "Typename",
+    "GQLId",
+    "SerializedToJson",
+    "AliasChoices",
+    "computed_field",
+    "field_validator",
+    "model_validator",
+]

wandb/_pydantic/base.py

@@ -0,0 +1,113 @@
+"""Base classes and other customizations for generated pydantic types."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Literal, TypeVar
+
+from pydantic import BaseModel, ConfigDict, Field, Json
+from typing_extensions import Annotated, TypedDict, Unpack, override
+
+from .v1_compat import PydanticCompatMixin
+
+if TYPE_CHECKING:
+    from pydantic.main import IncEx
+
+
+class ModelDumpKwargs(TypedDict, total=False):
+    """Shared keyword arguments for `BaseModel.model_{dump,dump_json}`."""
+
+    include: IncEx | None
+    exclude: IncEx | None
+    context: dict[str, Any] | None
+    by_alias: bool | None
+    exclude_unset: bool
+    exclude_defaults: bool
+    exclude_none: bool
+    round_trip: bool
+    warnings: bool | Literal["none", "warn", "error"]
+    fallback: Callable[[Any], Any] | None
+    serialize_as_any: bool
+
+
+#: Custom overrides of default kwargs for `BaseModel.model_{dump,dump_json}`.
+MODEL_DUMP_DEFAULTS = ModelDumpKwargs(
+    by_alias=True,  # Always serialize with aliases (e.g. camelCase names)
+    round_trip=True,  # Ensure serialized values remain valid inputs for deserialization
+)
+
+
+# Base class for all generated classes/types.
+# Omitted from docstring to avoid inclusion in generated docs.
+class Base(PydanticCompatMixin, BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        validate_default=True,
+        extra="forbid",
+        use_attribute_docstrings=True,
+        from_attributes=True,
+        revalidate_instances="always",
+    )
+
+    @override
+    def model_dump(
+        self,
+        *,
+        mode: Literal["json", "python"] | str = "json",  # NOTE: changed default
+        **kwargs: Unpack[ModelDumpKwargs],
+    ) -> dict[str, Any]:
+        kwargs = {**MODEL_DUMP_DEFAULTS, **kwargs}
+        return super().model_dump(mode=mode, **kwargs)
+
+    @override
+    def model_dump_json(
+        self,
+        *,
+        indent: int | None = None,
+        **kwargs: Unpack[ModelDumpKwargs],
+    ) -> str:
+        kwargs = {**MODEL_DUMP_DEFAULTS, **kwargs}
+        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),
+]
+
+Typename = Annotated[
+    T,
+    Field(repr=False, alias="__typename", frozen=True),
+]
+
+
+# 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]

wandb/_pydantic/v1_compat.py

@@ -0,0 +1,262 @@
+"""Provides partial support for compatibility with Pydantic v1."""
+
+from __future__ import annotations
+
+import sys
+from importlib.metadata import version
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Literal,
+    Mapping,
+    TypeVar,
+    overload,
+)
+
+import pydantic
+from typing_extensions import ParamSpec
+
+if TYPE_CHECKING:
+    from typing import Protocol
+
+    class V1Model(Protocol):
+        __config__: ClassVar[type]
+        __fields__: ClassVar[dict[str, Any]]
+        __fields_set__: set[str]
+
+        @classmethod
+        def update_forward_refs(cls, *args: Any, **kwargs: Any) -> None: ...
+        @classmethod
+        def construct(cls, *args: Any, **kwargs: Any) -> V1Model: ...
+        @classmethod
+        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")
+
+
+# Maps {v2 -> v1} model config keys that were renamed in v2.
+# See: https://docs.pydantic.dev/latest/migration/#changes-to-config
+_V1_CONFIG_KEYS = {
+    "populate_by_name": "allow_population_by_field_name",
+    "str_to_lower": "anystr_lower",
+    "str_strip_whitespace": "anystr_strip_whitespace",
+    "str_to_upper": "anystr_upper",
+    "ignored_types": "keep_untouched",
+    "str_max_length": "max_anystr_length",
+    "str_min_length": "min_anystr_length",
+    "from_attributes": "orm_mode",
+    "json_schema_extra": "schema_extra",
+    "validate_default": "validate_all",
+}
+
+
+def _convert_v2_config(v2_config: dict[str, Any]) -> dict[str, Any]:
+    """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()}
+
+
+# Pydantic BaseModels are defined with a custom metaclass, but its namespace
+# has changed between pydantic versions.
+#
+# In v1, it can be imported as `from pydantic.main import ModelMetaclass`
+# In v2, it's defined in an internal module so we avoid directly importing it.
+PydanticModelMetaclass: type = type(pydantic.BaseModel)
+
+
+class V1MixinMetaclass(PydanticModelMetaclass):
+    def __new__(
+        cls,
+        name: str,
+        bases: tuple[type, ...],
+        namespace: dict[str, Any],
+        **kwargs: Any,
+    ):
+        # Converts a `model_config` dict in a V2 class definition, e.g.:
+        #
+        #     class MyModel(BaseModel):
+        #         model_config = ConfigDict(populate_by_name=True)
+        #
+        # ...to a `Config` class in a V1 class definition, e.g.:
+        #
+        #     class MyModel(BaseModel):
+        #         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))
+        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__
+
+
+# Mixin to ensure compatibility of Pydantic models if Pydantic v1 is detected.
+# These are "best effort" implementations and cannot guarantee complete
+# compatibility in v1 environments.
+#
+# Whenever possible, users should strongly prefer upgrading to Pydantic v2 to
+# ensure full compatibility.
+class V1Mixin(metaclass=V1MixinMetaclass):
+    @classmethod
+    def __try_update_forward_refs__(cls: type[V1Model], **localns: Any) -> None:
+        if hasattr(sup := super(), "__try_update_forward_refs__"):
+            sup.__try_update_forward_refs__(**localns)
+
+    @classmethod
+    def model_rebuild(cls, *args: Any, **kwargs: Any) -> None:
+        return cls.update_forward_refs(*args, **kwargs)
+
+    @classmethod
+    def model_construct(cls, *args: Any, **kwargs: Any) -> V1Model:
+        return cls.construct(*args, **kwargs)
+
+    @classmethod
+    def model_validate(cls, *args: Any, **kwargs: Any) -> V1Model:
+        return cls.parse_obj(*args, **kwargs)
+
+    @classmethod
+    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_json(self: V1Model, *args: Any, **kwargs: Any) -> str:
+        return self.json(*args, **kwargs)
+
+    def model_copy(self: V1Model, *args: Any, **kwargs: Any) -> V1Model:
+        return self.copy(*args, **kwargs)
+
+    # 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):
+
+        @classmethod  # type: ignore[misc]
+        @property
+        def model_fields(cls: type[V1Model]) -> Mapping[str, Any]:
+            return cls.__fields__
+
+    @property
+    def model_fields_set(self: V1Model) -> set[str]:
+        return self.__fields_set__
+
+
+# Placeholder. Pydantic v2 is already compatible with itself, so no need for extra mixins.
+class V2Mixin:
+    pass
+
+
+# Pick the mixin type based on the detected Pydantic version.
+PydanticCompatMixin: type = V2Mixin if IS_PYDANTIC_V2 else V1Mixin
+
+
+# ----------------------------------------------------------------------------
+# Decorators and other pydantic helpers
+# ----------------------------------------------------------------------------
+if IS_PYDANTIC_V2:
+    field_validator = pydantic.field_validator
+    model_validator = pydantic.model_validator
+    AliasChoices = pydantic.AliasChoices
+    computed_field = pydantic.computed_field
+
+else:
+    # Redefines `@field_validator` with a v2-like signature
+    # to call `@validator` from v1 instead.
+    def field_validator(
+        field: str,
+        /,
+        *fields: str,
+        mode: Literal["before", "after", "wrap", "plain"] = "after",
+        check_fields: bool | None = None,
+        **_: Any,
+    ) -> Callable:
+        return pydantic.validator(
+            field,
+            *fields,
+            pre=(mode == "before"),
+            always=True,
+            check_fields=bool(check_fields),
+            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:
+        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:
+                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))
+
+                    # Pydantic v1 expects the validator to return a dict of {field_name -> value}
+                    return {
+                        name: getattr(validated, name) for name in validated.__fields__
+                    }
+
+                return pydantic.root_validator(pre=False, allow_reuse=True)(  # type: ignore[call-overload]
+                    classmethod(v1_method)
+                )
+
+            return _decorator
+        else:
+            return pydantic.root_validator(pre=(mode == "before"), allow_reuse=True)  # type: ignore[call-overload]
+
+    @overload  # type: ignore[no-redef]
+    def computed_field(func: Callable | property, /) -> property: ...
+    @overload
+    def computed_field(
+        func: None, /, **_: Any
+    ) -> Callable[[Callable | property], property]: ...
+
+    def computed_field(
+        func: Callable | property | None = None, /, **_: Any
+    ) -> property | Callable[[Callable | property], property]:
+        """Compatibility wrapper for Pydantic v2's `computed_field` in v1."""
+
+        def always_property(f: Callable | property) -> property:
+            # Convert the method to a property only if needed
+            return f if isinstance(f, property) else property(f)
+
+        # Handle both decorator styles
+        return always_property if (func is None) else always_property(func)
+
+    class AliasChoices:  # type: ignore [no-redef]
+        """Placeholder class for Pydantic v2's AliasChoices for partial v1 compatibility."""
+
+        aliases: list[str]
+
+        def __init__(self, *aliases: str):
+            self.aliases = list(aliases)

wandb/apis/paginator.py

@@ -1,75 +1,103 @@
-from typing import TYPE_CHECKING, Any, MutableMapping, Optional
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    ClassVar,
+    Iterator,
+    Mapping,
+    Protocol,
+    Sized,
+    TypeVar,
+    overload,
+)
 
 if TYPE_CHECKING:
-    from wandb_gql import Client
+    from wandb_graphql.language.ast import Document
+
+T = TypeVar("T")
+
+
+# Structural type hint for the client instance
+class _Client(Protocol):
+    def execute(self, *args: Any, **kwargs: Any) -> dict[str, Any]: ...
+
 
+class Paginator(Iterator[T]):
+    """An iterator for paginated objects from GraphQL requests."""
 
-class Paginator:
-    QUERY = None
+    QUERY: ClassVar[Document | None] = None
 
     def __init__(
         self,
-        client: "Client",
-        variables: MutableMapping[str, Any],
-        per_page: Optional[int] = None,
+        client: _Client,
+        variables: Mapping[str, Any],
+        per_page: int = 50,  # We don't allow unbounded paging
     ):
-        self.client = client
-        self.variables = variables
-        # We don't allow unbounded paging
-        self.per_page = per_page
-        if self.per_page is None:
-            self.per_page = 50
-        self.objects = []
-        self.index = -1
-        self.last_response = None
+        self.client: _Client = client
 
-    def __iter__(self):
-        self.index = -1
-        return self
+        # shallow copy partly guards against mutating the original input
+        self.variables: dict[str, Any] = dict(variables)
 
-    def __len__(self):
-        if self.length is None:
-            self._load_page()
-        if self.length is None:
-            raise ValueError("Object doesn't provide length")
-        return self.length
+        self.per_page: int = per_page
+        self.objects: list[T] = []
+        self.index: int = -1
+        self.last_response: object | None = None
 
-    @property
-    def length(self):
-        raise NotImplementedError
+    def __iter__(self) -> Iterator[T]:
+        self.index = -1
+        return self
 
     @property
-    def more(self):
+    @abstractmethod
+    def more(self) -> bool:
+        """Whether there are more pages to be fetched."""
         raise NotImplementedError
 
     @property
-    def cursor(self):
+    @abstractmethod
+    def cursor(self) -> str | None:
+        """The start cursor to use for the next fetched page."""
         raise NotImplementedError
 
-    def convert_objects(self):
+    @abstractmethod
+    def convert_objects(self) -> list[T]:
+        """Convert the last fetched response data into the iterated objects."""
         raise NotImplementedError
 
-    def update_variables(self):
+    def update_variables(self) -> None:
+        """Update the query variables for the next page fetch."""
         self.variables.update({"perPage": self.per_page, "cursor": self.cursor})
 
-    def _load_page(self):
-        if not self.more:
-            return False
-        self.update_variables()
+    def _update_response(self) -> None:
+        """Fetch and store the response data for the next page."""
         self.last_response = self.client.execute(
             self.QUERY, variable_values=self.variables
         )
+
+    def _load_page(self) -> bool:
+        """Fetch the next page, if any, returning True and storing the response if there was one."""
+        if not self.more:
+            return False
+        self.update_variables()
+        self._update_response()
         self.objects.extend(self.convert_objects())
         return True
 
-    def __getitem__(self, index):
+    @overload
+    def __getitem__(self, index: int) -> T: ...
+    @overload
+    def __getitem__(self, index: slice) -> list[T]: ...
+
+    def __getitem__(self, index: int | slice) -> T | list[T]:
         loaded = True
         stop = index.stop if isinstance(index, slice) else index
         while loaded and stop > len(self.objects) - 1:
             loaded = self._load_page()
         return self.objects[index]
 
-    def __next__(self):
+    def __next__(self) -> T:
         self.index += 1
         if len(self.objects) <= self.index:
             if not self._load_page():
@@ -79,3 +107,19 @@ class Paginator:
         return self.objects[self.index]
 
     next = __next__
+
+
+class SizedPaginator(Paginator[T], Sized):
+    """A Paginator for objects with a known total count."""
+
+    def __len__(self) -> int:
+        if self.length is None:
+            self._load_page()
+        if self.length is None:
+            raise ValueError("Object doesn't provide length")
+        return self.length
+
+    @property
+    @abstractmethod
+    def length(self) -> int | None:
+        raise NotImplementedError