prefect-client 3.0.0rc6__tar.gz → 3.0.0rc8__tar.gz

{prefect-client-3.0.0rc6/src/prefect_client.egg-info → prefect-client-3.0.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 3.0.0rc6
+Version: 3.0.0rc8
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

prefect-client-3.0.0rc8/src/prefect/__init__.py

@@ -0,0 +1,121 @@
+# isort: skip_file
+
+# Setup version and path constants
+
+from . import _version
+import importlib
+import pathlib
+from typing import TYPE_CHECKING, Any
+
+__version_info__ = _version.get_versions()
+__version__ = __version_info__["version"]
+
+# The absolute path to this module
+__module_path__ = pathlib.Path(__file__).parent
+# The absolute path to the root of the repository, only valid for use during development
+__development_base_path__ = __module_path__.parents[1]
+
+# The absolute path to the built UI within the Python module, used by
+# `prefect server start` to serve a dynamic build of the UI
+__ui_static_subpath__ = __module_path__ / "server" / "ui_build"
+
+# The absolute path to the built UI within the Python module
+__ui_static_path__ = __module_path__ / "server" / "ui"
+
+del _version, pathlib
+
+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__ = [
+    "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",
+    "__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-client-3.0.0rc6 → prefect-client-3.0.0rc8}/src/prefect/_internal/compatibility/migration.py

@@ -30,8 +30,8 @@ MOVED_IN_V3 = {
 }
 
 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.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-client-3.0.0rc6 → prefect-client-3.0.0rc8}/src/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-3.0.0rc6 → prefect-client-3.0.0rc8}/src/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-3.0.0rc6 → prefect-client-3.0.0rc8}/src/prefect/client/schemas/objects.py

@@ -179,7 +179,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 +194,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 +258,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 +1050,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.",

{prefect-client-3.0.0rc6 → prefect-client-3.0.0rc8}/src/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-3.0.0rc6 → prefect-client-3.0.0rc8}/src/prefect/flows.py

@@ -8,7 +8,6 @@ import ast
 import datetime
 import importlib.util
 import inspect
-import json
 import os
 import re
 import sys
@@ -72,8 +71,9 @@ from prefect.logging.loggers import flow_run_logger
 from prefect.results import ResultSerializer, ResultStorage
 from prefect.runner.storage import (
     BlockStorageAdapter,
+    LocalStorage,
     RunnerStorage,
-    create_storage_from_url,
+    create_storage_from_source,
 )
 from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
