prefect-client 3.0.0rc8__py3-none-any.whl → 3.0.0rc10__py3-none-any.whl

prefect/_internal/compatibility/deprecated.py

@@ -16,6 +16,7 @@ import warnings
 from typing import Any, Callable, List, Optional, Type, TypeVar
 
 import pendulum
+import wrapt
 from pydantic import BaseModel
 
 from prefect.utilities.callables import get_call_parameters
@@ -272,3 +273,55 @@ def register_renamed_module(old_name: str, new_name: str, start_date: str):
     DEPRECATED_MODULE_ALIASES.append(
         AliasedModuleDefinition(old_name, new_name, callback)
     )
+
+
+class AsyncCompatProxy(wrapt.ObjectProxy):
+    """
+    A proxy object that allows for awaiting a method that is no longer async.
+
+    See https://wrapt.readthedocs.io/en/master/wrappers.html#object-proxy for more
+    """
+
+    def __init__(self, wrapped, class_name: str, method_name: str):
+        super().__init__(wrapped)
+        self._self_class_name = class_name
+        self._self_method_name = method_name
+        self._self_already_awaited = False
+
+    def __await__(self):
+        if not self._self_already_awaited:
+            warnings.warn(
+                (
+                    f"The {self._self_method_name!r} method on {self._self_class_name!r}"
+                    " is no longer async and awaiting it will raise an error after Dec 2024"
+                    " - please remove the `await` keyword."
+                ),
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            self._self_already_awaited = True
+        yield
+        return self.__wrapped__
+
+    def __repr__(self):
+        return repr(self.__wrapped__)
+
+    def __reduce_ex__(self, protocol):
+        return (
+            type(self),
+            (self.__wrapped__,),
+            {"_self_already_awaited": self._self_already_awaited},
+        )
+
+
+def deprecated_async_method(wrapped):
+    """Decorator that wraps a sync method to allow awaiting it even though it is no longer async."""
+
+    @wrapt.decorator
+    def wrapper(wrapped, instance, args, kwargs):
+        result = wrapped(*args, **kwargs)
+        return AsyncCompatProxy(
+            result, class_name=instance.__class__.__name__, method_name=wrapped.__name__
+        )
+
+    return wrapper(wrapped)

prefect/_internal/compatibility/migration.py

@@ -5,11 +5,41 @@ The `getattr_migration` function is used to handle imports for moved or removed
 It is used in the `__getattr__` attribute of modules that have moved or removed objects.
 
 Usage:
-```python
-from prefect._internal.compatibility.migration import getattr_migration
 
-__getattr__ = getattr_migration(__name__)
-```
+Moved objects:
+1. Add the old and new path to the `MOVED_IN_V3` dictionary, e.g. `MOVED_IN_V3 = {"old_path": "new_path"}`
+2. In the module where the object was moved from, add the following lines:
+    ```python
+    # at top
+    from prefect._internal.compatibility.migration import getattr_migration
+
+    # at bottom
+    __getattr__ = getattr_migration(__name__)
+    ```
+
+    Example at src/prefect/engine.py
+
+Removed objects:
+1. Add the old path and error message to the `REMOVED_IN_V3` dictionary, e.g. `REMOVED_IN_V3 = {"old_path": "error_message"}`
+2. In the module where the object was removed, add the following lines:
+    ```python
+    # at top
+    from prefect._internal.compatibility.migration import getattr_migration
+
+    # at bottom
+    __getattr__ = getattr_migration(__name__)
+
+    ```
+    If the entire old module was removed, add a stub for the module with the following lines:
+    ```python
+    # at top
+    from prefect._internal.compatibility.migration import getattr_migration
+    
+    # at bottom
+    __getattr__ = getattr_migration(__name__)
+    ```
+
+    Example at src/prefect/infrastructure/base.py
 """
 
 import sys
@@ -27,15 +57,27 @@ MOVED_IN_V3 = {
     "prefect.engine:resume_flow_run": "prefect.flow_runs:resume_flow_run",
     "prefect.engine:suspend_flow_run": "prefect.flow_runs:suspend_flow_run",
     "prefect.engine:_in_process_pause": "prefect.flow_runs:_in_process_pause",
+    "prefect.client:get_client": "prefect.client.orchestration:get_client",
 }
 
+upgrade_guide_msg = "Refer to the upgrade guide for more information: https://docs.prefect.io/latest/guides/upgrade-guide-agents-to-workers/."
+
 REMOVED_IN_V3 = {
-    "prefect.deployments.deployments:Deployment": "Use 'flow.serve()', `flow.deploy()`, or `prefect deploy` instead.",
-    "prefect.deployments:Deployment": "Use 'flow.serve()', `flow.deploy()`, or `prefect deploy` instead.",
-    "prefect.filesystems:GCS": "Use 'prefect_gcp' instead.",
-    "prefect.filesystems:Azure": "Use 'prefect_azure' instead.",
-    "prefect.filesystems:S3": "Use 'prefect_aws' instead.",
-    "prefect.engine:_out_of_process_pause": "Use 'prefect.flow_runs.pause_flow_run' instead.",
+    "prefect.client.schemas.objects:MinimalDeploymentSchedule": "Use `prefect.client.schemas.actions.DeploymentScheduleCreate` instead.",
+    "prefect.context:PrefectObjectRegistry": upgrade_guide_msg,
+    "prefect.deployments.deployments:Deployment": "Use `flow.serve()`, `flow.deploy()`, or `prefect deploy` instead.",
+    "prefect.deployments:Deployment": "Use `flow.serve()`, `flow.deploy()`, or `prefect deploy` instead.",
+    "prefect.filesystems:GCS": "Use `prefect_gcp.GcsBucket` instead.",
+    "prefect.filesystems:Azure": "Use `prefect_azure.AzureBlobStorageContainer` instead.",
+    "prefect.filesystems:S3": "Use `prefect_aws.S3Bucket` instead.",
+    "prefect.filesystems:GitHub": "Use `prefect_github.GitHubRepository` instead.",
+    "prefect.engine:_out_of_process_pause": "Use `prefect.flow_runs.pause_flow_run` instead.",
+    "prefect.agent:PrefectAgent": "Use workers instead. " + upgrade_guide_msg,
+    "prefect.infrastructure:KubernetesJob": "Use workers instead. " + upgrade_guide_msg,
+    "prefect.infrastructure.base:Infrastructure": "Use the `BaseWorker` class to create custom infrastructure integrations instead. "
+    + upgrade_guide_msg,
+    "prefect.workers.block:BlockWorkerJobConfiguration": upgrade_guide_msg,
+    "prefect.workers.cloud:BlockWorker": upgrade_guide_msg,
 }
 
 # IMPORTANT FOR USAGE: When adding new modules to MOVED_IN_V3 or REMOVED_IN_V3, include the following lines at the bottom of that module:
@@ -112,7 +154,7 @@ def getattr_migration(module_name: str) -> Callable[[str], Any]:
         if import_path in REMOVED_IN_V3.keys():
             error_message = REMOVED_IN_V3[import_path]
             raise PrefectImportError(
-                f"{import_path!r} has been removed. {error_message}"
+                f"`{import_path}` has been removed. {error_message}"
             )
 
         globals: Dict[str, Any] = sys.modules[module_name].__dict__

prefect/_internal/integrations.py

@@ -0,0 +1,7 @@
+KNOWN_EXTRAS_FOR_PACKAGES = {
+    "prefect-kubernetes": "prefect[kubernetes]",
+    "prefect-aws": "prefect[aws]",
+    "prefect-gcp": "prefect[gcp]",
+    "prefect-azure": "prefect[azure]",
+    "prefect-docker": "prefect[docker]",
+}

prefect/agent.py

@@ -0,0 +1,6 @@
+"""
+2024-06-27: This surfaces an actionable error message for moved or removed objects in Prefect 3.0 upgrade.
+"""
+from prefect._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)

prefect/blocks/core.py

@@ -798,7 +798,7 @@ class Block(BaseModel, ABC):
         name: str,
         validate: bool = True,
         client: Optional["PrefectClient"] = None,
-    ):
+    ) -> "Self":
         """
         Retrieves data from the block document with the given name for the block type
         that corresponds with the current class and returns an instantiated version of

prefect/client/__init__.py

@@ -15,3 +15,7 @@ $ python -m asyncio
 ```
 </div>
 """
+
+from prefect._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)

prefect/client/schemas/objects.py

@@ -8,7 +8,6 @@ from typing import (
     Generic,
     List,
     Optional,
-    TypeVar,
     Union,
     overload,
 )
@@ -26,8 +25,9 @@ from pydantic import (
     model_validator,
 )
 from pydantic_extra_types.pendulum_dt import DateTime
-from typing_extensions import Literal, Self
+from typing_extensions import Literal, Self, TypeVar
 
+from prefect._internal.compatibility.migration import getattr_migration
 from prefect._internal.schemas.bases import ObjectBaseModel, PrefectBaseModel
 from prefect._internal.schemas.fields import CreatedBy, UpdatedBy
 from prefect._internal.schemas.validators import (
@@ -60,7 +60,7 @@ if TYPE_CHECKING:
     from prefect.results import BaseResult
 
 
-R = TypeVar("R")
+R = TypeVar("R", default=Any)
 
 
 DEFAULT_BLOCK_SCHEMA_VERSION = "non-versioned"
@@ -1604,3 +1604,6 @@ class CsrfToken(ObjectBaseModel):
     expiration: datetime.datetime = Field(
         default=..., description="The expiration time of the CSRF token"
     )
+
+
+__getattr__ = getattr_migration(__name__)

prefect/client/utilities.py

@@ -78,10 +78,10 @@ def client_injector(
 
 
 def inject_client(
-    fn: Callable[P, Coroutine[Any, Any, Any]],
-) -> Callable[P, Coroutine[Any, Any, Any]]:
+    fn: Callable[P, Coroutine[Any, Any, R]],
+) -> Callable[P, Coroutine[Any, Any, R]]:
     """
-    Simple helper to provide a context managed client to a asynchronous function.
+    Simple helper to provide a context managed client to an asynchronous function.
 
     The decorated function _must_ take a `client` kwarg and if a client is passed when
     called it will be used instead of creating a new one, but it will not be context
@@ -89,7 +89,7 @@ def inject_client(
     """
 
     @wraps(fn)
-    async def with_injected_client(*args: P.args, **kwargs: P.kwargs) -> Any:
+    async def with_injected_client(*args: P.args, **kwargs: P.kwargs) -> R:
         client = cast(Optional["PrefectClient"], kwargs.pop("client", None))
         client, inferred = get_or_create_client(client)
         if not inferred:

prefect/context.py

@@ -32,6 +32,7 @@ from typing_extensions import Self
 import prefect.logging
 import prefect.logging.configuration
 import prefect.settings
+from prefect._internal.compatibility.migration import getattr_migration
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_client
 from prefect.client.schemas import FlowRun, TaskRun
 from prefect.events.worker import EventsWorker
@@ -608,3 +609,8 @@ def root_settings_context():
 
 
 GLOBAL_SETTINGS_CONTEXT: SettingsContext = root_settings_context()
+
+
+# 2024-07-02: This surfaces an actionable error message for removed objects
+# in Prefect 3.0 upgrade.
+__getattr__ = getattr_migration(__name__)

prefect/deployments/schedules.py

@@ -1,11 +1,14 @@
-from typing import TYPE_CHECKING, Any, List, Optional
+from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Union
 
 from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.schedules import is_schedule_type
 
 if TYPE_CHECKING:
     from prefect.client.schemas.schedules import SCHEDULE_TYPES
-    from prefect.client.types.flexible_schedule_list import FlexibleScheduleList
+
+FlexibleScheduleList = Sequence[
+    Union[DeploymentScheduleCreate, dict[str, Any], "SCHEDULE_TYPES"]
+]
 
 
 def create_deployment_schedule_create(

prefect/deployments/steps/core.py

@@ -22,6 +22,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 from prefect._internal.compatibility.deprecated import PrefectDeprecationWarning
 from prefect._internal.concurrency.api import Call, from_async
+from prefect._internal.integrations import KNOWN_EXTRAS_FOR_PACKAGES
 from prefect.logging.loggers import get_logger
 from prefect.settings import PREFECT_DEBUG_MODE
 from prefect.utilities.importtools import import_object
@@ -84,6 +85,11 @@ def _get_function_for_step(
             raise
 
     try:
+        packages = [
+            KNOWN_EXTRAS_FOR_PACKAGES.get(package, package)
+            for package in packages
+            if package
+        ]
         subprocess.check_call([sys.executable, "-m", "pip", "install", *packages])
     except subprocess.CalledProcessError:
         get_logger("deployments.steps.core").warning(

prefect/engine.py

@@ -31,16 +31,16 @@ if __name__ == "__main__":
     try:
         from prefect.flow_engine import (
             load_flow_and_flow_run,
-            run_flow_async,
-            run_flow_sync,
+            run_flow,
         )
 
         flow_run, flow = load_flow_and_flow_run(flow_run_id=flow_run_id)
         # run the flow
         if flow.isasync:
-            run_coro_as_sync(run_flow_async(flow, flow_run=flow_run))
+            run_coro_as_sync(run_flow(flow, flow_run=flow_run))
         else:
-            run_flow_sync(flow, flow_run=flow_run)
+            run_flow(flow, flow_run=flow_run)
+
     except Abort as exc:
         engine_logger.info(
             f"Engine execution of flow run '{flow_run_id}' aborted by orchestrator:"

prefect/events/schemas/automations.py

@@ -187,18 +187,18 @@ class EventTrigger(ResourceTrigger):
         within: Optional[timedelta] = data.get("within")
 
         if isinstance(within, (int, float)):
-            data["within"] = within = timedelta(seconds=within)
+            within = timedelta(seconds=within)
 
         if posture == Posture.Proactive:
             if not within or within == timedelta(0):
-                data["within"] = timedelta(seconds=10.0)
+                within = timedelta(seconds=10.0)
             elif within < timedelta(seconds=10.0):
                 raise ValueError(
                     "`within` for Proactive triggers must be greater than or equal to "
                     "10 seconds"
                 )
 
-        return data
+        return data | {"within": within} if within else data
 
     def describe_for_cli(self, indent: int = 0) -> str:
         """Return a human-readable description of this trigger for the CLI"""

prefect/exceptions.py

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

prefect/filesystems.py

@@ -95,7 +95,7 @@ class LocalFileSystem(WritableFileSystem, WritableDeploymentStorage):
     def cast_pathlib(cls, value):
         return stringify_path(value)
 
-    def _resolve_path(self, path: str) -> Path:
+    def _resolve_path(self, path: str, validate: bool = False) -> Path:
         # Only resolve the base path at runtime, default to the current directory
         basepath = (
             Path(self.basepath).expanduser().resolve()
@@ -114,11 +114,12 @@ class LocalFileSystem(WritableFileSystem, WritableDeploymentStorage):
             resolved_path = basepath / resolved_path
         else:
             resolved_path = resolved_path.resolve()
+
+        if validate:
             if basepath not in resolved_path.parents and (basepath != resolved_path):
                 raise ValueError(
                     f"Provided path {resolved_path} is outside of the base path {basepath}."
                 )
-
         return resolved_path
 
     @sync_compatible
@@ -184,7 +185,7 @@ class LocalFileSystem(WritableFileSystem, WritableDeploymentStorage):
         Defaults to copying the entire contents of the current working directory to the block's basepath.
         An `ignore_file` path may be provided that can include gitignore style expressions for filepaths to ignore.
         """
-        destination_path = self._resolve_path(to_path)
+        destination_path = self._resolve_path(to_path, validate=True)
 
         if not local_path:
             local_path = Path(".").absolute()

prefect/flow_engine.py

@@ -16,6 +16,7 @@ from typing import (
     Literal,
     Optional,
     Tuple,
+    Type,
     TypeVar,
     Union,
     cast,
@@ -30,7 +31,13 @@ from prefect.client.schemas import FlowRun, TaskRun
 from prefect.client.schemas.filters import FlowRunFilter
 from prefect.client.schemas.sorting import FlowRunSort
 from prefect.context import ClientContext, FlowRunContext, TagsContext
-from prefect.exceptions import Abort, Pause, PrefectException, UpstreamTaskError
+from prefect.exceptions import (
+    Abort,
+    Pause,
+    PrefectException,
+    TerminationSignal,
+    UpstreamTaskError,
+)
 from prefect.flows import Flow, load_flow_from_entrypoint, load_flow_from_flow_run
 from prefect.futures import PrefectFuture, resolve_futures_to_states
 from prefect.logging.loggers import (
@@ -39,7 +46,7 @@ from prefect.logging.loggers import (
     get_run_logger,
     patch_print,
 )
-from prefect.results import ResultFactory
+from prefect.results import BaseResult, ResultFactory
 from prefect.settings import PREFECT_DEBUG_MODE
 from prefect.states import (
     Failed,
@@ -50,8 +57,13 @@ from prefect.states import (
     exception_to_failed_state,
     return_value_to_state,
 )
+from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import run_coro_as_sync
-from prefect.utilities.callables import call_with_parameters, parameters_to_args_kwargs
+from prefect.utilities.callables import (
+    call_with_parameters,
+    get_call_parameters,
+    parameters_to_args_kwargs,
+)
 from prefect.utilities.collections import visit_collection
 from prefect.utilities.engine import (
     _get_hook_name,
@@ -68,6 +80,10 @@ P = ParamSpec("P")
 R = TypeVar("R")
 
 
+class FlowRunTimeoutError(TimeoutError):
+    """Raised when a flow run exceeds its defined timeout."""
+
+
 def load_flow_and_flow_run(flow_run_id: UUID) -> Tuple[FlowRun, Flow]:
     ## TODO: add error handling to update state and log tracebacks
     entrypoint = os.environ.get("PREFECT__FLOW_ENTRYPOINT")
@@ -91,6 +107,10 @@ class FlowRunEngine(Generic[P, R]):
     flow_run_id: Optional[UUID] = None
     logger: logging.Logger = field(default_factory=lambda: get_logger("engine"))
     wait_for: Optional[Iterable[PrefectFuture]] = None
+    # holds the return value from the user code
+    _return_value: Union[R, Type[NotSet]] = NotSet
+    # holds the exception raised by the user code, if any
+    _raised: Union[Exception, Type[NotSet]] = NotSet
     _is_started: bool = False
     _client: Optional[SyncPrefectClient] = None
     short_circuit: bool = False
@@ -204,6 +224,30 @@ class FlowRunEngine(Generic[P, R]):
         return state
 
     def result(self, raise_on_failure: bool = True) -> "Union[R, State, None]":
+        if self._return_value is not NotSet and not isinstance(
+            self._return_value, State
+        ):
+            if isinstance(self._return_value, BaseResult):
+                _result = self._return_value.get()
+            else:
+                _result = self._return_value
+
+            if inspect.isawaitable(_result):
+                # getting the value for a BaseResult may return an awaitable
+                # depending on whether the parent frame is sync or not
+                _result = run_coro_as_sync(_result)
+            return _result
+
+        if self._raised is not NotSet:
+            if raise_on_failure:
+                raise self._raised
+            return self._raised
+
+        # This is a fall through case which leans on the existing state result mechanics to get the
+        # return value. This is necessary because we currently will return a State object if the
+        # the State was Prefect-created.
+        # TODO: Remove the need to get the result from a State except in cases where the return value
+        # is a State object.
         _result = self.state.result(raise_on_failure=raise_on_failure, fetch=True)  # type: ignore
         # state.result is a `sync_compatible` function that may or may not return an awaitable
         # depending on whether the parent frame is sync or not
@@ -215,13 +259,15 @@ class FlowRunEngine(Generic[P, R]):
         result_factory = getattr(FlowRunContext.get(), "result_factory", None)
         if result_factory is None:
             raise ValueError("Result factory is not set")
+        resolved_result = resolve_futures_to_states(result)
         terminal_state = run_coro_as_sync(
             return_value_to_state(
-                resolve_futures_to_states(result),
+                resolved_result,
                 result_factory=result_factory,
             )
         )
         self.set_state(terminal_state)
+        self._return_value = resolved_result
         return result
 
     def handle_exception(
@@ -248,10 +294,16 @@ class FlowRunEngine(Generic[P, R]):
                 ),
             )
             state = self.set_state(Running())
+        self._raised = exc
         return state
 
     def handle_timeout(self, exc: TimeoutError) -> None:
-        message = f"Flow run exceeded timeout of {self.flow.timeout_seconds} seconds"
+        if isinstance(exc, FlowRunTimeoutError):
+            message = (
+                f"Flow run exceeded timeout of {self.flow.timeout_seconds} second(s)"
+            )
+        else:
+            message = f"Flow run failed due to timeout: {exc!r}"
         self.logger.error(message)
         state = Failed(
             data=exc,
@@ -259,12 +311,14 @@ class FlowRunEngine(Generic[P, R]):
             name="TimedOut",
         )
         self.set_state(state)
+        self._raised = exc
 
     def handle_crash(self, exc: BaseException) -> None:
         state = run_coro_as_sync(exception_to_crashed_state(exc))
         self.logger.error(f"Crash detected! {state.message}")
         self.logger.debug("Crash details:", exc_info=exc)
         self.set_state(state, force=True)
+        self._raised = exc
 
     def load_subflow_run(
         self,
@@ -311,7 +365,9 @@ class FlowRunEngine(Generic[P, R]):
                 limit=1,
             )
             if flow_runs:
-                return flow_runs[-1]
+                loaded_flow_run = flow_runs[-1]
+                self._return_value = loaded_flow_run.state
+                return loaded_flow_run
 
     def create_flow_run(self, client: SyncPrefectClient) -> FlowRun:
         flow_run_ctx = FlowRunContext.get()
@@ -359,7 +415,7 @@ class FlowRunEngine(Generic[P, R]):
 
         return flow_run
 
-    def call_hooks(self, state: State = None) -> Iterable[Callable]:
+    def call_hooks(self, state: Optional[State] = None) -> Iterable[Callable]:
         if state is None:
             state = self.state
         flow = self.flow
@@ -500,6 +556,11 @@ class FlowRunEngine(Generic[P, R]):
                 )
             try:
                 yield self
+
+            except TerminationSignal as exc:
+                self.cancel_all_tasks()
+                self.handle_crash(exc)
+                raise
             except Exception:
                 # regular exceptions are caught and re-raised to the user
                 raise
@@ -535,6 +596,10 @@ class FlowRunEngine(Generic[P, R]):
             return False  # TODO: handle this differently?
         return getattr(self, "flow_run").state.is_pending()
 
+    def cancel_all_tasks(self):
+        if hasattr(self.flow.task_runner, "cancel_all"):
+            self.flow.task_runner.cancel_all()  # type: ignore
+
     # --------------------------
     #
     # The following methods compose the main task run loop
@@ -560,7 +625,10 @@ class FlowRunEngine(Generic[P, R]):
         # reenter the run context to ensure it is up to date for every run
         with self.setup_run_context():
             try:
-                with timeout_context(seconds=self.flow.timeout_seconds):
+                with timeout_context(
+                    seconds=self.flow.timeout_seconds,
+                    timeout_exc_type=FlowRunTimeoutError,
+                ):
                     self.logger.debug(
                         f"Executing flow {self.flow.name!r} for flow run {self.flow_run.name!r}..."
                     )
@@ -568,7 +636,7 @@ class FlowRunEngine(Generic[P, R]):
             except TimeoutError as exc:
                 self.handle_timeout(exc)
             except Exception as exc:
-                self.logger.exception(f"Encountered exception during execution: {exc}")
+                self.logger.exception("Encountered exception during execution: %r", exc)
                 self.handle_exception(exc)
 
     def call_flow_fn(self) -> Union[R, Coroutine[Any, Any, R]]:
@@ -595,10 +663,11 @@ def run_flow_sync(
     wait_for: Optional[Iterable[PrefectFuture]] = None,
     return_type: Literal["state", "result"] = "result",
 ) -> Union[R, State, None]:
-    parameters = flow_run.parameters if flow_run else parameters
-
     engine = FlowRunEngine[P, R](
-        flow=flow, parameters=parameters, flow_run=flow_run, wait_for=wait_for
+        flow=flow,
+        parameters=parameters,
+        flow_run=flow_run,
+        wait_for=wait_for,
     )
 
     with engine.start():
@@ -616,8 +685,6 @@ async def run_flow_async(
     wait_for: Optional[Iterable[PrefectFuture]] = None,
     return_type: Literal["state", "result"] = "result",
 ) -> Union[R, State, None]:
-    parameters = flow_run.parameters if flow_run else parameters
-
     engine = FlowRunEngine[P, R](
         flow=flow, parameters=parameters, flow_run=flow_run, wait_for=wait_for
     )
@@ -714,10 +781,13 @@ def run_flow(
     kwargs = dict(
         flow=flow,
         flow_run=flow_run,
-        parameters=parameters,
+        parameters=_flow_parameters(
+            flow=flow, flow_run=flow_run, parameters=parameters
+        ),
         wait_for=wait_for,
         return_type=return_type,
     )
+
     if flow.isasync and flow.isgenerator:
         return run_generator_flow_async(**kwargs)
     elif flow.isgenerator:
@@ -726,3 +796,20 @@ def run_flow(
         return run_flow_async(**kwargs)
     else:
         return run_flow_sync(**kwargs)
+
+
+def _flow_parameters(
+    flow: Flow[P, R], flow_run: Optional[FlowRun], parameters: Optional[Dict[str, Any]]
+) -> Dict[str, Any]:
+    if parameters:
+        # This path is taken when a flow is being called directly with
+        # parameters, in that case just return the parameters as-is.
+        return parameters
+
+    # Otherwise the flow is being executed indirectly and we may need to grab
+    # the parameters from the flow run. We also need to resolve any default
+    # parameters that are defined on the flow function itself.
+
+    parameters = flow_run.parameters if flow_run else {}
+    call_args, call_kwargs = parameters_to_args_kwargs(flow.fn, parameters)
+    return get_call_parameters(flow.fn, call_args, call_kwargs)

prefect/flow_runs.py

@@ -340,7 +340,7 @@ async def suspend_flow_run(
     already started will run until completion. When resumed, the flow run will
     be rescheduled to finish execution. In order suspend a flow run in this
     way, the flow needs to have an associated deployment and results need to be
-    configured with the `persist_results` option.
+    configured with the `persist_result` option.
 
     Args:
         flow_run_id: a flow run id. If supplied, this function will attempt to