prefect-client 3.0.0rc7__py3-none-any.whl → 3.0.0rc9__py3-none-any.whl

prefect/__init__.py

@@ -5,6 +5,7 @@
 from . import _version
 import importlib
 import pathlib
+from typing import TYPE_CHECKING, Any
 
 __version_info__ = _version.get_versions()
 __version__ = __version_info__["version"]
@@ -23,63 +24,55 @@ __ui_static_path__ = __module_path__ / "server" / "ui"
 
 del _version, pathlib
 
-
-# Import user-facing API
-from prefect.deployments import deploy
-from prefect.states import State
-from prefect.logging import get_run_logger
-from prefect.flows import flow, Flow, serve
-from prefect.transactions import Transaction
-from prefect.tasks import task, Task
-from prefect.context import tags
-from prefect.manifests import Manifest
-from prefect.utilities.annotations import unmapped, allow_failure
-from prefect.results import BaseResult
-from prefect.flow_runs import pause_flow_run, resume_flow_run, suspend_flow_run
-from prefect.client.orchestration import get_client, PrefectClient
-from prefect.client.cloud import get_cloud_client, CloudClient
-import prefect.variables
-import prefect.runtime
-
-# Import modules that register types
-import prefect.serializers
-import prefect.blocks.notifications
-import prefect.blocks.system
-
-# Initialize the process-wide profile and registry at import time
-import prefect.context
-
-# Perform any forward-ref updates needed for Pydantic models
-import prefect.client.schemas
-
-prefect.context.FlowRunContext.model_rebuild()
-prefect.context.TaskRunContext.model_rebuild()
-prefect.client.schemas.State.model_rebuild()
-prefect.client.schemas.StateCreate.model_rebuild()
-Transaction.model_rebuild()
-
-
-prefect.plugins.load_extra_entrypoints()
-
-# Configure logging
-import prefect.logging.configuration
-
-prefect.logging.configuration.setup_logging()
-prefect.logging.get_logger("profiles").debug(
-    f"Using profile {prefect.context.get_settings_context().profile.name!r}"
-)
-
-# Ensure moved names are accessible at old locations
-prefect.client.get_client = get_client
-prefect.client.PrefectClient = PrefectClient
-
-
-from prefect._internal.compatibility.deprecated import (
-    inject_renamed_module_alias_finder,
-)
-
-inject_renamed_module_alias_finder()
-
+if TYPE_CHECKING:
+    from .main import (
+        allow_failure,
+        flow,
+        Flow,
+        get_client,
+        get_run_logger,
+        Manifest,
+        State,
+        tags,
+        task,
+        Task,
+        Transaction,
+        unmapped,
+        serve,
+        deploy,
+        pause_flow_run,
+        resume_flow_run,
+        suspend_flow_run,
+    )
+
+_slots: dict[str, Any] = {
+    "__version_info__": __version_info__,
+    "__version__": __version__,
+    "__module_path__": __module_path__,
+    "__development_base_path__": __development_base_path__,
+    "__ui_static_subpath__": __ui_static_subpath__,
+    "__ui_static_path__": __ui_static_path__,
+}
+
+_public_api: dict[str, tuple[str, str]] = {
+    "allow_failure": (__spec__.parent, ".main"),
+    "flow": (__spec__.parent, ".main"),
+    "Flow": (__spec__.parent, ".main"),
+    "get_client": (__spec__.parent, ".main"),
+    "get_run_logger": (__spec__.parent, ".main"),
+    "Manifest": (__spec__.parent, ".main"),
+    "State": (__spec__.parent, ".main"),
+    "tags": (__spec__.parent, ".main"),
+    "task": (__spec__.parent, ".main"),
+    "Task": (__spec__.parent, ".main"),
+    "Transaction": (__spec__.parent, ".main"),
+    "unmapped": (__spec__.parent, ".main"),
+    "serve": (__spec__.parent, ".main"),
+    "deploy": (__spec__.parent, ".main"),
+    "pause_flow_run": (__spec__.parent, ".main"),
+    "resume_flow_run": (__spec__.parent, ".main"),
+    "suspend_flow_run": (__spec__.parent, ".main"),
+}
 
 # Declare API for type-checkers
 __all__ = [
@@ -100,4 +93,29 @@ __all__ = [
     "pause_flow_run",
     "resume_flow_run",
     "suspend_flow_run",
+    "__version_info__",
+    "__version__",
+    "__module_path__",
+    "__development_base_path__",
+    "__ui_static_subpath__",
+    "__ui_static_path__",
 ]
+
+
+def __getattr__(attr_name: str) -> object:
+    if attr_name in _slots:
+        return _slots[attr_name]
+
+    dynamic_attr = _public_api.get(attr_name)
+    if dynamic_attr is None:
+        return importlib.import_module(f".{attr_name}", package=__name__)
+
+    package, module_name = dynamic_attr
+
+    from importlib import import_module
+
+    if module_name == "__module__":
+        return import_module(f".{attr_name}", package=package)
+    else:
+        module = import_module(module_name, package=package)
+        return getattr(module, attr_name)

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

@@ -27,15 +27,17 @@ 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",
 }
 
 REMOVED_IN_V3 = {
-    "prefect.deployments.deployments:Deployment": "Use 'flow.serve()' or `prefect deploy` instead.",
-    "prefect.deployments:Deployment": "Use 'flow.serve()' 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.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.",
 }
 
 # 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:

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/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/orchestration.py

