checkpointer 2.11.0__py3-none-any.whl → 2.11.1__py3-none-any.whl

checkpointer/checkpoint.py

@@ -129,7 +129,7 @@ class CachedFunction(Generic[Fn]):
     for ident in depend_idents: ident.fn_hash
     return self
 
-  def get_call_id(self, args: tuple, kw: dict[str, object]) -> str:
+  def get_call_hash(self, args: tuple, kw: dict[str, object]) -> str:
     args = self.bound + args
     pos_args = args[len(self.arg_names):]
     named_pos_args = dict(zip(self.arg_names, args))
@@ -143,8 +143,8 @@ class CachedFunction(Generic[Fn]):
         pos_args = tuple(map(pos_hash_by, pos_args))
     return str(ObjectHash(named_args, pos_args, self.ident.captured_hash, digest_size=16))
 
-  async def _resolve_coroutine(self, call_id: str, coroutine: Coroutine):
-    return self.storage.store(call_id, AwaitableValue(await coroutine)).value
+  async def _resolve_coroutine(self, call_hash: str, coroutine: Coroutine):
+    return self.storage.store(call_hash, AwaitableValue(await coroutine)).value
 
   def _call(self: CachedFunction[Callable[P, R]], args: tuple, kw: dict, rerun=False) -> R:
     full_args = self.bound + args
@@ -152,27 +152,27 @@ class CachedFunction(Generic[Fn]):
     if not params.when:
       return self.fn(*full_args, **kw)
 
-    call_id = self.get_call_id(args, kw)
-    call_id_long = f"{self.fn_dir}/{self.ident.fn_hash}/{call_id}"
+    call_hash = self.get_call_hash(args, kw)
+    call_hash_long = f"{self.fn_dir}/{self.ident.fn_hash}/{call_hash}"
 
     refresh = rerun \
-      or not self.storage.exists(call_id) \
-      or (params.should_expire and params.should_expire(self.storage.checkpoint_date(call_id)))
+      or not self.storage.exists(call_hash) \
+      or (params.should_expire and params.should_expire(self.storage.checkpoint_date(call_hash)))
 
     if refresh:
-      print_checkpoint(params.verbosity >= 1, "MEMORIZING", call_id_long, "blue")
+      print_checkpoint(params.verbosity >= 1, "MEMORIZING", call_hash_long, "blue")
       data = self.fn(*full_args, **kw)
       if iscoroutine(data):
-        return self._resolve_coroutine(call_id, data)
-      return self.storage.store(call_id, data)
+        return self._resolve_coroutine(call_hash, data)
+      return self.storage.store(call_hash, data)
 
     try:
-      data = self.storage.load(call_id)
-      print_checkpoint(params.verbosity >= 2, "REMEMBERED", call_id_long, "green")
+      data = self.storage.load(call_hash)
+      print_checkpoint(params.verbosity >= 2, "REMEMBERED", call_hash_long, "green")
       return data
     except (EOFError, FileNotFoundError):
       pass
