checkpointer 2.9.0__tar.gz → 2.9.2__tar.gz

checkpointer-2.9.2/PKG-INFO

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: checkpointer
+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
+License: Copyright 2018-2025 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.
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+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.
+
+## 📦 Installation
+
+```bash
+pip install checkpointer
+```
+
+## 🚀 Quick Start
+
+Apply the `@checkpoint` decorator to any function:
+
+```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 a function decorated with `@checkpoint` is called:
+
+1.  `checkpointer` computes a unique identifier (hash) for the function call based on its source code, its dependencies, and the arguments passed.
+2.  It attempts to retrieve a cached result using this identifier.
+3.  If a cached result is found, it's returned immediately.
+4.  If no cached result exists or the cache has expired, the original function is executed, its result is stored, and then returned.
+
+### ♻️ Automatic Cache Invalidation
+
+`checkpointer` ensures caches are invalidated automatically when the underlying computation changes. A function's hash, which determines cache validity, updates if:
+
+* **Function Code Changes**: The source code of the decorated function itself is modified.
+* **Dependencies Change**: Any user-defined function in its dependency tree (direct or indirect, even across modules or not decorated with `@checkpoint`) is modified.
+* **Captured Variables Change** (with `capture=True`): Global or closure-based variables used within the function are altered.
+
+**Example: Dependency Invalidation**
+
+```python
+def multiply(a, b):
+    return a * b
+
+@checkpoint
+def helper(x):
+    # Depends on `multiply`
+    return multiply(x + 1, 2)
+
+@checkpoint
+def compute(a, b):
+    # Depends on `helper` and `multiply`
+    return helper(a) + helper(b)
+```
+
+If `multiply` is modified, caches for both `helper` and `compute` will automatically be invalidated and recomputed upon their next call.
+
+## 💡 Usage
+
+Once a function is decorated with `@checkpoint`, you can interact with its caching behavior using the following methods:
+
+* **`expensive_function(...)`**:
+    Call the function normally. This will either compute and cache the result or load it from the cache if available.
+
+* **`expensive_function.rerun(...)`**:
+    Forces the original function to execute, compute a new result, and overwrite any existing cached value for the given arguments.
+
+* **`expensive_function.fn(...)`**:
+    Calls the original, undecorated function directly, bypassing the cache entirely. This is particularly useful within recursive functions to prevent caching intermediate steps.
+
+* **`expensive_function.get(...)`**:
+    Attempts to retrieve the cached result for the given arguments without executing the original function. Raises `CheckpointError` if no valid cached result exists.
+
+* **`expensive_function.exists(...)`**:
+    Checks if a cached result exists for the given arguments without attempting to compute or load it. Returns `True` if a valid checkpoint exists, `False` otherwise.
+
+* **`expensive_function.delete(...)`**:
+    Removes the cached entry for the specified arguments.
+
+* **`expensive_function.reinit()`**:
+    Recalculates the function's internal hash. This is primarily used when `capture=True` and you need to update the cache based on changes to external variables within the same Python session.
+
+## ⚙️ Configuration & Customization
+
+The `@checkpoint` decorator accepts the following parameters to customize its behavior:
+
+* **`format`** (Type: `str` or `checkpointer.Storage`, Default: `"pickle"`)
+    Defines the storage backend to use. Built-in options are `"pickle"` (disk-based, persistent) and `"memory"` (in-memory, non-persistent). You can also provide a custom `Storage` class.
+
+* **`root_path`** (Type: `str` or `pathlib.Path` or `None`, Default: `~/.cache/checkpoints`)
+    The base directory for storing disk-based checkpoints. This parameter is only relevant when `format` is set to `"pickle"`.
+
+* **`when`** (Type: `bool`, Default: `True`)
+    A boolean flag to enable or disable checkpointing for the decorated function. This is particularly useful for toggling caching based on environment variables (e.g., `when=os.environ.get("ENABLE_CACHING", "false").lower() == "true"`).
+
+* **`capture`** (Type: `bool`, Default: `False`)
+    If set to `True`, `checkpointer` includes global or closure-based variables used by the function in its hash calculation. This ensures that changes to these external variables also trigger cache invalidation and recomputation.
+
+* **`should_expire`** (Type: `Callable[[datetime.datetime], bool]`, Default: `None`)
+    A custom callable that receives the `datetime` timestamp of a cached result. It should return `True` if the cached result is considered expired and needs recomputation, or `False` otherwise.
+
+* **`hash_by`** (Type: `Callable[..., Any]`, Default: `None`)
+    A custom callable that takes the function's arguments (`*args`, `**kwargs`) and returns a hashable object (or tuple of objects). This allows for custom argument normalization (e.g., sorting lists before hashing) or optimized hashing for complex input types, which can improve cache hit rates or speed up the hashing process.
+
+* **`fn_hash`** (Type: `checkpointer.ObjectHash`, Default: `None`)
+    An optional parameter that takes an instance of `checkpointer.ObjectHash`. This allows you to override the automatically computed function hash, giving you explicit control over when the function's cache should be invalidated. You can pass any values relevant to your invalidation logic to `ObjectHash` (e.g., `ObjectHash(version_string, config_id, ...)`, as it can consistently hash most Python values.
+
+* **`verbosity`** (Type: `int` (`0`, `1`, or `2`), Default: `1`)
+    Controls the level of logging output from `checkpointer`.
+    * `0`: No output.
+    * `1`: Shows when functions are computed and cached.
+    * `2`: Also shows when cached results are remembered (loaded from cache).
+
+### 🗄️ Custom Storage Backends
+
+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`.
+
+#### Example: Custom Storage Backend
+
+```python
+from checkpointer import checkpoint, Storage
+from datetime import datetime
+
+class MyCustomStorage(Storage):
+    def exists(self, call_id):
+        # 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()
+
+    def checkpoint_date(self, call_id): ...
+    def store(self, call_id, data): ...
+    def load(self, call_id): ...
+    def delete(self, call_id): ...
+
+@checkpoint(format=MyCustomStorage)
+def custom_cached_function(x: int):
+    return x ** 2
+```
+
+## 🧱 Layered Caching
+
+You can apply multiple `@checkpoint` decorators to a single function to create layered caching strategies. `checkpointer` processes these decorators from bottom to top, meaning the decorator closest to the function definition is evaluated first.
+
+This is useful for scenarios like combining a fast, ephemeral cache (e.g., in-memory) with a persistent, slower cache (e.g., disk-based).
+
+**Example: Memory Cache over Disk Cache**
+
+```python
+from checkpointer import checkpoint
+
+@checkpoint(format="memory") # Layer 2: Fast, ephemeral in-memory cache
+@checkpoint(format="pickle") # Layer 1: Persistent disk cache
+def some_expensive_operation():
+    print("Performing a time-consuming operation...")
+    return sum(i for i in range(10**7))
+```
+
+## ⚡ Async Support
+
+`checkpointer` works seamlessly with Python's `asyncio` and other async runtimes.
+
+```python
+import asyncio
+from checkpointer import checkpoint
+
+@checkpoint
+async def async_compute_sum(a: int, b: int) -> int:
+    print(f"Asynchronously computing {a} + {b}...")
+    await asyncio.sleep(1)
+    return a + b
+
+async def main():
+    # First call computes and caches
+    result1 = await async_compute_sum(3, 7)
+    print(f"Result 1: {result1}")
+
+    # Second call loads from cache
+    result2 = await async_compute_sum(3, 7)
+    print(f"Result 2: {result2}")
+
+    # Retrieve from cache without re-running the async function
+    result3 = async_compute_sum.get(3, 7)
+    print(f"Result 3 (from cache): {result3}")
+
+asyncio.run(main())
+```