@@ -1601,7 +1601,6 @@ class PrefectClient:
         work_pool_name: Optional[str] = None,
         tags: Optional[List[str]] = None,
         storage_document_id: Optional[UUID] = None,
-        manifest_path: Optional[str] = None,
         path: Optional[str] = None,
         entrypoint: Optional[str] = None,
         infrastructure_document_id: Optional[UUID] = None,
@@ -1650,7 +1649,6 @@ class PrefectClient:
             storage_document_id=storage_document_id,
             path=path,
             entrypoint=entrypoint,
-            manifest_path=manifest_path,  # for backwards compat
             infrastructure_document_id=infrastructure_document_id,
             job_variables=dict(job_variables or {}),
             parameter_openapi_schema=parameter_openapi_schema,
@@ -1723,7 +1721,6 @@ class PrefectClient:
             description=deployment.description,
             work_queue_name=deployment.work_queue_name,
             tags=deployment.tags,
-            manifest_path=deployment.manifest_path,
             path=deployment.path,
             entrypoint=deployment.entrypoint,
             parameters=deployment.parameters,

prefect/client/schemas/actions.py

@@ -173,7 +173,6 @@ class DeploymentCreate(ActionBaseModel):
     tags: List[str] = Field(default_factory=list)
     pull_steps: Optional[List[dict]] = Field(None)
 
-    manifest_path: Optional[str] = Field(None)
     work_queue_name: Optional[str] = Field(None)
     work_pool_name: Optional[str] = Field(
         default=None,
@@ -246,7 +245,6 @@ class DeploymentUpdate(ActionBaseModel):
         description="Overrides to apply to flow run infrastructure at runtime.",
     )
     entrypoint: Optional[str] = Field(None)
