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

prefect/events/schemas/automations.py

@@ -1,4 +1,5 @@
 import abc
+import textwrap
 from datetime import timedelta
 from enum import Enum
 from typing import (
@@ -45,6 +46,10 @@ class Trigger(PrefectBaseModel, abc.ABC, extra="ignore"):
 
     type: str
 
+    @abc.abstractmethod
+    def describe_for_cli(self, indent: int = 0) -> str:
+        """Return a human-readable description of this trigger for the CLI"""
+
 
 class ResourceTrigger(Trigger, abc.ABC):
     """
@@ -101,7 +106,7 @@ class EventTrigger(ResourceTrigger):
         ),
     )
     posture: Literal[Posture.Reactive, Posture.Proactive] = Field(  # type: ignore[valid-type]
-        ...,
+        Posture.Reactive,
         description=(
             "The posture of this trigger, either Reactive or Proactive.  Reactive "
             "triggers respond to the _presence_ of the expected events, while "
@@ -148,6 +153,28 @@ class EventTrigger(ResourceTrigger):
 
         return values
 
+    def describe_for_cli(self, indent: int = 0) -> str:
+        """Return a human-readable description of this trigger for the CLI"""
+        if self.posture == Posture.Reactive:
+            return textwrap.indent(
+                "\n".join(
+                    [
+                        f"Reactive: expecting {self.threshold} of {self.expect}",
+                    ],
+                ),
+                prefix="  " * indent,
+            )
+        else:
+            return textwrap.indent(
+                "\n".join(
+                    [
+                        f"Proactive: expecting {self.threshold} {self.expect} event "
+                        f"within {self.within}",
+                    ],
+                ),
+                prefix="  " * indent,
+            )
+
 
 class MetricTriggerOperator(Enum):
     LT = "<"
@@ -224,6 +251,18 @@ class MetricTrigger(ResourceTrigger):
         description="The metric query to evaluate for this trigger. ",
     )
 
+    def describe_for_cli(self, indent: int = 0) -> str:
+        """Return a human-readable description of this trigger for the CLI"""
+        m = self.metric
+        return textwrap.indent(
+            "\n".join(
+                [
+                    f"Metric: {m.name.value} {m.operator.value} {m.threshold} for {m.range}",
+                ]
+            ),
+            prefix="  " * indent,
+        )
+
 
 class CompositeTrigger(Trigger, abc.ABC):
     """
@@ -256,6 +295,23 @@ class CompoundTrigger(CompositeTrigger):
 
         return values
 
+    def describe_for_cli(self, indent: int = 0) -> str:
+        """Return a human-readable description of this trigger for the CLI"""
+        return textwrap.indent(
+            "\n".join(
+                [
+                    f"{str(self.require).capitalize()} of:",
+                    "\n".join(
+                        [
+                            trigger.describe_for_cli(indent=indent + 1)
+                            for trigger in self.triggers
+                        ]
+                    ),
+                ]
+            ),
+            prefix="  " * indent,
+        )
+
 
 class SequenceTrigger(CompositeTrigger):
     """A composite trigger that requires some number of triggers to have fired
@@ -263,6 +319,23 @@ class SequenceTrigger(CompositeTrigger):
 
     type: Literal["sequence"] = "sequence"
 
+    def describe_for_cli(self, indent: int = 0) -> str:
+        """Return a human-readable description of this trigger for the CLI"""
+        return textwrap.indent(
+            "\n".join(
+                [
+                    "In this order:",
+                    "\n".join(
+                        [
+                            trigger.describe_for_cli(indent=indent + 1)
+                            for trigger in self.triggers
+                        ]
+                    ),
+                ]
+            ),
+            prefix="  " * indent,
+        )
+
 
 TriggerTypes: TypeAlias = Union[
     EventTrigger, MetricTrigger, CompoundTrigger, SequenceTrigger
@@ -273,7 +346,7 @@ CompoundTrigger.update_forward_refs()
 SequenceTrigger.update_forward_refs()
 
 
-class Automation(PrefectBaseModel, extra="ignore"):
+class AutomationCore(PrefectBaseModel, extra="ignore"):
     """Defines an action a user wants to take when a certain number of events
     do or don't happen to the matching resources"""
 
@@ -310,5 +383,5 @@ class Automation(PrefectBaseModel, extra="ignore"):
     )
 
 
-class ExistingAutomation(Automation):
+class Automation(AutomationCore):
     id: UUID = Field(..., description="The ID of this automation")

