checkpointer 2.9.1__tar.gz → 2.9.2__tar.gz

{checkpointer-2.9.1 → checkpointer-2.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: checkpointer
-Version: 2.9.1
+Version: 2.9.2
 Summary: A Python library for memoizing function results with support for multiple storage backends, async runtimes, and automatic cache invalidation
 Project-URL: Repository, https://github.com/Reddan/checkpointer.git
 Author: Hampus Hallman
@@ -76,7 +76,7 @@ def helper(x):
 
 @checkpoint
 def compute(a, b):
-    # Depends on `helper`
+    # Depends on `helper` and `multiply`
     return helper(a) + helper(b)
 ```
 

{checkpointer-2.9.1 → checkpointer-2.9.2}/README.md

@@ -56,7 +56,7 @@ def helper(x):
 
 @checkpoint
 def compute(a, b):
-    # Depends on `helper`
+    # Depends on `helper` and `multiply`
     return helper(a) + helper(b)
 ```
 

{checkpointer-2.9.1 → checkpointer-2.9.2}/checkpointer/__init__.py

@@ -1,7 +1,7 @@
 import gc
 import tempfile
 from typing import Callable
-from .checkpoint import Checkpointer, CheckpointError, CheckpointFn
+from .checkpoint import CachedFunction, Checkpointer, CheckpointError
 from .object_hash import ObjectHash
 from .storages import MemoryStorage, PickleStorage, Storage
 
@@ -14,8 +14,8 @@ static_checkpoint = Checkpointer(fn_hash=ObjectHash())
 
 def cleanup_all(invalidated=True, expired=True):
   for obj in gc.get_objects():
-    if isinstance(obj, CheckpointFn):
+    if isinstance(obj, CachedFunction):
       obj.cleanup(invalidated=invalidated, expired=expired)
 
 def get_function_hash(fn: Callable, capture=False) -> str:
-  return CheckpointFn(Checkpointer(capture=capture), fn).fn_hash
+  return CachedFunction(Checkpointer(capture=capture), fn).fn_hash

{checkpointer-2.9.1 → checkpointer-2.9.2}/checkpointer/checkpoint.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 import inspect
 import re
-from contextlib import suppress
 from datetime import datetime
 from functools import cached_property, update_wrapper
 from pathlib import Path
@@ -43,17 +42,17 @@ class Checkpointer:
     self.fn_hash = opts.get("fn_hash")
 
   @overload
-  def __call__(self, fn: Fn, **override_opts: Unpack[CheckpointerOpts]) -> CheckpointFn[Fn]: ...
+  def __call__(self, fn: Fn, **override_opts: Unpack[CheckpointerOpts]) -> CachedFunction[Fn]: ...
   @overload
   def __call__(self, fn: None=None, **override_opts: Unpack[CheckpointerOpts]) -> Checkpointer: ...
-  def __call__(self, fn: Fn | None=None, **override_opts: Unpack[CheckpointerOpts]) -> Checkpointer | CheckpointFn[Fn]:
+  def __call__(self, fn: Fn | None=None, **override_opts: Unpack[CheckpointerOpts]) -> Checkpointer | CachedFunction[Fn]:
     if override_opts:
       opts = CheckpointerOpts(**{**self.__dict__, **override_opts})
       return Checkpointer(**opts)(fn)
 
-    return CheckpointFn(self, fn) if callable(fn) else self
+    return CachedFunction(self, fn) if callable(fn) else self
 
-class CheckpointFn(Generic[Fn]):
+class CachedFunction(Generic[Fn]):
   def __init__(self, checkpointer: Checkpointer, fn: Fn):
     wrapped = unwrap_fn(fn)
     fn_file = Path(wrapped.__code__.co_filename).name
@@ -80,15 +79,15 @@ class CheckpointFn(Generic[Fn]):
 
   @cached_property
   def fn_hash(self) -> str:
-    fn_hash = self.checkpointer.fn_hash
     deep_hashes = [depend.fn_hash_raw for depend in self.deep_depends()]
-    return str(fn_hash or ObjectHash(digest_size=16).write_text(self.fn_hash_raw, *deep_hashes))[:32]
+    fn_hash = ObjectHash(digest_size=16).write_text(self.fn_hash_raw, *deep_hashes)
+    return str(self.checkpointer.fn_hash or fn_hash)[:32]
 
-  def reinit(self, recursive=False) -> CheckpointFn[Fn]:
+  def reinit(self, recursive=False) -> CachedFunction[Fn]:
     depends = list(self.deep_depends()) if recursive else [self]
     for depend in depends:
-      with suppress(AttributeError):
-        del depend.ident_tuple, depend.fn_hash
+      self.__dict__.pop("fn_hash", None)
+      self.__dict__.pop("ident_tuple", None)
     for depend in depends:
       depend.fn_hash
     return self
@@ -150,21 +149,21 @@ class CheckpointFn(Generic[Fn]):
       raise CheckpointError("Could not load checkpoint") from ex
 
   def exists(self: Callable[P, R], *args: P.args, **kw: P.kwargs) -> bool: # type: ignore
-    self = cast(CheckpointFn, self)
+    self = cast(CachedFunction, self)
     return self.storage.exists(self.get_call_id(args, kw))
 
   def delete(self: Callable[P, R], *args: P.args, **kw: P.kwargs): # type: ignore
-    self = cast(CheckpointFn, self)
+    self = cast(CachedFunction, self)
     self.storage.delete(self.get_call_id(args, kw))
 
   def __repr__(self) -> str:
     return f"<CheckpointFn {self.fn.__name__} {self.fn_hash[:6]}>"
 
-  def deep_depends(self, visited: set[CheckpointFn] = set()) -> Iterable[CheckpointFn]:
+  def deep_depends(self, visited: set[CachedFunction] = set()) -> Iterable[CachedFunction]:
     if self not in visited:
       yield self
       visited = visited or set()
       visited.add(self)
       for depend in self.depends:
-        if isinstance(depend, CheckpointFn):
+        if isinstance(depend, CachedFunction):
           yield from depend.deep_depends(visited)

{checkpointer-2.9.1 → checkpointer-2.9.2}/checkpointer/fn_ident.py

@@ -8,7 +8,7 @@ from typing import Any, Iterable, Type, TypeGuard
 from .object_hash import ObjectHash
 from .utils import AttrDict, distinct, get_cell_contents, iterate_and_upcoming, transpose, unwrap_fn
 
-cwd = Path.cwd()
+cwd = Path.cwd().resolve()
 
 def is_class(obj) -> TypeGuard[Type]:
   # isinstance works too, but needlessly triggers _lazyinit()
@@ -72,23 +72,23 @@ def is_user_fn(candidate_fn) -> TypeGuard[Callable]:
   return cwd in fn_path.parents and ".venv" not in fn_path.parts
 
 def get_depend_fns(fn: Callable, capture: bool, captured_vals_by_fn: dict[Callable, list[Any]] = {}) -> dict[Callable, list[Any]]:
-  from .checkpoint import CheckpointFn
+  from .checkpoint import CachedFunction
   captured_vals_by_fn = captured_vals_by_fn or {}
   captured_vals = get_fn_captured_vals(fn)
   captured_vals_by_fn[fn] = [val for val in captured_vals if not callable(val)] * capture
-  child_fns = (unwrap_fn(val, checkpoint_fn=True) for val in captured_vals if callable(val))
+  child_fns = (unwrap_fn(val, cached_fn=True) for val in captured_vals if callable(val))
   for child_fn in child_fns:
-    if isinstance(child_fn, CheckpointFn):
+    if isinstance(child_fn, CachedFunction):
       captured_vals_by_fn[child_fn] = []
     elif child_fn not in captured_vals_by_fn and is_user_fn(child_fn):
       get_depend_fns(child_fn, capture, captured_vals_by_fn)
   return captured_vals_by_fn
 
 def get_fn_ident(fn: Callable, capture: bool) -> tuple[str, list[Callable]]:
-  from .checkpoint import CheckpointFn
+  from .checkpoint import CachedFunction
   captured_vals_by_fn = get_depend_fns(fn, capture)
   depends, depend_captured_vals = transpose(captured_vals_by_fn.items(), 2)
   depends = distinct(fn.__func__ if isinstance(fn, MethodType) else fn for fn in depends)
-  unwrapped_depends = [fn for fn in depends if not isinstance(fn, CheckpointFn)]
+  unwrapped_depends = [fn for fn in depends if not isinstance(fn, CachedFunction)]
   fn_hash = str(ObjectHash(fn, unwrapped_depends).update(depend_captured_vals, tolerate_errors=True))
   return fn_hash, depends

{checkpointer-2.9.1 → checkpointer-2.9.2}/checkpointer/storages/pickle_storage.py

@@ -34,11 +34,11 @@ class PickleStorage(Storage):
       old_dirs = [path for path in fn_path.iterdir() if path.is_dir() and path != version_path]
       for path in old_dirs:
         shutil.rmtree(path)
-      print(f"Removed {len(old_dirs)} invalidated directories for {self.checkpoint_fn.__qualname__}")
+      print(f"Removed {len(old_dirs)} invalidated directories for {self.cached_fn.__qualname__}")
     if expired and self.checkpointer.should_expire:
       count = 0
-      for pkl_path in fn_path.rglob("*.pkl"):
+      for pkl_path in fn_path.glob("**/*.pkl"):
         if self.checkpointer.should_expire(self.checkpoint_date(pkl_path.stem)):
           count += 1
           self.delete(pkl_path.stem)
-      print(f"Removed {count} expired checkpoints for {self.checkpoint_fn.__qualname__}")
+      print(f"Removed {count} expired checkpoints for {self.cached_fn.__qualname__}")

{checkpointer-2.9.1 → checkpointer-2.9.2}/checkpointer/storages/storage.py

@@ -4,18 +4,18 @@ from pathlib import Path
 from datetime import datetime
 
 if TYPE_CHECKING:
-  from ..checkpoint import Checkpointer, CheckpointFn
+  from ..checkpoint import Checkpointer, CachedFunction
 
 class Storage:
   checkpointer: Checkpointer
-  checkpoint_fn: CheckpointFn
+  cached_fn: CachedFunction
 
-  def __init__(self, checkpoint_fn: CheckpointFn):
-    self.checkpointer = checkpoint_fn.checkpointer
-    self.checkpoint_fn = checkpoint_fn
+  def __init__(self, cached_fn: CachedFunction):
+    self.checkpointer = cached_fn.checkpointer
+    self.cached_fn = cached_fn
 
   def fn_id(self) -> str:
-    return f"{self.checkpoint_fn.fn_dir}/{self.checkpoint_fn.fn_hash}"
+    return f"{self.cached_fn.fn_dir}/{self.cached_fn.fn_hash}"
 
   def fn_dir(self) -> Path:
     return self.checkpointer.root_path / self.fn_id()

{checkpointer-2.9.1 → checkpointer-2.9.2}/checkpointer/utils.py

@@ -32,10 +32,10 @@ def get_cell_contents(fn: Callable) -> Iterable[tuple[str, Any]]:
     except ValueError:
       pass
 
-def unwrap_fn(fn: Fn, checkpoint_fn=False) -> Fn:
-  from .checkpoint import CheckpointFn
+def unwrap_fn(fn: Fn, cached_fn=False) -> Fn:
+  from .checkpoint import CachedFunction
   while True:
-    if (checkpoint_fn and isinstance(fn, CheckpointFn)) or not hasattr(fn, "__wrapped__"):
+    if (cached_fn and isinstance(fn, CachedFunction)) or not hasattr(fn, "__wrapped__"):
       return cast(Fn, fn)
     fn = getattr(fn, "__wrapped__")
 

{checkpointer-2.9.1 → checkpointer-2.9.2}/pyproject.toml

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

{checkpointer-2.9.1 → checkpointer-2.9.2}/uv.lock

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