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

wandb/automations/_filters/operators.py

@@ -0,0 +1,267 @@
+"""Types that represent operators in MongoDB filter expressions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Tuple, TypeVar, Union, overload
+
+from pydantic import ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr
+from typing_extensions import TypeAlias, get_args
+
+from wandb._pydantic import Base
+
+if TYPE_CHECKING:
+    from wandb.automations._filters.run_metrics import MetricThresholdFilter
+    from wandb.automations.events import RunMetricFilter
+
+
+# for type annotations
+Scalar = Union[StrictStr, StrictInt, StrictFloat, StrictBool]
+# for runtime type checks
+ScalarTypes = get_args(Scalar)
+
+# See: https://rich.readthedocs.io/en/stable/pretty.html#rich-repr-protocol
+RichReprResult: TypeAlias = Iterable[
+    Union[
+        Any,
+        Tuple[Any],
+        Tuple[str, Any],
+        Tuple[str, Any, Any],
+    ]
+]
+
+T = TypeVar("T")
+TupleOf: TypeAlias = Tuple[T, ...]
+
+
+# NOTE: Wherever class descriptions that are not docstrings, this is deliberate.
+# This is done to ensure the descriptions are omitted from generated API docs.
+
+
+# Mixin to support syntactic sugar for MongoDB expressions with (bitwise) logical operators,
+# e.g. `a | b` -> `{"$or": [a, b]}` or `~a` -> `{"$not": a}`.
+class SupportsLogicalOpSyntax:
+    def __or__(self, other: Any) -> Or:
+        """Syntactic sugar for: `a | b` -> `Or(a, b)`."""
+        return Or(or_=[self, other])
+
+    @overload
+    def __and__(self, other: MetricThresholdFilter) -> RunMetricFilter: ...
+    @overload
+    def __and__(self, other: Any) -> And: ...
+    def __and__(self, other: Any) -> Any:
+        """Syntactic sugar for: `a & b` -> `And(a, b)`."""
+        from wandb.automations._filters.run_metrics import MetricThresholdFilter
+
+        # Special handling `run_filter & metric_filter`
+        if isinstance(other, MetricThresholdFilter):
+            return other.__and__(self)
+        return And(and_=[self, other])
+
+    def __invert__(self) -> Not:
+        """Syntactic sugar for: `~a` -> `Not(a)`."""
+        return Not(not_=self)
+
+
+# Base class for parsed MongoDB filter/query operators, e.g. `{"$and": [...]}`.
+class BaseOp(Base, SupportsLogicalOpSyntax):
+    model_config = ConfigDict(
+        frozen=True,  # Make pseudo-immutable for easier comparison and hashing
+    )
+
+    def __repr__(self) -> str:
+        # Display operand as a positional arg
+        values_repr = ", ".join(map(repr, self.model_dump().values()))
+        return f"{type(self).__name__}({values_repr})"
+
+    def __rich_repr__(self) -> RichReprResult:  # type: ignore[override]
+        # Display field values as positional args:
+        # https://rich.readthedocs.io/en/stable/pretty.html
+        yield from ((None, v) for v in self.model_dump().values())
+
+
+# Logical operator(s)
+# https://www.mongodb.com/docs/manual/reference/operator/query/and/
+# https://www.mongodb.com/docs/manual/reference/operator/query/or/
+# https://www.mongodb.com/docs/manual/reference/operator/query/nor/
+# https://www.mongodb.com/docs/manual/reference/operator/query/not/
+class And(BaseOp):
+    and_: TupleOf[Any] = Field(default=(), alias="$and")
+
+
+class Or(BaseOp):
+    or_: TupleOf[Any] = Field(default=(), alias="$or")
+
+    def __invert__(self) -> Nor:
+        """Syntactic sugar for: `~Or(a, b)` -> `Nor(a, b)`."""
+        return Nor(nor_=self.or_)
+
+
+class Nor(BaseOp):
+    nor_: TupleOf[Any] = Field(default=(), alias="$nor")
+
+    def __invert__(self) -> Or:
+        """Syntactic sugar for: `~Nor(a, b)` -> `Or(a, b)`."""
+        return Or(or_=self.nor_)
+
+
+class Not(BaseOp):
+    not_: Any = Field(alias="$not")
+
+    def __invert__(self) -> Any:
+        """Syntactic sugar for: `~Not(a)` -> `a`."""
+        return self.not_
+
+
+# Comparison operator(s)
+# https://www.mongodb.com/docs/manual/reference/operator/query/lt/
+# https://www.mongodb.com/docs/manual/reference/operator/query/gt/
+# https://www.mongodb.com/docs/manual/reference/operator/query/lte/
+# https://www.mongodb.com/docs/manual/reference/operator/query/gte/
+# https://www.mongodb.com/docs/manual/reference/operator/query/eq/
+# https://www.mongodb.com/docs/manual/reference/operator/query/ne/
+# https://www.mongodb.com/docs/manual/reference/operator/query/in/
+# https://www.mongodb.com/docs/manual/reference/operator/query/nin/
+class Lt(BaseOp):
+    lt_: Scalar = Field(alias="$lt")
+
+    def __invert__(self) -> Gte:
+        """Syntactic sugar for: `~Lt(a)` -> `Gte(a)`."""
+        return Gte(gte_=self.lt_)
+
+
+class Gt(BaseOp):
+    gt_: Scalar = Field(alias="$gt")
+
+    def __invert__(self) -> Lte:
+        """Syntactic sugar for: `~Gt(a)` -> `Lte(a)`."""
+        return Lte(lte_=self.gt_)
+
+
+class Lte(BaseOp):
+    lte_: Scalar = Field(alias="$lte")
+
+    def __invert__(self) -> Gt:
+        """Syntactic sugar for: `~Lte(a)` -> `Gt(a)`."""
+        return Gt(gt_=self.lte_)
+
+
+class Gte(BaseOp):
+    gte_: Scalar = Field(alias="$gte")
+
+    def __invert__(self) -> Lt:
+        """Syntactic sugar for: `~Gte(a)` -> `Lt(a)`."""
+        return Lt(lt_=self.gte_)
+
+
+class Eq(BaseOp):
+    eq_: Scalar = Field(alias="$eq")
+
+    def __invert__(self) -> Ne:
+        """Syntactic sugar for: `~Eq(a)` -> `Ne(a)`."""
+        return Ne(ne_=self.eq_)
+
+
+class Ne(BaseOp):
+    ne_: Scalar = Field(alias="$ne")
+
+    def __invert__(self) -> Eq:
+        """Syntactic sugar for: `~Ne(a)` -> `Eq(a)`."""
+        return Eq(eq_=self.ne_)
+
+
+class In(BaseOp):
+    in_: TupleOf[Scalar] = Field(default=(), alias="$in")
+
+    def __invert__(self) -> NotIn:
+        """Syntactic sugar for: `~In(a)` -> `NotIn(a)`."""
+        return NotIn(nin_=self.in_)
+
+
+class NotIn(BaseOp):
+    nin_: TupleOf[Scalar] = Field(default=(), alias="$nin")
+
+    def __invert__(self) -> In:
+        """Syntactic sugar for: `~NotIn(a)` -> `In(a)`."""
+        return In(in_=self.nin_)
+
+
+# Element operator(s)
+# https://www.mongodb.com/docs/manual/reference/operator/query/exists/
+class Exists(BaseOp):
+    exists_: bool = Field(alias="$exists")
+
+
+# Evaluation operator(s)
+# https://www.mongodb.com/docs/manual/reference/operator/query/regex/
+#
+# Note: "$contains" is NOT a formal MongoDB operator, but the backend recognizes and
+# executes it as a substring-match filter.
+class Regex(BaseOp):
+    regex_: str = Field(alias="$regex")  #: The regex expression to match against.
+
+
+class Contains(BaseOp):
+    contains_: str = Field(alias="$contains")  #: The substring to match against.
+
+
+And.model_rebuild()
+Or.model_rebuild()
+Not.model_rebuild()
+Lt.model_rebuild()
+Gt.model_rebuild()
+Lte.model_rebuild()
+Gte.model_rebuild()
+Eq.model_rebuild()
+Ne.model_rebuild()
+In.model_rebuild()
+NotIn.model_rebuild()
+Exists.model_rebuild()
+Regex.model_rebuild()
+Contains.model_rebuild()
+
+
+# ------------------------------------------------------------------------------
+# Convenience helpers, constants, and utils for supported MongoDB operators
+# ------------------------------------------------------------------------------
+KEY_TO_OP: dict[str, type[BaseOp]] = {
+    "$and": And,
+    "$or": Or,
+    "$nor": Nor,
+    "$not": Not,
+    "$lt": Lt,
+    "$gt": Gt,
+    "$lte": Lte,
+    "$gte": Gte,
+    "$eq": Eq,
+    "$ne": Ne,
+    "$in": In,
+    "$nin": NotIn,
+    "$exists": Exists,
+    "$regex": Regex,
+    "$contains": Contains,
+}
+
+
+KnownOp = Union[
+    And,
+    Or,
+    Nor,
+    Not,
+    Lt,
+    Gt,
+    Lte,
+    Gte,
+    Eq,
+    Ne,
+    In,
+    NotIn,
+    Exists,
+    Regex,
+    Contains,
+]
+UnknownOp = Dict[str, Any]
+
+# for type annotations
+Op = Union[KnownOp, UnknownOp]
+# for runtime type checks
+OpTypes: tuple[type, ...] = (*get_args(KnownOp), dict)

wandb/automations/_filters/run_metrics.py

@@ -0,0 +1,183 @@
+# ruff: noqa: UP007
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Final, Literal, Optional, Union, overload
+
+from pydantic import Field, PositiveInt, StrictFloat, StrictInt, field_validator
+from typing_extensions import Self, override
+
+from wandb._pydantic.base import Base, GQLBase
+
+from .expressions import FilterExpr
+from .operators import BaseOp, RichReprResult
+
+if TYPE_CHECKING:
+    from wandb.automations.events import RunMetricFilter
+
+# Maps MongoDB comparison operators -> Python literal (str) representations
+MONGO2PY_OPS: Final[dict[str, str]] = {
+    "$eq": "==",
+    "$ne": "!=",
+    "$gt": ">",
+    "$lt": "<",
+    "$gte": ">=",
+    "$lte": "<=",
+}
+# Reverse mapping from Python literal (str) -> MongoDB operator key
+PY2MONGO_OPS: Final[dict[str, str]] = {v: k for k, v in MONGO2PY_OPS.items()}
+
+
+class Agg(str, Enum):  # from `Aggregation`
+    """Supported run metric aggregation operations."""
+
+    MAX = "MAX"
+    MIN = "MIN"
+    AVERAGE = "AVERAGE"
+
+
+class ChangeType(str, Enum):  # from `RunMetricChangeType`
+    """Describes the metric change as absolute (arithmetic difference) or relative (decimal percentage)."""
+
+    ABSOLUTE = "ABSOLUTE"
+    RELATIVE = "RELATIVE"
+
+
+class ChangeDirection(str, Enum):  # from `RunMetricChangeDirection`
+    """Describes the direction of the metric change."""
+
+    INCREASE = "INCREASE"
+    DECREASE = "DECREASE"
+    ANY = "ANY"
+
+
+class _BaseMetricFilter(GQLBase):
+    name: str
+    """Name of the observed metric."""
+
+    agg: Optional[Agg]
+    """Aggregation operation, if any, to apply over the window size."""
+
+    window: PositiveInt
+    """Size of the window over which the metric is aggregated."""
+
+    # ------------------------------------------------------------------------------
+
+    threshold: Union[StrictInt, StrictFloat]
+    """Threshold value to compare against."""
+
+    @field_validator("agg", mode="before")
+    @classmethod
+    def _validate_agg(cls, v: Any) -> Any:
+        # Be helpful: e.g. "min" -> "MIN"
+        return v.strip().upper() if isinstance(v, str) else v
+
+    @overload
+    def __and__(self, other: BaseOp | FilterExpr) -> RunMetricFilter: ...
+    @overload
+    def __and__(self, other: Any) -> Any: ...
+    def __and__(self, other: BaseOp | FilterExpr | Any) -> RunMetricFilter | Any:
+        """Supports syntactic sugar for defining a triggering RunMetricEvent from `run_metric_filter & run_filter`."""
+        from wandb.automations.events import RunMetricFilter, _InnerRunMetricFilter
+
+        if isinstance(run_filter := other, (BaseOp, FilterExpr)):
+            # Assume `other` is a run filter, and we are building a RunMetricEvent.
+            # For the metric filter, delegate to the inner validator(s) to further wrap/nest as appropriate.
+            metric_filter = _InnerRunMetricFilter.model_validate(self)
+            return RunMetricFilter(
+                run_metric_filter=metric_filter, run_filter=run_filter
+            )
+        return other.__and__(self)  # Try switching the order of operands
+
+
+class MetricThresholdFilter(_BaseMetricFilter):  # from `RunMetricThresholdFilter`
+    """For run events, defines a metric filter comparing a metric against a user-defined threshold value."""
+
+    name: str
+    agg: Optional[Agg] = Field(default=None, alias="agg_op")
+    window: PositiveInt = Field(default=1, alias="window_size")
+
+    cmp: Literal["$gte", "$gt", "$lt", "$lte"] = Field(alias="cmp_op")
+    """Comparison operator used to compare the metric value (left) vs. the threshold value (right)."""
+
+    threshold: Union[StrictInt, StrictFloat]
+
+    @field_validator("cmp", mode="before")
+    @classmethod
+    def _validate_cmp(cls, v: Any) -> Any:
+        # Be helpful: e.g. ">" -> "$gt"
+        return PY2MONGO_OPS.get(v.strip(), v) if isinstance(v, str) else v
+
+    def __repr__(self) -> str:
+        metric = f"{self.agg.value}({self.name})" if self.agg else self.name
+        op = MONGO2PY_OPS.get(self.cmp, self.cmp)
+        expr = rf"{metric} {op} {self.threshold}"
+        return repr(expr)
+
+    @override
+    def __rich_repr__(self) -> RichReprResult:  # type: ignore[override]
+        yield None, repr(self)
+
+
+class MetricChangeFilter(_BaseMetricFilter):  # from `RunMetricChangeFilter`
+    # FIXME:
+    # - `prior_window` should be optional and default to `window` if not provided.
+    # - implement declarative syntax for `MetricChangeFilter` similar to `MetricThresholdFilter`.
+    # - split this into tagged union of relative/absolute change filters.
+
+    name: str
+    agg: Optional[Agg] = Field(default=None, alias="agg_op")
+
+    # FIXME: Set the `prior_window` to `window` if it's not provided, for convenience.
+    window: PositiveInt = Field(alias="current_window_size")
+    prior_window: PositiveInt = Field(alias="prior_window_size")
+    """Size of the preceding window over which the metric is aggregated."""
+
+    # NOTE: `cmp_op` isn't a field here.  In the backend, it's effectively `cmp_op` = "$gte"
+
+    change_type: ChangeType = Field(alias="change_type")
+    change_direction: ChangeDirection = Field(alias="change_dir")
+
+    threshold: Union[StrictInt, StrictFloat] = Field(alias="change_amount")
+
+
+class MetricOperand(Base):
+    name: str
+    agg: Optional[Agg] = Field(default=None, alias="agg_op")
+    window: PositiveInt = Field(default=1, alias="window_size")
+
+    def _agg(self, op: Agg, window: int) -> Self:
+        if self.agg is None:  # Prevent overwriting an existing aggregation operator
+            return self.model_copy(update={"agg": op, "window": window})
+        raise ValueError(f"Aggregation operator already set as: {self.agg!r}")
+
+    def max(self, window: int) -> Self:
+        return self._agg(Agg.MAX, window)
+
+    def min(self, window: int) -> Self:
+        return self._agg(Agg.MIN, window)
+
+    def average(self, window: int) -> Self:
+        return self._agg(Agg.AVERAGE, window)
+
+    # Aliased method for users familiar with e.g. torch/tf/numpy/pandas/polars/etc.
+    def mean(self, window: int) -> Self:
+        return self.average(window=window)
+
+    def gt(self, other: int | float) -> MetricThresholdFilter:
+        return MetricThresholdFilter(**dict(self), cmp="$gt", threshold=other)
+
+    def lt(self, other: int | float) -> MetricThresholdFilter:
+        return MetricThresholdFilter(**dict(self), cmp="$lt", threshold=other)
+
+    def gte(self, other: int | float) -> MetricThresholdFilter:
+        return MetricThresholdFilter(**dict(self), cmp="$gte", threshold=other)
+
+    def lte(self, other: int | float) -> MetricThresholdFilter:
+        return MetricThresholdFilter(**dict(self), cmp="$lte", threshold=other)
+
+    __gt__ = gt
+    __lt__ = lt
+    __ge__ = gte
+    __le__ = lte

wandb/automations/_generated/__init__.py

@@ -0,0 +1,184 @@
+# Generated by ariadne-codegen
+
+from .create_filter_trigger import CreateFilterTrigger
+from .create_generic_webhook_integration import (
+    CreateGenericWebhookIntegration,
+    CreateGenericWebhookIntegrationCreateGenericWebhookIntegration,
+    CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationGenericWebhookIntegration,
+    CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationIntegration,
+)
+from .delete_trigger import DeleteTrigger
+from .enums import (
+    AlertSeverity,
+    EventTriggeringConditionType,
+    TriggeredActionType,
+    TriggerScopeType,
+)
+from .fragments import (
+    ArtifactPortfolioScopeFields,
+    ArtifactSequenceScopeFields,
+    CreateFilterTriggerResult,
+    DeleteTriggerResult,
+    FilterEventFields,
+    GenericWebhookActionFields,
+    GenericWebhookActionFieldsIntegrationGenericWebhookIntegration,
+    GenericWebhookActionFieldsIntegrationIntegration,
+    GenericWebhookIntegrationConnectionFields,
+    GenericWebhookIntegrationConnectionFieldsEdges,
+    GenericWebhookIntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration,
+    GenericWebhookIntegrationConnectionFieldsEdgesNodeIntegration,
+    GenericWebhookIntegrationFields,
+    GithubIntegrationFields,
+    IntegrationConnectionFields,
+    IntegrationConnectionFieldsEdges,
+    IntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration,
+    IntegrationConnectionFieldsEdgesNodeIntegration,
+    IntegrationConnectionFieldsEdgesNodeSlackIntegration,
+    NoOpActionFields,
+    NotificationActionFields,
+    NotificationActionFieldsIntegrationIntegration,
+    NotificationActionFieldsIntegrationSlackIntegration,
+    PageInfoFields,
+    ProjectConnectionFields,
+    ProjectConnectionFieldsEdges,
+    ProjectConnectionFieldsEdgesNode,
+    ProjectScopeFields,
+    QueueJobActionFields,
+    RunQueueFields,
+    SlackIntegrationConnectionFields,
+    SlackIntegrationConnectionFieldsEdges,
+    SlackIntegrationConnectionFieldsEdgesNodeIntegration,
+    SlackIntegrationConnectionFieldsEdgesNodeSlackIntegration,
+    SlackIntegrationFields,
+    TriggerFields,
+    TriggerFieldsActionGenericWebhookTriggeredAction,
+    TriggerFieldsActionNoOpTriggeredAction,
+    TriggerFieldsActionNotificationTriggeredAction,
+    TriggerFieldsActionQueueJobTriggeredAction,
+    TriggerFieldsEventFilterEventTriggeringCondition,
+    TriggerFieldsScopeArtifactPortfolio,
+    TriggerFieldsScopeArtifactSequence,
+    TriggerFieldsScopeProject,
+    UpdateFilterTriggerResult,
+    UserFields,
+)
+from .generic_webhook_integrations_by_entity import (
+    GenericWebhookIntegrationsByEntity,
+    GenericWebhookIntegrationsByEntityEntity,
+)
+from .get_triggers import GetTriggers, GetTriggersSearchScope
+from .get_triggers_by_entity import GetTriggersByEntity, GetTriggersByEntitySearchScope
+from .input_types import (
+    CreateFilterTriggerInput,
+    CreateGenericWebhookIntegrationInput,
+    GenericWebhookActionInput,
+    NoOpTriggeredActionInput,
+    NotificationActionInput,
+    QueueJobActionInput,
+    TriggeredActionConfig,
+    UpdateFilterTriggerInput,
+)
+from .integrations_by_entity import IntegrationsByEntity, IntegrationsByEntityEntity
+from .operations import (
+    CREATE_FILTER_TRIGGER_GQL,
+    CREATE_GENERIC_WEBHOOK_INTEGRATION_GQL,
+    DELETE_TRIGGER_GQL,
+    GENERIC_WEBHOOK_INTEGRATIONS_BY_ENTITY_GQL,
+    GET_TRIGGERS_BY_ENTITY_GQL,
+    GET_TRIGGERS_GQL,
+    INTEGRATIONS_BY_ENTITY_GQL,
+    SLACK_INTEGRATIONS_BY_ENTITY_GQL,
+    UPDATE_FILTER_TRIGGER_GQL,
+)
+from .slack_integrations_by_entity import (
+    SlackIntegrationsByEntity,
+    SlackIntegrationsByEntityEntity,
+)
+from .update_filter_trigger import UpdateFilterTrigger
+
+__all__ = [
+    "CREATE_FILTER_TRIGGER_GQL",
+    "CREATE_GENERIC_WEBHOOK_INTEGRATION_GQL",
+    "DELETE_TRIGGER_GQL",
+    "GENERIC_WEBHOOK_INTEGRATIONS_BY_ENTITY_GQL",
+    "GET_TRIGGERS_BY_ENTITY_GQL",
+    "GET_TRIGGERS_GQL",
+    "INTEGRATIONS_BY_ENTITY_GQL",
+    "SLACK_INTEGRATIONS_BY_ENTITY_GQL",
+    "UPDATE_FILTER_TRIGGER_GQL",
+    "GetTriggers",
+    "GetTriggersSearchScope",
+    "GetTriggersByEntity",
+    "GetTriggersByEntitySearchScope",
+    "CreateFilterTrigger",
+    "UpdateFilterTrigger",
+    "DeleteTrigger",
+    "IntegrationsByEntity",
+    "IntegrationsByEntityEntity",
+    "SlackIntegrationsByEntity",
+    "SlackIntegrationsByEntityEntity",
+    "GenericWebhookIntegrationsByEntity",
+    "GenericWebhookIntegrationsByEntityEntity",
+    "CreateGenericWebhookIntegration",
+    "CreateGenericWebhookIntegrationCreateGenericWebhookIntegration",
+    "CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationGenericWebhookIntegration",
+    "CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationIntegration",
+    "CreateFilterTriggerInput",
+    "CreateGenericWebhookIntegrationInput",
+    "GenericWebhookActionInput",
+    "NoOpTriggeredActionInput",
+    "NotificationActionInput",
+    "QueueJobActionInput",
+    "TriggeredActionConfig",
+    "UpdateFilterTriggerInput",
+    "ArtifactPortfolioScopeFields",
+    "ArtifactSequenceScopeFields",
+    "CreateFilterTriggerResult",
+    "DeleteTriggerResult",
+    "FilterEventFields",
+    "GenericWebhookActionFields",
+    "GenericWebhookActionFieldsIntegrationGenericWebhookIntegration",
+    "GenericWebhookActionFieldsIntegrationIntegration",
+    "GenericWebhookIntegrationConnectionFields",
+    "GenericWebhookIntegrationConnectionFieldsEdges",
+    "GenericWebhookIntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration",
+    "GenericWebhookIntegrationConnectionFieldsEdgesNodeIntegration",
+    "GenericWebhookIntegrationFields",
+    "GithubIntegrationFields",
+    "IntegrationConnectionFields",
+    "IntegrationConnectionFieldsEdges",
+    "IntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration",
+    "IntegrationConnectionFieldsEdgesNodeIntegration",
+    "IntegrationConnectionFieldsEdgesNodeSlackIntegration",
+    "NoOpActionFields",
+    "NotificationActionFields",
+    "NotificationActionFieldsIntegrationIntegration",
+    "NotificationActionFieldsIntegrationSlackIntegration",
+    "PageInfoFields",
+    "ProjectConnectionFields",
+    "ProjectConnectionFieldsEdges",
+    "ProjectConnectionFieldsEdgesNode",
+    "ProjectScopeFields",
+    "QueueJobActionFields",
+    "RunQueueFields",
+    "SlackIntegrationConnectionFields",
+    "SlackIntegrationConnectionFieldsEdges",
+    "SlackIntegrationConnectionFieldsEdgesNodeIntegration",
+    "SlackIntegrationConnectionFieldsEdgesNodeSlackIntegration",
+    "SlackIntegrationFields",
+    "TriggerFields",
+    "TriggerFieldsActionGenericWebhookTriggeredAction",
+    "TriggerFieldsActionNoOpTriggeredAction",
+    "TriggerFieldsActionNotificationTriggeredAction",
+    "TriggerFieldsActionQueueJobTriggeredAction",
+    "TriggerFieldsEventFilterEventTriggeringCondition",
+    "TriggerFieldsScopeArtifactPortfolio",
+    "TriggerFieldsScopeArtifactSequence",
+    "TriggerFieldsScopeProject",
+    "UpdateFilterTriggerResult",
+    "UserFields",
+    "AlertSeverity",
+    "EventTriggeringConditionType",
+    "TriggerScopeType",
+    "TriggeredActionType",
+]

wandb/automations/_generated/create_filter_trigger.py

@@ -0,0 +1,21 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/automations/
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase
+
+from .fragments import CreateFilterTriggerResult
+
+
+class CreateFilterTrigger(GQLBase):
+    create_filter_trigger: Optional[CreateFilterTriggerResult] = Field(
+        alias="createFilterTrigger"
+    )
+
+
+CreateFilterTrigger.model_rebuild()

wandb/automations/_generated/create_generic_webhook_integration.py

@@ -0,0 +1,43 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/automations/
+
+from __future__ import annotations
+
+from typing import Literal, Optional, Union
+
+from pydantic import Field
+
+from wandb._pydantic import GQLBase, Typename
+
+from .fragments import GenericWebhookIntegrationFields
+
+
+class CreateGenericWebhookIntegration(GQLBase):
+    create_generic_webhook_integration: Optional[
+        CreateGenericWebhookIntegrationCreateGenericWebhookIntegration
+    ] = Field(alias="createGenericWebhookIntegration")
+
+
+class CreateGenericWebhookIntegrationCreateGenericWebhookIntegration(GQLBase):
+    integration: Union[
+        CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationIntegration,
+        CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationGenericWebhookIntegration,
+    ] = Field(discriminator="typename__")
+
+
+class CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationIntegration(
+    GQLBase
+):
+    typename__: Typename[
+        Literal["GitHubOAuthIntegration", "Integration", "SlackIntegration"]
+    ]
+
+
+class CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationGenericWebhookIntegration(
+    GenericWebhookIntegrationFields
+):
+    typename__: Typename[Literal["GenericWebhookIntegration"]]
+
+
+CreateGenericWebhookIntegration.model_rebuild()
+CreateGenericWebhookIntegrationCreateGenericWebhookIntegration.model_rebuild()