checkpointer 2.14.9__tar.gz → 2.14.10__tar.gz

{checkpointer-2.14.9 → checkpointer-2.14.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: checkpointer
-Version: 2.14.9
+Version: 2.14.10
 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

{checkpointer-2.14.9 → checkpointer-2.14.10}/checkpointer/checkpoint.py

@@ -96,10 +96,10 @@ class FunctionIdent:
   @cached_property
   def fn_hash(self) -> str:
     if self.is_static():
-      return str(ObjectHash(self.checkpointer.fn_hash_from, digest_size=16))
+      return ObjectHash(self.checkpointer.fn_hash_from, digest_size=16).hexdigest()
     depends = self.deep_idents(past_static=False)
     deep_hashes = [d.fn_hash if d.is_static() else d.raw_ident.fn_hash for d in depends]
-    return str(ObjectHash(digest_size=16).write_text(iter=deep_hashes))
+    return ObjectHash(digest_size=16).write_text(iter=deep_hashes).hexdigest()
 
   @cached_property
   def capturables(self) -> list[Capturable]:
@@ -184,11 +184,11 @@ class CachedFunction(Generic[Fn]):
       elif key == b"**":
         for key in kw.keys() - ident.arg_names:
           named_args[key] = hash_by(named_args[key])
-    call_hash = ObjectHash(digest_size=16) \
+    return ObjectHash(digest_size=16) \
       .update(header="NAMED", iter=flatten(sorted(named_args.items()))) \
       .update(header="POS", iter=pos_args) \
-      .update(header="CAPTURED", iter=flatten(c.capture() for c in ident.capturables))
-    return str(call_hash)
+      .update(header="CAPTURED", iter=flatten(c.capture() for c in ident.capturables)) \
+      .hexdigest()
 
   def get_call_hash(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> str:
     return self._get_call_hash(args, kw)
@@ -203,15 +203,13 @@ class CachedFunction(Generic[Fn]):
   def is_expired(self, call_hash: str) -> bool:
     return not self.storage.exists(call_hash) or self.storage.expired(call_hash)
 
-  def _call(self: CachedFunction[Callable[P, R]], args: tuple, kw: dict, cached=True, rerun=False) -> R:
-    params = self.ident.checkpointer
-    if not cached:
-      return self.fn(*args, **kw)
+  def _call(self: CachedFunction[Callable[P, R]], args: tuple, kw: dict, rerun=False) -> R:
     call_hash = self._get_call_hash(args, kw)
     call_id = f"{self.storage.fn_id()}/{call_hash}"
+    verbosity = self.ident.checkpointer.verbosity
 
     if rerun or self.is_expired(call_hash):
-      print_checkpoint(params.verbosity >= 1, "MEMORIZING", call_id, "blue")
+      print_checkpoint(verbosity >= 1, "MEMORIZING", call_id, "blue")
       data = self.fn(*args, **kw)
       if iscoroutine(data):
         return self._store_coroutine(call_hash, data)
@@ -219,23 +217,22 @@ class CachedFunction(Generic[Fn]):
 
     try:
       data = self.storage.load(call_hash)
-      print_checkpoint(params.verbosity >= 2, "REMEMBERED", call_id, "green")
+      print_checkpoint(verbosity >= 2, "REMEMBERED", call_id, "green")
       if isinstance(data, AwaitableValue):
         return to_coroutine(data.value)  # type: ignore
       return data
     except (EOFError, FileNotFoundError):
       pass
-    print_checkpoint(params.verbosity >= 1, "CORRUPTED", call_id, "yellow")
+    print_checkpoint(verbosity >= 1, "CORRUPTED", call_id, "yellow")
     return self._call(args, kw, rerun=True)
 
   def __call__(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
-    return self._call(args, kw, self.ident.checkpointer.when)
+    if not self.ident.checkpointer.when:
+      return self.fn(*args, **kw)
+    return self._call(args, kw)
 
   def cached(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
-    return self._call(args, kw, True)
-
-  def uncached(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
-    return self._call(args, kw, False)
+    return self._call(args, kw)
 
   def rerun(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
     return self._call(args, kw, rerun=True)

{checkpointer-2.14.9 → checkpointer-2.14.10}/checkpointer/object_hash.py

@@ -68,6 +68,17 @@ class ObjectHash:
   def __eq__(self, value: object) -> bool:
     return isinstance(value, ObjectHash) and str(self) == str(value)
 
+  def __hash__(self) -> int:
+    self.update = self.write_bytes = self.write_text = self._update_immutable
+    return hash(str(self))
+
+  def _update_immutable(self, *_, **__) -> Self:
+    raise TypeError(
+      "This ObjectHash instance is now immutable and can’t accept more data. "
+      "You already called __hash__, which freezes it. "
+      "Create a new ObjectHash or use .copy() if you need to continue hashing."
+    )
+
   def nested_hash(self, *objs: object) -> str:
     return ObjectHash(iter=objs, tolerable=self.tolerable.value).hexdigest()
 

{checkpointer-2.14.9 → checkpointer-2.14.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "checkpointer"
-version = "2.14.9"
+version = "2.14.10"
 requires-python = ">=3.11"
 dependencies = []
 authors = [

{checkpointer-2.14.9 → checkpointer-2.14.10}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "checkpointer"
-version = "2.14.9"
+version = "2.14.10"
 source = { editable = "." }
 
 [package.dev-dependencies]