-    manifest_path: Optional[str] = Field(None)
     storage_document_id: Optional[UUID] = Field(None)
     infrastructure_document_id: Optional[UUID] = Field(None)
     enforce_parameter_schema: Optional[bool] = Field(

prefect/client/schemas/objects.py

@@ -28,6 +28,7 @@ from pydantic import (
 from pydantic_extra_types.pendulum_dt import DateTime
 from typing_extensions import Literal, Self
 
+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 (
@@ -179,7 +180,10 @@ class State(ObjectBaseModel, Generic[R]):
         ...
 
     def result(
-        self, raise_on_failure: bool = True, fetch: Optional[bool] = None
+        self,
+        raise_on_failure: bool = True,
+        fetch: Optional[bool] = None,
+        retry_result_failure: bool = True,
     ) -> Union[R, Exception]:
         """
         Retrieve the result attached to this state.
@@ -191,6 +195,8 @@ class State(ObjectBaseModel, Generic[R]):
                 results into data. For synchronous users, this defaults to `True`.
                 For asynchronous users, this defaults to `False` for backwards
                 compatibility.
+            retry_result_failure: a boolean specifying whether to retry on failures to
+                load the result from result storage
 
         Raises:
             TypeError: If the state is failed but the result is not an exception.
@@ -253,7 +259,12 @@ class State(ObjectBaseModel, Generic[R]):
         """
         from prefect.states import get_state_result
 
-        return get_state_result(self, raise_on_failure=raise_on_failure, fetch=fetch)
+        return get_state_result(
+            self,
+            raise_on_failure=raise_on_failure,
+            fetch=fetch,
+            retry_result_failure=retry_result_failure,
+        )
 
     def to_state_create(self):
         """
@@ -1040,12 +1051,6 @@ class Deployment(ObjectBaseModel):
             "The path to the entrypoint for the workflow, relative to the `path`."
         ),
     )
-    manifest_path: Optional[str] = Field(
-        default=None,
-        description=(
-            "The path to the flow's manifest file, relative to the chosen storage."
-        ),
-    )
     storage_document_id: Optional[UUID] = Field(
         default=None,
         description="The block document defining storage used for this flow.",
@@ -1600,3 +1605,6 @@ class CsrfToken(ObjectBaseModel):
     expiration: datetime.datetime = Field(
         default=..., description="The expiration time of the CSRF token"
     )
+
+
+__getattr__ = getattr_migration(__name__)

prefect/client/schemas/responses.py

@@ -371,12 +371,6 @@ class DeploymentResponse(ObjectBaseModel):
             "The path to the entrypoint for the workflow, relative to the `path`."
         ),
     )
-    manifest_path: Optional[str] = Field(
-        default=None,
-        description=(
-            "The path to the flow's manifest file, relative to the chosen storage."
-        ),
-    )
     storage_document_id: Optional[UUID] = Field(
         default=None,
         description="The block document defining storage used for this flow.",

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/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/flow_engine.py

@@ -51,7 +51,11 @@ from prefect.states import (
     return_value_to_state,
 )
 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,
@@ -595,10 +599,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 +621,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 +717,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 +732,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

prefect/flows.py

@@ -8,7 +8,6 @@ import ast
 import datetime
 import importlib.util
 import inspect
-import json
 import os
 import re
 import sys
@@ -54,8 +53,6 @@ from prefect.client.schemas.objects import Flow as FlowSchema
 from prefect.client.schemas.objects import FlowRun
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.client.utilities import client_injector
-from prefect.deployments.runner import deploy
-from prefect.deployments.steps.core import run_steps
 from prefect.docker.docker_image import DockerImage
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
@@ -70,11 +67,6 @@ 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,
-    RunnerStorage,
-    create_storage_from_url,
-)
 from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
     PREFECT_FLOW_DEFAULT_RETRIES,
@@ -120,6 +112,7 @@ if TYPE_CHECKING:
     from prefect.client.types.flexible_schedule_list import FlexibleScheduleList
     from prefect.deployments.runner import RunnerDeployment
     from prefect.flows import FlowRun
+    from prefect.runner.storage import RunnerStorage
 
 
 class Flow(Generic[P, R]):
@@ -353,7 +346,7 @@ class Flow(Generic[P, R]):
         self.on_running_hooks = on_running or []
 
         # Used for flows loaded from remote storage
-        self._storage: Optional[RunnerStorage] = None
+        self._storage: Optional["RunnerStorage"] = None
         self._entrypoint: Optional[str] = None
 
         module = fn.__module__
@@ -919,7 +912,7 @@ class Flow(Generic[P, R]):
     @sync_compatible
     async def from_source(
         cls: Type[F],
-        source: Union[str, RunnerStorage, ReadableDeploymentStorage],
+        source: Union[str, "RunnerStorage", ReadableDeploymentStorage],
         entrypoint: str,
     ) -> F:
         """
@@ -968,8 +961,16 @@ class Flow(Generic[P, R]):
             my_flow()
             ```
         """
+
+        from prefect.runner.storage import (
+            BlockStorageAdapter,
+            LocalStorage,
+            RunnerStorage,
+            create_storage_from_source,
+        )
+
         if isinstance(source, str):
-            storage = create_storage_from_url(source)
+            storage = create_storage_from_source(source)
         elif isinstance(source, RunnerStorage):
             storage = source
         elif hasattr(source, "get_directory"):
@@ -980,6 +981,9 @@ class Flow(Generic[P, R]):
                 " URL to remote storage or a storage object."
             )
         with tempfile.TemporaryDirectory() as tmpdir:
+            if not isinstance(storage, LocalStorage):
+                storage.set_base_path(Path(tmpdir))
+                await storage.pull_code()
             storage.set_base_path(Path(tmpdir))
             await storage.pull_code()
 
@@ -1142,7 +1146,9 @@ class Flow(Generic[P, R]):
             entrypoint_type=entrypoint_type,
         )
 
-        deployment_ids = await deploy(
+        from prefect.deployments import runner
+
+        deployment_ids = await runner.deploy(
             deployment,
             work_pool_name=work_pool_name,
             image=image,
@@ -1811,7 +1817,7 @@ async def load_flow_from_flow_run(
             )
             storage_block = Block._from_block_document(storage_document)
         else:
-            basepath = deployment.path or Path(deployment.manifest_path).parent
+            basepath = deployment.path
             if runner_storage_base_path:
                 basepath = str(basepath).replace(
                     "$STORAGE_BASE_PATH", runner_storage_base_path
@@ -1830,19 +1836,15 @@ async def load_flow_from_flow_run(
         run_logger.debug(
             f"Running {len(deployment.pull_steps)} deployment pull step(s)"
         )
+
+        from prefect.deployments.steps.core import run_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))