prefect-client 2.17.1__py3-none-any.whl → 2.18.1__py3-none-any.whl

prefect/events/worker.py

@@ -1,6 +1,7 @@
 from contextlib import asynccontextmanager
 from contextvars import Context, copy_context
-from typing import Any, Optional, Tuple, Type
+from typing import Any, Dict, Optional, Tuple, Type
+from uuid import UUID
 
 from typing_extensions import Self
 
@@ -17,6 +18,7 @@ from .clients import (
     EventsClient,
     NullEventsClient,
     PrefectCloudEventsClient,
+    PrefectEphemeralEventsClient,
     PrefectEventsClient,
 )
 from .related import related_resources_from_run_context
@@ -24,7 +26,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:
@@ -36,7 +42,11 @@ def emit_events_to_cloud() -> bool:
 
 def should_emit_events_to_running_server() -> bool:
     api_url = PREFECT_API_URL.value()
-    return isinstance(api_url, str) and PREFECT_EXPERIMENTAL_EVENTS
+    return isinstance(api_url, str) and PREFECT_EXPERIMENTAL_EVENTS.value()
+
+
+def should_emit_events_to_ephemeral_server() -> bool:
+    return PREFECT_API_KEY.value() is None and PREFECT_EXPERIMENTAL_EVENTS.value()
 
 
 class EventsWorker(QueueService[Event]):
@@ -47,6 +57,7 @@ class EventsWorker(QueueService[Event]):
         self.client_type = client_type
         self.client_options = client_options
         self._client: EventsClient
+        self._context_cache: Dict[UUID, Context] = {}
 
     @asynccontextmanager
     async def _lifespan(self):
@@ -55,11 +66,12 @@ class EventsWorker(QueueService[Event]):
         async with self._client:
             yield
 
-    def _prepare_item(self, event: Event) -> Tuple[Event, Context]:
-        return (event, copy_context())
+    def _prepare_item(self, event: Event) -> Event:
+        self._context_cache[event.id] = copy_context()
+        return event
 
-    async def _handle(self, event_and_context: Tuple[Event, Context]):
-        event, context = event_and_context
+    async def _handle(self, event: Event):
+        context = self._context_cache.pop(event.id)
         with temporary_context(context=context):
             await self.attach_related_resources_from_context(event)
 
@@ -85,7 +97,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/flows.py

@@ -34,20 +34,10 @@ from typing import (
 )
 from uuid import UUID
 
-from prefect._vendor.fastapi.encoders import jsonable_encoder
-from typing_extensions import Self
+from rich.console import Console
+from typing_extensions import Literal, ParamSpec, Self
 
-from prefect._internal.compatibility.deprecated import deprecated_parameter
-from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect.client.orchestration import get_client
-from prefect.deployments.runner import DeploymentImage, EntrypointType, deploy
-from prefect.filesystems import ReadableDeploymentStorage
-from prefect.runner.storage import (
-    BlockStorageAdapter,
-    RunnerStorage,
-    create_storage_from_url,
-)
 
 if HAS_PYDANTIC_V2:
     import pydantic.v1 as pydantic
@@ -67,26 +57,36 @@ else:
 
     V2ValidationError = None
 
-from rich.console import Console
-from typing_extensions import Literal, ParamSpec
+from prefect._vendor.fastapi.encoders import jsonable_encoder
 
+from prefect._internal.compatibility.deprecated import deprecated_parameter
+from prefect._internal.concurrency.api import create_call, from_async
 from prefect._internal.schemas.validators import raise_on_name_with_banned_characters
+from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import Flow as FlowSchema
 from prefect.client.schemas.objects import FlowRun, MinimalDeploymentSchedule
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.context import PrefectObjectRegistry, registry_from_script
-from prefect.events import DeploymentTriggerTypes
+from prefect.deployments.runner import DeploymentImage, EntrypointType, deploy
+from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     MissingFlowError,
     ObjectNotFound,
     ParameterTypeError,
     UnspecifiedFlowError,
 )
+from prefect.filesystems import ReadableDeploymentStorage
 from prefect.futures import PrefectFuture
 from prefect.logging import get_logger
 from prefect.results import ResultSerializer, ResultStorage
+from prefect.runner.storage import (
+    BlockStorageAdapter,
+    RunnerStorage,
+    create_storage_from_url,
+)
 from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
+    PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE,
     PREFECT_FLOW_DEFAULT_RETRIES,
     PREFECT_FLOW_DEFAULT_RETRY_DELAY_SECONDS,
     PREFECT_UI_URL,
@@ -618,7 +618,7 @@ class Flow(Generic[P, R]):
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
@@ -748,7 +748,7 @@ class Flow(Generic[P, R]):
         schedules: Optional[List["FlexibleScheduleList"]] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
@@ -962,7 +962,7 @@ class Flow(Generic[P, R]):
         schedules: Optional[List[MinimalDeploymentSchedule]] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
