prefect-client 3.0.0rc19__py3-none-any.whl → 3.0.1__py3-none-any.whl

prefect/locking/protocol.py

@@ -0,0 +1,122 @@
+from typing import Optional, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class LockManager(Protocol):
+    def acquire_lock(
+        self,
+        key: str,
+        holder: str,
+        acquire_timeout: Optional[float] = None,
+        hold_timeout: Optional[float] = None,
+    ) -> bool:
+        """
+        Acquire a lock for a transaction record with the given key. Will block other
+        actors from updating this transaction record until the lock is
+        released.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock.
+            acquire_timeout: Max number of seconds to wait for the record to become
+                available if it is locked while attempting to acquire a lock. Pass 0
+                to attempt to acquire a lock without waiting. Blocks indefinitely by
+                default.
+            hold_timeout: Max number of seconds to hold the lock for. Holds the lock
+                indefinitely by default.
+
+        Returns:
+            bool: True if the lock was successfully acquired; False otherwise.
+        """
+        ...
+
+    async def aacquire_lock(
+        self,
+        key: str,
+        holder: str,
+        acquire_timeout: Optional[float] = None,
+        hold_timeout: Optional[float] = None,
+    ) -> bool:
+        """
+        Acquire a lock for a transaction record with the given key. Will block other
+        actors from updating this transaction record until the lock is
+        released.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock.
+            acquire_timeout: Max number of seconds to wait for the record to become
+                available if it is locked while attempting to acquire a lock. Pass 0
+                to attempt to acquire a lock without waiting. Blocks indefinitely by
+                default.
+            hold_timeout: Max number of seconds to hold the lock for. Holds the lock
+                indefinitely by default.
+
+        Returns:
+            bool: True if the lock was successfully acquired; False otherwise.
+        """
+        ...
+
+    def release_lock(self, key: str, holder: str):
+        """
+        Releases the lock on the corresponding transaction record.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock. Must match the
+                holder provided when acquiring the lock.
+        """
+        ...
+
+    def is_locked(self, key: str) -> bool:
+        """
+        Simple check to see if the corresponding record is currently locked.
+
+        Args:
+            key: Unique identifier for the transaction record.
+
+        Returns:
+            True is the record is locked; False otherwise.
+        """
+        ...
+
+    def is_lock_holder(self, key: str, holder: str) -> bool:
+        """
+        Check if the current holder is the lock holder for the transaction record.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            holder: Unique identifier for the holder of the lock.
+
+        Returns:
+            bool: True if the current holder is the lock holder; False otherwise.
+        """
+        ...
+
+    def wait_for_lock(self, key: str, timeout: Optional[float] = None) -> bool:
+        """
+        Wait for the corresponding transaction record to become free.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            timeout: Maximum time to wait. None means to wait indefinitely.
+
+        Returns:
+            bool: True if the lock becomes free within the timeout; False
+                otherwise.
+        """
+        ...
+
+    async def await_for_lock(self, key: str, timeout: Optional[float] = None) -> bool:
+        """
+        Wait for the corresponding transaction record to become free.
+
+        Args:
+            key: Unique identifier for the transaction record.
+            timeout: Maximum time to wait. None means to wait indefinitely.
+
+        Returns:
+            bool: True if the lock becomes free within the timeout; False
+                otherwise.
+        """
+        ...

prefect/logging/handlers.py

@@ -157,7 +157,10 @@ class APILogHandler(logging.Handler):
             if log_handling_when_missing_flow == "warn":
                 # Warn when a logger is used outside of a run context, the stack level here
                 # gets us to the user logging call
-                warnings.warn(str(exc), stacklevel=8)
+                warnings.warn(
+                    f"{exc} Set PREFECT_LOGGING_TO_API_WHEN_MISSING_FLOW=ignore to suppress this warning.",
+                    stacklevel=8,
+                )
                 return
             elif log_handling_when_missing_flow == "ignore":
                 return

prefect/main.py

@@ -6,7 +6,6 @@ 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
@@ -26,10 +25,14 @@ 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()
+prefect.context.FlowRunContext.model_rebuild(
+    _types_namespace={"Flow": Flow, "BaseResult": BaseResult}
+)
+prefect.context.TaskRunContext.model_rebuild(_types_namespace={"Task": Task})
+prefect.client.schemas.State.model_rebuild(_types_namespace={"BaseResult": BaseResult})
+prefect.client.schemas.StateCreate.model_rebuild(
+    _types_namespace={"BaseResult": BaseResult}
+)
 Transaction.model_rebuild()
 
 # Configure logging
@@ -55,7 +58,6 @@ __all__ = [
     "Flow",
     "get_client",
     "get_run_logger",
-    "Manifest",
     "State",
     "tags",
     "task",

prefect/records/filesystem.py

@@ -76,7 +76,7 @@ class FileSystemRecordStore(RecordStore):
             return None
 
     def read(
-        self, key: str, holder: Optional[str] = None
+        self, key: str, holder: Optional[str] = None, timeout: Optional[float] = None
     ) -> Optional[TransactionRecord]:
         if not self.exists(key):
             return None
@@ -84,7 +84,9 @@ class FileSystemRecordStore(RecordStore):
         holder = holder or self.generate_default_holder()
 
         if self.is_locked(key) and not self.is_lock_holder(key, holder):
-            self.wait_for_lock(key)
+            unlocked = self.wait_for_lock(key, timeout=timeout)
+            if not unlocked:
+                return None
         record_data = self.records_directory.joinpath(key).read_text()
         return TransactionRecord(
             key=key, result=BaseResult.model_validate_json(record_data)

prefect/records/result_store.py

@@ -3,7 +3,7 @@ from typing import Any, Optional
 
 import pendulum
 
-from prefect.results import BaseResult, PersistedResult, ResultFactory
+from prefect.results import BaseResult, PersistedResult, ResultStore
 from prefect.transactions import IsolationLevel
 from prefect.utilities.asyncutils import run_coro_as_sync
 
@@ -11,8 +11,14 @@ from .base import RecordStore, TransactionRecord
 
 
 @dataclass
-class ResultFactoryStore(RecordStore):
-    result_factory: ResultFactory
+class ResultRecordStore(RecordStore):
+    """
+    A record store for result records.
+
+    Collocates result metadata with result data.
+    """
+
+    result_store: ResultStore
     cache: Optional[PersistedResult] = None
 
     def exists(self, key: str) -> bool:
@@ -38,8 +44,8 @@ class ResultFactoryStore(RecordStore):
             return TransactionRecord(key=key, result=self.cache)
         try:
             result = PersistedResult(
-                serializer_type=self.result_factory.serializer.type,
-                storage_block_id=self.result_factory.storage_block_id,
+                serializer_type=self.result_store.serializer.type,
+                storage_block_id=self.result_store.result_storage_block_id,
                 storage_key=key,
             )
             return TransactionRecord(key=key, result=result)
@@ -52,7 +58,7 @@ class ResultFactoryStore(RecordStore):
             # if the value is already a persisted result, write it
             result.write(_sync=True)
         elif not isinstance(result, BaseResult):
-            run_coro_as_sync(self.result_factory.create_result(obj=result, key=key))
+            run_coro_as_sync(self.result_store.create_result(obj=result, key=key))
 
     def supports_isolation_level(self, isolation_level: IsolationLevel) -> bool:
         return isolation_level == IsolationLevel.READ_COMMITTED