prefect-client 3.0.0rc2__py3-none-any.whl → 3.0.0rc3__py3-none-any.whl

prefect/flows.py

@@ -4,7 +4,6 @@ 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
@@ -15,6 +14,7 @@ import re
 import sys
 import tempfile
 import warnings
+from copy import copy
 from functools import partial, update_wrapper
 from pathlib import Path
 from tempfile import NamedTemporaryFile
@@ -102,7 +102,7 @@ from prefect.utilities.callables import (
 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.importtools import import_object, safe_load_namespace
 
 from ._internal.pydantic.v2_schema import is_v2_type
 from ._internal.pydantic.v2_validated_func import V2ValidatedFunction
@@ -354,6 +354,28 @@ class Flow(Generic[P, R]):
 
         self._entrypoint = f"{module}:{fn.__name__}"
 
+    @property
+    def ismethod(self) -> bool:
+        return hasattr(self.fn, "__prefect_self__")
+
+    def __get__(self, instance, owner):
+        """
+        Implement the descriptor protocol so that the flow can be used as an instance method.
+        When an instance method is loaded, this method is called with the "self" instance as
+        an argument. We return a copy of the flow with that instance bound to the flow's function.
+        """
+
+        # if no instance is provided, it's being accessed on the class
+        if instance is None:
+            return self
+
+        # if the flow is being accessed on an instance, bind the instance to the __prefect_self__ attribute
+        # of the flow's function. This will allow it to be automatically added to the flow's parameters
+        else:
+            bound_flow = copy(self)
+            bound_flow.fn.__prefect_self__ = instance
+            return bound_flow
+
     def with_options(
         self,
         *,
@@ -555,6 +577,9 @@ class Flow(Generic[P, R]):
         """
         serialized_parameters = {}
         for key, value in parameters.items():
+            # do not serialize the bound self object
+            if self.ismethod and value is self.fn.__prefect_self__:
+                continue
             try:
                 serialized_parameters[key] = jsonable_encoder(value)
             except (TypeError, ValueError):
@@ -1241,19 +1266,14 @@ 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)
 
-        from prefect.flow_engine import run_flow, run_flow_sync
+        from prefect.flow_engine import run_flow
 
-        run_kwargs = dict(
+        return run_flow(
             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)
 
     @sync_compatible
     async def visualize(self, *args, **kwargs):
@@ -1329,8 +1349,8 @@ def flow(
     retries: Optional[int] = None,
     retry_delay_seconds: Optional[Union[int, float]] = None,
     task_runner: Optional[TaskRunner] = None,
-    description: str = None,
-    timeout_seconds: Union[int, float] = 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,
@@ -1358,11 +1378,11 @@ def flow(
     name: Optional[str] = None,
     version: Optional[str] = None,
     flow_run_name: Optional[Union[Callable[[], str], str]] = None,
-    retries: int = None,
-    retry_delay_seconds: Union[int, float] = None,
+    retries: Optional[int] = None,
+    retry_delay_seconds: Union[int, float, None] = None,
     task_runner: Optional[TaskRunner] = None,
-    description: str = None,
-    timeout_seconds: Union[int, float] = 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,
@@ -1485,6 +1505,9 @@ def flow(
         >>>     pass
     """
     if __fn:
+        if isinstance(__fn, (classmethod, staticmethod)):
+            method_decorator = type(__fn).__name__
+            raise TypeError(f"@{method_decorator} should be applied on top of @flow")
         return cast(
             Flow[P, R],
             Flow(
@@ -1560,7 +1583,9 @@ flow.from_source = Flow.from_source
 
 
 def select_flow(
-    flows: Iterable[Flow], flow_name: str = None, from_message: str = None
+    flows: Iterable[Flow],
+    flow_name: Optional[str] = None,
+    from_message: Optional[str] = None,
 ) -> Flow:
     """
     Select the only flow in an iterable or a flow specified by name.
@@ -1574,33 +1599,33 @@ def select_flow(
         UnspecifiedFlowError: If multiple flows exist but no flow name was provided
     """
     # Convert to flows by name
-    flows = {f.name: f for f in flows}
+    flows_dict = {f.name: f for f in flows}
 
     # Add a leading space if given, otherwise use an empty string
     from_message = (" " + from_message) if from_message else ""
-    if not flows:
+    if not Optional:
         raise MissingFlowError(f"No flows found{from_message}.")
 
-    elif flow_name and flow_name not in flows:
+    elif flow_name and flow_name not in flows_dict:
         raise MissingFlowError(
             f"Flow {flow_name!r} not found{from_message}. "
-            f"Found the following flows: {listrepr(flows.keys())}. "
+            f"Found the following flows: {listrepr(flows_dict.keys())}. "
             "Check to make sure that your flow function is decorated with `@flow`."
         )
 
-    elif not flow_name and len(flows) > 1:
+    elif not flow_name and len(flows_dict) > 1:
         raise UnspecifiedFlowError(
             (
-                f"Found {len(flows)} flows{from_message}:"
-                f" {listrepr(sorted(flows.keys()))}. Specify a flow name to select a"
+                f"Found {len(flows_dict)} flows{from_message}:"
+                f" {listrepr(sorted(flows_dict.keys()))}. Specify a flow name to select a"
                 " flow."
             ),
         )
 
     if flow_name:
-        return flows[flow_name]
+        return flows_dict[flow_name]
     else:
-        return list(flows.values())[0]
+        return list(flows_dict.values())[0]
 
 
 def load_flows_from_script(path: str) -> List[Flow]:
@@ -1617,7 +1642,7 @@ def load_flows_from_script(path: str) -> List[Flow]:
     return registry_from_script(path).get_instances(Flow)
 
 
-def load_flow_from_script(path: str, flow_name: str = None) -> Flow:
+def load_flow_from_script(path: str, flow_name: Optional[str] = None) -> Flow:
     """
     Extract a flow object from a script by running all of the code in the file.
 
@@ -1661,7 +1686,7 @@ def load_flow_from_entrypoint(
         FlowScriptError: If an exception is encountered while running the script
         MissingFlowError: If the flow function specified in the entrypoint does not exist
     """
-    with PrefectObjectRegistry(
+    with PrefectObjectRegistry(  # type: ignore
         block_code_execution=True,
         capture_failures=True,
     ):
@@ -1686,7 +1711,7 @@ def load_flow_from_entrypoint(
         return flow
 
 
-def load_flow_from_text(script_contents: AnyStr, flow_name: str):
+def load_flow_from_text(script_contents: AnyStr, flow_name: str) -> Flow:
     """
     Load a flow from a text script.
 
@@ -1717,7 +1742,7 @@ async def serve(
     print_starting_message: bool = True,
     limit: Optional[int] = None,
     **kwargs,
-):
+) -> NoReturn:
     """
     Serve the provided list of deployments.
 
@@ -1807,7 +1832,7 @@ async def load_flow_from_flow_run(
     flow_run: "FlowRun",
     ignore_storage: bool = False,
     storage_base_path: Optional[str] = None,
-) -> "Flow":
+) -> Flow:
     """
     Load a flow from the location/script provided in a deployment's storage document.
 
@@ -1861,7 +1886,9 @@ async def load_flow_from_flow_run(
         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")
+        run_logger.debug(
+            f"Running {len(deployment.pull_steps)} deployment pull step(s)"
+        )
         output = await run_steps(deployment.pull_steps)
         if output.get("directory"):
             run_logger.debug(f"Changing working directory to {output['directory']!r}")
@@ -1933,11 +1960,33 @@ def load_flow_argument_from_entrypoint(
         ):
             for keyword in decorator.keywords:
                 if keyword.arg == arg:
-                    return (
-                        keyword.value.value
-                    )  # Return the string value of the argument
+                    if isinstance(keyword.value, ast.Constant):
+                        return (
+                            keyword.value.value
+                        )  # Return the string value of the argument
+
+                    # if the arg value is not a raw str (i.e. a variable or expression),
+                    # then attempt to evaluate it
+                    namespace = safe_load_namespace(source_code)
+                    literal_arg_value = ast.get_source_segment(
+                        source_code, keyword.value
+                    )
+                    try:
+                        evaluated_value = eval(literal_arg_value, namespace)  # type: ignore
+                    except Exception as e:
+                        logger.info(
+                            "Failed to parse @flow argument: `%s=%s` due to the following error. Ignoring and falling back to default behavior.",
+                            arg,
+                            literal_arg_value,
+                            exc_info=e,
+                        )
+                        # ignore the decorator arg and fallback to default behavior
+                        break
+                    return str(evaluated_value)
 
     if arg == "name":
         return func_name.replace(
             "_", "-"
         )  # If no matching decorator or keyword argument is found
+
+    return None

prefect/infrastructure/provisioners/container_instance.py

@@ -10,6 +10,7 @@ Classes:
     ContainerInstancePushProvisioner: A class for provisioning infrastructure using Azure Container Instances.
 
 """
+
 import json
 import random
 import shlex

prefect/infrastructure/provisioners/ecs.py

@@ -367,7 +367,7 @@ class AuthenticationResource:
         work_pool_name: str,
         user_name: str = "prefect-ecs-user",
         policy_name: str = "prefect-ecs-policy",
-        credentials_block_name: str = None,
+        credentials_block_name: Optional[str] = None,
     ):
         self._user_name = user_name
         self._credentials_block_name = (
@@ -1130,7 +1130,7 @@ class ElasticContainerServicePushProvisioner:
         work_pool_name: str,
         user_name: str = "prefect-ecs-user",
         policy_name: str = "prefect-ecs-policy",
-        credentials_block_name: str = None,
+        credentials_block_name: Optional[str] = None,
         cluster_name: str = "prefect-ecs-cluster",
         vpc_name: str = "prefect-ecs-vpc",
         ecs_security_group_name: str = "prefect-ecs-security-group",

prefect/input/__init__.py

@@ -12,6 +12,8 @@ from .run_input import (
     RunInputMetadata,
     keyset_from_base_key,
     keyset_from_paused_state,
+    receive_input,
+    send_input,
 )
 
 __all__ = [
@@ -26,4 +28,6 @@ __all__ = [
     "keyset_from_base_key",
     "keyset_from_paused_state",
     "read_flow_run_input",
+    "receive_input",
+    "send_input",
 ]

prefect/logging/formatters.py

@@ -78,8 +78,8 @@ class PrefectFormatter(logging.Formatter):
         validate=True,
         *,
         defaults=None,
-        task_run_fmt: str = None,
-        flow_run_fmt: str = None,
+        task_run_fmt: Optional[str] = None,
+        flow_run_fmt: Optional[str] = None,
     ) -> None:
         """
         Implementation of the standard Python formatter with support for multiple

prefect/logging/handlers.py

@@ -108,8 +108,8 @@ class APILogHandler(logging.Handler):
                 )
 
             # Not ideal, but this method is called by the stdlib and cannot return a
-            # coroutine so we just schedule the drain in a new thread and continue
-            from_sync.call_soon_in_new_thread(create_call(APILogWorker.drain_all))
+            # coroutine so we just schedule the drain in the global loop thread and continue
+            from_sync.call_soon_in_loop_thread(create_call(APILogWorker.drain_all))
             return None
         else:
             # We set a timeout of 5s because we don't want to block forever if the worker

prefect/logging/loggers.py

@@ -69,7 +69,7 @@ class PrefectLogAdapter(logging.LoggerAdapter):
 
 
 @lru_cache()
-def get_logger(name: str = None) -> logging.Logger:
+def get_logger(name: Optional[str] = None) -> logging.Logger:
     """
     Get a `prefect` logger. These loggers are intended for internal use within the
     `prefect` package.

prefect/plugins.py

@@ -7,6 +7,7 @@ Currently supported entrypoints:
     - prefect.collections: Identifies this package as a Prefect collection that
         should be imported when Prefect is imported.
 """
+
 import sys
 from types import ModuleType
 from typing import Any, Dict, Union

prefect/records/cache_policies.py

@@ -77,7 +77,7 @@ class CacheKeyFnPolicy(CachePolicy):
 
 @dataclass
 class CompoundCachePolicy(CachePolicy):
-    policies: list = None
+    policies: Optional[list] = None
 
     def compute_key(
         self,
@@ -87,7 +87,7 @@ class CompoundCachePolicy(CachePolicy):
         **kwargs,
     ) -> Optional[str]:
         keys = []
-        for policy in self.policies:
+        for policy in self.policies or []:
             keys.append(
                 policy.compute_key(
                     task_ctx=task_ctx,
@@ -153,7 +153,7 @@ class Inputs(CachePolicy):
     And exclude/include config.
     """
 
-    exclude: list = None
+    exclude: Optional[list] = None
 
     def compute_key(
         self,

prefect/records/result_store.py

@@ -1,7 +1,8 @@
 from dataclasses import dataclass
 from typing import Any
 
-from prefect.exceptions import ObjectNotFound
+import pendulum
+
 from prefect.results import BaseResult, PersistedResult, ResultFactory
 from prefect.utilities.asyncutils import run_coro_as_sync
 
@@ -17,9 +18,15 @@ class ResultFactoryStore(RecordStore):
         try:
             result = self.read(key)
             result.get(_sync=True)
+            if result.expiration:
+                # if the result has an expiration,
+                # check if it is still in the future
+                exists = result.expiration > pendulum.now("utc")
+            else:
+                exists = True
             self.cache = result
-            return True
-        except (ObjectNotFound, ValueError):
+            return exists
+        except Exception:
             return False
 
     def read(self, key: str) -> BaseResult:

prefect/results.py

@@ -18,6 +18,7 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field, PrivateAttr, ValidationError
 from pydantic_core import PydanticUndefinedType
+from pydantic_extra_types.pendulum_dt import DateTime
 from typing_extensions import ParamSpec, Self
 
 import prefect
@@ -37,6 +38,7 @@ from prefect.settings import (
     PREFECT_RESULTS_DEFAULT_SERIALIZER,
     PREFECT_RESULTS_PERSIST_BY_DEFAULT,
     PREFECT_TASK_SCHEDULING_DEFAULT_STORAGE_BLOCK,
+    default_result_storage_block_name,
 )
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import sync_compatible
@@ -66,11 +68,18 @@ async def get_default_result_storage() -> ResultStorage:
     """
     Generate a default file system for result storage.
     """
-    return (
-        await Block.load(PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value())
-        if PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value() is not None
-        else LocalFileSystem(basepath=PREFECT_LOCAL_STORAGE_PATH.value())
-    )
+    try:
+        return await Block.load(PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value())
+    except ValueError as e:
+        if "Unable to find" not in str(e):
+            raise e
+        elif (
+            PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value()
+            == default_result_storage_block_name()
+        ):
+            return LocalFileSystem(basepath=PREFECT_LOCAL_STORAGE_PATH.value())
+        else:
+            raise
 
 
 _default_task_scheduling_storages: Dict[Tuple[str, str], WritableFileSystem] = {}
@@ -271,13 +280,6 @@ class ResultFactory(BaseModel):
         """
         Create a new result factory for a task.
         """
-        from prefect.context import FlowRunContext
-
-        ctx = FlowRunContext.get()
-
-        if ctx and ctx.autonomous_task_run:
-            return await cls.from_autonomous_task(task, client=client)
-
         return await cls._from_task(task, get_default_result_storage, client=client)
 
     @classmethod
@@ -426,16 +428,16 @@ class ResultFactory(BaseModel):
             )
 
     @sync_compatible
-    async def create_result(self, obj: R, key: str = None) -> Union[R, "BaseResult[R]"]:
+    async def create_result(
+        self, obj: R, key: Optional[str] = None, expiration: Optional[DateTime] = None
+    ) -> Union[R, "BaseResult[R]"]:
         """
         Create a result type for the given object.
 
         If persistence is disabled, the object is wrapped in an `UnpersistedResult` and
         returned.
 
-        If persistence is enabled:
-        - Bool and null types are converted into `LiteralResult`.
-        - Other types are serialized, persisted to storage, and a reference is returned.
+        If persistence is enabled the object is serialized, persisted to storage, and a reference is returned.
         """
         # Null objects are "cached" in memory at no cost
         should_cache_object = self.cache_result_in_memory or obj is None
@@ -443,9 +445,6 @@ class ResultFactory(BaseModel):
         if not self.persist_result:
             return await UnpersistedResult.create(obj, cache_object=should_cache_object)
 
-        if type(obj) in LITERAL_TYPES:
-            return await LiteralResult.create(obj)
-
         if key:
 
             def key_fn():
@@ -462,6 +461,7 @@ class ResultFactory(BaseModel):
             storage_key_fn=storage_key_fn,
             serializer=self.serializer,
             cache_object=should_cache_object,
+            expiration=expiration,
         )
 
     @sync_compatible
@@ -569,41 +569,6 @@ class UnpersistedResult(BaseResult):
         return result
 
 
-class LiteralResult(BaseResult):
-    """
-    Result type for literal values like `None`, `True`, `False`.
-
-    These values are stored inline and JSON serialized when sent to the Prefect API.
-    They are not persisted to external result storage.
-    """
-
-    type: str = "literal"
-    value: Any = None
-
-    def has_cached_object(self) -> bool:
-        # This result type always has the object cached in memory
-        return True
-
-    @sync_compatible
-    async def get(self) -> R:
-        return self.value
-
-    @classmethod
-    @sync_compatible
-    async def create(
-        cls: "Type[LiteralResult]",
-        obj: R,
-    ) -> "LiteralResult[R]":
-        if type(obj) not in LITERAL_TYPES:
-            raise TypeError(
-                f"Unsupported type {type(obj).__name__!r} for result literal. Expected"
-                f" one of: {', '.join(type_.__name__ for type_ in LITERAL_TYPES)}"
-            )
-
-        description = f"Result with value `{obj}` persisted to Prefect."
-        return cls(value=obj, artifact_type="result", artifact_description=description)
-
-
 class PersistedResult(BaseResult):
     """
     Result type which stores a reference to a persisted result.
@@ -619,6 +584,7 @@ class PersistedResult(BaseResult):
     serializer_type: str
     storage_block_id: uuid.UUID
     storage_key: str
+    expiration: Optional[DateTime] = None
 
     _should_cache_object: bool = PrivateAttr(default=True)
 
@@ -634,6 +600,7 @@ class PersistedResult(BaseResult):
 
         blob = await self._read_blob(client=client)
         obj = blob.serializer.loads(blob.data)
+        self.expiration = blob.expiration
 
         if self._should_cache_object:
             self._cache_object(obj)
@@ -673,6 +640,7 @@ class PersistedResult(BaseResult):
         storage_key_fn: Callable[[], str],
         serializer: Serializer,
         cache_object: bool = True,
+        expiration: Optional[DateTime] = None,
     ) -> "PersistedResult[R]":
         """
         Create a new result reference from a user's object.
@@ -684,7 +652,9 @@ class PersistedResult(BaseResult):
             storage_block_id is not None
         ), "Unexpected storage block ID. Was it persisted?"
         data = serializer.dumps(obj)
-        blob = PersistedResultBlob(serializer=serializer, data=data)
+        blob = PersistedResultBlob(
+            serializer=serializer, data=data, expiration=expiration
+        )
 
         key = storage_key_fn()
         if not isinstance(key, str):
@@ -709,6 +679,7 @@ class PersistedResult(BaseResult):
             storage_key=key,
             artifact_type="result",
             artifact_description=description,
+            expiration=expiration,
         )
 
         if cache_object:
@@ -730,6 +701,7 @@ class PersistedResultBlob(BaseModel):
     serializer: Serializer
     data: bytes
     prefect_version: str = Field(default=prefect.__version__)
+    expiration: Optional[DateTime] = None
 
     def to_bytes(self) -> bytes:
         return self.model_dump_json(serialize_as_any=True).encode()

prefect/runner/runner.py

@@ -209,7 +209,7 @@ class Runner:
     async def add_flow(
         self,
         flow: Flow,
-        name: str = None,
+        name: Optional[str] = None,
         interval: Optional[
             Union[
                 Iterable[Union[int, float, datetime.timedelta]],

prefect/runner/server.py

@@ -42,7 +42,7 @@ class RunnerGenericFlowRunRequest(BaseModel):
     parent_task_run_id: Optional[uuid.UUID] = None
 
 
-def perform_health_check(runner, delay_threshold: int = None) -> JSONResponse:
+def perform_health_check(runner, delay_threshold: Optional[int] = None) -> JSONResponse:
     if delay_threshold is None:
         delay_threshold = (
             PREFECT_RUNNER_SERVER_MISSED_POLLS_TOLERANCE.value()

prefect/runtime/__init__.py

@@ -8,6 +8,7 @@ Example usage:
     print(f"This script is running from deployment {deployment.id} with parameters {deployment.parameters}")
     ```
 """
+
 import prefect.runtime.deployment
 import prefect.runtime.flow_run
 import prefect.runtime.task_run

prefect/runtime/deployment.py

@@ -24,6 +24,7 @@ Available attributes:
         include default values set on the flow function, only the parameter values set on the deployment
         object or those directly provided via API for this run
 """
+
 import os
 from typing import Any, Dict, List, Optional
 

prefect/runtime/flow_run.py

@@ -18,6 +18,7 @@ Available attributes:
     - `parent_deployment_id`: the ID of the deployment that triggered this run, if any
     - `run_count`: the number of times this flow run has been run
 """
+
 import os
 from typing import Any, Dict, List, Optional
 

prefect/runtime/task_run.py

@@ -14,6 +14,7 @@ Available attributes:
     - `run_count`: the number of times this task run has been run
     - `task_name`: the name of the task
 """
+
 import os
 from typing import Any, Dict, List, Optional