checkpointer-2.9.2/README.md

@@ -0,0 +1,195 @@
+# 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.
+
+## 📦 Installation
+
+```bash
+pip install checkpointer
+```
+
+## 🚀 Quick Start
+
+Apply the `@checkpoint` decorator to any function:
+
+```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 a function decorated with `@checkpoint` is called:
+
+1.  `checkpointer` computes a unique identifier (hash) for the function call based on its source code, its dependencies, and the arguments passed.
+2.  It attempts to retrieve a cached result using this identifier.
+3.  If a cached result is found, it's returned immediately.
+4.  If no cached result exists or the cache has expired, the original function is executed, its result is stored, and then returned.
+
+### ♻️ Automatic Cache Invalidation
+
+`checkpointer` ensures caches are invalidated automatically when the underlying computation changes. A function's hash, which determines cache validity, updates if:
+
+* **Function Code Changes**: The source code of the decorated function itself is modified.
+* **Dependencies Change**: Any user-defined function in its dependency tree (direct or indirect, even across modules or not decorated with `@checkpoint`) is modified.
+* **Captured Variables Change** (with `capture=True`): Global or closure-based variables used within the function are altered.
+
+**Example: Dependency Invalidation**
+
+```python
+def multiply(a, b):
+    return a * b
+
+@checkpoint
+def helper(x):
+    # Depends on `multiply`
+    return multiply(x + 1, 2)
+
+@checkpoint
+def compute(a, b):
+    # Depends on `helper` and `multiply`
+    return helper(a) + helper(b)
+```
+
+If `multiply` is modified, caches for both `helper` and `compute` will automatically be invalidated and recomputed upon their next call.
+
+## 💡 Usage
+
+Once a function is decorated with `@checkpoint`, you can interact with its caching behavior using the following methods:
+
+* **`expensive_function(...)`**:
+    Call the function normally. This will either compute and cache the result or load it from the cache if available.
+
+* **`expensive_function.rerun(...)`**:
+    Forces the original function to execute, compute a new result, and overwrite any existing cached value for the given arguments.
+
+* **`expensive_function.fn(...)`**:
+    Calls the original, undecorated function directly, bypassing the cache entirely. This is particularly useful within recursive functions to prevent caching intermediate steps.
+
+* **`expensive_function.get(...)`**:
+    Attempts to retrieve the cached result for the given arguments without executing the original function. Raises `CheckpointError` if no valid cached result exists.
+
+* **`expensive_function.exists(...)`**:
+    Checks if a cached result exists for the given arguments without attempting to compute or load it. Returns `True` if a valid checkpoint exists, `False` otherwise.
+
+* **`expensive_function.delete(...)`**:
+    Removes the cached entry for the specified arguments.
+
+* **`expensive_function.reinit()`**:
+    Recalculates the function's internal hash. This is primarily used when `capture=True` and you need to update the cache based on changes to external variables within the same Python session.
+
+## ⚙️ Configuration & Customization
+
+The `@checkpoint` decorator accepts the following parameters to customize its behavior:
+
+* **`format`** (Type: `str` or `checkpointer.Storage`, Default: `"pickle"`)
+    Defines the storage backend to use. Built-in options are `"pickle"` (disk-based, persistent) and `"memory"` (in-memory, non-persistent). You can also provide a custom `Storage` class.
+
+* **`root_path`** (Type: `str` or `pathlib.Path` or `None`, Default: `~/.cache/checkpoints`)
+    The base directory for storing disk-based checkpoints. This parameter is only relevant when `format` is set to `"pickle"`.
+
+* **`when`** (Type: `bool`, Default: `True`)
+    A boolean flag to enable or disable checkpointing for the decorated function. This is particularly useful for toggling caching based on environment variables (e.g., `when=os.environ.get("ENABLE_CACHING", "false").lower() == "true"`).
+
+* **`capture`** (Type: `bool`, Default: `False`)
+    If set to `True`, `checkpointer` includes global or closure-based variables used by the function in its hash calculation. This ensures that changes to these external variables also trigger cache invalidation and recomputation.
+
+* **`should_expire`** (Type: `Callable[[datetime.datetime], bool]`, Default: `None`)
+    A custom callable that receives the `datetime` timestamp of a cached result. It should return `True` if the cached result is considered expired and needs recomputation, or `False` otherwise.
+
+* **`hash_by`** (Type: `Callable[..., Any]`, Default: `None`)
+    A custom callable that takes the function's arguments (`*args`, `**kwargs`) and returns a hashable object (or tuple of objects). This allows for custom argument normalization (e.g., sorting lists before hashing) or optimized hashing for complex input types, which can improve cache hit rates or speed up the hashing process.
+
+* **`fn_hash`** (Type: `checkpointer.ObjectHash`, Default: `None`)
+    An optional parameter that takes an instance of `checkpointer.ObjectHash`. This allows you to override the automatically computed function hash, giving you explicit control over when the function's cache should be invalidated. You can pass any values relevant to your invalidation logic to `ObjectHash` (e.g., `ObjectHash(version_string, config_id, ...)`, as it can consistently hash most Python values.
+
+* **`verbosity`** (Type: `int` (`0`, `1`, or `2`), Default: `1`)
+    Controls the level of logging output from `checkpointer`.
+    * `0`: No output.
+    * `1`: Shows when functions are computed and cached.
+    * `2`: Also shows when cached results are remembered (loaded from cache).
+
+### 🗄️ Custom Storage Backends
+
+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`.
+
+#### Example: Custom Storage Backend
+
+```python
+from checkpointer import checkpoint, Storage
+from datetime import datetime
+
+class MyCustomStorage(Storage):
+    def exists(self, call_id):
+        # 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()
+
+    def checkpoint_date(self, call_id): ...
+    def store(self, call_id, data): ...
+    def load(self, call_id): ...
+    def delete(self, call_id): ...
+
+@checkpoint(format=MyCustomStorage)
+def custom_cached_function(x: int):
+    return x ** 2
+```
+
+## 🧱 Layered Caching
+
+You can apply multiple `@checkpoint` decorators to a single function to create layered caching strategies. `checkpointer` processes these decorators from bottom to top, meaning the decorator closest to the function definition is evaluated first.
+
+This is useful for scenarios like combining a fast, ephemeral cache (e.g., in-memory) with a persistent, slower cache (e.g., disk-based).
+
+**Example: Memory Cache over Disk Cache**
+
+```python
+from checkpointer import checkpoint
+
+@checkpoint(format="memory") # Layer 2: Fast, ephemeral in-memory cache
+@checkpoint(format="pickle") # Layer 1: Persistent disk cache
+def some_expensive_operation():
+    print("Performing a time-consuming operation...")
+    return sum(i for i in range(10**7))
+```
+
+## ⚡ Async Support
+
+`checkpointer` works seamlessly with Python's `asyncio` and other async runtimes.
+
+```python
+import asyncio
+from checkpointer import checkpoint
+
+@checkpoint
+async def async_compute_sum(a: int, b: int) -> int:
+    print(f"Asynchronously computing {a} + {b}...")
+    await asyncio.sleep(1)
+    return a + b
+
+async def main():
+    # First call computes and caches
+    result1 = await async_compute_sum(3, 7)
+    print(f"Result 1: {result1}")
+
+    # Second call loads from cache
+    result2 = await async_compute_sum(3, 7)
+    print(f"Result 2: {result2}")
+
+    # Retrieve from cache without re-running the async function
+    result3 = async_compute_sum.get(3, 7)
+    print(f"Result 3 (from cache): {result3}")
+
+asyncio.run(main())
+```

