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

wandb/automations/_filters/run_metrics.py

@@ -0,0 +1,332 @@
+# ruff: noqa: UP007
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Final, Literal, Optional, Union, overload
+
+from pydantic import (
+    Field,
+    PositiveFloat,
+    PositiveInt,
+    StrictFloat,
+    StrictInt,
+    field_validator,
+)
+from typing_extensions import Annotated, TypeAlias, override
+
+from wandb._pydantic import GQLBase
+from wandb.automations._validators import LenientStrEnum
+
+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()}
+
+# Type hint for positive numbers (int or float)
+PosNum: TypeAlias = Union[PositiveInt, PositiveFloat]
+
+
+class Agg(LenientStrEnum):  # from: Aggregation
+    """Supported run metric aggregation operations."""
+
+    MAX = "MAX"
+    MIN = "MIN"
+    AVERAGE = "AVERAGE"
+
+    # Shorter aliases for convenience
+    AVG = AVERAGE
+
+
+class ChangeType(LenientStrEnum):  # from: RunMetricChangeType
+    """Describes the metric change as absolute (arithmetic difference) or relative (decimal percentage)."""
+
+    ABSOLUTE = "ABSOLUTE"
+    RELATIVE = "RELATIVE"
+
+    # Shorter aliases for convenience
+    ABS = ABSOLUTE
+    REL = RELATIVE
+
+
+class ChangeDir(LenientStrEnum):  # from: RunMetricChangeDirection
+    """Describes the direction of the metric change."""
+
+    INCREASE = "INCREASE"
+    DECREASE = "DECREASE"
+    ANY = "ANY"
+
+    # Shorter aliases for convenience
+    INC = INCREASE
+    DEC = DECREASE
+
+
+class BaseMetricFilter(GQLBase, ABC, extra="forbid"):
+    name: str
+    """Name of the observed metric."""
+
+    agg: Optional[Agg]
+    """Aggregate operation, if any, to apply over the window size."""
+
+    window: PositiveInt
+    """Size of the window over which the metric is aggregated (ignored if `agg is None`)."""
+
+    # ------------------------------------------------------------------------------
+    cmp: Optional[str]
+    """Comparison between the metric expression (left) vs. the threshold or target value (right)."""
+
+    # ------------------------------------------------------------------------------
+    threshold: Union[StrictInt, StrictFloat]
+    """Threshold value to compare against."""
+
+    def __and__(self, other: Any) -> RunMetricFilter:
+        """Implements `(metric_filter & run_filter) -> RunMetricFilter`."""
+        from wandb.automations.events import RunMetricFilter
+
+        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.
+            return RunMetricFilter(run=run_filter, metric=self)
+        return NotImplemented
+
+    def __rand__(self, other: BaseOp | FilterExpr) -> RunMetricFilter:
+        """Ensures `&` is commutative: `(run_filter & metric_filter) == (metric_filter & run_filter)`."""
+        return self.__and__(other)
+
+    @abstractmethod
+    def __repr__(self) -> str:
+        """The text representation of the metric filter."""
+        raise NotImplementedError
+
+    @override
+    def __rich_repr__(self) -> RichReprResult:  # type: ignore[override]
+        """The representation of the metric filter when using `rich` for pretty-printing."""
+        # See: https://rich.readthedocs.io/en/stable/pretty.html#rich-repr-protocol
+        yield None, repr(self)
+
+
+class MetricThresholdFilter(BaseMetricFilter):  # from: RunMetricThresholdFilter
+    """Defines a filter that compares a run metric against a user-defined threshold value."""
+
+    name: str
+    agg: Annotated[Optional[Agg], Field(alias="agg_op")] = None
+    window: Annotated[PositiveInt, Field(alias="window_size")] = 1
+
+    cmp: Annotated[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")
+    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)
+        return repr(rf"{metric} {op} {self.threshold}")
+
+
+class MetricChangeFilter(BaseMetricFilter):  # from: RunMetricChangeFilter
+    """Defines a filter that compares a change in a run metric against a user-defined threshold.
+
+    The change is calculated over "tumbling" windows, i.e. the difference
+    between the current window and the non-overlapping prior window.
+    """
+
+    name: str
+    agg: Annotated[Optional[Agg], Field(alias="agg_op")] = None
+    window: Annotated[PositiveInt, Field(alias="current_window_size")] = 1
+
+    # `prior_window` is only for `RUN_METRIC_CHANGE` events
+    prior_window: Annotated[
+        PositiveInt,
+        # By default, set `window -> prior_window` if the latter wasn't provided.
+        Field(alias="prior_window_size", default_factory=lambda data: data["window"]),
+    ]
+    """Size of the prior window over which the metric is aggregated (ignored if `agg is None`).
+
+    If omitted, defaults to the size of the current window.
+    """
+
+    # ------------------------------------------------------------------------------
+    # NOTE:
+    # - The "comparison" operator isn't actually part of the backend schema,
+    #   but it's defined here for consistency -- and ignored otherwise.
+    # - In the backend, it's effectively "$gte" or "$lte", depending on the sign
+    #   (change_dir), though again, this is not explicit in the schema.
+    cmp: Annotated[None, Field(frozen=True, exclude=True, repr=False)] = None
+    """Ignored."""
+
+    # ------------------------------------------------------------------------------
+    change_type: Annotated[ChangeType, Field(alias="change_type")]
+    change_dir: Annotated[ChangeDir, Field(alias="change_dir")]
+    threshold: Annotated[PosNum, Field(alias="change_amount")]
+
+    def __repr__(self) -> str:
+        metric = f"{self.agg.value}({self.name})" if self.agg else self.name
+        verb = (
+            "changes"
+            if (self.change_dir is ChangeDir.ANY)
+            else f"{self.change_dir.value.lower()}s"
+        )
+
+        fmt_spec = ".2%" if (self.change_type is ChangeType.REL) else ""
+        amt = f"{self.threshold:{fmt_spec}}"
+        return repr(rf"{metric} {verb} {amt}")
+
+
+class BaseMetricOperand(GQLBase, extra="forbid"):
+    def gt(self, value: int | float, /) -> MetricThresholdFilter:
+        """Defines a `MetricThresholdFilter` that observes for `metric_expr > threshold`."""
+        return self > value
+
+    def lt(self, value: int | float, /) -> MetricThresholdFilter:
+        """Defines a `MetricThresholdFilter` that observes for `metric_expr < threshold`."""
+        return self < value
+
+    def gte(self, value: int | float, /) -> MetricThresholdFilter:
+        """Defines a `MetricThresholdFilter` that observes for `metric_expr >= threshold`."""
+        return self >= value
+
+    def lte(self, value: int | float, /) -> MetricThresholdFilter:
+        """Defines a `MetricThresholdFilter` that observes for `metric_expr <= threshold`."""
+        return self <= value
+
+    # Overloads to implement:
+    # - `(metric_operand > threshold) -> MetricThresholdFilter`
+    # - `(metric_operand < threshold) -> MetricThresholdFilter`
+    # - `(metric_operand >= threshold) -> MetricThresholdFilter`
+    # - `(metric_operand <= threshold) -> MetricThresholdFilter`
+    def __gt__(self, other: Any) -> MetricThresholdFilter:
+        if isinstance(other, (int, float)):
+            return MetricThresholdFilter(**dict(self), cmp="$gt", threshold=other)
+        return NotImplemented
+
+    def __lt__(self, other: Any) -> MetricThresholdFilter:
+        if isinstance(other, (int, float)):
+            return MetricThresholdFilter(**dict(self), cmp="$lt", threshold=other)
+        return NotImplemented
+
+    def __ge__(self, other: Any) -> MetricThresholdFilter:
+        if isinstance(other, (int, float)):
+            return MetricThresholdFilter(**dict(self), cmp="$gte", threshold=other)
+        return NotImplemented
+
+    def __le__(self, other: Any) -> MetricThresholdFilter:
+        if isinstance(other, (int, float)):
+            return MetricThresholdFilter(**dict(self), cmp="$lte", threshold=other)
+        return NotImplemented
+
+    @overload
+    def changes_by(self, *, diff: PosNum, frac: None) -> MetricChangeFilter: ...
+    @overload
+    def changes_by(self, *, diff: None, frac: PosNum) -> MetricChangeFilter: ...
+    @overload  # NOTE: This overload is for internal use only.
+    def changes_by(
+        self, *, diff: PosNum | None, frac: PosNum | None, _dir: ChangeDir
+    ) -> MetricChangeFilter: ...
+    def changes_by(
+        self,
+        *,
+        diff: PosNum | None = None,
+        frac: PosNum | None = None,
+        _dir: ChangeDir = ChangeDir.ANY,
+    ) -> MetricChangeFilter:
+        """Defines a filter that observes for any change (increase OR decrease) in a run metric.
+
+        Exactly one of the keyword arguments `frac` or `diff` must be provided.
+
+        Args:
+            diff:
+                If given, the arithmetic difference that must be observed
+                in the metric.  Must be a positive number.
+            frac:
+                If given, the fractional (relative) change that must be observed
+                in the metric.  Must be a positive number.  E.g. `frac=0.1`
+                denotes a 10% relative increase OR decrease.
+        """
+        # Enforce mutually exclusive keyword args
+        if (frac is None) is (diff is None):
+            raise ValueError("Must provide exactly one of `frac` or `diff`")
+
+        # Enforce positive values
+        if (frac is not None) and (frac <= 0):
+            raise ValueError(f"Expected positive quantity, got: {frac=}")
+        if (diff is not None) and (diff <= 0):
+            raise ValueError(f"Expected positive quantity, got: {diff=}")
+
+        if diff is None:
+            change_kws = dict(change_type=ChangeType.REL, threshold=frac)
+            return MetricChangeFilter(**dict(self), change_dir=_dir, **change_kws)
+        else:
+            change_kws = dict(change_type=ChangeType.ABS, threshold=diff)
+            return MetricChangeFilter(**dict(self), change_dir=_dir, **change_kws)
+
+    @overload
+    def increases_by(self, *, diff: PosNum, frac: None) -> MetricChangeFilter: ...
+    @overload
+    def increases_by(self, *, diff: None, frac: PosNum) -> MetricChangeFilter: ...
+    def increases_by(
+        self, *, diff: PosNum | None = None, frac: PosNum | None = None
+    ) -> MetricChangeFilter:
+        """Defines a filter that observes for an increase in the numerical value of a run metric.
+
+        Arguments are the same as for `.changes_by()`.
+        """
+        return self.changes_by(diff=diff, frac=frac, _dir=ChangeDir.INC)
+
+    @overload
+    def decreases_by(self, *, diff: PosNum, frac: None) -> MetricChangeFilter: ...
+    @overload
+    def decreases_by(self, *, diff: None, frac: PosNum) -> MetricChangeFilter: ...
+    def decreases_by(
+        self, *, diff: PosNum | None = None, frac: PosNum | None = None
+    ) -> MetricChangeFilter:
+        """Defines a filter that observes for a decrease in the numerical value of a run metric.
+
+        Arguments are the same as for `.changes_by()`.
+        """
+        return self.changes_by(diff=diff, frac=frac, _dir=ChangeDir.DEC)
+
+
+class MetricVal(BaseMetricOperand):
+    """Represents a single, unaggregated metric value when defining a metric filter."""
+
+    name: str
+
+    # Allow users to convert this single-value metric into an aggregated metric expression.
+    def max(self, window: int) -> MetricAgg:
+        return MetricAgg(name=self.name, agg=Agg.MAX, window=window)
+
+    def min(self, window: int) -> MetricAgg:
+        return MetricAgg(name=self.name, agg=Agg.MIN, window=window)
+
+    def avg(self, window: int) -> MetricAgg:
+        return MetricAgg(name=self.name, agg=Agg.AVG, window=window)
+
+    # Aliased method for users familiar with e.g. torch/tf/numpy/pandas/polars/etc.
+    def mean(self, window: int) -> MetricAgg:
+        return self.avg(window=window)
+
+
+class MetricAgg(BaseMetricOperand):
+    """Represents an aggregated metric value when defining a metric filter."""
+
+    name: str
+    agg: Annotated[Agg, Field(alias="agg_op")]
+    window: Annotated[PositiveInt, Field(alias="window_size")]

