prefect-client 2.19.2__py3-none-any.whl → 3.0.0rc1__py3-none-any.whl

prefect/flows.py

@@ -5,9 +5,14 @@ Module containing the base workflow class and decorator - for most use cases, us
 # This file requires type-checking with pyright because mypy does not yet support PEP612
 # See https://github.com/python/mypy/issues/8645
 
+import ast
 import datetime
+import importlib.util
 import inspect
+import json
 import os
+import re
+import sys
 import tempfile
 import warnings
 from functools import partial, update_wrapper
@@ -34,50 +39,38 @@ from typing import (
 )
 from uuid import UUID
 
+import pydantic
+from fastapi.encoders import jsonable_encoder
+from pydantic.v1 import BaseModel as V1BaseModel
+from pydantic.v1.decorator import ValidatedFunction as V1ValidatedFunction
+from pydantic.v1.errors import ConfigError  # TODO
 from rich.console import Console
 from typing_extensions import Literal, ParamSpec, Self
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-    from pydantic import ValidationError as V2ValidationError
-    from pydantic.v1 import BaseModel as V1BaseModel
-    from pydantic.v1.decorator import ValidatedFunction as V1ValidatedFunction
-
-    from ._internal.pydantic.v2_schema import is_v2_type
-    from ._internal.pydantic.v2_validated_func import V2ValidatedFunction
-    from ._internal.pydantic.v2_validated_func import (
-        V2ValidatedFunction as ValidatedFunction,
-    )
-
-else:
-    import pydantic
-    from pydantic.decorator import ValidatedFunction
-
-    V2ValidationError = None
-
-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.blocks.core import Block
 from prefect.client.orchestration import get_client
+from prefect.client.schemas.actions import DeploymentScheduleCreate
 from prefect.client.schemas.objects import Flow as FlowSchema
-from prefect.client.schemas.objects import FlowRun, MinimalDeploymentSchedule
+from prefect.client.schemas.objects import FlowRun
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
+from prefect.client.utilities import client_injector
 from prefect.context import PrefectObjectRegistry, registry_from_script
 from prefect.deployments.runner import DeploymentImage, EntrypointType, deploy
+from prefect.deployments.steps.core import run_steps
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
+    InvalidNameError,
     MissingFlowError,
     ObjectNotFound,
     ParameterTypeError,
     UnspecifiedFlowError,
 )
-from prefect.filesystems import ReadableDeploymentStorage
+from prefect.filesystems import LocalFileSystem, ReadableDeploymentStorage
 from prefect.futures import PrefectFuture
 from prefect.logging import get_logger
+from prefect.logging.loggers import flow_run_logger
 from prefect.results import ResultSerializer, ResultStorage
 from prefect.runner.storage import (
     BlockStorageAdapter,
@@ -86,16 +79,20 @@ from prefect.runner.storage import (
 )
 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,
     PREFECT_UNIT_TEST_MODE,
 )
 from prefect.states import State
-from prefect.task_runners import BaseTaskRunner, ConcurrentTaskRunner
+from prefect.task_runners import TaskRunner, ThreadPoolTaskRunner
+from prefect.types import BANNED_CHARACTERS, WITHOUT_BANNED_CHARACTERS
 from prefect.utilities.annotations import NotSet