@@ -1225,6 +1225,21 @@ class Flow(Generic[P, R]):
             # we can add support for exploring subflows for tasks in the future.
             return track_viz_task(self.isasync, self.name, parameters)
 
+        if PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE.value():
+            from prefect.new_flow_engine import run_flow
+            from prefect.utilities.asyncutils import run_sync
+
+            awaitable = run_flow(
+                flow=self,
+                parameters=parameters,
+                wait_for=wait_for,
+                return_type=return_type,
+            )
+            if self.isasync:
+                return awaitable
+            else:
+                return run_sync(awaitable)
+
         return enter_flow_run_engine_from_flow_call(
             self,
             parameters,

prefect/input/actions.py

@@ -5,7 +5,7 @@ import orjson
 import pydantic
 
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-from prefect.client.utilities import inject_client
+from prefect.client.utilities import client_injector
 from prefect.context import FlowRunContext
 from prefect.exceptions import PrefectHTTPStatusError
 from prefect.utilities.asyncutils import sync_compatible
@@ -52,13 +52,13 @@ async def create_flow_run_input_from_model(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def create_flow_run_input(
+    client: "PrefectClient",
     key: str,
     value: Any,
     flow_run_id: Optional[UUID] = None,
     sender: Optional[str] = None,
-    client: "PrefectClient" = None,
 ):
     """
     Create a new flow run input. The given `value` will be serialized to JSON
@@ -81,13 +81,13 @@ async def create_flow_run_input(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def filter_flow_run_input(
+    client: "PrefectClient",
     key_prefix: str,
     limit: int = 1,
     exclude_keys: Optional[Set[str]] = None,
     flow_run_id: Optional[UUID] = None,
-    client: "PrefectClient" = None,
 ):
     if exclude_keys is None:
         exclude_keys = set()
@@ -103,9 +103,9 @@ async def filter_flow_run_input(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def read_flow_run_input(
-    key: str, flow_run_id: Optional[UUID] = None, client: "PrefectClient" = None
+    client: "PrefectClient", key: str, flow_run_id: Optional[UUID] = None
 ) -> Any:
     """Read a flow run input.
 
@@ -126,9 +126,9 @@ async def read_flow_run_input(
 
 
 @sync_compatible
-@inject_client
+@client_injector
 async def delete_flow_run_input(
-    key: str, flow_run_id: Optional[UUID] = None, client: "PrefectClient" = None
+    client: "PrefectClient", key: str, flow_run_id: Optional[UUID] = None
 ):
     """Delete a flow run input.
 

prefect/input/run_input.py

@@ -58,7 +58,7 @@ async def receiver_flow():
 ```
 """
 
-
+from inspect import isclass
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -96,7 +96,7 @@ if HAS_PYDANTIC_V2:
     from prefect._internal.pydantic.v2_schema import create_v2_schema
 
 R = TypeVar("R", bound="RunInput")
-T = TypeVar("T")
+T = TypeVar("T", bound="object")
 
 Keyset = Dict[
     Union[Literal["description"], Literal["response"], Literal["schema"]], str
@@ -114,7 +114,8 @@ def keyset_from_paused_state(state: "State") -> Keyset:
     if not state.is_paused():
         raise RuntimeError(f"{state.type.value!r} is unsupported.")
 
-    base_key = f"{state.name.lower()}-{str(state.state_details.pause_key)}"
+    state_name = state.name or ""
+    base_key = f"{state_name.lower()}-{str(state.state_details.pause_key)}"
     return keyset_from_base_key(base_key)
 
 
@@ -234,7 +235,7 @@ class RunInput(pydantic.BaseModel):
                 a flow run that requires input
             - kwargs (Any): the initial data to populate the subclass
         """
-        fields = {}
+        fields: Dict[str, Any] = {}
         for key, value in kwargs.items():
             fields[key] = (type(value), value)
         model = pydantic.create_model(cls.__name__, **fields, __base__=cls)
@@ -340,31 +341,34 @@ class AutomaticRunInput(RunInput, Generic[T]):
     def subclass_from_type(cls, _type: Type[T]) -> Type["AutomaticRunInput[T]"]:
         """
         Create a new `AutomaticRunInput` subclass from the given type.
+
+        This method uses the type's name as a key prefix to identify related
+        flow run inputs. This helps in ensuring that values saved under a type
+        (like List[int]) are retrievable under the generic type name (like "list").
         """
-        fields = {"value": (_type, ...)}
-
-        # Sending a value to a flow run that relies on an AutomaticRunInput will
-        # produce a key prefix that includes the type name. For example, if the
-        # value is a list, the key will include "list" as the type. If the user
-        # then tries to receive the value with a type annotation like List[int],
-        # we need to find the key we saved with "list" as the type (not
-        # "List[int]"). Calling __name__.lower() on a type annotation like
-        # List[int] produces the string "list", which is what we need.
-        if hasattr(_type, "__name__"):
-            type_prefix = _type.__name__.lower()
-        elif hasattr(_type, "_name"):
-            # On Python 3.9 and earlier, type annotation values don't have a
-            # __name__ attribute, but they do have a _name.
-            type_prefix = _type._name.lower()
-        else:
-            # If we can't identify a type name that we can use as a key
-            # prefix that will match an input, we'll have to use
-            # "AutomaticRunInput" as the generic name. This will match all
-            # automatic inputs sent to the flow run, rather than a specific
-            # type.
-            type_prefix = ""
+        fields: Dict[str, Any] = {"value": (_type, ...)}
+
+        # Explanation for using getattr for type name extraction:
+        # - "__name__": This is the usual attribute for getting the name of
+        #   most types.
+        # - "_name": Used as a fallback, some type annotations in Python 3.9
+        #   and earlier might only have this attribute instead of __name__.
+        # - If neither is available, defaults to an empty string to prevent
+        #   errors, but typically we should find at least one valid name
+        #   attribute. This will match all automatic inputs sent to the flow
+        #   run, rather than a specific type.
+        #
+        # This approach ensures compatibility across Python versions and
+        # handles various edge cases in type annotations.
+
+        type_prefix: str = getattr(
+            _type, "__name__", getattr(_type, "_name", "")
+        ).lower()
+
         class_name = f"{type_prefix}AutomaticRunInput"
 
+        # Creating a new Pydantic model class dynamically with the name based
+        # on the type prefix.
         new_cls: Type["AutomaticRunInput"] = pydantic.create_model(
             class_name, **fields, __base__=AutomaticRunInput
         )
@@ -384,18 +388,19 @@ def run_input_subclass_from_type(
     """
     Create a new `RunInput` subclass from the given type.
     """
-    try:
+    if isclass(_type):
         if issubclass(_type, RunInput):
             return cast(Type[R], _type)
         elif issubclass(_type, pydantic.BaseModel):
             return cast(Type[R], RunInput.subclass_from_base_model_type(_type))
-    except TypeError:
-        pass
 
     # Could be something like a typing._GenericAlias or any other type that
     # isn't a `RunInput` subclass or `pydantic.BaseModel` subclass. Try passing
     # it to AutomaticRunInput to see if we can create a model from it.
-    return cast(Type[AutomaticRunInput[T]], AutomaticRunInput.subclass_from_type(_type))
+    return cast(
+        Type[AutomaticRunInput[T]],
+        AutomaticRunInput.subclass_from_type(cast(Type[T], _type)),
+    )
 
 
 class GetInputHandler(Generic[R]):
@@ -425,7 +430,7 @@ class GetInputHandler(Generic[R]):
 
     def __next__(self) -> R:
         try:
-            return self.next()
+            return cast(R, self.next())
         except TimeoutError:
             if self.raise_timeout_error:
                 raise
@@ -502,9 +507,11 @@ async def _send_input(
     key_prefix: Optional[str] = None,
 ):
     if isinstance(run_input, RunInput):
-        _run_input = run_input
+        _run_input: RunInput = run_input
     else:
-        input_cls = run_input_subclass_from_type(type(run_input))
+        input_cls: Type[AutomaticRunInput] = run_input_subclass_from_type(
+            type(run_input)
+        )
         _run_input = input_cls(value=run_input)
 
     if key_prefix is None:
@@ -533,8 +540,8 @@ async def send_input(
 
 
 @overload
-def receive_input(
-    input_type: Type[R],
+def receive_input(  # type: ignore[overload-overlap]
+    input_type: Union[Type[R], pydantic.BaseModel],
     timeout: Optional[float] = 3600,
     poll_interval: float = 10,
     raise_timeout_error: bool = False,
@@ -561,7 +568,7 @@ def receive_input(
 
 
 def receive_input(
-    input_type: Union[Type[R], Type[T]],
+    input_type: Union[Type[R], Type[T], pydantic.BaseModel],
     timeout: Optional[float] = 3600,
     poll_interval: float = 10,
     raise_timeout_error: bool = False,
@@ -570,7 +577,12 @@ def receive_input(
     flow_run_id: Optional[UUID] = None,
     with_metadata: bool = False,
 ) -> Union[GetAutomaticInputHandler[T], GetInputHandler[R]]:
-    input_cls = run_input_subclass_from_type(input_type)
+    # The typing in this module is a bit complex, and at this point `mypy`
+    # thinks that `run_input_subclass_from_type` accepts a `Type[Never]` but
+    # the signature is the same as here:
+    #   Union[Type[R], Type[T], pydantic.BaseModel],
+    # Seems like a possible mypy bug, so we'll ignore the type check here.
+    input_cls = run_input_subclass_from_type(input_type)  # type: ignore[arg-type]
 
     if issubclass(input_cls, AutomaticRunInput):
         return input_cls.receive(

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)