checkpointer 2.6.2__py3-none-any.whl → 2.7.1__py3-none-any.whl

checkpointer/__init__.py

@@ -9,7 +9,8 @@ create_checkpointer = Checkpointer
 checkpoint = Checkpointer()
 capture_checkpoint = Checkpointer(capture=True)
 memory_checkpoint = Checkpointer(format="memory", verbosity=0)
-tmp_checkpoint = Checkpointer(root_path=tempfile.gettempdir() + "/checkpoints")
+tmp_checkpoint = Checkpointer(root_path=f"{tempfile.gettempdir()}/checkpoints")
+static_checkpoint = Checkpointer(fn_hash=ObjectHash())
 
 def cleanup_all(invalidated=True, expired=True):
   for obj in gc.get_objects():

checkpointer/checkpoint.py

@@ -4,7 +4,7 @@ import re
 from datetime import datetime
 from functools import update_wrapper
 from pathlib import Path
-from typing import Any, Callable, Generic, Iterable, Literal, Type, TypedDict, TypeVar, Unpack, cast, overload
+from typing import Any, Callable, Generic, Iterable, Literal, ParamSpec, Type, TypedDict, TypeVar, Unpack, cast, overload
 from .fn_ident import get_fn_ident
 from .object_hash import ObjectHash
 from .print_checkpoint import print_checkpoint
@@ -12,6 +12,8 @@ from .storages import STORAGE_MAP, Storage
 from .utils import resolved_awaitable, sync_resolve_coroutine, unwrap_fn
 
 Fn = TypeVar("Fn", bound=Callable)
+P = ParamSpec("P")
+R = TypeVar("R")
 
 DEFAULT_DIR = Path.home() / ".cache/checkpoints"
 
@@ -26,7 +28,7 @@ class CheckpointerOpts(TypedDict, total=False):
   hash_by: Callable | None
   should_expire: Callable[[datetime], bool] | None
   capture: bool
-  fn_hash: str | None
+  fn_hash: ObjectHash | None
 
 class Checkpointer:
   def __init__(self, **opts: Unpack[CheckpointerOpts]):
@@ -61,14 +63,14 @@ class CheckpointFn(Generic[Fn]):
     return self
 
   def _lazyinit(self):
+    params = self.checkpointer
     wrapped = unwrap_fn(self.fn)
     fn_file = Path(wrapped.__code__.co_filename).name
     fn_name = re.sub(r"[^\w.]", "", wrapped.__qualname__)
     update_wrapper(cast(Callable, self), wrapped)
-    store_format = self.checkpointer.format
-    Storage = STORAGE_MAP[store_format] if isinstance(store_format, str) else store_format
+    Storage = STORAGE_MAP[params.format] if isinstance(params.format, str) else params.format
     deep_hashes = [child._set_ident().fn_hash_raw for child in iterate_checkpoint_fns(self)]
-    self.fn_hash = self.checkpointer.fn_hash or str(ObjectHash().write_text(self.fn_hash_raw, *deep_hashes))
+    self.fn_hash = str(params.fn_hash or ObjectHash().write_text(self.fn_hash_raw, *deep_hashes))
     self.fn_subdir = f"{fn_file}/{fn_name}/{self.fn_hash[:16]}"
     self.is_async: bool = self.fn.is_async if isinstance(self.fn, CheckpointFn) else inspect.iscoroutinefunction(self.fn)
     self.storage = Storage(self)
@@ -91,20 +93,21 @@ class CheckpointFn(Generic[Fn]):
     return self
 
   def get_checkpoint_id(self, args: tuple, kw: dict) -> str:
-    hash_params = [self.checkpointer.hash_by(*args, **kw)] if self.checkpointer.hash_by else (args, kw)
-    call_hash = ObjectHash(self.fn_hash, *hash_params, digest_size=16)
+    hash_by = self.checkpointer.hash_by
+    hash_params = hash_by(*args, **kw) if hash_by else (args, kw)
+    call_hash = ObjectHash(hash_params, digest_size=16)
     return f"{self.fn_subdir}/{call_hash}"
 
   async def _store_on_demand(self, args: tuple, kw: dict, rerun: bool):
+    params = self.checkpointer
     checkpoint_id = self.get_checkpoint_id(args, kw)
-    checkpoint_path = self.checkpointer.root_path / checkpoint_id
-    verbosity = self.checkpointer.verbosity
+    checkpoint_path = params.root_path / checkpoint_id
     refresh = rerun \
       or not self.storage.exists(checkpoint_path) \
-      or (self.checkpointer.should_expire and self.checkpointer.should_expire(self.storage.checkpoint_date(checkpoint_path)))
+      or (params.should_expire and params.should_expire(self.storage.checkpoint_date(checkpoint_path)))
 
     if refresh:
