checkpointer 2.11.0__py3-none-any.whl → 2.11.2__py3-none-any.whl

checkpointer/checkpoint.py

@@ -6,23 +6,20 @@ from inspect import Parameter, Signature, iscoroutine, signature
 from pathlib import Path
 from typing import (
   Annotated, Callable, Concatenate, Coroutine, Generic,
-  Iterable, Literal, ParamSpec, Self, Type, TypedDict,
-  TypeVar, Unpack, cast, get_args, get_origin, overload,
+  Iterable, Literal, Self, Type, TypedDict,
+  Unpack, cast, get_args, get_origin, overload,
 )
 from .fn_ident import RawFunctionIdent, get_fn_ident
 from .object_hash import ObjectHash
 from .print_checkpoint import print_checkpoint
 from .storages import STORAGE_MAP, Storage
-from .types import AwaitableValue, HashBy
+from .types import AwaitableValue, C, Coro, Fn, HashBy, P, R
 from .utils import unwrap_fn
 
-Fn = TypeVar("Fn", bound=Callable)
-P = ParamSpec("P")
-R = TypeVar("R")
-C = TypeVar("C")
-
 DEFAULT_DIR = Path.home() / ".cache/checkpoints"
 
+empty_set = cast(set, frozenset())
+
 class CheckpointError(Exception):
   pass
 
@@ -72,8 +69,8 @@ class FunctionIdent:
 
   @cached_property
   def fn_hash(self) -> str:
-    if self.cached_fn.checkpointer.fn_hash_from is not None:
-      return str(ObjectHash(self.cached_fn.checkpointer.fn_hash_from, digest_size=16))
+    if (hash_from := self.cached_fn.checkpointer.fn_hash_from) is not None:
+      return str(ObjectHash(hash_from, digest_size=16))
     deep_hashes = [depend.ident.raw_ident.fn_hash for depend in self.cached_fn.deep_depends()]
     return str(ObjectHash(digest_size=16).write_text(iter=deep_hashes))
 
@@ -82,7 +79,7 @@ class FunctionIdent:
     deep_hashes = [depend.ident.raw_ident.captured_hash for depend in self.cached_fn.deep_depends()]
     return str(ObjectHash().write_text(iter=deep_hashes))
 
-  def clear(self):
+  def reset(self):
     self.__init__(self.cached_fn)
 
 class CachedFunction(Generic[Fn]):
@@ -98,6 +95,7 @@ class CachedFunction(Generic[Fn]):
     self.storage = Storage(self)
     self.cleanup = self.storage.cleanup
     self.bound = ()
+    self.attrname: str | None = None
 
     sig = signature(wrapped)
     params = list(sig.parameters.items())
@@ -107,6 +105,10 @@ class CachedFunction(Generic[Fn]):
     self.hash_by_map = get_hash_by_map(sig)
     self.ident = FunctionIdent(self)
 
+  def __set_name__(self, _, name: str):
+    assert self.attrname is None
+    self.attrname = name
+
   @overload
   def __get__(self: Self, instance: None, owner: Type[C]) -> Self: ...
   @overload
@@ -114,9 +116,12 @@ class CachedFunction(Generic[Fn]):
   def __get__(self, instance, owner):
     if instance is None:
       return self
+    assert self.attrname is not None
     bound_fn = object.__new__(CachedFunction)
     bound_fn.__dict__ |= self.__dict__
     bound_fn.bound = (instance,)
+    if hasattr(instance, "__dict__"):
+      setattr(instance, self.attrname, bound_fn)
     return bound_fn
 
   @property
@@ -125,11 +130,11 @@ class CachedFunction(Generic[Fn]):
 
   def reinit(self, recursive=False) -> CachedFunction[Fn]:
     depend_idents = [depend.ident for depend in self.deep_depends()] if recursive else [self.ident]
-    for ident in depend_idents: ident.clear()
+    for ident in depend_idents: ident.reset()
     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 +148,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 +157,26 @@ 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_id = f"{self.storage.fn_id()}/{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_id, "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_id, "green")
       return data
     except (EOFError, FileNotFoundError):
       pass