wandb/automations/_generated/__init__.py

@@ -0,0 +1,177 @@
+# Generated by ariadne-codegen
+
+from .create_automation import CreateAutomation
+from .create_generic_webhook_integration import (
+    CreateGenericWebhookIntegration,
+    CreateGenericWebhookIntegrationCreateGenericWebhookIntegration,
+    CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationGenericWebhookIntegration,
+    CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationIntegration,
+)
+from .delete_automation import DeleteAutomation
+from .enums import (
+    AlertSeverity,
+    EventTriggeringConditionType,
+    TriggeredActionType,
+    TriggerScopeType,
+)
+from .fragments import (
+    ArtifactPortfolioScopeFields,
+    ArtifactSequenceScopeFields,
+    FilterEventFields,
+    GenericWebhookActionFields,
+    GenericWebhookActionFieldsIntegrationGenericWebhookIntegration,
+    GenericWebhookActionFieldsIntegrationIntegration,
+    GenericWebhookIntegrationConnectionFields,
+    GenericWebhookIntegrationConnectionFieldsEdges,
+    GenericWebhookIntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration,
+    GenericWebhookIntegrationConnectionFieldsEdgesNodeIntegration,
+    GenericWebhookIntegrationFields,
+    IntegrationConnectionFields,
+    IntegrationConnectionFieldsEdges,
+    IntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration,
+    IntegrationConnectionFieldsEdgesNodeIntegration,
+    IntegrationConnectionFieldsEdgesNodeSlackIntegration,
+    NoOpActionFields,
+    NotificationActionFields,
+    NotificationActionFieldsIntegrationIntegration,
+    NotificationActionFieldsIntegrationSlackIntegration,
+    PageInfoFields,
+    ProjectConnectionFields,
+    ProjectConnectionFieldsEdges,
+    ProjectConnectionFieldsEdgesNode,
+    ProjectScopeFields,
+    QueueJobActionFields,
+    QueueJobActionFieldsQueue,
+    SlackIntegrationConnectionFields,
+    SlackIntegrationConnectionFieldsEdges,
+    SlackIntegrationConnectionFieldsEdgesNodeIntegration,
+    SlackIntegrationConnectionFieldsEdgesNodeSlackIntegration,
+    SlackIntegrationFields,
+    TriggerFields,
+    TriggerFieldsActionGenericWebhookTriggeredAction,
+    TriggerFieldsActionNoOpTriggeredAction,
+    TriggerFieldsActionNotificationTriggeredAction,
+    TriggerFieldsActionQueueJobTriggeredAction,
+    TriggerFieldsEventFilterEventTriggeringCondition,
+    TriggerFieldsScopeArtifactPortfolio,
+    TriggerFieldsScopeArtifactSequence,
+    TriggerFieldsScopeProject,
+)
+from .generic_webhook_integrations_by_entity import (
+    GenericWebhookIntegrationsByEntity,
+    GenericWebhookIntegrationsByEntityEntity,
+)
+from .get_automations import GetAutomations, GetAutomationsSearchScope
+from .get_automations_by_entity import (
+    GetAutomationsByEntity,
+    GetAutomationsByEntitySearchScope,
+)
+from .input_types import (
+    CreateFilterTriggerInput,
+    CreateGenericWebhookIntegrationInput,
+    GenericWebhookActionInput,
+    NoOpTriggeredActionInput,
+    NotificationActionInput,
+    QueueJobActionInput,
+    TriggeredActionConfig,
+    UpdateFilterTriggerInput,
+)
+from .integrations_by_entity import IntegrationsByEntity, IntegrationsByEntityEntity
+from .operations import (
+    CREATE_AUTOMATION_GQL,
+    CREATE_GENERIC_WEBHOOK_INTEGRATION_GQL,
+    DELETE_AUTOMATION_GQL,
+    GENERIC_WEBHOOK_INTEGRATIONS_BY_ENTITY_GQL,
+    GET_AUTOMATIONS_BY_ENTITY_GQL,
+    GET_AUTOMATIONS_GQL,
+    INTEGRATIONS_BY_ENTITY_GQL,
+    SLACK_INTEGRATIONS_BY_ENTITY_GQL,
+    UPDATE_AUTOMATION_GQL,
+)
+from .slack_integrations_by_entity import (
+    SlackIntegrationsByEntity,
+    SlackIntegrationsByEntityEntity,
+)
+from .update_automation import UpdateAutomation
+
+__all__ = [
+    "CREATE_AUTOMATION_GQL",
+    "CREATE_GENERIC_WEBHOOK_INTEGRATION_GQL",
+    "DELETE_AUTOMATION_GQL",
+    "GENERIC_WEBHOOK_INTEGRATIONS_BY_ENTITY_GQL",
+    "GET_AUTOMATIONS_BY_ENTITY_GQL",
+    "GET_AUTOMATIONS_GQL",
+    "INTEGRATIONS_BY_ENTITY_GQL",
+    "SLACK_INTEGRATIONS_BY_ENTITY_GQL",
+    "UPDATE_AUTOMATION_GQL",
+    "GetAutomations",
+    "GetAutomationsSearchScope",
+    "GetAutomationsByEntity",
+    "GetAutomationsByEntitySearchScope",
+    "CreateAutomation",
+    "UpdateAutomation",
+    "DeleteAutomation",
+    "IntegrationsByEntity",
+    "IntegrationsByEntityEntity",
+    "SlackIntegrationsByEntity",
+    "SlackIntegrationsByEntityEntity",
+    "GenericWebhookIntegrationsByEntity",
+    "GenericWebhookIntegrationsByEntityEntity",
+    "CreateGenericWebhookIntegration",
+    "CreateGenericWebhookIntegrationCreateGenericWebhookIntegration",
+    "CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationGenericWebhookIntegration",
+    "CreateGenericWebhookIntegrationCreateGenericWebhookIntegrationIntegrationIntegration",
+    "CreateFilterTriggerInput",
+    "CreateGenericWebhookIntegrationInput",
+    "GenericWebhookActionInput",
+    "NoOpTriggeredActionInput",
+    "NotificationActionInput",
+    "QueueJobActionInput",
+    "TriggeredActionConfig",
+    "UpdateFilterTriggerInput",
+    "ArtifactPortfolioScopeFields",
+    "ArtifactSequenceScopeFields",
+    "FilterEventFields",
+    "GenericWebhookActionFields",
+    "GenericWebhookActionFieldsIntegrationGenericWebhookIntegration",
+    "GenericWebhookActionFieldsIntegrationIntegration",
+    "GenericWebhookIntegrationConnectionFields",
+    "GenericWebhookIntegrationConnectionFieldsEdges",
+    "GenericWebhookIntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration",
+    "GenericWebhookIntegrationConnectionFieldsEdgesNodeIntegration",
+    "GenericWebhookIntegrationFields",
+    "IntegrationConnectionFields",
+    "IntegrationConnectionFieldsEdges",
+    "IntegrationConnectionFieldsEdgesNodeGenericWebhookIntegration",
+    "IntegrationConnectionFieldsEdgesNodeIntegration",
+    "IntegrationConnectionFieldsEdgesNodeSlackIntegration",
+    "NoOpActionFields",
+    "NotificationActionFields",
+    "NotificationActionFieldsIntegrationIntegration",
+    "NotificationActionFieldsIntegrationSlackIntegration",
+    "PageInfoFields",
+    "ProjectConnectionFields",
+    "ProjectConnectionFieldsEdges",
+    "ProjectConnectionFieldsEdgesNode",
+    "ProjectScopeFields",
+    "QueueJobActionFields",
+    "QueueJobActionFieldsQueue",
+    "SlackIntegrationConnectionFields",
+    "SlackIntegrationConnectionFieldsEdges",
+    "SlackIntegrationConnectionFieldsEdgesNodeIntegration",
+    "SlackIntegrationConnectionFieldsEdgesNodeSlackIntegration",
+    "SlackIntegrationFields",
+    "TriggerFields",
+    "TriggerFieldsActionGenericWebhookTriggeredAction",
+    "TriggerFieldsActionNoOpTriggeredAction",
+    "TriggerFieldsActionNotificationTriggeredAction",
+    "TriggerFieldsActionQueueJobTriggeredAction",
+    "TriggerFieldsEventFilterEventTriggeringCondition",
+    "TriggerFieldsScopeArtifactPortfolio",
+    "TriggerFieldsScopeArtifactSequence",
+    "TriggerFieldsScopeProject",
+    "AlertSeverity",
+    "EventTriggeringConditionType",
+    "TriggerScopeType",
+    "TriggeredActionType",
+]