-      print_checkpoint(verbosity >= 1, "MEMORIZING", checkpoint_id, "blue")
+      print_checkpoint(params.verbosity >= 1, "MEMORIZING", checkpoint_id, "blue")
       data = self.fn(*args, **kw)
       if inspect.iscoroutine(data):
         data = await data
@@ -113,11 +116,11 @@ class CheckpointFn(Generic[Fn]):
 
     try:
       data = self.storage.load(checkpoint_path)
-      print_checkpoint(verbosity >= 2, "REMEMBERED", checkpoint_id, "green")
+      print_checkpoint(params.verbosity >= 2, "REMEMBERED", checkpoint_id, "green")
       return data
     except (EOFError, FileNotFoundError):
       pass
-    print_checkpoint(verbosity >= 1, "CORRUPTED", checkpoint_id, "yellow")
+    print_checkpoint(params.verbosity >= 1, "CORRUPTED", checkpoint_id, "yellow")
     return await self._store_on_demand(args, kw, True)
 
   def _call(self, args: tuple, kw: dict, rerun=False):
@@ -126,20 +129,21 @@ class CheckpointFn(Generic[Fn]):
     coroutine = self._store_on_demand(args, kw, rerun)
     return coroutine if self.is_async else sync_resolve_coroutine(coroutine)
 
-  def _get(self, args, kw) -> Any:
+  def get(self: Callable[P, R], *args: P.args, **kw: P.kwargs) -> R: # type: ignore
+    self = cast(CheckpointFn, self)
     checkpoint_path = self.checkpointer.root_path / self.get_checkpoint_id(args, kw)
     try:
       val = self.storage.load(checkpoint_path)
-      return resolved_awaitable(val) if self.is_async else val
+      return cast(R, resolved_awaitable(val) if self.is_async else val)
     except Exception as ex:
       raise CheckpointError("Could not load checkpoint") from ex
 
-  def exists(self, *args: tuple, **kw: dict) -> bool:
+  def exists(self: Callable[P, R], *args: P.args, **kw: P.kwargs) -> bool: # type: ignore
+    self = cast(CheckpointFn, self)
     return self.storage.exists(self.checkpointer.root_path / self.get_checkpoint_id(args, kw))
 
   __call__: Fn = cast(Fn, lambda self, *args, **kw: self._call(args, kw))
   rerun: Fn = cast(Fn, lambda self, *args, **kw: self._call(args, kw, True))
-  get: Fn = cast(Fn, lambda self, *args, **kw: self._get(args, kw))
 
   def __repr__(self) -> str:
     return f"<CheckpointFn {self.fn.__name__} {self.fn_hash[:6]}>"

checkpointer/object_hash.py

@@ -56,6 +56,9 @@ class ObjectHash:
 
   __str__ = hexdigest
 
+  def __eq__(self, value: object) -> bool:
+    return isinstance(value, ObjectHash) and str(self) == str(value)
+
   def nested_hash(self, *objs: Any) -> str:
     return ObjectHash(iter=objs, tolerate_errors=self.tolerate_errors.value).hexdigest()
 

checkpointer/test_checkpointer.py

@@ -6,7 +6,7 @@ from . import checkpoint
 from .checkpoint import CheckpointError
 from .utils import AttrDict
 
-def global_multiply(a, b):
+def global_multiply(a: int, b: int) -> int:
   return a * b
 
 @pytest.fixture(autouse=True)
@@ -27,15 +27,15 @@ def test_basic_caching():
 
 def test_cache_invalidation():
   @checkpoint
-  def multiply(a, b):
+  def multiply(a: int, b: int):
     return a * b
 
   @checkpoint
-  def helper(x):
+  def helper(x: int):
     return multiply(x + 1, 2)
 
   @checkpoint
-  def compute(a, b):
+  def compute(a: int, b: int):
     return helper(a) + helper(b)
 
   result1 = compute(3, 4)
@@ -46,7 +46,7 @@ def test_layered_caching():
 
   @checkpoint(format="memory")
   @dev_checkpoint
-  def expensive_function(x):
+  def expensive_function(x: int):
     return x ** 2
 
   assert expensive_function(4) == 16
@@ -95,7 +95,7 @@ def test_force_recalculation():
 def test_multi_layer_decorator():
   @checkpoint(format="memory")
   @checkpoint(format="pickle")
-  def add(a, b):
+  def add(a: int, b: int) -> int:
     return a + b
 
   assert add(2, 3) == 5
@@ -124,18 +124,18 @@ def test_capture():
   assert test_a.fn_hash != init_hash_a
 
 def test_depends():
-  def multiply_wrapper(a, b):
+  def multiply_wrapper(a: int, b: int) -> int:
     return global_multiply(a, b)
 
-  def helper(a, b):
+  def helper(a: int, b: int) -> int:
     return multiply_wrapper(a + 1, b + 1)
 
   @checkpoint
