checkpointer 2.11.0__tar.gz → 2.11.2__tar.gz

{checkpointer-2.11.0 → checkpointer-2.11.2}/PKG-INFO

@@ -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.0 → checkpointer-2.11.2}/README.md

@@ -1,8 +1,6 @@
 # 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
 
@@ -146,7 +144,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**
 
@@ -155,18 +153,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.0 → checkpointer-2.11.2}/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-2.11.0 → checkpointer-2.11.2}/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-2.11.0 → checkpointer-2.11.2}/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-2.11.0 → checkpointer-2.11.2}/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-2.11.0 → checkpointer-2.11.2}/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-2.11.2/checkpointer/types.py

@@ -0,0 +1,21 @@
+from typing import Annotated, Callable, Coroutine, Generic, ParamSpec, TypeVar
+
+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(Generic[T]):
+  def __init__(self, value: T):
+    self.value = value
+
+  def __await__(self):
+    yield
+    return self.value

{checkpointer-2.11.0 → checkpointer-2.11.2}/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 → checkpointer-2.11.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "checkpointer"
-version = "2.11.0"
+version = "2.11.2"
 requires-python = ">=3.11"
 dependencies = []
 authors = [
@@ -21,7 +21,7 @@ Repository = "https://github.com/Reddan/checkpointer.git"
 [dependency-groups]
 dev = [
   "numpy>=2.2.1",
-  "omg>=1.3.5",
+  "omg>=1.3.6",
   "poethepoet>=0.30.0",
   "pytest>=8.3.5",
   "pytest-asyncio>=0.26.0",

{checkpointer-2.11.0 → checkpointer-2.11.2}/uv.lock

@@ -8,7 +8,7 @@ resolution-markers = [
 
 [[package]]
 name = "checkpointer"
-version = "2.11.0"
+version = "2.11.2"
 source = { editable = "." }
 
 [package.dev-dependencies]
@@ -27,7 +27,7 @@ dev = [
 [package.metadata.requires-dev]
 dev = [
     { name = "numpy", specifier = ">=2.2.1" },
-    { name = "omg", specifier = ">=1.3.5" },
+    { name = "omg", specifier = ">=1.3.6" },
     { name = "poethepoet", specifier = ">=0.30.0" },
     { name = "pytest", specifier = ">=8.3.5" },
     { name = "pytest-asyncio", specifier = ">=0.26.0" },
@@ -330,14 +330,14 @@ wheels = [
 
 [[package]]
 name = "omg"
-version = "1.3.5"
+version = "1.3.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "watchdog" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/29/6b/0ef0bf8cbd936d1ffb9b0b8f5904ef9f98bc965aeb211bb1a8f6139d401c/omg-1.3.5.tar.gz", hash = "sha256:1b105041c28c4278f7c6631f294b60574baa3d4af0c1892643f0f925aa718454", size = 14260 }
+sdist = { url = "https://files.pythonhosted.org/packages/65/06/da0a3778b7ff8f1333ed7ddc0931ffff3c86ab5cb8bc4a96a1d0edb8671b/omg-1.3.6.tar.gz", hash = "sha256:465a51b7576fa31ef313e2b9a77d57f5d4816fb0a14dca0fc5c09ff471074fe6", size = 14268 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/6e/6f7577de8246b963ea1ad9da62e3ea8ab0a2502c21b153319b856ce19f34/omg-1.3.5-py3-none-any.whl", hash = "sha256:b67f8d13ad55370e5a488f714d9676bc319aa353f676309485d55acaa190540c", size = 7990 },
+    { url = "https://files.pythonhosted.org/packages/dd/d2/87346e94dbecd3a65a09e2156c1adf30c162f31e69d0936343c3eff53e7a/omg-1.3.6-py3-none-any.whl", hash = "sha256:8e3ac99a18d5284ceef2ed98492d288d5f22ee2bb417591654a7d2433e196607", size = 7988 },
 ]
 
 [[package]]

checkpointer-2.11.0/checkpointer/types.py

@@ -1,17 +0,0 @@
-from typing import Annotated, Callable, Generic, TypeVar
-
-T = TypeVar("T")
-Fn = TypeVar("Fn", bound=Callable)
-
-class HashBy(Generic[Fn]):
-  pass
-
-NoHash = Annotated[T, HashBy[lambda _: None]]
-
-class AwaitableValue:
-  def __init__(self, value):
-    self.value = value
-
-  def __await__(self):
-    yield
-    return self.value