{checkpointer-2.9.0 → 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.0 → 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
@@ -62,9 +61,9 @@ class CheckpointFn(Generic[Fn]):
     update_wrapper(cast(Callable, self), wrapped)
     self.checkpointer = checkpointer
     self.fn = fn
+    self.fn_dir = f"{fn_file}/{fn_name}"
     self.storage = Storage(self)
     self.cleanup = self.storage.cleanup
-    self.fn_dir = f"{fn_file}/{fn_name}"
 
   @cached_property
   def ident_tuple(self) -> tuple[str, list[Callable]]:
@@ -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.0 → 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.0 → checkpointer-2.9.2}/checkpointer/storages/memory_storage.py

@@ -7,7 +7,7 @@ item_map: dict[Path, dict[str, tuple[datetime, Any]]] = {}
 
 class MemoryStorage(Storage):
   def get_dict(self):
-    return item_map.setdefault(self.dir(), {})
+    return item_map.setdefault(self.fn_dir(), {})
 
   def store(self, call_id, data):
     self.get_dict()[call_id] = (datetime.now(), data)
@@ -25,7 +25,7 @@ class MemoryStorage(Storage):
     self.get_dict().pop(call_id, None)
 
   def cleanup(self, invalidated=True, expired=True):
-    curr_key = self.dir()
+    curr_key = self.fn_dir()
     for key, calldict in list(item_map.items()):
       if key.parent == curr_key.parent:
         if invalidated and key != curr_key:

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