-  def test_a(a, b):
+  def test_a(a: int, b: int) -> int:
     return helper(a, b)
 
   @checkpoint
-  def test_b(a, b):
+  def test_b(a: int, b: int) -> int:
     return test_a(a, b) + multiply_wrapper(a, b)
 
   assert set(test_a.depends) == {test_a.fn, helper, multiply_wrapper, global_multiply}
@@ -143,17 +143,17 @@ def test_depends():
 
 def test_lazy_init():
   @checkpoint
-  def fn1(x):
+  def fn1(x: object) -> object:
     return fn2(x)
 
   @checkpoint
-  def fn2(x):
+  def fn2(x: object) -> object:
     return fn1(x)
 
-  assert type(object.__getattribute__(fn1, "_getattribute")) == MethodType
+  assert type(object.__getattribute__(fn1, "_getattribute")) is MethodType
   with pytest.raises(AttributeError):
     object.__getattribute__(fn1, "fn_hash")
   assert fn1.fn_hash == object.__getattribute__(fn1, "fn_hash")
-  assert type(object.__getattribute__(fn1, "_getattribute")) == MethodWrapperType
+  assert type(object.__getattribute__(fn1, "_getattribute")) is MethodWrapperType
   assert set(fn1.depends) == {fn1.fn, fn2}
   assert set(fn2.depends) == {fn1, fn2.fn}

{checkpointer-2.6.2.dist-info → checkpointer-2.7.1.dist-info}/METADATA

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

{checkpointer-2.6.2.dist-info → checkpointer-2.7.1.dist-info}/RECORD

@@ -1,16 +1,16 @@
-checkpointer/__init__.py,sha256=ZJ6frUNgkklUi85b5uXTyTfRzMvZgQOJY-ZOnu7jh78,777
-checkpointer/checkpoint.py,sha256=3ohNeAqzZLCT9IHJ7nsDbtZ8rjI0rdApbqp8KowDRtc,6332
+checkpointer/__init__.py,sha256=HRLsQ24ZhxgmDcHchZ-hX6wA0NMCSedGA0NmCnUdS_c,832
+checkpointer/checkpoint.py,sha256=H1RQJIIuEmRcXd42Y-qUfyU3z0OGp3smY0LoKQN0IYU,6425
 checkpointer/fn_ident.py,sha256=SWaksNCTlskMom0ztqjECSRjZYPWXUA1p1ZCb-9tWo0,4297
-checkpointer/object_hash.py,sha256=rcHzVYZAeygLyqeKv1NODIDp0M_knLuDZefcBV_7ln4,7371
+checkpointer/object_hash.py,sha256=cxuWRDrg4F9wC18aC12zOZYOPv3bk2Qf6tZ0_WgAb6Y,7484
 checkpointer/print_checkpoint.py,sha256=aJCeWMRJiIR3KpyPk_UOKTaD906kArGrmLGQ3LqcVgo,1369
-checkpointer/test_checkpointer.py,sha256=uJ2Pg9Miq1W0l28eNlRhMjuT_R8c-ygYwp3KP3VW8Os,3600
+checkpointer/test_checkpointer.py,sha256=VdINXiaA_BoDdVYEB73ctfQ42fw3EDoYa9vYacoB13A,3768
 checkpointer/utils.py,sha256=E1AV96NTh3tuVmgPrr0JSKZaokw-Jely5Y6-NjlMCp8,3141
 checkpointer/storages/__init__.py,sha256=Kl4Og5jhYxn6m3tB_kTMsabf4_eWVLmFVAoC-pikNQE,301
 checkpointer/storages/bcolz_storage.py,sha256=3QkSUSeG5s2kFuVV_LZpzMn1A5E7kqC7jk7w35c0NyQ,2314
 checkpointer/storages/memory_storage.py,sha256=S5ayOZE_CyaFQJ-vSgObTanldPzG3gh3NksjNAc7vsk,1282
 checkpointer/storages/pickle_storage.py,sha256=idh9sBMdWuyvS220oa_7bAUpc9Xo9v6Ud9aYKGWasUs,1593
 checkpointer/storages/storage.py,sha256=_m18Z8TKrdAbi6YYYQmuNOnhna4RB2sJDn1v3liaU3U,721
-checkpointer-2.6.2.dist-info/METADATA,sha256=fpt1kQbTghSeSIbDranjL0-iGYaA3LbWFlyAfSTgJB0,10606
-checkpointer-2.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-checkpointer-2.6.2.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
-checkpointer-2.6.2.dist-info/RECORD,,
+checkpointer-2.7.1.dist-info/METADATA,sha256=wEdB7ZEnYVW3-bcwFBpZAQXbv76MNU1PvUpKMhW1Ids,10606
+checkpointer-2.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+checkpointer-2.7.1.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
+checkpointer-2.7.1.dist-info/RECORD,,