-    print_checkpoint(params.verbosity >= 1, "CORRUPTED", call_id_long, "yellow")
+    print_checkpoint(params.verbosity >= 1, "CORRUPTED", call_hash_long, "yellow")
     return self._call(args, kw, True)
 
   def __call__(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
@@ -181,23 +181,30 @@ class CachedFunction(Generic[Fn]):
   def rerun(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
     return self._call(args, kw, True)
 
+  def exists(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> bool:
+    return self.storage.exists(self.get_call_hash(args, kw))
+
+  def delete(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs):
+    self.storage.delete(self.get_call_hash(args, kw))
+
   @overload
   def get(self: Callable[P, Coroutine[object, object, R]], *args: P.args, **kw: P.kwargs) -> R: ...
   @overload
   def get(self: Callable[P, R], *args: P.args, **kw: P.kwargs) -> R: ...
   def get(self, *args, **kw):
-    call_id = self.get_call_id(args, kw)
+    call_hash = self.get_call_hash(args, kw)
     try:
-      data = self.storage.load(call_id)
+      data = self.storage.load(call_hash)
       return data.value if isinstance(data, AwaitableValue) else data
     except Exception as ex:
       raise CheckpointError("Could not load checkpoint") from ex
 
-  def exists(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> bool:
-    return self.storage.exists(self.get_call_id(args, kw))
-
-  def delete(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs):
-    self.storage.delete(self.get_call_id(args, kw))
+  @overload
+  def _set(self: Callable[P, Coroutine[object, object, R]], value: AwaitableValue[R], *args: P.args, **kw: P.kwargs): ...
+  @overload
+  def _set(self: Callable[P, R], value: R, *args: P.args, **kw: P.kwargs): ...
+  def _set(self, value, *args, **kw):
+    self.storage.store(self.get_call_hash(args, kw), value)
 
   def __repr__(self) -> str:
     return f"<CachedFunction {self.fn.__name__} {self.ident.fn_hash[:6]}>"

checkpointer/storages/memory_storage.py

@@ -9,21 +9,21 @@ class MemoryStorage(Storage):
   def get_dict(self):
     return item_map.setdefault(self.fn_dir(), {})
 
-  def store(self, call_id, data):
-    self.get_dict()[call_id] = (datetime.now(), data)
+  def store(self, call_hash, data):
+    self.get_dict()[call_hash] = (datetime.now(), data)
     return data
 
-  def exists(self, call_id):
-    return call_id in self.get_dict()
+  def exists(self, call_hash):
+    return call_hash in self.get_dict()
 
-  def checkpoint_date(self, call_id):
-    return self.get_dict()[call_id][0]
+  def checkpoint_date(self, call_hash):
+    return self.get_dict()[call_hash][0]
 
-  def load(self, call_id):
-    return self.get_dict()[call_id][1]
+  def load(self, call_hash):
+    return self.get_dict()[call_hash][1]
 
-  def delete(self, call_id):
-    self.get_dict().pop(call_id, None)
+  def delete(self, call_hash):
+    self.get_dict().pop(call_hash, None)
 
   def cleanup(self, invalidated=True, expired=True):
     curr_key = self.fn_dir()
@@ -32,6 +32,6 @@ class MemoryStorage(Storage):
         if invalidated and key != curr_key:
           del item_map[key]
         elif expired and self.checkpointer.should_expire:
-          for call_id, (date, _) in list(calldict.items()):
+          for call_hash, (date, _) in list(calldict.items()):
             if self.checkpointer.should_expire(date):
-              del calldict[call_id]
+              del calldict[call_hash]

checkpointer/storages/pickle_storage.py

@@ -8,29 +8,29 @@ def filedate(path: Path) -> datetime:
   return datetime.fromtimestamp(path.stat().st_mtime)
 
 class PickleStorage(Storage):
-  def get_path(self, call_id: str):
-    return self.fn_dir() / f"{call_id}.pkl"
+  def get_path(self, call_hash: str):
+    return self.fn_dir() / f"{call_hash}.pkl"
 
-  def store(self, call_id, data):
-    path = self.get_path(call_id)
+  def store(self, call_hash, data):
+    path = self.get_path(call_hash)
     path.parent.mkdir(parents=True, exist_ok=True)
     with path.open("wb") as file:
       pickle.dump(data, file, -1)
     return data
 
-  def exists(self, call_id):
-    return self.get_path(call_id).exists()
+  def exists(self, call_hash):
+    return self.get_path(call_hash).exists()
 
-  def checkpoint_date(self, call_id):
+  def checkpoint_date(self, call_hash):
     # Should use st_atime/access time?
-    return filedate(self.get_path(call_id))
+    return filedate(self.get_path(call_hash))
 
-  def load(self, call_id):
-    with self.get_path(call_id).open("rb") as file:
+  def load(self, call_hash):
+    with self.get_path(call_hash).open("rb") as file:
       return pickle.load(file)
 
-  def delete(self, call_id):
-    self.get_path(call_id).unlink(missing_ok=True)
+  def delete(self, call_hash):
+    self.get_path(call_hash).unlink(missing_ok=True)
 
   def cleanup(self, invalidated=True, expired=True):
     version_path = self.fn_dir()

checkpointer/storages/storage.py

@@ -20,14 +20,14 @@ class Storage:
   def fn_dir(self) -> Path:
     return self.checkpointer.root_path / self.fn_id()
 
-  def store(self, call_id: str, data: Any) -> Any: ...
+  def store(self, call_hash: str, data: Any) -> Any: ...
 
-  def exists(self, call_id: str) -> bool: ...
+  def exists(self, call_hash: str) -> bool: ...
 
-  def checkpoint_date(self, call_id: str) -> datetime: ...
+  def checkpoint_date(self, call_hash: str) -> datetime: ...
 
-  def load(self, call_id: str) -> Any: ...
+  def load(self, call_hash: str) -> Any: ...
 
-  def delete(self, call_id: str) -> None: ...
+  def delete(self, call_hash: str) -> None: ...
 
   def cleanup(self, invalidated=True, expired=True): ...

checkpointer/types.py

@@ -8,8 +8,8 @@ class HashBy(Generic[Fn]):
 
 NoHash = Annotated[T, HashBy[lambda _: None]]
 
-class AwaitableValue:
-  def __init__(self, value):
+class AwaitableValue(Generic[T]):
+  def __init__(self, value: T):
     self.value = value
 
   def __await__(self):

{checkpointer-2.11.0.dist-info → checkpointer-2.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: checkpointer
-Version: 2.11.0
+Version: 2.11.1
 Summary: checkpointer adds code-aware caching to Python functions, maintaining correctness and speeding up execution as your code changes.
 Project-URL: Repository, https://github.com/Reddan/checkpointer.git
 Author: Hampus Hallman
@@ -166,7 +166,7 @@ In this example, the cache key for `numbers` ignores order, `data_file` is hashe
 
 For integration with databases, cloud storage, or custom serialization, implement your own storage backend by inheriting from `checkpointer.Storage` and implementing its abstract methods.
 
-Within custom storage methods, `call_id` identifies calls by arguments. Use `self.fn_id()` to get the function's unique identity (name + hash/version), crucial for organizing stored checkpoints (e.g., by function version). Access global `Checkpointer` config via `self.checkpointer`.
+Within custom storage methods, `call_hash` identifies calls by arguments. Use `self.fn_id()` to get the function's unique identity (name + hash/version), crucial for organizing stored checkpoints (e.g., by function version). Access global `Checkpointer` config via `self.checkpointer`.
 
 **Example: Custom Storage Backend**
 
@@ -175,18 +175,18 @@ from checkpointer import checkpoint, Storage
 from datetime import datetime
 
 class MyCustomStorage(Storage):
-    def exists(self, call_id):
+    def exists(self, call_hash):
         # Example: Constructing a path based on function ID and call ID
         fn_dir = self.checkpointer.root_path / self.fn_id()
-        return (fn_dir / call_id).exists()
+        return (fn_dir / call_hash).exists()
 
-    def store(self, call_id, data):
-        ... # Store the serialized data for `call_id`
+    def store(self, call_hash, data):
+        ... # Store the serialized data for `call_hash`
         return data # This method must return the data back to checkpointer
 
-    def checkpoint_date(self, call_id): ...
-    def load(self, call_id): ...
-    def delete(self, call_id): ...
+    def checkpoint_date(self, call_hash): ...
+    def load(self, call_hash): ...
+    def delete(self, call_hash): ...
 
 @checkpoint(format=MyCustomStorage)
 def custom_cached_function(x: int):

checkpointer-2.11.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+checkpointer/__init__.py,sha256=ayjFyHwvl_HRHwocY-hOJvAx0Ko5X9IMZrNT4CwfoMU,824
+checkpointer/checkpoint.py,sha256=fSIgZATbTMBwZWLeWH3wIzHoPRQ5LySeb9Ygi30rCg8,9415
+checkpointer/fn_ident.py,sha256=-5XbovQowVyYCFc7JdT9z1NoIEiL8h9fi7alF_34Ils,4470
+checkpointer/object_hash.py,sha256=YlyFupQrg3V2mpzTLfOqpqlZWhoSCHliScQ4cKd36T0,8133
+checkpointer/print_checkpoint.py,sha256=aJCeWMRJiIR3KpyPk_UOKTaD906kArGrmLGQ3LqcVgo,1369
+checkpointer/test_checkpointer.py,sha256=-EvsMMNOOiIxhTcG97LLX0jUMWp534ko7qCKDSFWiA0,3802
+checkpointer/types.py,sha256=_dxYqzqzV8GB_g-MQlN_Voie32syKy8u7RHbc0i4upY,338
+checkpointer/utils.py,sha256=0cGVSlTnABgs3jI1uHoTfz353kkGa-qtTfe7jG4NCr0,2192
+checkpointer/storages/__init__.py,sha256=en32nTUltpCSgz8RVGS_leIHC1Y1G89IqG1ZqAb6qUo,236
+checkpointer/storages/memory_storage.py,sha256=aQRSOmAfS0UudubCpv8cdfu2ycM8mlsO9tFMcD2kmgo,1133
+checkpointer/storages/pickle_storage.py,sha256=je1LM2lTSs5yzm25Apg5tJ9jU9T6nXCgD9SlqQRIFaM,1652
+checkpointer/storages/storage.py,sha256=5Jel7VlmCG9gnIbZFKT1NrEiAePz8ZD8hfsD-tYEiP4,905
+checkpointer-2.11.1.dist-info/METADATA,sha256=vpXrjRj8-yid19Lh_tU45cNdVkYalFj_RP3pRCm3S8A,11633
+checkpointer-2.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+checkpointer-2.11.1.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
+checkpointer-2.11.1.dist-info/RECORD,,

checkpointer-2.11.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-checkpointer/__init__.py,sha256=ayjFyHwvl_HRHwocY-hOJvAx0Ko5X9IMZrNT4CwfoMU,824
-checkpointer/checkpoint.py,sha256=zU67_PGrVCMP90clPTR7AA4vfxECqmeFr0jJElUL5iQ,9051
-checkpointer/fn_ident.py,sha256=-5XbovQowVyYCFc7JdT9z1NoIEiL8h9fi7alF_34Ils,4470
-checkpointer/object_hash.py,sha256=YlyFupQrg3V2mpzTLfOqpqlZWhoSCHliScQ4cKd36T0,8133
-checkpointer/print_checkpoint.py,sha256=aJCeWMRJiIR3KpyPk_UOKTaD906kArGrmLGQ3LqcVgo,1369
-checkpointer/test_checkpointer.py,sha256=-EvsMMNOOiIxhTcG97LLX0jUMWp534ko7qCKDSFWiA0,3802
-checkpointer/types.py,sha256=rAdjZNn1-jk35df7UVtby_qlp-8_18ucXfVCtS4RI_M,323
-checkpointer/utils.py,sha256=0cGVSlTnABgs3jI1uHoTfz353kkGa-qtTfe7jG4NCr0,2192
-checkpointer/storages/__init__.py,sha256=en32nTUltpCSgz8RVGS_leIHC1Y1G89IqG1ZqAb6qUo,236
-checkpointer/storages/memory_storage.py,sha256=Br30b1AyNOcNjjAaDui1mBjDKfhDbu--jV4WmJenzaE,1109
-checkpointer/storages/pickle_storage.py,sha256=xS96q8TvwxH_TOZsiKmrMrhFwQKZCcaH7XOiECmuwl8,1628
-checkpointer/storages/storage.py,sha256=5NWmnfsU2QY24NwKC5MZNe4h7pcYhADw-y800v17aYE,895
-checkpointer-2.11.0.dist-info/METADATA,sha256=GFRKdyTOIQwvmzIIrkV2owT8NO-X2ONRXdnadY9j5xY,11617
-checkpointer-2.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-checkpointer-2.11.0.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
-checkpointer-2.11.0.dist-info/RECORD,,