@@ -5,7 +5,7 @@ from .storage import Storage
 
 class PickleStorage(Storage):
   def get_path(self, call_id: str):
-    return self.dir() / f"{call_id}.pkl"
+    return self.fn_dir() / f"{call_id}.pkl"
 
   def store(self, call_id, data):
     path = self.get_path(call_id)
@@ -28,17 +28,17 @@ class PickleStorage(Storage):
     self.get_path(call_id).unlink(missing_ok=True)
 
   def cleanup(self, invalidated=True, expired=True):
-    version_path = self.dir()
+    version_path = self.fn_dir()
     fn_path = version_path.parent
     if invalidated:
       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.0 → checkpointer-2.9.2}/checkpointer/storages/storage.py

@@ -4,18 +4,21 @@ 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 dir(self) -> Path:
-    return self.checkpointer.root_path / self.checkpoint_fn.fn_dir / self.checkpoint_fn.fn_hash
+  def fn_id(self) -> str:
+    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()
 
   def store(self, call_id: str, data: Any) -> None: ...
 

{checkpointer-2.9.0 → checkpointer-2.9.2}/checkpointer/test_checkpointer.py

@@ -1,10 +1,3 @@
-"""
-TODO: Add tests for:
-- Checkpointing with different formats (pickle, memory, etc.)
-- Classes and methods - instances and classes
-- reinit deep depends
-"""
-
 import asyncio
 import pytest
 from riprint import riprint as print