prefect/events/schemas/deployment_triggers.py

@@ -11,7 +11,6 @@ create them from YAML.
 
 import abc
 import textwrap
-import warnings
 from datetime import timedelta
 from typing import (
     Any,
@@ -37,20 +36,11 @@ else:
     from pydantic import Field, PrivateAttr, root_validator, validator
     from pydantic.fields import ModelField
 
-from prefect._internal.compatibility.experimental import (
-    EXPERIMENTAL_WARNING,
-    PREFECT_EXPERIMENTAL_WARN,
-    ExperimentalFeature,
-    experiment_enabled,
-)
 from prefect._internal.schemas.bases import PrefectBaseModel
 from prefect.events.actions import RunDeployment
-from prefect.settings import (
-    PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES,
-)
 
 from .automations import (
-    Automation,
+    AutomationCore,
     CompoundTrigger,
     EventTrigger,
     MetricTrigger,
@@ -106,26 +96,6 @@ class BaseDeploymentTrigger(PrefectBaseModel, abc.ABC, extra="ignore"):
         return f"prefect.deployment.{self._deployment_id}"
 
     def actions(self) -> List[RunDeployment]:
-        if self.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,
-                )
-        if not experiment_enabled("flow_run_infra_overrides"):
-            # nullify job_variables if the flag is disabled
-            self.job_variables = None
-
         assert self._deployment_id
         return [
             RunDeployment(
@@ -135,11 +105,11 @@ class BaseDeploymentTrigger(PrefectBaseModel, abc.ABC, extra="ignore"):
             )
         ]
 
-    def as_automation(self) -> Automation:
+    def as_automation(self) -> AutomationCore:
         if not self.name:
             raise ValueError("name is required")
 
-        return Automation(
+        return AutomationCore(
             name=self.name,
             description=self.description,
             enabled=self.enabled,
@@ -176,6 +146,8 @@ class DeploymentEventTrigger(DeploymentResourceTrigger):
     period of time.
     """
 
+    trigger_type = EventTrigger
+
     type: Literal["event"] = "event"
 
     after: Set[str] = Field(
@@ -256,7 +228,7 @@ class DeploymentEventTrigger(DeploymentResourceTrigger):
         return values
 
     def as_trigger(self) -> Trigger:
-        return EventTrigger(
+        return self.trigger_type(
             match=self.match,
             match_related=self.match_related,
             after=self.after,
@@ -273,6 +245,8 @@ class DeploymentMetricTrigger(DeploymentResourceTrigger):
     A trigger that fires based on the results of a metric query.
     """
 
+    trigger_type = MetricTrigger
+
     type: Literal["metric"] = "metric"
 
     posture: Literal[Posture.Metric] = Field(  # type: ignore[valid-type]
@@ -286,7 +260,7 @@ class DeploymentMetricTrigger(DeploymentResourceTrigger):
     )
 
     def as_trigger(self) -> Trigger:
-        return MetricTrigger(
+        return self.trigger_type(
             match=self.match,
             match_related=self.match_related,
             posture=self.posture,
@@ -309,6 +283,8 @@ class DeploymentCompoundTrigger(DeploymentCompositeTrigger):
     """A composite trigger that requires some number of triggers to have
     fired within the given time period"""
 
+    trigger_type = CompoundTrigger
+
     type: Literal["compound"] = "compound"
     require: Union[int, Literal["any", "all"]]
 
@@ -327,7 +303,7 @@ class DeploymentCompoundTrigger(DeploymentCompositeTrigger):
         return values
 
     def as_trigger(self) -> Trigger:
-        return CompoundTrigger(
+        return self.trigger_type(
             require=self.require,
             triggers=self.triggers,
             within=self.within,
@@ -339,10 +315,12 @@ class DeploymentSequenceTrigger(DeploymentCompositeTrigger):
     """A composite trigger that requires some number of triggers to have fired
     within the given time period in a specific order"""
 
+    trigger_type = SequenceTrigger
+
     type: Literal["sequence"] = "sequence"
 
     def as_trigger(self) -> Trigger:
-        return SequenceTrigger(
+        return self.trigger_type(
             triggers=self.triggers,
             within=self.within,
             job_variables=self.job_variables,
@@ -480,7 +458,7 @@ class DeploymentTrigger(PrefectBaseModel):
         ),
     )
 
-    def as_automation(self) -> Automation:
+    def as_automation(self) -> AutomationCore:
         assert self.name
 
         if self.posture == Posture.Metric:
@@ -503,7 +481,7 @@ class DeploymentTrigger(PrefectBaseModel):
                 within=self.within,
             )
 
-        return Automation(
+        return AutomationCore(
             name=self.name,
             description=self.description,
             enabled=self.enabled,
@@ -519,26 +497,6 @@ class DeploymentTrigger(PrefectBaseModel):
         return f"prefect.deployment.{self._deployment_id}"
 
     def actions(self) -> List[RunDeployment]:
-        if self.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,
-                )
-        if not experiment_enabled("flow_run_infra_overrides"):
-            # nullify job_variables if the flag is disabled
-            self.job_variables = None
-
         assert self._deployment_id
         return [
             RunDeployment(

prefect/events/utilities.py

@@ -9,6 +9,7 @@ from prefect._internal.schemas.fields import DateTimeTZ
 from .clients import (
     AssertingEventsClient,
     PrefectCloudEventsClient,
+    PrefectEphemeralEventsClient,
     PrefectEventsClient,
 )
 from .schemas.events import Event, RelatedResource
@@ -53,6 +54,7 @@ def emit_event(
         AssertingEventsClient,
         PrefectCloudEventsClient,
         PrefectEventsClient,
+        PrefectEphemeralEventsClient,
     ]
     worker_instance = EventsWorker.instance()
 

prefect/events/worker.py

@@ -17,6 +17,7 @@ from .clients import (
     EventsClient,
     NullEventsClient,
     PrefectCloudEventsClient,
+    PrefectEphemeralEventsClient,
     PrefectEventsClient,
 )
 from .related import related_resources_from_run_context
@@ -24,7 +25,11 @@ from .schemas.events import Event
 
 
 def should_emit_events() -> bool:
-    return emit_events_to_cloud() or should_emit_events_to_running_server()
+    return (
+        emit_events_to_cloud()
+        or should_emit_events_to_running_server()
+        or should_emit_events_to_ephemeral_server()
+    )
 
 
 def emit_events_to_cloud() -> bool:
@@ -39,6 +44,10 @@ def should_emit_events_to_running_server() -> bool:
     return isinstance(api_url, str) and PREFECT_EXPERIMENTAL_EVENTS
 
 
+def should_emit_events_to_ephemeral_server() -> bool:
+    return PREFECT_API_KEY.value() is None and PREFECT_EXPERIMENTAL_EVENTS
+
+
 class EventsWorker(QueueService[Event]):
     def __init__(
         self, client_type: Type[EventsClient], client_options: Tuple[Tuple[str, Any]]
@@ -85,7 +94,8 @@ class EventsWorker(QueueService[Event]):
                 }
             elif should_emit_events_to_running_server():
                 client_type = PrefectEventsClient
-
+            elif should_emit_events_to_ephemeral_server():
+                client_type = PrefectEphemeralEventsClient
             else:
                 client_type = NullEventsClient
 

prefect/exceptions.py

@@ -178,7 +178,7 @@ class ParameterTypeError(PrefectException):
 
     @classmethod
     def from_validation_error(cls, exc: ValidationError) -> Self:
-        bad_params = [f'{err["loc"][0]}: {err["msg"]}' for err in exc.errors()]
+        bad_params = [f'{".".join(err["loc"])}: {err["msg"]}' for err in exc.errors()]
         msg = "Flow run received invalid parameters:\n - " + "\n - ".join(bad_params)
         return cls(msg)
 

prefect/logging/__init__.py

@@ -1,3 +1,3 @@
-from .loggers import disable_run_logger, get_logger, get_run_logger
+from .loggers import disable_run_logger, get_logger, get_run_logger, LogEavesdropper
 
-__all__ = ["get_logger", "get_run_logger"]
+__all__ = ["get_logger", "get_run_logger", "LogEavesdropper"]

prefect/logging/loggers.py

@@ -5,7 +5,10 @@ import warnings
 from builtins import print
 from contextlib import contextmanager
 from functools import lru_cache
-from typing import TYPE_CHECKING, Dict, Optional, Union
+from logging import LogRecord
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+from typing_extensions import Self
 
 import prefect
 from prefect.exceptions import MissingContextError
@@ -295,3 +298,63 @@ def patch_print():
         yield
     finally:
         builtins.print = original
+
+
+class LogEavesdropper(logging.Handler):
+    """A context manager that collects logs for the duration of the context
+
+    Example:
+
+        ```python
+        import logging
+        from prefect.logging import LogEavesdropper
+
+        with LogEavesdropper("my_logger") as eavesdropper:
+            logging.getLogger("my_logger").info("Hello, world!")
+            logging.getLogger("my_logger.child_module").info("Another one!")
+
+        print(eavesdropper.text())
+
+        # Outputs: "Hello, world!\nAnother one!"
+    """
+
+    _target_logger: logging.Logger
+    _lines: List[str]
+
+    def __init__(self, eavesdrop_on: str, level: int = logging.NOTSET):
+        """
+        Args:
+            eavesdrop_on (str): the name of the logger to eavesdrop on
+            level (int): the minimum log level to eavesdrop on; if omitted, all levels
+                are captured
+        """
+
+        super().__init__(level=level)
+        self.eavesdrop_on = eavesdrop_on
+        self._target_logger = None
+
+        # It's important that we use a very minimalistic formatter for use cases where
+        # we may present these logs back to the user.  We shouldn't leak filenames,
+        # versions, or other environmental information.
+        self.formatter = logging.Formatter("[%(levelname)s]: %(message)s")
+
+    def __enter__(self) -> Self:
+        self._target_logger = logging.getLogger(self.eavesdrop_on)
+        self._original_level = self._target_logger.level
+        self._target_logger.level = self.level
+        self._target_logger.addHandler(self)
+        self._lines = []
+        return self
+
+    def __exit__(self, *_):
+        if self._target_logger:
+            self._target_logger.removeHandler(self)
+            self._target_logger.level = self._original_level
+
+    def emit(self, record: LogRecord) -> None:
+        """The logging.Handler implementation, not intended to be called directly."""
+        self._lines.append(self.format(record))
+
+    def text(self) -> str:
+        """Return the collected logs as a single newline-delimited string"""
+        return "\n".join(self._lines)

prefect/results.py

@@ -20,13 +20,6 @@ from typing_extensions import Self
 
 import prefect
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-
-else:
-    import pydantic
-
 from prefect.blocks.core import Block
 from prefect.client.utilities import inject_client
 from prefect.exceptions import MissingResult
@@ -46,7 +39,14 @@ from prefect.settings import (
 )
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import sync_compatible
-from prefect.utilities.pydantic import add_type_dispatch
+from prefect.utilities.pydantic import get_dispatch_key, lookup_type, register_base_type
+
+if HAS_PYDANTIC_V2:
+    import pydantic.v1 as pydantic
+
+else:
+    import pydantic
+
 
 if TYPE_CHECKING:
     from prefect import Flow, Task
@@ -480,12 +480,27 @@ class ResultFactory(pydantic.BaseModel):
         return self.serializer.loads(blob.data)
 
 
-@add_type_dispatch
+@register_base_type
 class BaseResult(pydantic.BaseModel, abc.ABC, Generic[R]):
     type: str
     artifact_type: Optional[str]
     artifact_description: Optional[str]
 
+    def __init__(self, **data: Any) -> None:
+        type_string = get_dispatch_key(self) if type(self) != BaseResult else "__base__"
+        data.setdefault("type", type_string)
+        super().__init__(**data)
+
+    def __new__(cls: Type[Self], **kwargs) -> Self:
+        if "type" in kwargs:
+            try:
+                subcls = lookup_type(cls, dispatch_key=kwargs["type"])
+            except KeyError as exc:
+                raise pydantic.ValidationError(errors=[exc], model=cls)
+            return super().__new__(subcls)
+        else:
+            return super().__new__(cls)
+
     _cache: Any = pydantic.PrivateAttr(NotSet)
 
     def _cache_object(self, obj: Any) -> None:
@@ -511,6 +526,10 @@ class BaseResult(pydantic.BaseModel, abc.ABC, Generic[R]):
     class Config:
         extra = "forbid"
 
+    @classmethod
+    def __dispatch_key__(cls, **kwargs):
+        return cls.__fields__.get("type").get_default()
+
 
 class UnpersistedResult(BaseResult):
     """
@@ -713,7 +732,7 @@ class PersistedResultBlob(pydantic.BaseModel):
 
 class UnknownResult(BaseResult):
     """
-    Result type for unknown results. Typipcally used to represent the result
+    Result type for unknown results. Typically used to represent the result
     of tasks that were forced from a failure state into a completed state.
 
     The value for this result is always None and is not persisted to external