prefect-client 3.1.15__py3-none-any.whl → 3.2.0__py3-none-any.whl

prefect/results.py

@@ -14,14 +14,12 @@ from typing import (
     Any,
     Callable,
     ClassVar,
-    Generic,
     Optional,
     TypeVar,
     Union,
 )
 from uuid import UUID
 
-import pendulum
 from cachetools import LRUCache
 from pydantic import (
     BaseModel,
@@ -29,22 +27,16 @@ from pydantic import (
     Discriminator,
     Field,
     Tag,
-    ValidationError,
-    model_validator,
 )
 from typing_extensions import ParamSpec, Self
 
 import prefect
-from prefect._experimental.lineage import (
-    emit_result_read_event,
-    emit_result_write_event,
-)
 from prefect._internal.compatibility.async_dispatch import async_dispatch
+from prefect._result_records import R, ResultRecord, ResultRecordMetadata
 from prefect.blocks.core import Block
 from prefect.exceptions import (
     ConfigurationError,
     MissingContextError,
-    SerializationError,
 )
 from prefect.filesystems import (
     LocalFileSystem,
@@ -53,7 +45,7 @@ from prefect.filesystems import (
 )
 from prefect.locking.protocol import LockManager
 from prefect.logging import get_logger
-from prefect.serializers import PickleSerializer, Serializer
+from prefect.serializers import Serializer
 from prefect.settings.context import get_current_settings
 from prefect.types import DateTime
 from prefect.utilities.annotations import NotSet
@@ -77,7 +69,6 @@ def DEFAULT_STORAGE_KEY_FN() -> str:
 
 logger: "logging.Logger" = get_logger("results")
 P = ParamSpec("P")
-R = TypeVar("R")
 
 _default_storages: dict[tuple[str, str], WritableFileSystem] = {}
 
@@ -373,6 +364,31 @@ class ResultStore(BaseModel):
             return None
         return getattr(self.result_storage, "_block_document_id", None)
 
+    @classmethod
+    async def _from_metadata(cls, metadata: ResultRecordMetadata) -> "ResultRecord[R]":
+        """
+        Create a result record from metadata.
+
+        Will use the result record metadata to fetch data via a result store.
+
+        Args:
+            metadata: The metadata to create the result record from.
+
+        Returns:
+            ResultRecord: The result record.
+        """
+        if metadata.storage_block_id is None:
+            storage_block = None
+        else:
+            storage_block = await aresolve_result_storage(metadata.storage_block_id)
+        store = cls(result_storage=storage_block, serializer=metadata.serializer)
+        if metadata.storage_key is None:
+            raise ValueError(
+                "storage_key is required to hydrate a result record from metadata"
+            )
+        result = await store.aread(metadata.storage_key)
+        return result
+
     @sync_compatible
     async def update_for_flow(self, flow: "Flow[..., Any]") -> Self:
         """
@@ -503,7 +519,7 @@ class ResultStore(BaseModel):
         if metadata.expiration:
             # if the result has an expiration,
             # check if it is still in the future
-            exists = metadata.expiration > pendulum.now("utc")
+            exists = metadata.expiration > DateTime.now("utc")
         else:
             exists = True
         return exists
@@ -555,6 +571,8 @@ class ResultStore(BaseModel):
             A result record.
         """
 
+        from prefect._experimental.lineage import emit_result_read_event
+
         if self.lock_manager is not None and not self.is_lock_holder(key, holder):
             await self.await_for_lock(key)
 
@@ -576,19 +594,19 @@ class ResultStore(BaseModel):
                 {},
             )
             metadata = ResultRecordMetadata.load_bytes(metadata_content)
-            assert (
-                metadata.storage_key is not None
-            ), "Did not find storage key in metadata"
+            assert metadata.storage_key is not None, (
+                "Did not find storage key in metadata"
+            )
             result_content = await _call_explicitly_async_block_method(
                 self.result_storage,
                 "read_path",
                 (metadata.storage_key,),
                 {},
             )
-            result_record: ResultRecord[
-                Any
-            ] = ResultRecord.deserialize_from_result_and_metadata(
-                result=result_content, metadata=metadata_content
+            result_record: ResultRecord[Any] = (
+                ResultRecord.deserialize_from_result_and_metadata(
+                    result=result_content, metadata=metadata_content
+                )
             )
             await emit_result_read_event(self, resolved_key_path)
         else:
@@ -740,9 +758,11 @@ class ResultStore(BaseModel):
             result_record: The result record to persist.
             holder: The holder of the lock if a lock was set on the record.
         """
-        assert (
-            result_record.metadata.storage_key is not None
-        ), "Storage key is required on result record"
+        assert result_record.metadata.storage_key is not None, (
+            "Storage key is required on result record"
+        )
+
+        from prefect._experimental.lineage import emit_result_write_event
 
         key = result_record.metadata.storage_key
         if result_record.metadata.storage_block_id is None:
@@ -1008,230 +1028,3 @@ def get_result_store() -> ResultStore:
     else:
         result_store = run_context.result_store
     return result_store
-
-
-class ResultRecordMetadata(BaseModel):
-    """
-    Metadata for a result record.
-    """
-
-    storage_key: Optional[str] = Field(
-        default=None
-    )  # optional for backwards compatibility
-    expiration: Optional[DateTime] = Field(default=None)
-    serializer: Serializer = Field(default_factory=PickleSerializer)
-    prefect_version: str = Field(default=prefect.__version__)
-    storage_block_id: Optional[uuid.UUID] = Field(default=None)
-
-    def dump_bytes(self) -> bytes:
-        """
-        Serialize the metadata to bytes.
-
-        Returns:
-            bytes: the serialized metadata
-        """
-        return self.model_dump_json(serialize_as_any=True).encode()
-
-    @classmethod
-    def load_bytes(cls, data: bytes) -> "ResultRecordMetadata":
-        """
-        Deserialize metadata from bytes.
-
-        Args:
-            data: the serialized metadata
-
-        Returns:
-            ResultRecordMetadata: the deserialized metadata
-        """
-        return cls.model_validate_json(data)
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, ResultRecordMetadata):
-            return False
-        return (
-            self.storage_key == other.storage_key
-            and self.expiration == other.expiration
-            and self.serializer == other.serializer
-            and self.prefect_version == other.prefect_version
-            and self.storage_block_id == other.storage_block_id
-        )
-
-
-class ResultRecord(BaseModel, Generic[R]):
-    """
-    A record of a result.
-    """
-
-    metadata: ResultRecordMetadata
-    result: R
-
-    @property
-    def expiration(self) -> DateTime | None:
-        return self.metadata.expiration
-
-    @property
-    def serializer(self) -> Serializer:
-        return self.metadata.serializer
-
-    def serialize_result(self) -> bytes:
-        try:
-            data = self.serializer.dumps(self.result)
-        except Exception as exc:
-            extra_info = (
-                'You can try a different serializer (e.g. result_serializer="json") '
-                "or disabling persistence (persist_result=False) for this flow or task."
-            )
-            # check if this is a known issue with cloudpickle and pydantic
-            # and add extra information to help the user recover
-
-            if (
-                isinstance(exc, TypeError)
-                and isinstance(self.result, BaseModel)
-                and str(exc).startswith("cannot pickle")
-            ):
-                try:
-                    from IPython.core.getipython import get_ipython
-
-                    if get_ipython() is not None:
-                        extra_info = inspect.cleandoc(
-                            """
-                            This is a known issue in Pydantic that prevents
-                            locally-defined (non-imported) models from being
-                            serialized by cloudpickle in IPython/Jupyter
-                            environments. Please see
-                            https://github.com/pydantic/pydantic/issues/8232 for
-                            more information. To fix the issue, either: (1) move
-                            your Pydantic class definition to an importable
-                            location, (2) use the JSON serializer for your flow
-                            or task (`result_serializer="json"`), or (3)
-                            disable result persistence for your flow or task
-                            (`persist_result=False`).
-                            """
-                        ).replace("\n", " ")
-                except ImportError:
-                    pass
-            raise SerializationError(
-                f"Failed to serialize object of type {type(self.result).__name__!r} with "
-                f"serializer {self.serializer.type!r}. {extra_info}"
-            ) from exc
-
-        return data
-
-    @model_validator(mode="before")
-    @classmethod
-    def coerce_old_format(cls, value: dict[str, Any] | Any) -> dict[str, Any]:
-        if isinstance(value, dict):
-            if "data" in value:
-                value["result"] = value.pop("data")
-            if "metadata" not in value:
-                value["metadata"] = {}
-            if "expiration" in value:
-                value["metadata"]["expiration"] = value.pop("expiration")
-            if "serializer" in value:
-                value["metadata"]["serializer"] = value.pop("serializer")
-            if "prefect_version" in value:
-                value["metadata"]["prefect_version"] = value.pop("prefect_version")
-        return value
-
-    @classmethod
-    async def _from_metadata(cls, metadata: ResultRecordMetadata) -> "ResultRecord[R]":
-        """
-        Create a result record from metadata.
-
-        Will use the result record metadata to fetch data via a result store.
-
-        Args:
-            metadata: The metadata to create the result record from.
-
-        Returns:
-            ResultRecord: The result record.
-        """
-        if metadata.storage_block_id is None:
-            storage_block = None
-        else:
-            storage_block = await aresolve_result_storage(metadata.storage_block_id)
-        store = ResultStore(
-            result_storage=storage_block, serializer=metadata.serializer
-        )
-        if metadata.storage_key is None:
-            raise ValueError(
-                "storage_key is required to hydrate a result record from metadata"
-            )
-        result = await store.aread(metadata.storage_key)
-        return result
-
-    def serialize_metadata(self) -> bytes:
-        return self.metadata.dump_bytes()
-
-    def serialize(
-        self,
-    ) -> bytes:
-        """
-        Serialize the record to bytes.
-
-        Returns:
-            bytes: the serialized record
-
-        """
-        return (
-            self.model_copy(update={"result": self.serialize_result()})
-            .model_dump_json(serialize_as_any=True)
-            .encode()
-        )
-
-    @classmethod
-    def deserialize(
-        cls, data: bytes, backup_serializer: Serializer | None = None
-    ) -> "ResultRecord[R]":
-        """
-        Deserialize a record from bytes.
-
-        Args:
-            data: the serialized record
-            backup_serializer: The serializer to use to deserialize the result record. Only
-                necessary if the provided data does not specify a serializer.
-
-        Returns:
-            ResultRecord: the deserialized record
-        """
-        try:
-            instance = cls.model_validate_json(data)
-        except ValidationError:
-            if backup_serializer is None:
-                raise
-            else:
-                result = backup_serializer.loads(data)
-                return cls(
-                    metadata=ResultRecordMetadata(serializer=backup_serializer),
-                    result=result,
-                )
-        if isinstance(instance.result, bytes):
-            instance.result = instance.serializer.loads(instance.result)
-        elif isinstance(instance.result, str):
-            instance.result = instance.serializer.loads(instance.result.encode())
-        return instance
-
-    @classmethod
-    def deserialize_from_result_and_metadata(
-        cls, result: bytes, metadata: bytes
-    ) -> "ResultRecord[R]":
-        """
-        Deserialize a record from separate result and metadata bytes.
-
-        Args:
-            result: the result
-            metadata: the serialized metadata
-
-        Returns:
-            ResultRecord: the deserialized record
-        """
-        result_record_metadata = ResultRecordMetadata.load_bytes(metadata)
-        return cls(
-            metadata=result_record_metadata,
-            result=result_record_metadata.serializer.loads(result),
-        )
-
-    def __eq__(self, other: Any | "ResultRecord[Any]") -> bool:
-        if not isinstance(other, ResultRecord):
-            return False
-        return self.metadata == other.metadata and self.result == other.result

prefect/runner/runner.py

@@ -64,7 +64,6 @@ from uuid import UUID, uuid4
 
 import anyio
 import anyio.abc
-import pendulum
 from cachetools import LRUCache
 from typing_extensions import Self
 
@@ -95,6 +94,7 @@ from prefect.exceptions import Abort, ObjectNotFound
 from prefect.flows import Flow, FlowStateHook, load_flow_from_flow_run
 from prefect.logging.loggers import PrefectLogAdapter, flow_run_logger, get_logger
 from prefect.runner.storage import RunnerStorage
+from prefect.schedules import Schedule
 from prefect.settings import (
     PREFECT_API_URL,
     PREFECT_RUNNER_SERVER_ENABLE,
@@ -105,6 +105,7 @@ from prefect.states import (
     Pending,
     exception_to_failed_state,
 )
+from prefect.types._datetime import DateTime
 from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.asyncutils import (
     asyncnullcontext,
@@ -278,6 +279,7 @@ class Runner:
         cron: Optional[Union[Iterable[str], str]] = None,
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
+        schedule: Optional[Schedule] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
         concurrency_limit: Optional[Union[int, ConcurrencyLimitConfig, None]] = None,
         parameters: Optional[dict[str, Any]] = None,
@@ -303,6 +305,8 @@ class Runner:
             cron: A cron schedule of when to execute runs of this flow.
             rrule: An rrule schedule of when to execute runs of this flow.
             paused: Whether or not to set the created deployment as paused.
+            schedule: A schedule object defining when to execute runs of this deployment.
+                Used to provide additional scheduling options like `timezone` or `parameters`.
             schedules: A list of schedule objects defining when to execute runs of this flow.
                 Used to define multiple schedules or additional scheduling options like `timezone`.
             concurrency_limit: The maximum number of concurrent runs of this flow to allow.
@@ -317,7 +321,7 @@ class Runner:
                 entrypoint, ensure that the module will be importable in the execution environment.
         """
         api = PREFECT_API_URL.value()
-        if any([interval, cron, rrule]) and not api:
+        if any([interval, cron, rrule, schedule, schedules]) and not api:
             self._logger.warning(
                 "Cannot schedule flows on an ephemeral server; run `prefect server"
                 " start` to start the scheduler."
@@ -329,6 +333,7 @@ class Runner:
             interval=interval,
             cron=cron,
             rrule=rrule,
+            schedule=schedule,
             schedules=schedules,
             paused=paused,
             triggers=triggers,
@@ -797,7 +802,7 @@ class Runner:
         if self.stopping:
             return
         runs_response = await self._get_scheduled_flow_runs()
-        self.last_polled: pendulum.DateTime = pendulum.now("UTC")
+        self.last_polled: DateTime = DateTime.now("UTC")
         return await self._submit_scheduled_flow_runs(flow_run_response=runs_response)
 
     async def _check_for_cancelled_flow_runs(
@@ -1063,7 +1068,7 @@ class Runner:
         """
         Retrieve scheduled flow runs for this runner.
         """
-        scheduled_before = pendulum.now("utc").add(seconds=int(self._prefetch_seconds))
+        scheduled_before = DateTime.now("utc").add(seconds=int(self._prefetch_seconds))
         self._logger.debug(
             f"Querying for flow runs scheduled before {scheduled_before}"
         )

prefect/runner/server.py

@@ -1,7 +1,6 @@
 import uuid
 from typing import TYPE_CHECKING, Any, Callable, Coroutine, Hashable, Optional, Tuple
 
-import pendulum
 import uvicorn
 from fastapi import APIRouter, FastAPI, HTTPException, status
 from fastapi.responses import JSONResponse
@@ -22,6 +21,7 @@ from prefect.settings import (
     PREFECT_RUNNER_SERVER_MISSED_POLLS_TOLERANCE,
     PREFECT_RUNNER_SERVER_PORT,
 )
+from prefect.types._datetime import DateTime
 from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.importtools import load_script_as_module
 
@@ -54,7 +54,7 @@ def perform_health_check(
         )
 
     def _health_check():
-        now = pendulum.now("utc")
+        now = DateTime.now("utc")
         poll_delay = (now - runner.last_polled).total_seconds()
 
         if poll_delay > delay_threshold:
@@ -139,9 +139,9 @@ async def get_deployment_router(
             )
 
             # Used for updating the route schemas later on
-            schemas[
-                f"{deployment.name}-{deployment_id}"
-            ] = deployment.parameter_openapi_schema
+            schemas[f"{deployment.name}-{deployment_id}"] = (
+                deployment.parameter_openapi_schema
+            )
             schemas[deployment_id] = deployment.name
     return router, schemas
 

prefect/runner/storage.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import shutil
 import subprocess
 from copy import deepcopy
@@ -61,7 +63,7 @@ class RunnerStorage(Protocol):
         """
         ...
 
-    def to_pull_step(self) -> dict[str, Any]:
+    def to_pull_step(self) -> dict[str, Any] | list[dict[str, Any]]:
         """
         Returns a dictionary representation of the storage object that can be
         used as a deployment pull step.
@@ -347,13 +349,13 @@ class GitRepository:
             }
         }
         if self._include_submodules:
-            pull_step["prefect.deployments.steps.git_clone"][
-                "include_submodules"
-            ] = self._include_submodules
+            pull_step["prefect.deployments.steps.git_clone"]["include_submodules"] = (
+                self._include_submodules
+            )
         if isinstance(self._credentials, Block):
-            pull_step["prefect.deployments.steps.git_clone"][
-                "credentials"
-            ] = f"{{{{ {self._credentials.get_block_placeholder()} }}}}"
+            pull_step["prefect.deployments.steps.git_clone"]["credentials"] = (
+                f"{{{{ {self._credentials.get_block_placeholder()} }}}}"
+            )
         elif isinstance(self._credentials, dict):
             if isinstance(self._credentials.get("access_token"), Secret):
                 pull_step["prefect.deployments.steps.git_clone"]["credentials"] = {
@@ -546,9 +548,9 @@ class RemoteStorage:
             }
         }
         if required_package:
-            step["prefect.deployments.steps.pull_from_remote_storage"][
-                "requires"
-            ] = required_package
+            step["prefect.deployments.steps.pull_from_remote_storage"]["requires"] = (
+                required_package
+            )
         return step
 
     def __eq__(self, __value: Any) -> bool:

prefect/runner/submit.py

@@ -101,8 +101,7 @@ def submit_to_runner(
     prefect_callable: Union[Flow[Any, Any], Task[Any, Any]],
     parameters: Dict[str, Any],
     retry_failed_submissions: bool = True,
-) -> FlowRun:
-    ...
+) -> FlowRun: ...
 
 
 @overload
@@ -110,8 +109,7 @@ def submit_to_runner(
     prefect_callable: Union[Flow[Any, Any], Task[Any, Any]],
     parameters: list[dict[str, Any]],
     retry_failed_submissions: bool = True,
-) -> list[FlowRun]:
-    ...
+) -> list[FlowRun]: ...
 
 
 @sync_compatible