{checkpointer-2.9.0 → 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.0 → checkpointer-2.9.2}/pyproject.toml

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

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

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

checkpointer-2.9.0/PKG-INFO

@@ -1,262 +0,0 @@
-Metadata-Version: 2.4
-Name: checkpointer
-Version: 2.9.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 2018-2025 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.
-License-File: LICENSE
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.11
-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 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.
-- ⚡ **Custom Argument Hashing**: Override argument hashing for speed or specialized hashing logic.
-
----
-
-## 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. **Function Code**: The hash updates when the function’s own source code changes.
-2. **Dependencies**: If the function calls other user-defined functions, changes in those dependencies also update the hash.
-3. **External Variables** *(with `capture=True`)*: Any global or closure-based variables used by the function are included in its hash, so changes to those variables also trigger cache invalidation.
-
-### 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**8))
-```
-
-- **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)
-```
-
-### Refresh Function Hash
-
-If `capture=True`, you might need to re-hash a function during the same Python session. For that, call `reinit`:
-
-```python
-expensive_function.reinit()
-```
-
-This tells `checkpointer` to recalculate the function hash, reflecting changes in captured variables.
-
----
-
-## Storage Backends
-
-`checkpointer` works with 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, call_id) -> bool: ...  # Check if a checkpoint exists
-    def checkpoint_date(self, call_id) -> datetime: ...  # Get the checkpoint's timestamp
-    def store(self, call_id, data): ...  # Save data to the checkpoint
-    def load(self, call_id): ...  # Load data from the checkpoint
-    def delete(self, call_id): ...  # Delete the checkpoint
-
-@checkpoint(format=CustomStorage)
-def custom_cached(x: int):
-    return x ** 2
-```
-
-Use a custom backend to integrate with databases, cloud storage, or specialized 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`, `1` or `2`                     | `1`                  | Logging verbosity.                                        |
-| `should_expire` | `Callable[[datetime], bool]`        | `None`               | Custom expiration logic.                                  |
-| `hash_by`       | `Callable[..., Any]`                | `None`               | Custom function that transforms arguments before hashing. |
-
----
-
-## 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 = async_compute_sum.get(3, 7)
-    print(result3)  # Outputs 10
-
-asyncio.run(main())
-```

checkpointer-2.9.0/README.md

@@ -1,242 +0,0 @@
-# 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 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.
-- ⚡ **Custom Argument Hashing**: Override argument hashing for speed or specialized hashing logic.
-
----
-
-## 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. **Function Code**: The hash updates when the function’s own source code changes.
-2. **Dependencies**: If the function calls other user-defined functions, changes in those dependencies also update the hash.
-3. **External Variables** *(with `capture=True`)*: Any global or closure-based variables used by the function are included in its hash, so changes to those variables also trigger cache invalidation.
-
-### 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**8))
-```
-
-- **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)
-```
-
-### Refresh Function Hash
-
-If `capture=True`, you might need to re-hash a function during the same Python session. For that, call `reinit`:
-
-```python
-expensive_function.reinit()
-```
-
-This tells `checkpointer` to recalculate the function hash, reflecting changes in captured variables.
-
----
-
-## Storage Backends
-
-`checkpointer` works with 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, call_id) -> bool: ...  # Check if a checkpoint exists
-    def checkpoint_date(self, call_id) -> datetime: ...  # Get the checkpoint's timestamp
-    def store(self, call_id, data): ...  # Save data to the checkpoint
-    def load(self, call_id): ...  # Load data from the checkpoint
-    def delete(self, call_id): ...  # Delete the checkpoint
-
-@checkpoint(format=CustomStorage)
-def custom_cached(x: int):
-    return x ** 2
-```
-
-Use a custom backend to integrate with databases, cloud storage, or specialized 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`, `1` or `2`                     | `1`                  | Logging verbosity.                                        |
-| `should_expire` | `Callable[[datetime], bool]`        | `None`               | Custom expiration logic.                                  |
-| `hash_by`       | `Callable[..., Any]`                | `None`               | Custom function that transforms arguments before hashing. |
-
----
-
-## 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 = async_compute_sum.get(3, 7)
-    print(result3)  # Outputs 10
-
-asyncio.run(main())
-```