checkpointer 2.11.0__tar.gz → 2.11.1__tar.gz

{checkpointer-2.11.0 → checkpointer-2.11.1}/PKG-INFO

@@ -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.0 → checkpointer-2.11.1}/README.md

@@ -146,7 +146,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**
 
@@ -155,18 +155,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.0 → checkpointer-2.11.1}/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-2.11.0 → checkpointer-2.11.1}/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-2.11.0 → checkpointer-2.11.1}/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-2.11.0 → checkpointer-2.11.1}/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-2.11.0 → checkpointer-2.11.1}/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 → checkpointer-2.11.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "checkpointer"
-version = "2.11.0"
+version = "2.11.1"
 requires-python = ">=3.11"
 dependencies = []
 authors = [
@@ -21,7 +21,7 @@ Repository = "https://github.com/Reddan/checkpointer.git"
 [dependency-groups]
 dev = [
   "numpy>=2.2.1",
-  "omg>=1.3.5",
+  "omg>=1.3.6",
   "poethepoet>=0.30.0",
   "pytest>=8.3.5",
   "pytest-asyncio>=0.26.0",

{checkpointer-2.11.0 → checkpointer-2.11.1}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "checkpointer"
-version = "2.11.0"
+version = "2.11.1"
 source = { editable = "." }
 
 [package.dev-dependencies]
@@ -27,7 +27,7 @@ dev = [
 [package.metadata.requires-dev]
 dev = [
     { name = "numpy", specifier = ">=2.2.1" },
-    { name = "omg", specifier = ">=1.3.5" },
+    { name = "omg", specifier = ">=1.3.6" },
     { name = "poethepoet", specifier = ">=0.30.0" },
     { name = "pytest", specifier = ">=8.3.5" },
     { name = "pytest-asyncio", specifier = ">=0.26.0" },
@@ -330,14 +330,14 @@ wheels = [
 
 [[package]]
 name = "omg"
-version = "1.3.5"
+version = "1.3.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "watchdog" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/29/6b/0ef0bf8cbd936d1ffb9b0b8f5904ef9f98bc965aeb211bb1a8f6139d401c/omg-1.3.5.tar.gz", hash = "sha256:1b105041c28c4278f7c6631f294b60574baa3d4af0c1892643f0f925aa718454", size = 14260 }
+sdist = { url = "https://files.pythonhosted.org/packages/65/06/da0a3778b7ff8f1333ed7ddc0931ffff3c86ab5cb8bc4a96a1d0edb8671b/omg-1.3.6.tar.gz", hash = "sha256:465a51b7576fa31ef313e2b9a77d57f5d4816fb0a14dca0fc5c09ff471074fe6", size = 14268 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/6e/6f7577de8246b963ea1ad9da62e3ea8ab0a2502c21b153319b856ce19f34/omg-1.3.5-py3-none-any.whl", hash = "sha256:b67f8d13ad55370e5a488f714d9676bc319aa353f676309485d55acaa190540c", size = 7990 },
+    { url = "https://files.pythonhosted.org/packages/dd/d2/87346e94dbecd3a65a09e2156c1adf30c162f31e69d0936343c3eff53e7a/omg-1.3.6-py3-none-any.whl", hash = "sha256:8e3ac99a18d5284ceef2ed98492d288d5f22ee2bb417591654a7d2433e196607", size = 7988 },
 ]
 
 [[package]]