prefect-client 3.0.0rc20__py3-none-any.whl → 3.0.2__py3-none-any.whl

prefect/records/filesystem.py

@@ -6,6 +6,7 @@ from typing import Dict, Optional
 import pendulum
 from typing_extensions import TypedDict
 
+from prefect._internal.compatibility import deprecated
 from prefect.logging.loggers import get_logger
 from prefect.records.base import RecordStore, TransactionRecord
 from prefect.results import BaseResult
@@ -29,6 +30,11 @@ class _LockInfo(TypedDict):
     path: Path
 
 
+@deprecated.deprecated_class(
+    start_date="Sep 2024",
+    end_date="Nov 2024",
+    help="Use `ResultStore` with a `LocalFileSystem` for `metadata_storage` and a `FileSystemLockManager` instead.",
+)
 class FileSystemRecordStore(RecordStore):
     """
     A record store that stores data on the local filesystem.
@@ -56,7 +62,6 @@ class FileSystemRecordStore(RecordStore):
     def _get_lock_info(self, key: str, use_cache=True) -> Optional[_LockInfo]:
         if use_cache:
             if (lock_info := self._locks.get(key)) is not None:
-                print("Got lock info from cache")
                 return lock_info
 
         lock_path = self._lock_path_for_key(key)
@@ -70,13 +75,12 @@ class FileSystemRecordStore(RecordStore):
                     pendulum.parse(expiration) if expiration is not None else None
                 )
             self._locks[key] = lock_info
-            print("Got lock info from file")
             return lock_info
         except FileNotFoundError:
             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 +88,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/memory.py

@@ -1,6 +1,7 @@
 import threading
 from typing import Dict, Optional, TypedDict
 
+from prefect._internal.compatibility import deprecated
 from prefect.results import BaseResult
 from prefect.transactions import IsolationLevel
 
@@ -22,6 +23,11 @@ class _LockInfo(TypedDict):
     expiration_timer: Optional[threading.Timer]
 
 
+@deprecated.deprecated_class(
+    start_date="Sep 2024",
+    end_date="Nov 2024",
+    help="Use `ResultStore` with a `MemoryLockManager` instead.",
+)
 class MemoryRecordStore(RecordStore):
     """
     A record store that stores data in memory.

prefect/records/result_store.py

@@ -3,16 +3,28 @@ from typing import Any, Optional
 
 import pendulum
 
-from prefect.results import BaseResult, PersistedResult, ResultFactory
+from prefect._internal.compatibility import deprecated
+from prefect.results import BaseResult, PersistedResult, ResultStore
 from prefect.transactions import IsolationLevel
 from prefect.utilities.asyncutils import run_coro_as_sync
 
 from .base import RecordStore, TransactionRecord
 
 
+@deprecated.deprecated_class(
+    start_date="Sep 2024",
+    end_date="Nov 2024",
+    help="Use `ResultStore` directly instead.",
+)
 @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 +50,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 +64,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