-from prefect.utilities.asyncutils import is_async_fn, sync_compatible
+from prefect.utilities.asyncutils import (
+    is_async_fn,
+    run_sync_in_worker_thread,
+    sync_compatible,
+)
 from prefect.utilities.callables import (
     get_call_parameters,
     parameter_schema,
@@ -103,18 +100,14 @@ from prefect.utilities.callables import (
     raise_for_reserved_arguments,
 )
 from prefect.utilities.collections import listrepr
+from prefect.utilities.filesystem import relative_path_to_current_platform
 from prefect.utilities.hashing import file_hash
 from prefect.utilities.importtools import import_object
-from prefect.utilities.visualization import (
-    FlowVisualizationError,
-    GraphvizExecutableNotFoundError,
-    GraphvizImportError,
-    TaskVizTracker,
-    VisualizationUnsupportedError,
-    build_task_dependencies,
-    get_task_viz_tracker,
-    track_viz_task,
-    visualize_task_dependencies,
+
+from ._internal.pydantic.v2_schema import is_v2_type
+from ._internal.pydantic.v2_validated_func import V2ValidatedFunction
+from ._internal.pydantic.v2_validated_func import (
+    V2ValidatedFunction as ValidatedFunction,
 )
 
 T = TypeVar("T")  # Generic type var for capturing the inner return type of async funcs
@@ -125,7 +118,9 @@ F = TypeVar("F", bound="Flow")  # The type of the flow
 logger = get_logger("flows")
 
 if TYPE_CHECKING:
+    from prefect.client.orchestration import PrefectClient
     from prefect.deployments.runner import FlexibleScheduleList, RunnerDeployment
+    from prefect.flows import FlowRun
 
 
 @PrefectObjectRegistry.register_instances
@@ -196,9 +191,9 @@ class Flow(Generic[P, R]):
         flow_run_name: Optional[Union[Callable[[], str], str]] = None,
         retries: Optional[int] = None,
         retry_delay_seconds: Optional[Union[int, float]] = None,
-        task_runner: Union[Type[BaseTaskRunner], BaseTaskRunner] = ConcurrentTaskRunner,
-        description: str = None,
-        timeout_seconds: Union[int, float] = None,
+        task_runner: Union[Type[TaskRunner], TaskRunner, None] = None,
+        description: Optional[str] = None,
+        timeout_seconds: Union[int, float, None] = None,
         validate_parameters: bool = True,
         persist_result: Optional[bool] = None,
         result_storage: Optional[ResultStorage] = None,
@@ -245,8 +240,6 @@ class Flow(Generic[P, R]):
         ]
         for hooks, hook_name in zip(hook_categories, hook_names):
             if hooks is not None:
-                if not hooks:
-                    raise ValueError(f"Empty list passed for '{hook_name}'")
                 try:
                     hooks = list(hooks)
                 except TypeError:
@@ -273,7 +266,7 @@ class Flow(Generic[P, R]):
 
         # Validate name if given
         if name:
-            raise_on_name_with_banned_characters(name)
+            _raise_on_name_with_banned_characters(name)
 
         self.name = name or fn.__name__.replace("_", "-")
 
@@ -285,7 +278,8 @@ class Flow(Generic[P, R]):
                 )
         self.flow_run_name = flow_run_name
 
-        task_runner = task_runner or ConcurrentTaskRunner()
+        default_task_runner = ThreadPoolTaskRunner()
+        task_runner = task_runner or default_task_runner
         self.task_runner = (
             task_runner() if isinstance(task_runner, type) else task_runner
         )
@@ -333,7 +327,7 @@ class Flow(Generic[P, R]):
             # is not picklable in some environments
             try:
                 ValidatedFunction(self.fn, config={"arbitrary_types_allowed": True})
