checkpointer 2.0.1__tar.gz → 2.1.0__tar.gz

checkpointer-2.1.0/PKG-INFO

@@ -0,0 +1,248 @@
+Metadata-Version: 2.3
+Name: checkpointer
+Version: 2.1.0
+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
+License: Copyright 2024 Hampus Hallman
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Requires-Python: >=3.12
+Requires-Dist: relib
+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/) [![Python 3.12](https://img.shields.io/badge/python-3.12-blue)](https://pypi.org/project/checkpointer/)
+
+`checkpointer` is a Python library for memoizing function results. It provides a decorator-based API with support for multiple storage backends. Use it for computationally expensive operations where caching can save time, or during development to avoid waiting for redundant computations.
+
+Adding or removing `@checkpoint` doesn't change how your code works. You can apply it to any function, including ones you've already written, without altering their behavior or introducing side effects. The original function remains unchanged and can still be called directly when needed.
+
+### Key Features:
+- 🗂️ **Multiple Storage Backends**: Built-in support for in-memory and pickle-based storage, or create your own.
+- 🎯 **Simple Decorator API**: Apply `@checkpoint` to functions without boilerplate.
+- 🔄 **Async and Sync Compatibility**: Works with synchronous functions and any Python async runtime (e.g., `asyncio`, `Trio`, `Curio`).
+- ⏲️ **Custom Expiration Logic**: Automatically invalidate old checkpoints.
+- 📂 **Flexible Path Configuration**: Control where checkpoints are stored.
+- 📦 **Captured Variables Handling**: Optionally include captured variables in cache invalidation.
+
+---
+
+## Installation
+
+```bash
+pip install checkpointer
+```
+
+---
+
+## Quick Start 🚀
+
+```python
+from checkpointer import checkpoint
+
+@checkpoint
+def expensive_function(x: int) -> int:
+    print("Computing...")
+    return x ** 2
+
+result = expensive_function(4)  # Computes and stores the result
+result = expensive_function(4)  # Loads from the cache
+```
+
+---
+
+## How It Works
+
+When you use `@checkpoint`, the function's **arguments** (`args`, `kwargs`) are hashed to create a unique identifier for each call. This identifier is used to store and retrieve cached results. If the same arguments are passed again, `checkpointer` loads the cached result instead of recomputing.
+
+Additionally, `checkpointer` ensures that caches are invalidated when a function's implementation or any of its dependencies change. Each function is assigned a hash based on:
+
+1. **Its source code**: Changes to the function's code update its hash.
+2. **Dependent functions**: If a function calls others, changes in those dependencies will also update the hash.
+3. **Captured variables**: (Optional) If `capture=True`, changes to captured variables and global variables will also update the hash.
+
+### Example: Cache Invalidation
+
+```python
+def multiply(a, b):
+    return a * b
+
+@checkpoint
+def helper(x):
+    return multiply(x + 1, 2)
+
+@checkpoint
+def compute(a, b):
+    return helper(a) + helper(b)
+```
+
+If you modify `multiply`, caches for both `helper` and `compute` are invalidated and recomputed.
+
+---
+
+## Parameterization
+
+### Custom Configuration
+
+Set up a `Checkpointer` instance with custom settings, and extend it by calling itself with overrides:
+
+```python
+from checkpointer import checkpoint
+
+IS_DEVELOPMENT = True  # Toggle based on your environment
+
+tmp_checkpoint = checkpoint(root_path="/tmp/checkpoints")
+dev_checkpoint = tmp_checkpoint(when=IS_DEVELOPMENT)  # Adds development-specific behavior
+```
+
+### Per-Function Customization & Layered Caching
+
+Layer caches by stacking checkpoints:
+
+```python
+@checkpoint(format="memory")  # Always use memory storage
+@dev_checkpoint  # Adds caching during development
+def some_expensive_function():
+    print("Performing a time-consuming operation...")
+    return sum(i * i for i in range(10**6))
+```
+
+- **In development**: Both `dev_checkpoint` and `memory` caches are active.
+- **In production**: Only the `memory` cache is active.
+
+---
+
+## Usage
+
+### Basic Invocation and Caching
+
+Call the decorated function as usual. On the first call, the result is computed and stored in the cache. Subsequent calls with the same arguments load the result from the cache:
+
+```python
+result = expensive_function(4)  # Computes and stores the result
+result = expensive_function(4)  # Loads the result from the cache
+```
+
+### Force Recalculation
+
+Force a recalculation and overwrite the stored checkpoint:
+
+```python
+result = expensive_function.rerun(4)
+```
+
+### Call the Original Function
+
+Use `fn` to directly call the original, undecorated function:
+
+```python
+result = expensive_function.fn(4)
+```
+
+This is especially useful **inside recursive functions** to avoid redundant caching of intermediate steps while still caching the final result.
+
+### Retrieve Stored Checkpoints
+
+Access cached results without recalculating:
+
+```python
+stored_result = expensive_function.get(4)
+```
+
+---
+
+## Storage Backends
+
+`checkpointer` works with both built-in and custom storage backends, so you can use what's provided or roll your own as needed.
+
+### Built-In Backends
+
+1. **PickleStorage**: Stores checkpoints on disk using Python's `pickle`.
+2. **MemoryStorage**: Keeps checkpoints in memory for non-persistent, fast caching.
+
+You can specify a storage backend using either its name (`"pickle"` or `"memory"`) or its corresponding class (`PickleStorage` or `MemoryStorage`) in the `format` parameter:
+
+```python
+from checkpointer import checkpoint, PickleStorage, MemoryStorage
+
+@checkpoint(format="pickle")  # Short for format=PickleStorage
+def disk_cached(x: int) -> int:
+    return x ** 2
+
+@checkpoint(format="memory")  # Short for format=MemoryStorage
+def memory_cached(x: int) -> int:
+    return x * 10
+```
+
+### Custom Storage Backends
+
+Create a custom storage backend by inheriting from the `Storage` class and implementing its methods. Access configuration options through the `self.checkpointer` attribute, an instance of `Checkpointer`.
+
+#### Example: Custom Storage Backend
+
+```python
+from checkpointer import checkpoint, Storage
+from datetime import datetime
+
+class CustomStorage(Storage):
+    def exists(self, path) -> bool: ...  # Check if a checkpoint exists at the given path
+    def checkpoint_date(self, path) -> datetime: ...  # Return the date the checkpoint was created
+    def store(self, path, data): ...  # Save the checkpoint data
+    def load(self, path): ...  # Return the checkpoint data
+    def delete(self, path): ...  # Delete the checkpoint
+
+@checkpoint(format=CustomStorage)
+def custom_cached(x: int):
+    return x ** 2
+```
+
+Using a custom backend lets you tailor storage to your application, whether it involves databases, cloud storage, or custom file formats.
+
+---
+
+## Configuration Options ⚙️
+
+| Option          | Type                              | Default              | Description                                    |
+|-----------------|-----------------------------------|----------------------|------------------------------------------------|
+| `capture`       | `bool`                            | `False`              | Include captured variables in function hashes. |
+| `format`        | `"pickle"`, `"memory"`, `Storage` | `"pickle"`           | Storage backend format.                        |
+| `root_path`     | `Path`, `str`, or `None`          | ~/.cache/checkpoints | Root directory for storing checkpoints.        |
+| `when`          | `bool`                            | `True`               | Enable or disable checkpointing.               |
+| `verbosity`     | `0` or `1`                        | `1`                  | Logging verbosity.                             |
+| `path`          | `Callable[..., str]`              | `None`               | Custom path for checkpoint storage.            |
+| `should_expire` | `Callable[[datetime], bool]`      | `None`               | Custom expiration logic.                       |
+
+---
+
+## Full Example 🛠️
+
+```python
+import asyncio
+from checkpointer import checkpoint
+
+@checkpoint
+def compute_square(n: int) -> int:
+    print(f"Computing {n}^2...")
+    return n ** 2
+
+@checkpoint(format="memory")
+async def async_compute_sum(a: int, b: int) -> int:
+    await asyncio.sleep(1)
+    return a + b
+
+async def main():
+    result1 = compute_square(5)
+    print(result1)  # Outputs 25
+
+    result2 = await async_compute_sum(3, 7)
+    print(result2)  # Outputs 10
+
+    result3 = await async_compute_sum.get(3, 7)
+    print(result3)  # Outputs 10
+
+asyncio.run(main())
+```

checkpointer-2.1.0/README.md

@@ -0,0 +1,231 @@
+# 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/) [![Python 3.12](https://img.shields.io/badge/python-3.12-blue)](https://pypi.org/project/checkpointer/)
+
+`checkpointer` is a Python library for memoizing function results. It provides a decorator-based API with support for multiple storage backends. Use it for computationally expensive operations where caching can save time, or during development to avoid waiting for redundant computations.
+
+Adding or removing `@checkpoint` doesn't change how your code works. You can apply it to any function, including ones you've already written, without altering their behavior or introducing side effects. The original function remains unchanged and can still be called directly when needed.
+
+### Key Features:
+- 🗂️ **Multiple Storage Backends**: Built-in support for in-memory and pickle-based storage, or create your own.
+- 🎯 **Simple Decorator API**: Apply `@checkpoint` to functions without boilerplate.
+- 🔄 **Async and Sync Compatibility**: Works with synchronous functions and any Python async runtime (e.g., `asyncio`, `Trio`, `Curio`).
+- ⏲️ **Custom Expiration Logic**: Automatically invalidate old checkpoints.
+- 📂 **Flexible Path Configuration**: Control where checkpoints are stored.
+- 📦 **Captured Variables Handling**: Optionally include captured variables in cache invalidation.
+
+---
+
+## Installation
+
+```bash
+pip install checkpointer
+```
+
+---
+
+## Quick Start 🚀
+
+```python
+from checkpointer import checkpoint
+
+@checkpoint
+def expensive_function(x: int) -> int:
+    print("Computing...")
+    return x ** 2
+
+result = expensive_function(4)  # Computes and stores the result
+result = expensive_function(4)  # Loads from the cache
+```
+
+---
+
+## How It Works
+
+When you use `@checkpoint`, the function's **arguments** (`args`, `kwargs`) are hashed to create a unique identifier for each call. This identifier is used to store and retrieve cached results. If the same arguments are passed again, `checkpointer` loads the cached result instead of recomputing.
+
+Additionally, `checkpointer` ensures that caches are invalidated when a function's implementation or any of its dependencies change. Each function is assigned a hash based on:
+
+1. **Its source code**: Changes to the function's code update its hash.
+2. **Dependent functions**: If a function calls others, changes in those dependencies will also update the hash.
+3. **Captured variables**: (Optional) If `capture=True`, changes to captured variables and global variables will also update the hash.
+
+### Example: Cache Invalidation
+
+```python
+def multiply(a, b):
+    return a * b
+
+@checkpoint
+def helper(x):
+    return multiply(x + 1, 2)
+
+@checkpoint
+def compute(a, b):
+    return helper(a) + helper(b)
+```
+
+If you modify `multiply`, caches for both `helper` and `compute` are invalidated and recomputed.
+
+---
+
+## Parameterization
+
+### Custom Configuration
+
+Set up a `Checkpointer` instance with custom settings, and extend it by calling itself with overrides:
+
+```python
+from checkpointer import checkpoint
+
+IS_DEVELOPMENT = True  # Toggle based on your environment
+
+tmp_checkpoint = checkpoint(root_path="/tmp/checkpoints")
+dev_checkpoint = tmp_checkpoint(when=IS_DEVELOPMENT)  # Adds development-specific behavior
+```
+
+### Per-Function Customization & Layered Caching
+
+Layer caches by stacking checkpoints:
+
+```python
+@checkpoint(format="memory")  # Always use memory storage
+@dev_checkpoint  # Adds caching during development
+def some_expensive_function():
+    print("Performing a time-consuming operation...")
+    return sum(i * i for i in range(10**6))
+```
+
+- **In development**: Both `dev_checkpoint` and `memory` caches are active.
+- **In production**: Only the `memory` cache is active.
+
+---
+
+## Usage
+
+### Basic Invocation and Caching
+
+Call the decorated function as usual. On the first call, the result is computed and stored in the cache. Subsequent calls with the same arguments load the result from the cache:
+
+```python
+result = expensive_function(4)  # Computes and stores the result
+result = expensive_function(4)  # Loads the result from the cache
+```
+
+### Force Recalculation
+
+Force a recalculation and overwrite the stored checkpoint:
+
+```python
+result = expensive_function.rerun(4)
+```
+
+### Call the Original Function
+
+Use `fn` to directly call the original, undecorated function:
+
+```python
+result = expensive_function.fn(4)
+```
+
+This is especially useful **inside recursive functions** to avoid redundant caching of intermediate steps while still caching the final result.
+
+### Retrieve Stored Checkpoints
+
+Access cached results without recalculating:
+
+```python
+stored_result = expensive_function.get(4)
+```
+
+---
+
+## Storage Backends
+
+`checkpointer` works with both built-in and custom storage backends, so you can use what's provided or roll your own as needed.
+
+### Built-In Backends
+
+1. **PickleStorage**: Stores checkpoints on disk using Python's `pickle`.
+2. **MemoryStorage**: Keeps checkpoints in memory for non-persistent, fast caching.
+
+You can specify a storage backend using either its name (`"pickle"` or `"memory"`) or its corresponding class (`PickleStorage` or `MemoryStorage`) in the `format` parameter:
+
+```python
+from checkpointer import checkpoint, PickleStorage, MemoryStorage
+
+@checkpoint(format="pickle")  # Short for format=PickleStorage
+def disk_cached(x: int) -> int:
+    return x ** 2
+
+@checkpoint(format="memory")  # Short for format=MemoryStorage
+def memory_cached(x: int) -> int:
+    return x * 10
+```
+
+### Custom Storage Backends
+
+Create a custom storage backend by inheriting from the `Storage` class and implementing its methods. Access configuration options through the `self.checkpointer` attribute, an instance of `Checkpointer`.
+
+#### Example: Custom Storage Backend
+
+```python
+from checkpointer import checkpoint, Storage
+from datetime import datetime
+
+class CustomStorage(Storage):
+    def exists(self, path) -> bool: ...  # Check if a checkpoint exists at the given path
+    def checkpoint_date(self, path) -> datetime: ...  # Return the date the checkpoint was created
+    def store(self, path, data): ...  # Save the checkpoint data
+    def load(self, path): ...  # Return the checkpoint data
+    def delete(self, path): ...  # Delete the checkpoint
+
+@checkpoint(format=CustomStorage)
+def custom_cached(x: int):
+    return x ** 2
+```
+
+Using a custom backend lets you tailor storage to your application, whether it involves databases, cloud storage, or custom file formats.
+
+---
+
+## Configuration Options ⚙️
+
+| Option          | Type                              | Default              | Description                                    |
+|-----------------|-----------------------------------|----------------------|------------------------------------------------|
+| `capture`       | `bool`                            | `False`              | Include captured variables in function hashes. |
+| `format`        | `"pickle"`, `"memory"`, `Storage` | `"pickle"`           | Storage backend format.                        |
+| `root_path`     | `Path`, `str`, or `None`          | ~/.cache/checkpoints | Root directory for storing checkpoints.        |
+| `when`          | `bool`                            | `True`               | Enable or disable checkpointing.               |
+| `verbosity`     | `0` or `1`                        | `1`                  | Logging verbosity.                             |
+| `path`          | `Callable[..., str]`              | `None`               | Custom path for checkpoint storage.            |
+| `should_expire` | `Callable[[datetime], bool]`      | `None`               | Custom expiration logic.                       |
+
+---
+
+## Full Example 🛠️
+
+```python
+import asyncio
+from checkpointer import checkpoint
+
+@checkpoint
+def compute_square(n: int) -> int:
+    print(f"Computing {n}^2...")
+    return n ** 2
+
+@checkpoint(format="memory")
+async def async_compute_sum(a: int, b: int) -> int:
+    await asyncio.sleep(1)
+    return a + b
+
+async def main():
+    result1 = compute_square(5)
+    print(result1)  # Outputs 25
+
+    result2 = await async_compute_sum(3, 7)
+    print(result2)  # Outputs 10
+
+    result3 = await async_compute_sum.get(3, 7)
+    print(result3)  # Outputs 10
+
+asyncio.run(main())
+```

{checkpointer-2.0.1 → checkpointer-2.1.0}/checkpointer/__init__.py

@@ -5,5 +5,6 @@ import tempfile
 
 create_checkpointer = Checkpointer
 checkpoint = Checkpointer()
-memory_checkpoint = Checkpointer(format="memory")
+capture_checkpoint = Checkpointer(capture=True)
+memory_checkpoint = Checkpointer(format="memory", verbosity=0)
 tmp_checkpoint = Checkpointer(root_path=tempfile.gettempdir() + "/checkpoints")

{checkpointer-2.0.1 → checkpointer-2.1.0}/checkpointer/checkpoint.py

@@ -1,32 +1,31 @@
+from __future__ import annotations
 import inspect
 import relib.hashing as hashing
-from typing import Generic, TypeVar, TypedDict, Callable, Unpack, Literal, Union, Any, cast, overload
-from datetime import datetime
+from typing import Generic, TypeVar, Type, TypedDict, Callable, Unpack, Literal, Any, cast, overload
 from pathlib import Path
+from datetime import datetime
 from functools import update_wrapper
 from .types import Storage
 from .function_body import get_function_hash
-from .utils import unwrap_fn, sync_resolve_coroutine
-from .storages.pickle_storage import PickleStorage
-from .storages.memory_storage import MemoryStorage
-from .storages.bcolz_storage import BcolzStorage
+from .utils import unwrap_fn, sync_resolve_coroutine, resolved_awaitable
+from .storages import STORAGE_MAP
 from .print_checkpoint import print_checkpoint
 
 Fn = TypeVar("Fn", bound=Callable)
 
 DEFAULT_DIR = Path.home() / ".cache/checkpoints"
-STORAGE_MAP = {"memory": MemoryStorage, "pickle": PickleStorage, "bcolz": BcolzStorage}
 
 class CheckpointError(Exception):
   pass
 
 class CheckpointerOpts(TypedDict, total=False):
-  format: Storage | Literal["pickle", "memory", "bcolz"]
+  format: Type[Storage] | Literal["pickle", "memory", "bcolz"]
   root_path: Path | str | None
   when: bool
   verbosity: Literal[0, 1]
   path: Callable[..., str] | None
   should_expire: Callable[[datetime], bool] | None
+  capture: bool
 
 class Checkpointer:
   def __init__(self, **opts: Unpack[CheckpointerOpts]):
@@ -36,15 +35,13 @@ class Checkpointer:
     self.verbosity = opts.get("verbosity", 1)
     self.path = opts.get("path")
     self.should_expire = opts.get("should_expire")
-
-  def get_storage(self) -> Storage:
-    return STORAGE_MAP[self.format] if isinstance(self.format, str) else self.format
+    self.capture = opts.get("capture", False)
 
   @overload
-  def __call__(self, fn: Fn, **override_opts: Unpack[CheckpointerOpts]) -> "CheckpointFn[Fn]": ...
+  def __call__(self, fn: Fn, **override_opts: Unpack[CheckpointerOpts]) -> CheckpointFn[Fn]: ...
   @overload
-  def __call__(self, fn: None=None, **override_opts: Unpack[CheckpointerOpts]) -> "Checkpointer": ...
-  def __call__(self, fn: Fn | None=None, **override_opts: Unpack[CheckpointerOpts]) -> Union["Checkpointer", "CheckpointFn[Fn]"]:
+  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]:
     if override_opts:
       opts = CheckpointerOpts(**{**self.__dict__, **override_opts})
       return Checkpointer(**opts)(fn)
@@ -56,15 +53,19 @@ class CheckpointFn(Generic[Fn]):
     wrapped = unwrap_fn(fn)
     file_name = Path(wrapped.__code__.co_filename).name
     update_wrapper(cast(Callable, self), wrapped)
+    storage = STORAGE_MAP[checkpointer.format] if isinstance(checkpointer.format, str) else checkpointer.format
     self.checkpointer = checkpointer
     self.fn = fn
-    self.fn_hash = get_function_hash(wrapped)
+    self.fn_hash, self.depends = get_function_hash(wrapped, self.checkpointer.capture)
     self.fn_id = f"{file_name}/{wrapped.__name__}"
     self.is_async = inspect.iscoroutinefunction(wrapped)
+    self.storage = storage(checkpointer)
 
   def get_checkpoint_id(self, args: tuple, kw: dict) -> str:
     if not callable(self.checkpointer.path):
-      return f"{self.fn_id}/{hashing.hash([self.fn_hash, args, kw or 0])}"
+      # TODO: use digest size before digesting instead of truncating the hash
+      call_hash = hashing.hash((self.fn_hash, args, kw), "blake2b")[:32]
+      return f"{self.fn_id}/{call_hash}"
     checkpoint_id = self.checkpointer.path(*args, **kw)
     if not isinstance(checkpoint_id, str):
       raise CheckpointError(f"path function must return a string, got {type(checkpoint_id)}")
@@ -73,27 +74,26 @@ class CheckpointFn(Generic[Fn]):
   async def _store_on_demand(self, args: tuple, kw: dict, rerun: bool):
     checkpoint_id = self.get_checkpoint_id(args, kw)
     checkpoint_path = self.checkpointer.root_path / checkpoint_id
-    storage = self.checkpointer.get_storage()
-    should_log = storage is not MemoryStorage and self.checkpointer.verbosity > 0
+    should_log = self.checkpointer.verbosity > 0
     refresh = rerun \
-      or not storage.exists(checkpoint_path) \
-      or (self.checkpointer.should_expire and self.checkpointer.should_expire(storage.checkpoint_date(checkpoint_path)))
+      or not self.storage.exists(checkpoint_path) \
+      or (self.checkpointer.should_expire and self.checkpointer.should_expire(self.storage.checkpoint_date(checkpoint_path)))
 
     if refresh:
       print_checkpoint(should_log, "MEMORIZING", checkpoint_id, "blue")
       data = self.fn(*args, **kw)
       if inspect.iscoroutine(data):
         data = await data
-      storage.store(checkpoint_path, data)
+      self.storage.store(checkpoint_path, data)
       return data
 
     try:
-      data = storage.load(checkpoint_path)
+      data = self.storage.load(checkpoint_path)
       print_checkpoint(should_log, "REMEMBERED", checkpoint_id, "green")
       return data
     except (EOFError, FileNotFoundError):
       print_checkpoint(should_log, "CORRUPTED", checkpoint_id, "yellow")
-      storage.delete(checkpoint_path)
+      self.storage.delete(checkpoint_path)
       return await self._store_on_demand(args, kw, rerun)
 
   def _call(self, args: tuple, kw: dict, rerun=False):
@@ -102,13 +102,17 @@ class CheckpointFn(Generic[Fn]):
     coroutine = self._store_on_demand(args, kw, rerun)
     return coroutine if self.is_async else sync_resolve_coroutine(coroutine)
 
-  __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))
-
-  def get(self, *args, **kw) -> Any:
+  def _get(self, args, kw) -> Any:
     checkpoint_path = self.checkpointer.root_path / self.get_checkpoint_id(args, kw)
-    storage = self.checkpointer.get_storage()
     try:
-      return storage.load(checkpoint_path)
+      val = self.storage.load(checkpoint_path)
+      return resolved_awaitable(val) if self.is_async else val
     except:
       raise CheckpointError("Could not load checkpoint")
+
+  def exists(self, *args: tuple, **kw: dict) -> bool:
+    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))