checkpointer 2.14.9__tar.gz → 2.14.11__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: checkpointer
-Version: 2.14.9
+Version: 2.14.11
 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
@@ -177,6 +177,24 @@ def process(
 
 In this example, the hash for `numbers` ignores order, `data_file` is hashed based on its contents rather than path, and changes to `log` don't affect caching.
 
+## 🔑 Custom Instance Hashing with `__objecthash__`
+
+Any class can implement `__objecthash__` to control how its instances are hashed by `checkpointer`. When an instance is encountered during hashing, `checkpointer` calls `__objecthash__()` and hashes the returned value instead of inspecting the object's internals.
+
+```python
+class Model:
+    def __init__(self, id: str, weights: list[float]):
+        self.id = id
+        self.weights = weights
+
+    def __objecthash__(self):
+        return self.id  # Hash instances by their id only
+```
+
+The return value of `__objecthash__` can be any Python value — a string, int, tuple, dict, or anything else `checkpointer` knows how to hash. This makes it easy to define a precise, stable identity for your objects without relying on pickle or attribute inspection.
+
+Once defined, `__objecthash__` applies everywhere the class is used — as a function argument, captured variable, or nested value — with no need for `HashBy` annotations at each call site.
+
 ## 🎯 Capturing Global Variables
 
 `checkpointer` can include **captured global variables** in call hashes - these are globals your function reads during execution that may affect results.

{checkpointer-2.14.9 → checkpointer-2.14.11}/README.md

@@ -160,6 +160,24 @@ def process(
 
 In this example, the hash for `numbers` ignores order, `data_file` is hashed based on its contents rather than path, and changes to `log` don't affect caching.
 
+## 🔑 Custom Instance Hashing with `__objecthash__`
+
+Any class can implement `__objecthash__` to control how its instances are hashed by `checkpointer`. When an instance is encountered during hashing, `checkpointer` calls `__objecthash__()` and hashes the returned value instead of inspecting the object's internals.
+
+```python
+class Model:
+    def __init__(self, id: str, weights: list[float]):
+        self.id = id
+        self.weights = weights
+
+    def __objecthash__(self):
+        return self.id  # Hash instances by their id only
+```
+
+The return value of `__objecthash__` can be any Python value — a string, int, tuple, dict, or anything else `checkpointer` knows how to hash. This makes it easy to define a precise, stable identity for your objects without relying on pickle or attribute inspection.
+
+Once defined, `__objecthash__` applies everywhere the class is used — as a function argument, captured variable, or nested value — with no need for `HashBy` annotations at each call site.
+
 ## 🎯 Capturing Global Variables
 
 `checkpointer` can include **captured global variables** in call hashes - these are globals your function reads during execution that may affect results.

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

@@ -5,6 +5,7 @@ from datetime import datetime, timedelta
 from functools import cached_property, update_wrapper
 from inspect import Parameter, iscoroutine, signature, unwrap
 from pathlib import Path
+from types import MethodType
 from typing import (
   Callable, Concatenate, Coroutine, Generic, Iterable,
   Literal, Self, Type, TypedDict, Unpack, overload,
@@ -96,10 +97,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]:
@@ -151,7 +152,7 @@ class CachedFunction(Generic[Fn]):
   @property
   def fn(self) -> Fn:
     if self.bound:
-      return self.ident.fn.__get__(self.bound[0], self.bound[0].__class__)  # type: ignore
+      return MethodType(self.ident.fn, self.bound[0])  # type: ignore
     return self.ident.fn  # type: ignore
 
   @cached_property
@@ -184,11 +185,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 +204,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 +218,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.11}/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.11}/checkpointer/storages/memory_storage.py

@@ -47,6 +47,8 @@ class MemoryStorage(Storage):
           for call_hash, (date, _) in list(calldict.items()):
             if self.expired_dt(date):
               del calldict[call_hash]
+          if not calldict:
+            del item_map[key]
 
   def clear(self):
     fn_path = self.fn_dir().parent

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

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

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

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