-            except pydantic.ConfigError as exc:
+            except ConfigError as exc:
                 raise ValueError(
                     "Flow function is not compatible with `validate_parameters`. "
                     "Disable validation or change the argument names."
@@ -343,11 +337,11 @@ class Flow(Generic[P, R]):
         self.result_storage = result_storage
         self.result_serializer = result_serializer
         self.cache_result_in_memory = cache_result_in_memory
-        self.on_completion = on_completion
-        self.on_failure = on_failure
-        self.on_cancellation = on_cancellation
-        self.on_crashed = on_crashed
-        self.on_running = on_running
+        self.on_completion_hooks = on_completion or []
+        self.on_failure_hooks = on_failure or []
+        self.on_cancellation_hooks = on_cancellation or []
+        self.on_crashed_hooks = on_crashed or []
+        self.on_running_hooks = on_running or []
 
         # Used for flows loaded from remote storage
         self._storage: Optional[RunnerStorage] = None
@@ -363,20 +357,20 @@ class Flow(Generic[P, R]):
     def with_options(
         self,
         *,
-        name: str = None,
-        version: str = None,
+        name: Optional[str] = None,
+        version: Optional[str] = None,
         retries: Optional[int] = None,
         retry_delay_seconds: Optional[Union[int, float]] = None,
-        description: str = None,
+        description: Optional[str] = None,
         flow_run_name: Optional[Union[Callable[[], str], str]] = None,
-        task_runner: Union[Type[BaseTaskRunner], BaseTaskRunner] = None,
-        timeout_seconds: Union[int, float] = None,
-        validate_parameters: bool = None,
-        persist_result: Optional[bool] = NotSet,
-        result_storage: Optional[ResultStorage] = NotSet,
-        result_serializer: Optional[ResultSerializer] = NotSet,
-        cache_result_in_memory: bool = None,
-        log_prints: Optional[bool] = NotSet,
+        task_runner: Union[Type[TaskRunner], TaskRunner, None] = None,
+        timeout_seconds: Union[int, float, None] = None,
+        validate_parameters: Optional[bool] = None,
+        persist_result: Optional[bool] = NotSet,  # type: ignore
+        result_storage: Optional[ResultStorage] = NotSet,  # type: ignore
+        result_serializer: Optional[ResultSerializer] = NotSet,  # type: ignore
+        cache_result_in_memory: Optional[bool] = None,
+        log_prints: Optional[bool] = NotSet,  # type: ignore
         on_completion: Optional[
             List[Callable[[FlowSchema, FlowRun, State], None]]
         ] = None,
@@ -432,15 +426,14 @@ class Flow(Generic[P, R]):
             Create a new flow from an existing flow, update the task runner, and call
             it without an intermediate variable:
 
-            >>> from prefect.task_runners import SequentialTaskRunner
+            >>> from prefect.task_runners import ThreadPoolTaskRunner
             >>>
             >>> @flow
             >>> def my_flow(x, y):
             >>>     return x + y
             >>>
-            >>> state = my_flow.with_options(task_runner=SequentialTaskRunner)(1, 3)
+            >>> state = my_flow.with_options(task_runner=ThreadPoolTaskRunner)(1, 3)
             >>> assert state.result() == 4
-
         """
         new_flow = Flow(
             fn=self.fn,
@@ -480,11 +473,11 @@ class Flow(Generic[P, R]):
                 else self.cache_result_in_memory
             ),
             log_prints=log_prints if log_prints is not NotSet else self.log_prints,
-            on_completion=on_completion or self.on_completion,
-            on_failure=on_failure or self.on_failure,
-            on_cancellation=on_cancellation or self.on_cancellation,
-            on_crashed=on_crashed or self.on_crashed,
-            on_running=on_running or self.on_running,
+            on_completion=on_completion or self.on_completion_hooks,
+            on_failure=on_failure or self.on_failure_hooks,
+            on_cancellation=on_cancellation or self.on_cancellation_hooks,
+            on_crashed=on_crashed or self.on_crashed_hooks,
+            on_running=on_running or self.on_running_hooks,
         )
         new_flow._storage = self._storage
         new_flow._entrypoint = self._entrypoint
@@ -503,49 +496,52 @@ class Flow(Generic[P, R]):
         """
         args, kwargs = parameters_to_args_kwargs(self.fn, parameters)
 
-        if HAS_PYDANTIC_V2:
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore", category=pydantic.warnings.PydanticDeprecatedSince20
+            )
             has_v1_models = any(isinstance(o, V1BaseModel) for o in args) or any(
                 isinstance(o, V1BaseModel) for o in kwargs.values()
             )
-            has_v2_types = any(is_v2_type(o) for o in args) or any(
-                is_v2_type(o) for o in kwargs.values()
-            )
 
-            if has_v1_models and has_v2_types:
-                raise ParameterTypeError(
-                    "Cannot mix Pydantic v1 and v2 types as arguments to a flow."
-                )
+        has_v2_types = any(is_v2_type(o) for o in args) or any(
+            is_v2_type(o) for o in kwargs.values()
+        )
 
-            if has_v1_models:
-                validated_fn = V1ValidatedFunction(
-                    self.fn, config={"arbitrary_types_allowed": True}
-                )
-            else:
-                validated_fn = V2ValidatedFunction(
-                    self.fn, config={"arbitrary_types_allowed": True}
-                )
+        if has_v1_models and has_v2_types:
+            raise ParameterTypeError(
+                "Cannot mix Pydantic v1 and v2 types as arguments to a flow."
+            )
 
-        else:
-            validated_fn = ValidatedFunction(
+        if has_v1_models:
+            validated_fn = V1ValidatedFunction(
                 self.fn, config={"arbitrary_types_allowed": True}
             )
+        else:
+            validated_fn = V2ValidatedFunction(
+                self.fn, config=pydantic.ConfigDict(arbitrary_types_allowed=True)
+            )
 
         try:
-            model = validated_fn.init_model_instance(*args, **kwargs)
+            with warnings.catch_warnings():
+                warnings.filterwarnings(
+                    "ignore", category=pydantic.warnings.PydanticDeprecatedSince20
+                )
+                model = validated_fn.init_model_instance(*args, **kwargs)
         except pydantic.ValidationError as exc:
             # We capture the pydantic exception and raise our own because the pydantic
             # exception is not picklable when using a cythonized pydantic installation
-            raise ParameterTypeError.from_validation_error(exc) from None
-        except V2ValidationError as exc:
-            # We capture the pydantic exception and raise our own because the pydantic
-            # exception is not picklable when using a cythonized pydantic installation
+            logger.error(
+                f"Parameter validation failed for flow {self.name!r}: {exc.errors()}"
+                f"\nParameters: {parameters}"
+            )
             raise ParameterTypeError.from_validation_error(exc) from None
 
         # Get the updated parameter dict with cast values from the model
         cast_parameters = {
             k: v
-            for k, v in model._iter()
-            if k in model.__fields_set__ or model.__fields__[k].default_factory
+            for k, v in dict(model).items()
+            if k in model.model_fields_set or model.model_fields[k].default_factory
         }
         return cast_parameters
 
@@ -605,7 +601,7 @@ class Flow(Generic[P, R]):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
-        enforce_parameter_schema: bool = False,
+        enforce_parameter_schema: bool = True,
         work_pool_name: Optional[str] = None,
         work_queue_name: Optional[str] = None,
         job_variables: Optional[Dict[str, Any]] = None,
@@ -667,7 +663,8 @@ class Flow(Generic[P, R]):
         from prefect.deployments.runner import RunnerDeployment
 
         if not name.endswith(".py"):
-            raise_on_name_with_banned_characters(name)
+            _raise_on_name_with_banned_characters(name)
+
         if self._storage and self._entrypoint:
             return await RunnerDeployment.from_storage(
                 storage=self._storage,
@@ -713,6 +710,36 @@ class Flow(Generic[P, R]):
                 entrypoint_type=entrypoint_type,
             )
 
+    def on_completion(
+        self, fn: Callable[["Flow", FlowRun, State], None]
+    ) -> Callable[["Flow", FlowRun, State], None]:
+        self.on_completion_hooks.append(fn)
+        return fn
+
+    def on_cancellation(
+        self, fn: Callable[["Flow", FlowRun, State], None]
+    ) -> Callable[["Flow", FlowRun, State], None]:
+        self.on_cancellation_hooks.append(fn)
+        return fn
+
+    def on_crashed(
+        self, fn: Callable[["Flow", FlowRun, State], None]
+    ) -> Callable[["Flow", FlowRun, State], None]:
+        self.on_crashed_hooks.append(fn)
+        return fn
+
+    def on_running(
+        self, fn: Callable[["Flow", FlowRun, State], None]
+    ) -> Callable[["Flow", FlowRun, State], None]:
+        self.on_running_hooks.append(fn)
+        return fn
+
+    def on_failure(
+        self, fn: Callable[["Flow", FlowRun, State], None]
+    ) -> Callable[["Flow", FlowRun, State], None]:
+        self.on_failure_hooks.append(fn)
+        return fn
+
     @sync_compatible
     async def serve(
         self,
@@ -736,7 +763,7 @@ class Flow(Generic[P, R]):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
-        enforce_parameter_schema: bool = False,
+        enforce_parameter_schema: bool = True,
         pause_on_shutdown: bool = True,
         print_starting_message: bool = True,
         limit: Optional[int] = None,
@@ -945,7 +972,7 @@ class Flow(Generic[P, R]):
         cron: Optional[str] = None,
         rrule: Optional[str] = None,
         paused: Optional[bool] = None,
-        schedules: Optional[List[MinimalDeploymentSchedule]] = None,
+        schedules: Optional[List[DeploymentScheduleCreate]] = None,
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
@@ -953,7 +980,7 @@ class Flow(Generic[P, R]):
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,
-        enforce_parameter_schema: bool = False,
+        enforce_parameter_schema: bool = True,
         entrypoint_type: EntrypointType = EntrypointType.FILE_PATH,
         print_next_steps: bool = True,
         ignore_warnings: bool = False,
@@ -1198,7 +1225,10 @@ class Flow(Generic[P, R]):
             >>> with tags("db", "blue"):
             >>>     my_flow("foo")
         """
-        from prefect.engine import enter_flow_run_engine_from_flow_call
+        from prefect.utilities.visualization import (
+            get_task_viz_tracker,
+            track_viz_task,
+        )
 
         # Convert the call args/kwargs to a parameter dict
         parameters = get_call_parameters(self.fn, args, kwargs)
@@ -1211,72 +1241,19 @@ 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, run_flow_sync
+        from prefect.flow_engine import run_flow, run_flow_sync
 
-            run_kwargs = dict(
-                flow=self,
-                parameters=parameters,
-                wait_for=wait_for,
-                return_type=return_type,
-            )
-            if self.isasync:
-                # this returns an awaitable coroutine
-                return run_flow(**run_kwargs)
-            else:
-                return run_flow_sync(**run_kwargs)
-
-        return enter_flow_run_engine_from_flow_call(
-            self,
-            parameters,
+        run_kwargs = dict(
+            flow=self,
+            parameters=parameters,
             wait_for=wait_for,
             return_type=return_type,
         )
-
-    @overload
-    def _run(self: "Flow[P, NoReturn]", *args: P.args, **kwargs: P.kwargs) -> State[T]:
-        # `NoReturn` matches if a type can't be inferred for the function which stops a
-        # sync function from matching the `Coroutine` overload
-        ...
-
-    @overload
-    def _run(
-        self: "Flow[P, Coroutine[Any, Any, T]]", *args: P.args, **kwargs: P.kwargs
-    ) -> Awaitable[T]:
-        ...
-
-    @overload
-    def _run(self: "Flow[P, T]", *args: P.args, **kwargs: P.kwargs) -> State[T]:
-        ...
-
-    def _run(
-        self,
-        *args: "P.args",
-        wait_for: Optional[Iterable[PrefectFuture]] = None,
-        **kwargs: "P.kwargs",
-    ):
-        """
-        Run the flow and return its final state.
-
-        Examples:
-
-            Run a flow and get the returned result
-
-            >>> state = my_flow._run("marvin")
-            >>> state.result()
-           "goodbye marvin"
-        """
-        from prefect.engine import enter_flow_run_engine_from_flow_call
-
-        # Convert the call args/kwargs to a parameter dict
-        parameters = get_call_parameters(self.fn, args, kwargs)
-
-        return enter_flow_run_engine_from_flow_call(
-            self,
-            parameters,
-            wait_for=wait_for,
-            return_type="state",
-        )
+        if self.isasync:
+            # this returns an awaitable coroutine
+            return run_flow(**run_kwargs)
+        else:
+            return run_flow_sync(**run_kwargs)
 
     @sync_compatible
     async def visualize(self, *args, **kwargs):
@@ -1289,6 +1266,16 @@ class Flow(Generic[P, R]):
             - GraphvizExecutableNotFoundError: If the `dot` executable isn't found.
             - FlowVisualizationError: If the flow can't be visualized for any other reason.
         """
+        from prefect.utilities.visualization import (
+            FlowVisualizationError,
+            GraphvizExecutableNotFoundError,
+            GraphvizImportError,
+            TaskVizTracker,
+            VisualizationUnsupportedError,
+            build_task_dependencies,
+            visualize_task_dependencies,
+        )
+
         if not PREFECT_UNIT_TEST_MODE:
             warnings.warn(
                 "`flow.visualize()` will execute code inside of your flow that is not"
@@ -1341,7 +1328,7 @@ def flow(
     flow_run_name: Optional[Union[Callable[[], str], str]] = None,
     retries: Optional[int] = None,
     retry_delay_seconds: Optional[Union[int, float]] = None,
-    task_runner: BaseTaskRunner = ConcurrentTaskRunner,
+    task_runner: Optional[TaskRunner] = None,
     description: str = None,
     timeout_seconds: Union[int, float] = None,
     validate_parameters: bool = True,
@@ -1373,7 +1360,7 @@ def flow(
     flow_run_name: Optional[Union[Callable[[], str], str]] = None,
     retries: int = None,
     retry_delay_seconds: Union[int, float] = None,
-    task_runner: BaseTaskRunner = ConcurrentTaskRunner,
+    task_runner: Optional[TaskRunner] = None,
     description: str = None,
     timeout_seconds: Union[int, float] = None,
     validate_parameters: bool = True,
@@ -1551,6 +1538,23 @@ def flow(
         )
 
 
+def _raise_on_name_with_banned_characters(name: str) -> str:
+    """
+    Raise an InvalidNameError if the given name contains any invalid
+    characters.
+    """
+    if name is None:
+        return name
+
+    if not re.match(WITHOUT_BANNED_CHARACTERS, name):
+        raise InvalidNameError(
+            f"Name {name!r} contains an invalid character. "
+            f"Must not contain any of: {BANNED_CHARACTERS}."
+        )
+
+    return name
+
+
 # Add from_source so it is available on the flow function we all know and love
 flow.from_source = Flow.from_source
 
@@ -1640,7 +1644,9 @@ def load_flow_from_script(path: str, flow_name: str = None) -> Flow:
     )
 
 
-def load_flow_from_entrypoint(entrypoint: str) -> Flow:
+def load_flow_from_entrypoint(
+    entrypoint: str,
+) -> Flow:
     """
     Extract a flow object from a script at an entrypoint by running all of the code in the file.
 
@@ -1793,3 +1799,138 @@ async def serve(
         )
 
     await runner.start()
+
+
+@client_injector
+async def load_flow_from_flow_run(
+    client: "PrefectClient",
+    flow_run: "FlowRun",
+    ignore_storage: bool = False,
+    storage_base_path: Optional[str] = None,
+) -> "Flow":
+    """
+    Load a flow from the location/script provided in a deployment's storage document.
+
+    If `ignore_storage=True` is provided, no pull from remote storage occurs.  This flag
+    is largely for testing, and assumes the flow is already available locally.
+    """
+    deployment = await client.read_deployment(flow_run.deployment_id)
+
+    if deployment.entrypoint is None:
+        raise ValueError(
+            f"Deployment {deployment.id} does not have an entrypoint and can not be run."
+        )
+
+    run_logger = flow_run_logger(flow_run)
+
+    runner_storage_base_path = storage_base_path or os.environ.get(
+        "PREFECT__STORAGE_BASE_PATH"
+    )
+
+    # If there's no colon, assume it's a module path
+    if ":" not in deployment.entrypoint:
+        run_logger.debug(
+            f"Importing flow code from module path {deployment.entrypoint}"
+        )
+        flow = await run_sync_in_worker_thread(
+            load_flow_from_entrypoint, deployment.entrypoint
+        )
+        return flow
+
+    if not ignore_storage and not deployment.pull_steps:
+        sys.path.insert(0, ".")
+        if deployment.storage_document_id:
+            storage_document = await client.read_block_document(
+                deployment.storage_document_id
+            )
+            storage_block = Block._from_block_document(storage_document)
+        else:
+            basepath = deployment.path or Path(deployment.manifest_path).parent
+            if runner_storage_base_path:
+                basepath = str(basepath).replace(
+                    "$STORAGE_BASE_PATH", runner_storage_base_path
+                )
+            storage_block = LocalFileSystem(basepath=basepath)
+
+        from_path = (
+            str(deployment.path).replace("$STORAGE_BASE_PATH", runner_storage_base_path)
+            if runner_storage_base_path and deployment.path
+            else deployment.path
+        )
+        run_logger.info(f"Downloading flow code from storage at {from_path!r}")
+        await storage_block.get_directory(from_path=from_path, local_path=".")
+
+    if deployment.pull_steps:
+        run_logger.debug(f"Running {len(deployment.pull_steps)} deployment pull steps")
+        output = await run_steps(deployment.pull_steps)
+        if output.get("directory"):
+            run_logger.debug(f"Changing working directory to {output['directory']!r}")
+            os.chdir(output["directory"])
+
+    import_path = relative_path_to_current_platform(deployment.entrypoint)
+    # for backwards compat
+    if deployment.manifest_path:
+        with open(deployment.manifest_path, "r") as f:
+            import_path = json.load(f)["import_path"]
+            import_path = (
+                Path(deployment.manifest_path).parent / import_path
+            ).absolute()
+    run_logger.debug(f"Importing flow code from '{import_path}'")
+
+    flow = await run_sync_in_worker_thread(load_flow_from_entrypoint, str(import_path))
+
+    return flow
+
+
+def load_flow_argument_from_entrypoint(
+    entrypoint: str, arg: str = "name"
+) -> Optional[str]:
+    """
+    Extract a flow argument from an entrypoint string.
+
+    Loads the source code of the entrypoint and extracts the flow argument from the
+    `flow` decorator.
+
+    Args:
+        entrypoint: a string in the format `<path_to_script>:<flow_func_name>` or a module path
+            to a flow function
+
+    Returns:
+        The flow argument value
+    """
+    if ":" in entrypoint:
+        # split by the last colon once to handle Windows paths with drive letters i.e C:\path\to\file.py:do_stuff
+        path, func_name = entrypoint.rsplit(":", maxsplit=1)
+        source_code = Path(path).read_text()
+    else:
+        path, func_name = entrypoint.rsplit(".", maxsplit=1)
+        spec = importlib.util.find_spec(path)
+        if not spec or not spec.origin:
+            raise ValueError(f"Could not find module {path!r}")
+        source_code = Path(spec.origin).read_text()
+    parsed_code = ast.parse(source_code)
+    func_def = next(
+        (
+            node
+            for node in ast.walk(parsed_code)
+            if isinstance(node, ast.FunctionDef) and node.name == func_name
+        ),
+        None,
+    )
+    if not func_def:
+        raise ValueError(f"Could not find flow {func_name!r} in {path!r}")
+    for decorator in func_def.decorator_list:
+        if (
+            isinstance(decorator, ast.Call)
+            and getattr(decorator.func, "id", "") == "flow"
+        ):
+            for keyword in decorator.keywords:
+                if keyword.arg == arg:
+                    return (
+                        keyword.value.value
+                    )  # Return the string value of the argument
+
+    if arg == "name":
+        return func_name.replace(
+            "_", "-"
+        )  # If no matching decorator or keyword argument is found