@@ -969,7 +969,7 @@ class Flow(Generic[P, R]):
             ```
         """
         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 +980,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()
 
@@ -1811,7 +1814,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
@@ -1836,13 +1839,6 @@ async def load_flow_from_flow_run(
             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))

{prefect-client-3.0.0rc6 → prefect-client-3.0.0rc8}/src/prefect/futures.py

@@ -2,8 +2,9 @@ import abc
 import concurrent.futures
 import inspect
 import uuid
+from collections.abc import Iterator
 from functools import partial
-from typing import Any, Generic, Optional, Set, Union, cast
+from typing import Any, Generic, List, Optional, Set, Union, cast
 
 from typing_extensions import TypeVar
 
@@ -16,13 +17,15 @@ from prefect.task_runs import TaskRunWaiter
 from prefect.utilities.annotations import quote
 from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.collections import StopVisiting, visit_collection
+from prefect.utilities.timeout import timeout as timeout_context
 
 F = TypeVar("F")
+R = TypeVar("R")
 
 logger = get_logger(__name__)
 
 
-class PrefectFuture(abc.ABC):
+class PrefectFuture(abc.ABC, Generic[R]):
     """
     Abstract base class for Prefect futures. A Prefect future is a handle to the
     asynchronous execution of a task run. It provides methods to wait for the task
@@ -31,7 +34,7 @@ class PrefectFuture(abc.ABC):
 
     def __init__(self, task_run_id: uuid.UUID):
         self._task_run_id = task_run_id
-        self._final_state = None
+        self._final_state: Optional[State[R]] = None
 
     @property
     def task_run_id(self) -> uuid.UUID:
@@ -61,7 +64,7 @@ class PrefectFuture(abc.ABC):
         If the task run has already completed, this method will return immediately.
 
         Args:
-            - timeout: The maximum number of seconds to wait for the task run to complete.
+            timeout: The maximum number of seconds to wait for the task run to complete.
               If the task run has not completed after the timeout has elapsed, this method will return.
         """
 
@@ -70,7 +73,7 @@ class PrefectFuture(abc.ABC):
         self,
         timeout: Optional[float] = None,
         raise_on_failure: bool = True,
-    ) -> Any:
+    ) -> R:
         ...
         """
         Get the result of the task run associated with this future.
@@ -78,16 +81,16 @@ class PrefectFuture(abc.ABC):
         If the task run has not completed, this method will wait for the task run to complete.
 
         Args:
-            - timeout: The maximum number of seconds to wait for the task run to complete.
+            timeout: The maximum number of seconds to wait for the task run to complete.
             If the task run has not completed after the timeout has elapsed, this method will return.
-            - raise_on_failure: If `True`, an exception will be raised if the task run fails.
+            raise_on_failure: If `True`, an exception will be raised if the task run fails.
 
         Returns:
             The result of the task run.
         """
 
 
-class PrefectWrappedFuture(PrefectFuture, abc.ABC, Generic[F]):
+class PrefectWrappedFuture(PrefectFuture, abc.ABC, Generic[R, F]):
     """
     A Prefect future that wraps another future object.
     """
@@ -102,7 +105,7 @@ class PrefectWrappedFuture(PrefectFuture, abc.ABC, Generic[F]):
         return self._wrapped_future
 
 
-class PrefectConcurrentFuture(PrefectWrappedFuture[concurrent.futures.Future]):
+class PrefectConcurrentFuture(PrefectWrappedFuture[R, concurrent.futures.Future]):
     """
     A Prefect future that wraps a concurrent.futures.Future. This future is used
     when the task run is submitted to a ThreadPoolExecutor.
@@ -120,7 +123,7 @@ class PrefectConcurrentFuture(PrefectWrappedFuture[concurrent.futures.Future]):
         self,
         timeout: Optional[float] = None,
         raise_on_failure: bool = True,
-    ) -> Any:
+    ) -> R:
         if not self._final_state:
             try:
                 future_result = self._wrapped_future.result(timeout=timeout)
@@ -156,7 +159,7 @@ class PrefectConcurrentFuture(PrefectWrappedFuture[concurrent.futures.Future]):
         )
 
 
-class PrefectDistributedFuture(PrefectFuture):
+class PrefectDistributedFuture(PrefectFuture[R]):
     """
     Represents the result of a computation happening anywhere.
 
@@ -205,7 +208,7 @@ class PrefectDistributedFuture(PrefectFuture):
         self,
         timeout: Optional[float] = None,
         raise_on_failure: bool = True,
-    ) -> Any:
+    ) -> R:
         return run_coro_as_sync(
             self.result_async(timeout=timeout, raise_on_failure=raise_on_failure)
         )
@@ -214,7 +217,7 @@ class PrefectDistributedFuture(PrefectFuture):
         self,
         timeout: Optional[float] = None,
         raise_on_failure: bool = True,
-    ):
+    ) -> R:
         if not self._final_state:
             await self.wait_async(timeout=timeout)
             if not self._final_state:
@@ -232,6 +235,63 @@ class PrefectDistributedFuture(PrefectFuture):
         return self.task_run_id == other.task_run_id
 
 
+class PrefectFutureList(list, Iterator, Generic[F]):
+    """
+    A list of Prefect futures.
+
+    This class provides methods to wait for all futures
+    in the list to complete and to retrieve the results of all task runs.
+    """
+
+    def wait(self, timeout: Optional[float] = None) -> None:
+        """
+        Wait for all futures in the list to complete.
+
+        Args:
+            timeout: The maximum number of seconds to wait for all futures to
+                complete. This method will not raise if the timeout is reached.
+        """
+        try:
+            with timeout_context(timeout):
+                for future in self:
+                    future.wait()
+        except TimeoutError:
+            logger.debug("Timed out waiting for all futures to complete.")
+            return
+
+    def result(
+        self,
+        timeout: Optional[float] = None,
+        raise_on_failure: bool = True,
+    ) -> List:
+        """
+        Get the results of all task runs associated with the futures in the list.
+
+        Args:
+            timeout: The maximum number of seconds to wait for all futures to
+                complete.
+            raise_on_failure: If `True`, an exception will be raised if any task run fails.
+
+        Returns:
+            A list of results of the task runs.
+
+        Raises:
+            TimeoutError: If the timeout is reached before all futures complete.
+        """
+        try:
+            with timeout_context(timeout):
+                return [
+                    future.result(raise_on_failure=raise_on_failure) for future in self
+                ]
+        except TimeoutError as exc:
+            # timeout came from inside the task
+            if "Scope timed out after {timeout} second(s)." not in str(exc):
+                raise
+            raise TimeoutError(
+                f"Timed out waiting for all futures to complete within {timeout} seconds"
+            ) from exc
+
+
 def resolve_futures_to_states(
     expr: Union[PrefectFuture, Any],
 ) -> Union[State, Any]:

prefect-client-3.0.0rc6/src/prefect/__init__.py → prefect-client-3.0.0rc8/src/prefect/main.py

@@ -1,29 +1,3 @@
-# isort: skip_file
-
-# Setup version and path constants
-
-from . import _version
-import importlib
-import pathlib
-
-__version_info__ = _version.get_versions()
-__version__ = __version_info__["version"]
-
-# The absolute path to this module
-__module_path__ = pathlib.Path(__file__).parent
-# The absolute path to the root of the repository, only valid for use during development
-__development_base_path__ = __module_path__.parents[1]
-
-# The absolute path to the built UI within the Python module, used by
-# `prefect server start` to serve a dynamic build of the UI
-__ui_static_subpath__ = __module_path__ / "server" / "ui_build"
-
-# The absolute path to the built UI within the Python module
-__ui_static_path__ = __module_path__ / "server" / "ui"
-
-del _version, pathlib
-
-
 # Import user-facing API
 from prefect.deployments import deploy
 from prefect.states import State
@@ -58,9 +32,6 @@ 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
 
@@ -69,10 +40,6 @@ 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,

{prefect-client-3.0.0rc6 → prefect-client-3.0.0rc8}/src/prefect/plugins.py

@@ -8,12 +8,11 @@ Currently supported entrypoints:
         should be imported when Prefect is imported.
 """
 
-import sys
 from types import ModuleType
 from typing import Any, Dict, Union
 
 import prefect.settings
-from prefect.utilities.compat import EntryPoint, EntryPoints, entry_points
+from prefect.utilities.compat import EntryPoints, entry_points
 
 
 def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception, Any]]:
@@ -39,68 +38,6 @@ def safe_load_entrypoints(entrypoints: EntryPoints) -> Dict[str, Union[Exception
     return results
 
 
-def load_extra_entrypoints() -> Dict[str, Union[Exception, Any]]:
-    # Note: Return values are only exposed for testing.
-    results = {}
-
-    if not prefect.settings.PREFECT_EXTRA_ENTRYPOINTS.value():
-        return results
-
-    values = {
-        value.strip()
-        for value in prefect.settings.PREFECT_EXTRA_ENTRYPOINTS.value().split(",")
-    }
-
-    entrypoints = []
-    for value in values:
-        try:
-            entrypoint = EntryPoint(name=None, value=value, group="prefect-extra")
-        except Exception as exc:
-            print(
-                (
-                    f"Warning! Failed to parse extra entrypoint {value!r}:"
-                    f" {type(exc).__name__}: {exc}"
-                ),
-                file=sys.stderr,
-            )
-            results[value] = exc
-        else:
-            entrypoints.append(entrypoint)
-
-    for value, result in zip(
-        values, safe_load_entrypoints(EntryPoints(entrypoints)).values()
-    ):
-        results[value] = result
-
-        if isinstance(result, Exception):
-            print(
-                (
-                    f"Warning! Failed to load extra entrypoint {value!r}:"
-                    f" {type(result).__name__}: {result}"
-                ),
-                file=sys.stderr,
-            )
-        elif callable(result):
-            try:
-                results[value] = result()
-            except Exception as exc:
-                print(
-                    (
-                        f"Warning! Failed to run callable entrypoint {value!r}:"
-                        f" {type(exc).__name__}: {exc}"
-                    ),
-                    file=sys.stderr,
-                )
-                results[value] = exc
-        else:
-            if prefect.settings.PREFECT_DEBUG_MODE:
-                print(
-                    "Loaded extra entrypoint {value!r} successfully.", file=sys.stderr
-                )
-
-    return results
-
-
 def load_prefect_collections() -> Dict[str, ModuleType]:
     """
     Load all Prefect collections that define an entrypoint in the group