-    print_checkpoint(params.verbosity >= 1, "CORRUPTED", call_id_long, "yellow")
+    print_checkpoint(params.verbosity >= 1, "CORRUPTED", call_id, "yellow")
     return self._call(args, kw, True)
 
   def __call__(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
@@ -181,28 +185,35 @@ 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: ...
+  def get(self: Callable[P, Coro[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, Coro[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]}>"
 
-  def deep_depends(self, visited: set[CachedFunction] = set()) -> Iterable[CachedFunction]:
+  def deep_depends(self, visited: set[CachedFunction] = empty_set) -> Iterable[CachedFunction]:
     if self not in visited:
       yield self
       visited = visited or set()

checkpointer/print_checkpoint.py

@@ -29,7 +29,7 @@ COLOR_MAP: dict[Color, int] = {
   "white": 97,
 }
 
-def allow_color() -> bool:
+def _allow_color() -> bool:
   if "NO_COLOR" in os.environ or os.environ.get("TERM") == "dumb" or not hasattr(sys.stdout, "fileno"):
     return False
   try:
@@ -37,16 +37,17 @@ def allow_color() -> bool:
   except io.UnsupportedOperation:
     return sys.stdout.isatty()
 
-def colored_(text: str, color: Color | None = None, on_color: Color | None = None) -> str:
+allow_color = _allow_color()
+
+def colored(text: str, color: Color | None = None, on_color: Color | None = None) -> str:
+  if not allow_color:
+    return text
   if color:
     text = f"\033[{COLOR_MAP[color]}m{text}"
   if on_color:
     text = f"\033[{COLOR_MAP[on_color] + 10}m{text}"
   return text + "\033[0m"
 
-noop = lambda text, *a, **k: text
-colored = colored_ if allow_color() else noop
-
 def print_checkpoint(should_log: bool, title: str, text: str, color: Color):
   if should_log:
     print(f'{colored(f" {title} ", "grey", color)} {colored(text, color)}')

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/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/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/types.py

@@ -1,15 +1,19 @@
-from typing import Annotated, Callable, Generic, TypeVar
+from typing import Annotated, Callable, Coroutine, Generic, ParamSpec, TypeVar
 
-T = TypeVar("T")
 Fn = TypeVar("Fn", bound=Callable)
+P = ParamSpec("P")
+R = TypeVar("R")
+C = TypeVar("C")
+T = TypeVar("T")
 
 class HashBy(Generic[Fn]):
   pass
 
 NoHash = Annotated[T, HashBy[lambda _: None]]
+Coro = Coroutine[object, object, R]
 
-class AwaitableValue:
-  def __init__(self, value):
+class AwaitableValue(Generic[T]):
+  def __init__(self, value: T):
     self.value = value
 
   def __await__(self):

checkpointer/utils.py

@@ -1,13 +1,11 @@
 from contextlib import contextmanager
-from typing import Any, Callable, Generic, Iterable, TypeVar, cast
-
-T = TypeVar("T")
-Fn = TypeVar("Fn", bound=Callable)
+from typing import Callable, Generic, Iterable, cast
+from .types import Fn, T
 
 def distinct(seq: Iterable[T]) -> list[T]:
   return list(dict.fromkeys(seq))
 
-def get_cell_contents(fn: Callable) -> Iterable[tuple[str, Any]]:
+def get_cell_contents(fn: Callable) -> Iterable[tuple[str, object]]:
   for key, cell in zip(fn.__code__.co_freevars, fn.__closure__ or []):
     try:
       yield (key, cell.cell_contents)
@@ -26,11 +24,11 @@ class AttrDict(dict):
     super().__init__(*args, **kwargs)
     self.__dict__ = self
 
-  def __getattribute__(self, name: str) -> Any:
+  def __getattribute__(self, name: str):
     return super().__getattribute__(name)
 
-  def __setattr__(self, name: str, value: Any) -> None:
-    return super().__setattr__(name, value)
+  def __setattr__(self, name: str, value: object):
+    super().__setattr__(name, value)
 
   def set(self, d: dict) -> "AttrDict":
     if not d:
@@ -43,7 +41,7 @@ class AttrDict(dict):
       del d[attr]
     return d
 
-  def get_at(self, attrs: tuple[str, ...]) -> Any:
+  def get_at(self, attrs: tuple[str, ...]) -> object:
     d = self
     for attr in attrs:
       d = getattr(d, attr, None)

{checkpointer-2.11.0.dist-info → checkpointer-2.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: checkpointer
-Version: 2.11.0
+Version: 2.11.2
 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
@@ -20,9 +20,7 @@ Description-Content-Type: text/markdown
 
 # checkpointer · [![License](https://img.shields.io/badge/license-MIT-blue)](https://github.com/Reddan/checkpointer/blob/master/LICENSE) [![pypi](https://img.shields.io/pypi/v/checkpointer)](https://pypi.org/project/checkpointer/) [![pypi](https://img.shields.io/pypi/pyversions/checkpointer)](https://pypi.org/project/checkpointer/)
 
-`checkpointer` is a Python library providing a decorator-based API for memoizing (caching) function results. It helps you skip redundant, computationally expensive operations, saving execution time and streamlining your workflows.
-
-It works with synchronous and asynchronous functions, supports multiple storage backends, and automatically invalidates caches when function code, dependencies, or captured variables change.
+`checkpointer` is a Python library offering a decorator-based API for memoizing (caching) function results with code-aware cache invalidation. It works with sync and async functions, supports multiple storage backends, and refreshes caches automatically when your code or dependencies change - helping you maintain correctness, speed up execution, and smooth out your workflows by skipping redundant, costly operations.
 
 ## 📦 Installation
 
@@ -166,7 +164,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 +173,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.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+checkpointer/__init__.py,sha256=ayjFyHwvl_HRHwocY-hOJvAx0Ko5X9IMZrNT4CwfoMU,824
+checkpointer/checkpoint.py,sha256=jUTImaeAMde2skReH8DxmlTaUe8XzL1uKRSkbS1-N80,9523
+checkpointer/fn_ident.py,sha256=-5XbovQowVyYCFc7JdT9z1NoIEiL8h9fi7alF_34Ils,4470
+checkpointer/object_hash.py,sha256=YlyFupQrg3V2mpzTLfOqpqlZWhoSCHliScQ4cKd36T0,8133
+checkpointer/print_checkpoint.py,sha256=uUQ493fJCaB4nhp4Ox60govSCiBTIPbBX15zt2QiRGo,1356
+checkpointer/test_checkpointer.py,sha256=-EvsMMNOOiIxhTcG97LLX0jUMWp534ko7qCKDSFWiA0,3802
+checkpointer/types.py,sha256=n1CxJsh7c_o72pFEfSbZ8cZgMeSNfAbLWUwrca8-zNo,449
+checkpointer/utils.py,sha256=CXoofmu6nxY5uW7oPUqdH31qffi3jQn_sc1qXbzxCsU,2137
+checkpointer/storages/__init__.py,sha256=en32nTUltpCSgz8RVGS_leIHC1Y1G89IqG1ZqAb6qUo,236
+checkpointer/storages/memory_storage.py,sha256=aQRSOmAfS0UudubCpv8cdfu2ycM8mlsO9tFMcD2kmgo,1133
+checkpointer/storages/pickle_storage.py,sha256=je1LM2lTSs5yzm25Apg5tJ9jU9T6nXCgD9SlqQRIFaM,1652
+checkpointer/storages/storage.py,sha256=5Jel7VlmCG9gnIbZFKT1NrEiAePz8ZD8hfsD-tYEiP4,905
+checkpointer-2.11.2.dist-info/METADATA,sha256=5nwfJ3M_F-RjJLCr49fMaXdjbl5yk1dKZt6Fk7WCy_k,11630
+checkpointer-2.11.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+checkpointer-2.11.2.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
+checkpointer-2.11.2.dist-info/RECORD,,

checkpointer-2.11.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-checkpointer/__init__.py,sha256=ayjFyHwvl_HRHwocY-hOJvAx0Ko5X9IMZrNT4CwfoMU,824
-checkpointer/checkpoint.py,sha256=zU67_PGrVCMP90clPTR7AA4vfxECqmeFr0jJElUL5iQ,9051
-checkpointer/fn_ident.py,sha256=-5XbovQowVyYCFc7JdT9z1NoIEiL8h9fi7alF_34Ils,4470
-checkpointer/object_hash.py,sha256=YlyFupQrg3V2mpzTLfOqpqlZWhoSCHliScQ4cKd36T0,8133
-checkpointer/print_checkpoint.py,sha256=aJCeWMRJiIR3KpyPk_UOKTaD906kArGrmLGQ3LqcVgo,1369
-checkpointer/test_checkpointer.py,sha256=-EvsMMNOOiIxhTcG97LLX0jUMWp534ko7qCKDSFWiA0,3802
-checkpointer/types.py,sha256=rAdjZNn1-jk35df7UVtby_qlp-8_18ucXfVCtS4RI_M,323
-checkpointer/utils.py,sha256=0cGVSlTnABgs3jI1uHoTfz353kkGa-qtTfe7jG4NCr0,2192
-checkpointer/storages/__init__.py,sha256=en32nTUltpCSgz8RVGS_leIHC1Y1G89IqG1ZqAb6qUo,236
-checkpointer/storages/memory_storage.py,sha256=Br30b1AyNOcNjjAaDui1mBjDKfhDbu--jV4WmJenzaE,1109
-checkpointer/storages/pickle_storage.py,sha256=xS96q8TvwxH_TOZsiKmrMrhFwQKZCcaH7XOiECmuwl8,1628
-checkpointer/storages/storage.py,sha256=5NWmnfsU2QY24NwKC5MZNe4h7pcYhADw-y800v17aYE,895
-checkpointer-2.11.0.dist-info/METADATA,sha256=GFRKdyTOIQwvmzIIrkV2owT8NO-X2ONRXdnadY9j5xY,11617
-checkpointer-2.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-checkpointer-2.11.0.dist-info/licenses/LICENSE,sha256=9xVsdtv_-uSyY9Xl9yujwAPm4-mjcCLeVy-ljwXEWbo,1059
-checkpointer-2.11.0.dist-info/RECORD,,