wandb 0.19.9__py3-none-any.whl → 0.19.10__py3-none-any.whl

wandb/automations/events.py

@@ -0,0 +1,235 @@
+"""Events that trigger W&B Automations."""
+
+# ruff: noqa: UP007  # Avoid using `X | Y` for union fields, as this can cause issues with pydantic < 2.6
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
+
+from pydantic import Field
+from typing_extensions import Self, TypeAlias, get_args
+
+from wandb._pydantic import (
+    GQLBase,
+    SerializedToJson,
+    field_validator,
+    model_validator,
+    pydantic_isinstance,
+)
+
+from ._filters import And, MongoLikeFilter, Or
+from ._filters.expressions import FilterableField
+from ._filters.run_metrics import (
+    Agg,
+    MetricChangeFilter,
+    MetricOperand,
+    MetricThresholdFilter,
+)
+from ._generated import EventTriggeringConditionType, FilterEventFields
+from ._validators import simplify_op
+from .actions import InputAction, InputActionTypes
+from .scopes import ArtifactCollectionScope, InputScope, ProjectScope
+
+if TYPE_CHECKING:
+    from .automations import NewAutomation
+
+
+# NOTE: Re-defined publicly with a more readable name for easier access
+EventType = EventTriggeringConditionType
+"""The type of event that triggers an automation."""
+
+Agg = Agg
+
+
+# ------------------------------------------------------------------------------
+# Saved types: for parsing response data from saved automations
+
+
+# Note: In GQL responses containing saved automation data, the filter is wrapped in an extra `filter` key.
+class SavedEventFilter(GQLBase):
+    filter: SerializedToJson[MongoLikeFilter] = Field(default_factory=And)
+
+
+class _InnerRunMetricFilter(GQLBase):  # from `RunMetricFilter`
+    threshold_filter: Optional[MetricThresholdFilter] = None
+    change_filter: Optional[MetricChangeFilter] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def _wrap_metric_filter(cls, v: Any) -> Any:
+        if pydantic_isinstance(v, MetricThresholdFilter):
+            return cls(threshold_filter=v)
+        if pydantic_isinstance(v, MetricChangeFilter):
+            return cls(change_filter=v)
+        return v
+
+    @model_validator(mode="after")
+    def _ensure_exactly_one_set(self) -> Self:
+        set_field_names = [name for name, val in self if (val is not None)]
+        if not set_field_names:
+            raise ValueError("Must specify a run metric filter")
+        if len(set_field_names) > 1:
+            names = ", ".join(map(repr, set_field_names))
+            raise ValueError(f"Must specify a single run metric filter, got: {names}")
+        return self
+
+
+class RunMetricFilter(GQLBase):  # from `RunMetricEvent`
+    run_filter: SerializedToJson[MongoLikeFilter] = Field(default_factory=And)
+    run_metric_filter: _InnerRunMetricFilter
+
+    #: Legacy field to define triggers on run metrics from absolute thresholds.  Use `run_metric_filter` instead.
+    metric_filter: Optional[SerializedToJson[MetricThresholdFilter]] = Field(
+        default=None,
+        deprecated="The `metric_filter` field is deprecated: use `run_metric_filter` instead.",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def _wrap_metric_filter(cls, v: Any) -> Any:
+        if pydantic_isinstance(v, (MetricThresholdFilter, MetricChangeFilter)):
+            # If we're only given an (unwrapped) metric filter, automatically wrap it
+            # in the appropriate nested structure, and use the default run filter.
+
+            # Delegate to the inner validator to further wrap the filter as appropriate.
+            return cls(run_metric_filter=_InnerRunMetricFilter.model_validate(v))
+        return v
+
+    @field_validator("run_filter", mode="after")
+    @classmethod
+    def _wrap_run_filter(cls, v: MongoLikeFilter) -> Any:
+        v_new = simplify_op(v)
+        return (
+            And.model_validate(v_new)
+            if pydantic_isinstance(v_new, And)
+            else And(and_=[v_new])
+        )
+
+
+# type alias defined for naming consistency/clarity
+SavedRunMetricFilter: TypeAlias = RunMetricFilter
+
+
+class SavedEvent(FilterEventFields):  # from `FilterEventTriggeringCondition`
+    """A more introspection-friendly representation of a triggering event from a saved automation."""
+
+    # We override the type of the `filter` field since the original GraphQL
+    # schema (and generated class) defines it as a JSONString (str), but we
+    # have more specific expectations for the structure of the JSON data.
+    filter: SerializedToJson[Union[SavedEventFilter, SavedRunMetricFilter]]
+
+
+# ------------------------------------------------------------------------------
+# Input types: for creating or updating automations
+
+
+# Note: The GQL input for "eventFilter" does NOT wrap the filter in an extra `filter` key, unlike the
+# eventFilter returned in responses for saved automations.
+class _BaseEventInput(GQLBase):
+    event_type: EventType
+    scope: InputScope
+    filter: SerializedToJson[Any]
+
+    def add_action(self, action: InputAction) -> NewAutomation:
+        """Define an executed action to be triggered by this event."""
+        from .automations import NewAutomation
+
+        if isinstance(action, InputActionTypes):
+            return NewAutomation(scope=self.scope, event=self, action=action)
+
+        raise TypeError(f"Expected a valid action, got: {type(action).__qualname__!r}")
+
+    def __rshift__(self, other: InputAction) -> NewAutomation:
+        """Supports `event >> action` as syntactic sugar to combine an event and action."""
+        return self.add_action(other)
+
+
+class _BaseMutationEventInput(_BaseEventInput):
+    event_type: EventType
+    scope: InputScope
+    filter: SerializedToJson[MongoLikeFilter] = Field(default_factory=And)
+
+    @field_validator("filter", mode="after")
+    @classmethod
+    def _wrap_filter(cls, v: Any) -> Any:
+        """Ensure the given filter is wrapped like: `{"$or": [{"$and": [<original_filter>]}]}`.
+
+        This is awkward but necessary, because the frontend expects this format.
+        """
+        v_new = simplify_op(v)
+        v_new = (
+            And.model_validate(v_new)
+            if pydantic_isinstance(v_new, And)
+            else And(and_=[v_new])
+        )
+        v_new = Or(or_=[v_new])
+        return v_new
+
+
+class OnLinkArtifact(_BaseMutationEventInput):
+    """A new artifact is linked to a collection."""
+
+    event_type: Literal[EventType.LINK_MODEL] = EventType.LINK_MODEL
+    scope: InputScope
+
+
+class OnAddArtifactAlias(_BaseMutationEventInput):
+    """A new alias is assigned to an artifact."""
+
+    event_type: Literal[EventType.ADD_ARTIFACT_ALIAS] = EventType.ADD_ARTIFACT_ALIAS
+    scope: InputScope
+
+
+class OnCreateArtifact(_BaseMutationEventInput):
+    """A new artifact is created."""
+
+    event_type: Literal[EventType.CREATE_ARTIFACT] = EventType.CREATE_ARTIFACT
+    scope: ArtifactCollectionScope
+
+
+class OnRunMetric(_BaseEventInput):
+    """A run metric satisfies a user-defined absolute threshold."""
+
+    event_type: Literal[EventType.RUN_METRIC] = EventType.RUN_METRIC
+    scope: ProjectScope
+    filter: SerializedToJson[RunMetricFilter]
+
+
+# for type annotations
+InputEvent = Union[
+    OnLinkArtifact,
+    OnAddArtifactAlias,
+    OnCreateArtifact,
+    OnRunMetric,
+]
+# for runtime type checks
+InputEventTypes: tuple[type, ...] = get_args(InputEvent)
+
+
+# ----------------------------------------------------------------------------
+
+
+class RunEvent:
+    name = FilterableField("display_name")
+    # `Run.name` is actually filtered on `Run.display_name` in the backend.
+    # We can't reasonably expect users to know this a priori, so
+    # automatically fix it here.
+
+    @staticmethod
+    def metric(name: str) -> MetricOperand:
+        """Define a metric filter condition."""
+        return MetricOperand(name=name)
+
+
+class ArtifactEvent:
+    alias = FilterableField()
+
+
+MetricThresholdFilter.model_rebuild()
+RunMetricFilter.model_rebuild()
+SavedEventFilter.model_rebuild()
+
+OnLinkArtifact.model_rebuild()
+OnAddArtifactAlias.model_rebuild()
+OnCreateArtifact.model_rebuild()
+OnRunMetric.model_rebuild()

wandb/automations/integrations.py

@@ -0,0 +1,26 @@
+from typing import Union
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase
+from wandb.automations._generated import (
+    GenericWebhookIntegrationFields,
+    SlackIntegrationFields,
+)
+
+
+class SlackIntegration(SlackIntegrationFields):
+    pass
+
+
+class WebhookIntegration(GenericWebhookIntegrationFields):
+    pass
+
+
+Integration = Union[SlackIntegration, WebhookIntegration]
+
+
+# For parsing integration instances from paginated responses
+class _IntegrationEdge(GQLBase):
+    cursor: str
+    node: Integration = Field(discriminator="typename__")

wandb/automations/scopes.py

@@ -0,0 +1,76 @@
+"""Scopes in which a W&B Automation can be triggered."""
+
+from __future__ import annotations
+
+from typing import Literal, Union
+
+from pydantic import BeforeValidator, Field
+from typing_extensions import Annotated, TypeAlias, get_args
+
+from wandb._pydantic import GQLBase
+from wandb.automations._generated import (
+    ArtifactPortfolioScopeFields,
+    ArtifactSequenceScopeFields,
+    ProjectScopeFields,
+)
+
+from ._generated import TriggerScopeType
+from ._validators import validate_scope
+
+# NOTE: Re-defined publicly with a more readable name for easier access
+ScopeType = TriggerScopeType
+"""The type of scope that triggers an automation."""
+
+
+class _BaseScope(GQLBase):
+    scope_type: ScopeType
+
+
+class _ArtifactSequenceScope(_BaseScope, ArtifactSequenceScopeFields):
+    """The ID and name of a "sequence"-type ArtifactCollection scope of an automation."""
+
+    scope_type: Literal[ScopeType.ARTIFACT_COLLECTION] = ScopeType.ARTIFACT_COLLECTION
+
+
+class _ArtifactPortfolioScope(_BaseScope, ArtifactPortfolioScopeFields):
+    """The ID and name of a "portfolio"-type ArtifactCollection scope of an automation."""
+
+    scope_type: Literal[ScopeType.ARTIFACT_COLLECTION] = ScopeType.ARTIFACT_COLLECTION
+
+
+# for type annotations
+ArtifactCollectionScope = Annotated[
+    Union[_ArtifactSequenceScope, _ArtifactPortfolioScope],
+    BeforeValidator(validate_scope),
+    Field(discriminator="typename__"),
+]
+"""The ID and name of the ArtifactCollection scope of an automation."""
+
+# for runtime type checks
+ArtifactCollectionScopeTypes: tuple[type, ...] = (
+    _ArtifactSequenceScope,
+    _ArtifactPortfolioScope,
+)
+
+
+class ProjectScope(_BaseScope, ProjectScopeFields):
+    """The ID and name of the Project scope of an automation."""
+
+    scope_type: Literal[ScopeType.PROJECT] = ScopeType.PROJECT
+
+
+# for type annotations
+AutomationScope: TypeAlias = Annotated[
+    Union[_ArtifactSequenceScope, _ArtifactPortfolioScope, ProjectScope],
+    BeforeValidator(validate_scope),
+    Field(discriminator="typename__"),
+]
+# for runtime type checks
+AutomationScopeTypes: tuple[type, ...] = get_args(AutomationScope)
+
+# Aliases for naming clarity/consistency
+SavedScope: TypeAlias = AutomationScope
+InputScope: TypeAlias = AutomationScope
+
+SavedScopeTypes: tuple[type, ...] = get_args(SavedScope)
+InputScopeTypes: tuple[type, ...] = get_args(InputScope)

wandb/beta/workflows.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Optional, Union
 import wandb
 import wandb.data_types as data_types
 from wandb.data_types import _SavedModel
+from wandb.sdk import wandb_setup
 from wandb.sdk.artifacts.artifact import Artifact
 from wandb.sdk.artifacts.artifact_manifest_entry import ArtifactManifestEntry
 
@@ -85,12 +86,13 @@ def _log_artifact_version(
         Artifact
 
     """
-    if wandb.run is None:
+    run = wandb_setup._setup(start_service=False).most_recent_active_run
+    if not run:
         run = wandb.init(
-            project=project, job_type=job_type, settings=wandb.Settings(silent="true")
+            project=project,
+            job_type=job_type,
+            settings=wandb.Settings(silent=True),
         )
-    else:
-        run = wandb.run
 
     if not scope_project:
         name = f"{name}-{run.id}"
@@ -124,7 +126,7 @@ def log_model(
 
     Supported frameworks include PyTorch, Keras, Tensorflow, Scikit-learn, etc. Under
     the hood, we create a model artifact, bind it to the run that produced this model,
-    associate it with the latest metrics logged with `wandb.log(...)` and more.
+    associate it with the latest metrics logged with `run.log(...)` and more.
 
     Args:
         model_obj: any model object created with the following ML frameworks: PyTorch,
@@ -215,8 +217,7 @@ def use_model(aliased_path: str, unsafe: bool = False) -> "_SavedModel":
         )
 
     # Returns a _SavedModel instance
-    if wandb.run:
-        run = wandb.run
+    if run := wandb_setup._setup(start_service=False).most_recent_active_run:
         artifact = run.use_artifact(aliased_path)
         sm = artifact.get("index")
 
@@ -261,9 +262,7 @@ def link_model(
     """
     aliases = wandb.util._resolve_aliases(aliases)
 
-    if wandb.run:
-        run = wandb.run
-
+    if run := wandb_setup._setup(start_service=False).most_recent_active_run:
         # _artifact_source, if it exists, points to a Public Artifact.
         # Its existence means that _SavedModel was deserialized from a logged artifact, most likely from `use_model`.
         if model._artifact_source:

wandb/cli/cli.py

@@ -83,14 +83,13 @@ def cli_unsupported(argument):
 
 class ClickWandbException(ClickException):
     def format_message(self):
-        # log_file = util.get_log_file_path()
-        log_file = ""
         orig_type = f"{self.orig_type.__module__}.{self.orig_type.__name__}"
         if issubclass(self.orig_type, Error):
             return click.style(str(self.message), fg="red")
         else:
             return (
-                f"An Exception was raised, see {log_file} for full traceback.\n"
+                f"An Exception was raised, see {_wandb_log_path} for full"
+                " traceback.\n"
                 f"{orig_type}: {self.message}"
             )
 
@@ -257,6 +256,7 @@ def login(key, host, cloud, relogin, anonymously, verify, no_offline=False):
         key=key,
         relogin=relogin,
         verify=verify,
+        referrer="models",
     )
 
 

wandb/integration/keras/keras.py

@@ -12,8 +12,9 @@ import tensorflow as tf
 import tensorflow.keras.backend as K  # noqa: N812
 
 import wandb
+from wandb.proto.wandb_deprecated import Deprecated
 from wandb.sdk.integration_utils.data_logging import ValidationDataLogger
-from wandb.sdk.lib.deprecate import Deprecated, deprecate
+from wandb.sdk.lib.deprecate import deprecate
 from wandb.util import add_import_hook
 
 

wandb/integration/langchain/wandb_tracer.py

@@ -18,6 +18,7 @@ will be raised when importing this module.
 from packaging import version
 
 import wandb.util
+from wandb.proto.wandb_deprecated import Deprecated
 from wandb.sdk.lib import deprecate
 
 langchain = wandb.util.get_module(
@@ -40,7 +41,7 @@ class WandbTracer(WandbTracer):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         deprecate.deprecate(
-            field_name=deprecate.Deprecated.langchain_tracer,
+            field_name=Deprecated.langchain_tracer,
             warning_message="This feature is deprecated and has been moved to `langchain`. Enable tracing by setting "
             "LANGCHAIN_WANDB_TRACING=true in your environment. See the documentation at "
             "https://python.langchain.com/docs/ecosystem/integrations/agent_with_wandb_tracing for guidance. "