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

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
@@ -60,28 +61,15 @@ logger = get_logger("results")
 P = ParamSpec("P")
 R = TypeVar("R")
 
-
-@sync_compatible
-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())
-    )
-
-
-_default_task_scheduling_storages: Dict[Tuple[str, str], WritableFileSystem] = {}
+_default_storages: Dict[Tuple[str, str], WritableFileSystem] = {}
 
 
-async def get_or_create_default_task_scheduling_storage() -> ResultStorage:
+async def _get_or_create_default_storage(block_document_slug: str) -> ResultStorage:
     """
-    Generate a default file system for background task parameter/result storage.
+    Generate a default file system for storage.
     """
     default_storage_name, storage_path = cache_key = (
-        PREFECT_TASK_SCHEDULING_DEFAULT_STORAGE_BLOCK.value(),
+        block_document_slug,
         PREFECT_LOCAL_STORAGE_PATH.value(),
     )
 
@@ -96,8 +84,8 @@ async def get_or_create_default_task_scheduling_storage() -> ResultStorage:
         if block_type_slug == "local-file-system":
             block = LocalFileSystem(basepath=storage_path)
         else:
-            raise Exception(
-                "The default task storage block does not exist, but it is of type "
+            raise ValueError(
+                "The default storage block does not exist, but it is of type "
                 f"'{block_type_slug}' which cannot be created implicitly.  Please create "
                 "the block manually."
             )
@@ -114,13 +102,32 @@ async def get_or_create_default_task_scheduling_storage() -> ResultStorage:
         return block
 
     try:
-        return _default_task_scheduling_storages[cache_key]
+        return _default_storages[cache_key]
     except KeyError:
         storage = await get_storage()
-        _default_task_scheduling_storages[cache_key] = storage
+        _default_storages[cache_key] = storage
         return storage
 
 
+@sync_compatible
+async def get_or_create_default_result_storage() -> ResultStorage:
+    """
+    Generate a default file system for result storage.
+    """
+    return await _get_or_create_default_storage(
+        PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value()
+    )
+
+
+async def get_or_create_default_task_scheduling_storage() -> ResultStorage:
+    """
+    Generate a default file system for background task parameter/result storage.
+    """
+    return await _get_or_create_default_storage(
+        PREFECT_TASK_SCHEDULING_DEFAULT_STORAGE_BLOCK.value()
+    )
+
+
 def get_default_result_serializer() -> ResultSerializer:
     """
     Generate a default file system for result storage.
@@ -201,7 +208,9 @@ class ResultFactory(BaseModel):
                 kwargs.pop(key)
 
         # Apply defaults
-        kwargs.setdefault("result_storage", await get_default_result_storage())
+        kwargs.setdefault(
+            "result_storage", await get_or_create_default_result_storage()
+        )
         kwargs.setdefault("result_serializer", get_default_result_serializer())
         kwargs.setdefault("persist_result", get_default_persist_setting())
         kwargs.setdefault("cache_result_in_memory", True)
@@ -271,14 +280,9 @@ 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)
+        return await cls._from_task(
+            task, get_or_create_default_result_storage, client=client
+        )
 
     @classmethod
     @inject_client
@@ -426,16 +430,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 +447,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 +463,7 @@ class ResultFactory(BaseModel):
             storage_key_fn=storage_key_fn,
             serializer=self.serializer,
             cache_object=should_cache_object,
+            expiration=expiration,
         )
 
     @sync_compatible
@@ -569,41 +571,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 +586,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 +602,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 +642,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 +654,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 +681,7 @@ class PersistedResult(BaseResult):
             storage_key=key,
             artifact_type="result",
             artifact_description=description,
+            expiration=expiration,
         )
 
         if cache_object:
@@ -730,6 +703,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
 

prefect/settings.py

@@ -42,6 +42,7 @@ dependent on the value of other settings or perform other dynamic effects.
 
 import logging
 import os
+import socket
 import string
 import warnings
 from contextlib import contextmanager
@@ -84,6 +85,7 @@ from prefect._internal.schemas.validators import validate_settings
 from prefect.exceptions import MissingProfileError
 from prefect.utilities.names import OBFUSCATED_PREFIX, obfuscate
 from prefect.utilities.pydantic import add_cloudpickle_reduction
+from prefect.utilities.slugify import slugify
 
 T = TypeVar("T")
 
@@ -417,6 +419,18 @@ def warn_on_misconfigured_api_url(values):
     return values
 
 
+def default_result_storage_block_name(
+    settings: Optional["Settings"] = None, value: Optional[str] = None
+):
+    """
+    `value_callback` for `PREFECT_DEFAULT_RESULT_STORAGE_BLOCK_NAME` that sets the default
+    value to the hostname of the machine.
+    """
+    if value is None:
+        return f"local-file-system/{slugify(socket.gethostname())}-storage"
+    return value
+
+
 def default_database_connection_url(settings, value):
     templater = template_with_settings(PREFECT_HOME, PREFECT_API_DATABASE_PASSWORD)
 
@@ -1527,7 +1541,7 @@ The maximum number of retries to queue for submission.
 
 PREFECT_TASK_SCHEDULING_PENDING_TASK_TIMEOUT = Setting(
     timedelta,
-    default=timedelta(seconds=30),
+    default=timedelta(0),
 )
 """
 How long before a PENDING task are made available to another task worker.  In practice,
@@ -1575,8 +1589,7 @@ PREFECT_EXPERIMENTAL_ENABLE_SCHEDULE_CONCURRENCY = Setting(bool, default=False)
 # Defaults -----------------------------------------------------------------------------
 
 PREFECT_DEFAULT_RESULT_STORAGE_BLOCK = Setting(
-    Optional[str],
-    default=None,
+    Optional[str], default=None, value_callback=default_result_storage_block_name
 )
 """The `block-type/block-document` slug of a block to use as the default result storage."""
 

prefect/states.py

@@ -205,7 +205,10 @@ async def exception_to_failed_state(
 
 
 async def return_value_to_state(
-    retval: R, result_factory: ResultFactory, key: str = None
+    retval: R,
+    result_factory: ResultFactory,
+    key: Optional[str] = None,
+    expiration: Optional[datetime.datetime] = None,
 ) -> State[R]:
     """
     Given a return value from a user's function, create a `State` the run should
@@ -238,7 +241,9 @@ async def return_value_to_state(
         # Unless the user has already constructed a result explicitly, use the factory
         # to update the data to the correct type
         if not isinstance(state.data, BaseResult):
-            state.data = await result_factory.create_result(state.data, key=key)
+            state.data = await result_factory.create_result(
+                state.data, key=key, expiration=expiration
+            )
 
         return state
 
@@ -278,7 +283,9 @@ async def return_value_to_state(
         return State(
             type=new_state_type,
             message=message,
-            data=await result_factory.create_result(retval, key=key),
+            data=await result_factory.create_result(
+                retval, key=key, expiration=expiration
+            ),
         )
 
     # Generators aren't portable, implicitly convert them to a list.
@@ -291,7 +298,11 @@ async def return_value_to_state(
     if isinstance(data, BaseResult):
         return Completed(data=data)
     else:
-        return Completed(data=await result_factory.create_result(data, key=key))
+        return Completed(
+            data=await result_factory.create_result(
+                data, key=key, expiration=expiration
+            )
+        )
 
 
 @sync_compatible