prefect-client 2.17.0__py3-none-any.whl → 2.18.0__py3-none-any.whl

prefect/client/orchestration.py

@@ -8,6 +8,7 @@ from typing import (
     Dict,
     Iterable,
     List,
+    NoReturn,
     Optional,
     Set,
     Tuple,
@@ -23,15 +24,10 @@ import pendulum
 from prefect._internal.compatibility.deprecated import (
     handle_deprecated_infra_overrides_parameter,
 )
-from prefect._internal.compatibility.experimental import (
-    EXPERIMENTAL_WARNING,
-    ExperimentalFeature,
-    experiment_enabled,
-)
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect.settings import (
-    PREFECT_EXPERIMENTAL_WARN,
-    PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES,
+    PREFECT_API_SERVICES_TRIGGERS_ENABLED,
+    PREFECT_EXPERIMENTAL_EVENTS,
 )
 
 if HAS_PYDANTIC_V2:
@@ -133,7 +129,7 @@ from prefect.client.schemas.sorting import (
     TaskRunSort,
 )
 from prefect.deprecated.data_documents import DataDocument
-from prefect.events.schemas.automations import Automation, ExistingAutomation
+from prefect.events.schemas.automations import Automation, AutomationCore
 from prefect.logging import get_logger
 from prefect.settings import (
     PREFECT_API_DATABASE_CONNECTION_URL,
@@ -161,6 +157,12 @@ class ServerType(AutoEnum):
     SERVER = AutoEnum.auto()
     CLOUD = AutoEnum.auto()
 
+    def supports_automations(self) -> bool:
+        if self == ServerType.CLOUD:
+            return True
+
+        return PREFECT_EXPERIMENTAL_EVENTS and PREFECT_API_SERVICES_TRIGGERS_ENABLED
+
 
 def get_client(httpx_settings: Optional[dict] = None) -> "PrefectClient":
     """
@@ -568,21 +570,6 @@ class PrefectClient:
         Returns:
             The flow run model
         """
-        if job_variables is not None and experiment_enabled("flow_run_infra_overrides"):
-            if (
-                PREFECT_EXPERIMENTAL_WARN
-                and PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES
-            ):
-                warnings.warn(
-                    EXPERIMENTAL_WARNING.format(
-                        feature="Flow run job variables",
-                        group="flow_run_infra_overrides",
-                        help="To use this feature, update your workers to Prefect 2.16.4 or later. ",
-                    ),
-                    ExperimentalFeature,
-                    stacklevel=3,
-                )
-
         parameters = parameters or {}
         context = context or {}
         state = state or prefect.states.Scheduled()
@@ -703,21 +690,6 @@ class PrefectClient:
         Returns:
             an `httpx.Response` object from the PATCH request
         """
-        if job_variables is not None and experiment_enabled("flow_run_infra_overrides"):
-            if (
-                PREFECT_EXPERIMENTAL_WARN
-                and PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES
-            ):
-                warnings.warn(
-                    EXPERIMENTAL_WARNING.format(
-                        feature="Flow run job variables",
-                        group="flow_run_infra_overrides",
-                        help="To use this feature, update your workers to Prefect 2.16.4 or later. ",
-                    ),
-                    ExperimentalFeature,
-                    stacklevel=3,
-                )
-
         params = {}
         if flow_version is not None:
             params["flow_version"] = flow_version
@@ -2998,34 +2970,6 @@ class PrefectClient:
         response.raise_for_status()
         return response.json()
 
-    async def create_automation(self, automation: Automation) -> UUID:
-        """Creates an automation in Prefect Cloud."""
-        if self.server_type != ServerType.CLOUD:
-            raise RuntimeError("Automations are only supported for Prefect Cloud.")
-
-        response = await self._client.post(
-            "/automations/",
-            json=automation.dict(json_compatible=True),
-        )
-
-        return UUID(response.json()["id"])
-
-    async def read_resource_related_automations(
-        self, resource_id: str
-    ) -> List[ExistingAutomation]:
-        if self.server_type != ServerType.CLOUD:
-            raise RuntimeError("Automations are only supported for Prefect Cloud.")
-
-        response = await self._client.get(f"/automations/related-to/{resource_id}")
-        response.raise_for_status()
-        return pydantic.parse_obj_as(List[ExistingAutomation], response.json())
-
-    async def delete_resource_owned_automations(self, resource_id: str):
-        if self.server_type != ServerType.CLOUD:
-            raise RuntimeError("Automations are only supported for Prefect Cloud.")
-
-        await self._client.delete(f"/automations/owned-by/{resource_id}")
-
     async def increment_concurrency_slots(
         self, names: List[str], slots: int, mode: str
     ) -> httpx.Response:
@@ -3165,6 +3109,121 @@ class PrefectClient:
         response = await self._client.delete(f"/flow_runs/{flow_run_id}/input/{key}")
         response.raise_for_status()
 
+    def _raise_for_unsupported_automations(self) -> NoReturn:
+        if not PREFECT_EXPERIMENTAL_EVENTS:
+            raise RuntimeError(
+                "The current server and client configuration does not support "
+                "events.  Enable experimental events support with the "
+                "PREFECT_EXPERIMENTAL_EVENTS setting."
+            )
+        else:
+            raise RuntimeError(
+                "The current server and client configuration does not support "
+                "automations.  Enable experimental automations with the "
+                "PREFECT_API_SERVICES_TRIGGERS_ENABLED setting."
+            )
+
+    async def create_automation(self, automation: AutomationCore) -> UUID:
+        """Creates an automation in Prefect Cloud."""
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        response = await self._client.post(
+            "/automations/",
+            json=automation.dict(json_compatible=True),
+        )
+
+        return UUID(response.json()["id"])
+
+    async def read_automations(self) -> List[Automation]:
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        response = await self._client.post("/automations/filter")
+        response.raise_for_status()
+        return pydantic.parse_obj_as(List[Automation], response.json())
+
+    async def find_automation(
+        self, id_or_name: str, exit_if_not_found: bool = True
+    ) -> Optional[Automation]:
+        try:
+            id = UUID(id_or_name)
+        except ValueError:
+            id = None
+
+        if id:
+            automation = await self.read_automation(id)
+            if automation:
+                return automation
+
+        automations = await self.read_automations()
+
+        # Look for it by an exact name
+        for automation in automations:
+            if automation.name == id_or_name:
+                return automation
+
+        # Look for it by a case-insensitive name
+        for automation in automations:
+            if automation.name.lower() == id_or_name.lower():
+                return automation
+
+        return None
+
+    async def read_automation(self, automation_id: UUID) -> Optional[Automation]:
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        response = await self._client.get(f"/automations/{automation_id}")
+        if response.status_code == 404:
+            return None
+        response.raise_for_status()
+        return Automation.parse_obj(response.json())
+
+    async def pause_automation(self, automation_id: UUID):
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        response = await self._client.patch(
+            f"/automations/{automation_id}", json={"enabled": False}
+        )
+        response.raise_for_status()
+
+    async def resume_automation(self, automation_id: UUID):
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        response = await self._client.patch(
+            f"/automations/{automation_id}", json={"enabled": True}
+        )
+        response.raise_for_status()
+
+    async def delete_automation(self, automation_id: UUID):
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        response = await self._client.delete(f"/automations/{automation_id}")
+        if response.status_code == 404:
+            return
+
+        response.raise_for_status()
+
+    async def read_resource_related_automations(
+        self, resource_id: str
+    ) -> List[Automation]:
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        response = await self._client.get(f"/automations/related-to/{resource_id}")
+        response.raise_for_status()
+        return pydantic.parse_obj_as(List[Automation], response.json())
+
+    async def delete_resource_owned_automations(self, resource_id: str):
+        if not self.server_type.supports_automations():
+            self._raise_for_unsupported_automations()
+
+        await self._client.delete(f"/automations/owned-by/{resource_id}")
+
     async def __aenter__(self):
         """
         Start the client.

prefect/client/schemas/actions.py

@@ -8,9 +8,9 @@ from prefect._internal.compatibility.deprecated import DeprecatedInfraOverridesF
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
 
 if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, conint, root_validator, validator
+    from pydantic.v1 import Field, root_validator, validator
 else:
-    from pydantic import Field, conint, root_validator, validator
+    from pydantic import Field, root_validator, validator
 
 import prefect.client.schemas.objects as objects
 from prefect._internal.schemas.bases import ActionBaseModel
@@ -26,6 +26,7 @@ from prefect._internal.schemas.validators import (
 )
 from prefect.client.schemas.objects import StateDetails, StateType
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
+from prefect.types import NonNegativeInteger
 from prefect.utilities.collections import listrepr
 from prefect.utilities.pydantic import get_class_fields_only
 
@@ -525,7 +526,7 @@ class WorkPoolCreate(ActionBaseModel):
         default=False,
         description="Whether the work pool is paused.",
     )
-    concurrency_limit: Optional[conint(ge=0)] = Field(
+    concurrency_limit: Optional[NonNegativeInteger] = Field(
         default=None, description="A concurrency limit for the work pool."
     )
 

prefect/client/schemas/objects.py

@@ -19,11 +19,12 @@ from prefect._internal.compatibility.deprecated import (
     DeprecatedInfraOverridesField,
 )
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
+from prefect.types import NonNegativeInteger, PositiveInteger
 
 if HAS_PYDANTIC_V2:
-    from pydantic.v1 import Field, HttpUrl, conint, root_validator, validator
+    from pydantic.v1 import Field, HttpUrl, root_validator, validator
 else:
-    from pydantic import Field, HttpUrl, conint, root_validator, validator
+    from pydantic import Field, HttpUrl, root_validator, validator
 
 from typing_extensions import Literal
 
@@ -1188,10 +1189,10 @@ class WorkQueue(ObjectBaseModel):
     is_paused: bool = Field(
         default=False, description="Whether or not the work queue is paused."
     )
-    concurrency_limit: Optional[conint(ge=0)] = Field(
+    concurrency_limit: Optional[NonNegativeInteger] = Field(
         default=None, description="An optional concurrency limit for the work queue."
     )
-    priority: conint(ge=1) = Field(
+    priority: PositiveInteger = Field(
         default=1,
         description=(
             "The queue's priority. Lower values are higher priority (1 is the highest)."
@@ -1351,7 +1352,7 @@ class WorkPool(ObjectBaseModel):
         default=False,
         description="Pausing the work pool stops the delivery of all work.",
     )
-    concurrency_limit: Optional[conint(ge=0)] = Field(
+    concurrency_limit: Optional[NonNegativeInteger] = Field(
         default=None, description="A concurrency limit for the work pool."
     )
     status: Optional[WorkPoolStatus] = Field(

prefect/client/schemas/schedules.py

@@ -15,11 +15,11 @@ from prefect._internal.schemas.fields import DateTimeTZ
 from prefect._internal.schemas.validators import (
     default_anchor_date,
     default_timezone,
-    interval_schedule_must_be_positive,
     validate_cron_string,
     validate_rrule_string,
     validate_rrule_timezone,
 )
+from prefect.types import PositiveDuration
 
 if HAS_PYDANTIC_V2:
     from pydantic.v1 import Field, validator
@@ -64,14 +64,10 @@ class IntervalSchedule(PrefectBaseModel):
         extra = "forbid"
         exclude_none = True
 
-    interval: datetime.timedelta
+    interval: PositiveDuration
     anchor_date: DateTimeTZ = None
     timezone: Optional[str] = Field(default=None, examples=["America/New_York"])
 
-    @validator("interval")
-    def validate_interval_schedule(cls, v):
-        return interval_schedule_must_be_positive(v)
-
     @validator("anchor_date", always=True)
     def validate_anchor_date(cls, v):
         return default_anchor_date(v)

prefect/deployments/__init__.py

@@ -1,9 +1,7 @@
 import prefect.deployments.base
 import prefect.deployments.steps
 from prefect.deployments.base import (
-    find_prefect_directory,
     initialize_project,
-    register_flow,
 )
 
 from prefect.deployments.deployments import (

prefect/deployments/base.py

@@ -1,5 +1,5 @@
 """
-Core primitives for managing Prefect projects.  Projects provide a minimally opinionated
+Core primitives for managing Prefect deployments via `prefect deploy`, providing a minimally opinionated
 build system for managing flows and deployments.
 
 To get started, follow along with [the deloyments tutorial](/tutorials/deployments/).
@@ -7,7 +7,6 @@ To get started, follow along with [the deloyments tutorial](/tutorials/deploymen
 
 import ast
 import asyncio
-import json
 import math
 import os
 import subprocess
@@ -22,50 +21,13 @@ from ruamel.yaml import YAML
 
 from prefect.client.schemas.objects import MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import IntervalSchedule
-from prefect.flows import load_flow_from_entrypoint
 from prefect.logging import get_logger
 from prefect.settings import PREFECT_DEBUG_MODE
-from prefect.utilities.asyncutils import LazySemaphore, run_sync_in_worker_thread
+from prefect.utilities.asyncutils import LazySemaphore
 from prefect.utilities.filesystem import create_default_ignore_file, get_open_file_limit
 from prefect.utilities.templating import apply_values
 
 
-def find_prefect_directory(path: Path = None) -> Optional[Path]:
-    """
-    Given a path, recurses upward looking for .prefect/ directories.
-
-    Once found, returns absolute path to the ./prefect directory, which is assumed to reside within the
-    root for the current project.
-
-    If one is never found, `None` is returned.
-    """
-    path = Path(path or ".").resolve()
-    parent = path.parent.resolve()
-    while path != parent:
-        prefect_dir = path.joinpath(".prefect")
-        if prefect_dir.is_dir():
-            return prefect_dir
-
-        path = parent.resolve()
-        parent = path.parent.resolve()
-
-
-def set_prefect_hidden_dir(path: str = None) -> bool:
-    """
-    Creates default `.prefect/` directory if one does not already exist.
-    Returns boolean specifying whether or not a directory was created.
-
-    If a path is provided, the directory will be created in that location.
-    """
-    path = Path(path or ".") / ".prefect"
-
-    # use exists so that we dont accidentally overwrite a file
-    if path.exists():
-        return False
-    path.mkdir(mode=0o0700)
-    return True
-
-
 def create_default_prefect_yaml(
     path: str, name: str = None, contents: Optional[Dict[str, Any]] = None
 ) -> bool:
@@ -270,114 +232,10 @@ def initialize_project(
         files.append(".prefectignore")
     if create_default_prefect_yaml(".", name=project_name, contents=configuration):
         files.append("prefect.yaml")
-    if set_prefect_hidden_dir():
-        files.append(".prefect/")
 
     return files
 
 
-async def register_flow(entrypoint: str, force: bool = False):
-    """
-    Register a flow with this project from an entrypoint.
-
-    Args:
-        entrypoint (str): the entrypoint to the flow to register
-        force (bool, optional): whether or not to overwrite an existing flow with the same name
-
-    Raises:
-        ValueError: if `force` is `False` and registration would overwrite an existing flow
-    """
-    try:
-        fpath, obj_name = entrypoint.rsplit(":", 1)
-    except ValueError as exc:
-        if str(exc) == "not enough values to unpack (expected 2, got 1)":
-            missing_flow_name_msg = (
-                "Your flow entrypoint must include the name of the function that is"
-                f" the entrypoint to your flow.\nTry {entrypoint}:<flow_name> as your"
-                f" entrypoint. If you meant to specify '{entrypoint}' as the deployment"
-                f" name, try `prefect deploy -n {entrypoint}`."
-            )
-            raise ValueError(missing_flow_name_msg)
-        else:
-            raise exc
-
-    flow = await run_sync_in_worker_thread(load_flow_from_entrypoint, entrypoint)
-
-    fpath = Path(fpath).absolute()
-    prefect_dir = find_prefect_directory()
-    if not prefect_dir:
-        raise FileNotFoundError(
-            "No .prefect directory could be found - run `prefect project"
-            " init` to create one."
-        )
-
-    entrypoint = f"{fpath.relative_to(prefect_dir.parent)!s}:{obj_name}"
-
-    flows_file = prefect_dir / "flows.json"
-    if flows_file.exists():
-        with flows_file.open(mode="r") as f:
-            flows = json.load(f)
-    else:
-        flows = {}
-
-    ## quality control
-    if flow.name in flows and flows[flow.name] != entrypoint:
-        if not force:
-            raise ValueError(
-                f"Conflicting entry found for flow with name {flow.name!r}.\nExisting"
-                f" entrypoint: {flows[flow.name]}\nAttempted entrypoint:"
-                f" {entrypoint}\n\nYou can try removing the existing entry for"
-                f" {flow.name!r} from your [yellow]~/.prefect/flows.json[/yellow]."
-            )
-
-    flows[flow.name] = entrypoint
-
-    with flows_file.open(mode="w") as f:
-        json.dump(flows, f, sort_keys=True, indent=2)
-
-    return flow
-
-
-def _copy_deployments_into_prefect_file():
-    """
-    Copy deployments from the `deloyment.yaml` file into the `prefect.yaml` file.
-
-    Used to migrate users from the old `prefect.yaml` + `deployment.yaml` structure
-    to a single `prefect.yaml` file.
-    """
-    prefect_file = Path("prefect.yaml")
-    deployment_file = Path("deployment.yaml")
-    if not deployment_file.exists() or not prefect_file.exists():
-        raise FileNotFoundError(
-            "Could not find `prefect.yaml` or `deployment.yaml` files."
-        )
-
-    with deployment_file.open(mode="r") as f:
-        raw_deployment_file_contents = f.read()
-        parsed_deployment_file_contents = yaml.safe_load(raw_deployment_file_contents)
-
-    deployments = parsed_deployment_file_contents.get("deployments")
-
-    with prefect_file.open(mode="a") as f:
-        # If deployment.yaml is empty, write an empty deployments list to prefect.yaml.
-        if not parsed_deployment_file_contents:
-            f.write("\n")
-            f.write(yaml.dump({"deployments": []}, sort_keys=False))
-        # If there is no 'deployments' key in deployment.yaml, assume that the
-        # entire file is a single deployment.
-        elif not deployments:
-            f.write("\n")
-            f.write(
-                yaml.dump(
-                    {"deployments": [parsed_deployment_file_contents]}, sort_keys=False
-                )
-            )
-        # Write all of deployment.yaml to prefect.yaml.
-        else:
-            f.write("\n")
-            f.write(raw_deployment_file_contents)
-
-
 def _format_deployment_for_saving_to_prefect_file(
     deployment: Dict,
 ) -> Dict:

prefect/deployments/deployments.py

@@ -41,7 +41,7 @@ else:
 
 from prefect.blocks.core import Block
 from prefect.blocks.fields import SecretDict
-from prefect.client.orchestration import PrefectClient, ServerType, get_client
+from prefect.client.orchestration import PrefectClient, get_client
 from prefect.client.schemas.objects import (
     FlowRun,
     MinimalDeploymentSchedule,
@@ -901,7 +901,7 @@ class Deployment(DeprecatedInfraOverridesField, BaseModel):
                 enforce_parameter_schema=self.enforce_parameter_schema,
             )
 
-            if client.server_type == ServerType.CLOUD:
+            if client.server_type.supports_automations():
                 # The triggers defined in the deployment spec are, essentially,
                 # anonymous and attempting truly sync them with cloud is not
                 # feasible. Instead, we remove all automations that are owned

prefect/deployments/runner.py

@@ -62,7 +62,7 @@ if HAS_PYDANTIC_V2:
 else:
     from pydantic import BaseModel, Field, PrivateAttr, root_validator, validator
 
-from prefect.client.orchestration import ServerType, get_client
+from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import (
     SCHEDULE_TYPES,
@@ -325,7 +325,7 @@ class RunnerDeployment(BaseModel):
                     f"Error while applying deployment: {str(exc)}"
                 ) from exc
 
-            if client.server_type == ServerType.CLOUD:
+            if client.server_type.supports_automations():
                 # The triggers defined in the deployment spec are, essentially,
                 # anonymous and attempting truly sync them with cloud is not
                 # feasible. Instead, we remove all automations that are owned

prefect/deployments/steps/core.py

@@ -1,11 +1,11 @@
 """
-Core primitives for running Prefect project steps.
+Core primitives for running Prefect deployment steps.
 
-Project steps are YAML representations of Python functions along with their inputs.
+Deployment steps are YAML representations of Python functions along with their inputs.
 
 Whenever a step is run, the following actions are taken:
 
-- The step's inputs and block / variable references are resolved (see [the projects concepts documentation](/concepts/projects/#templating-options) for more details)
+- The step's inputs and block / variable references are resolved (see [the `prefect deploy` documentation](/guides/prefect-deploy/#templating-options) for more details)
 - The step's function is imported; if it cannot be found, the `requires` keyword is used to install the necessary packages
 - The step's function is called with the resolved inputs
 - The step's output is returned and used to resolve inputs for subsequent steps

prefect/deprecated/packaging/serializers.py

@@ -55,20 +55,21 @@ class PickleSerializer(Serializer):
 
     picklelib: str = "cloudpickle"
     picklelib_version: str = None
+
     pickle_modules: List[str] = pydantic.Field(default_factory=list)
 
     @pydantic.validator("picklelib")
     def check_picklelib(cls, value):
         return validate_picklelib(value)
 
-    @pydantic.root_validator
-    def check_picklelib_version(cls, values):
-        return validate_picklelib_version(values)
-
     @pydantic.root_validator
     def check_picklelib_and_modules(cls, values):
         return validate_picklelib_and_modules(values)
 
+    @pydantic.root_validator
+    def check_picklelib_version(cls, values):
+        return validate_picklelib_version(values)
+
     def dumps(self, obj: Any) -> bytes:
         pickler = from_qualified_name(self.picklelib)
 

prefect/events/__init__.py

@@ -2,7 +2,9 @@ from .schemas.events import Event, ReceivedEvent
 from .schemas.events import Resource, RelatedResource, ResourceSpecification
 from .schemas.automations import (
     Automation,
+    AutomationCore,
     Posture,
+    TriggerTypes,
     Trigger,
     ResourceTrigger,
     EventTrigger,
@@ -20,6 +22,27 @@ from .schemas.deployment_triggers import (
     DeploymentCompoundTrigger,
     DeploymentSequenceTrigger,
 )
+from .actions import (
+    ActionTypes,
+    Action,
+    DoNothing,
+    RunDeployment,
+    PauseDeployment,
+    ResumeDeployment,
+    ChangeFlowRunState,
+    CancelFlowRun,
+    SuspendFlowRun,
+    CallWebhook,
+    SendNotification,
+    PauseWorkPool,
+    ResumeWorkPool,
+    PauseWorkQueue,
+    ResumeWorkQueue,
+    PauseAutomation,
+    ResumeAutomation,
+    DeclareIncident,
+)
+from .clients import get_events_client, get_events_subscriber
 from .utilities import emit_event
 
 __all__ = [
@@ -29,7 +52,9 @@ __all__ = [
     "RelatedResource",
     "ResourceSpecification",
     "Automation",
+    "AutomationCore",
     "Posture",
+    "TriggerTypes",
     "Trigger",
     "ResourceTrigger",
     "EventTrigger",
@@ -44,5 +69,25 @@ __all__ = [
     "DeploymentMetricTrigger",
     "DeploymentCompoundTrigger",
     "DeploymentSequenceTrigger",
+    "ActionTypes",
+    "Action",
+    "DoNothing",
+    "RunDeployment",
+    "PauseDeployment",
+    "ResumeDeployment",
+    "ChangeFlowRunState",
+    "CancelFlowRun",
+    "SuspendFlowRun",
+    "CallWebhook",
+    "SendNotification",
+    "PauseWorkPool",
+    "ResumeWorkPool",
+    "PauseWorkQueue",
+    "ResumeWorkQueue",
+    "PauseAutomation",
+    "ResumeAutomation",
+    "DeclareIncident",
     "emit_event",
+    "get_events_client",
+    "get_events_subscriber",
 ]