wandb/automations/_generated/create_automation.py

@@ -0,0 +1,17 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/automations/
+
+from __future__ import annotations
+
+from typing import Optional
+
+from wandb._pydantic import GQLBase
+
+from .fragments import CreateAutomationResult
+
+
+class CreateAutomation(GQLBase):
+    result: Optional[CreateAutomationResult]
+
+
+CreateAutomation.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()

wandb/automations/_generated/delete_automation.py

@@ -0,0 +1,17 @@
+# Generated by ariadne-codegen
+# Source: tools/graphql_codegen/automations/
+
+from __future__ import annotations
+
+from typing import Optional
+
+from wandb._pydantic import GQLBase
+
+from .fragments import DeleteAutomationResult
+
+
+class DeleteAutomation(GQLBase):
+    result: Optional[DeleteAutomationResult]
+
+
+DeleteAutomation.model_rebuild()

wandb/automations/_generated/enums.py

@@ -0,0 +1,33 @@
+# Generated by ariadne-codegen
+# Source: core/api/graphql/schemas/schema-latest.graphql
+
+from __future__ import annotations
+
+from enum import Enum
+
+
+class EventTriggeringConditionType(str, Enum):
+    CREATE_ARTIFACT = "CREATE_ARTIFACT"
+    UPDATE_ARTIFACT_ALIAS = "UPDATE_ARTIFACT_ALIAS"
+    ADD_ARTIFACT_ALIAS = "ADD_ARTIFACT_ALIAS"
+    LINK_MODEL = "LINK_MODEL"
+    RUN_METRIC = "RUN_METRIC"
+    RUN_METRIC_CHANGE = "RUN_METRIC_CHANGE"
+
+
+class TriggerScopeType(str, Enum):
+    PROJECT = "PROJECT"
+    ARTIFACT_COLLECTION = "ARTIFACT_COLLECTION"
+
+
+class AlertSeverity(str, Enum):
+    INFO = "INFO"
+    WARN = "WARN"
+    ERROR = "ERROR"
+
+
+class TriggeredActionType(str, Enum):
+    QUEUE_JOB = "QUEUE_JOB"
+    NOTIFICATION = "NOTIFICATION"
+    GENERIC_WEBHOOK = "GENERIC_WEBHOOK"
+    NO_OP = "NO_OP"