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

checkpointer-2.13.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.4
+Name: checkpointer
+Version: 2.13.0
+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
+License-Expression: MIT
+License-File: ATTRIBUTION.md
+License-File: LICENSE
+Keywords: async,cache,caching,data analysis,data processing,fast,hashing,invalidation,memoization,optimization,performance,workflow
+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 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
+
+```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 `@checkpoint`-decorated function is called, `checkpointer` computes a unique identifier for the call. This identifier derives from the function's source code, its dependencies, captured variables, and the arguments passed.
+
+It then tries to retrieve a cached result using this identifier. If a valid cached result is found, it's returned immediately. Otherwise, the original function executes, its result is stored, and then returned.
+
+### 🚨 What Triggers Cache Invalidation?
+
+`checkpointer` maintains cache correctness using two types of hashes:
+
+#### 1. Function Identity Hash (One-Time per Function)
+
+This hash represents the decorated function itself and is computed once (usually on first invocation). It covers:
+
+* **Decorated Function's Code:**\
+    The function's logic and signature (excluding parameter type annotations) are hashed. Formatting changes like whitespace, newlines, comments, or trailing commas do **not** cause invalidation.
+
+* **Dependencies:**\
+    All user-defined functions and methods the function calls or uses are included recursively. Dependencies are detected by:
+    * Inspecting the function's global scope for referenced functions/objects.
+    * Inferring from argument type annotations.
+    * Analyzing object constructions and method calls to identify classes and methods used.
+
+* **Top-Level Module Code:**\
+    Changes unrelated to the function or its dependencies in the module do **not** trigger invalidation.
+
+#### 2. Call Hash (Computed on Every Function Call)
+
+Each function call's cache key (the **call hash**) combines:
+
+* **Passed Arguments:**\
+    Includes positional and keyword arguments, combined with default values. Changing defaults alone doesn't necessarily trigger invalidation unless it affects actual call values.
+
+* **Captured Global Variables:**\
+    When `capture=True` or explicit capture annotations are used, `checkpointer` hashes global variables referenced by the function:
+    * `CaptureMe` variables are hashed on every call, so changes trigger invalidation.
+    * `CaptureMeOnce` variables are hashed once per session for performance optimization.
+
+* **Custom Argument Hashing:**\
+    Using `HashBy` annotations, arguments or captured variables can be transformed before hashing (e.g., sorting lists to ignore order), allowing more precise or efficient call hashes.
+
+## 💡 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 compute and cache the result or load it from cache.
+
+* **`expensive_function.rerun(...)`**:\
+    Force the original function to execute and overwrite any existing cached result.
+
+* **`expensive_function.fn(...)`**:\
+    Call the undecorated function directly, bypassing the cache (useful in recursion to prevent caching intermediate steps).
+
+* **`expensive_function.get(...)`**:\
+    Retrieve the cached result without executing the function. Raises `CheckpointError` if no valid cache exists.
+
+* **`expensive_function.exists(...)`**:\
+    Check if a cached result exists without computing or loading it.
+
+* **`expensive_function.delete(...)`**:\
+    Remove the cached entry for given arguments.
+
+* **`expensive_function.reinit(recursive: bool = False)`**:\
+    Recalculate the function identity hash and recapture `CaptureMeOnce` variables, updating the cached function state within the same Python session.
+
+## ⚙️ Configuration & Customization
+
+The `@checkpoint` decorator accepts the following parameters:
+
+* **`storage`** (Type: `str` or `checkpointer.Storage`, Default: `"pickle"`)\
+    Storage backend to use: `"pickle"` (disk-based, persistent), `"memory"` (in-memory, non-persistent), or a custom `Storage` class.
+
+* **`directory`** (Type: `str` or `pathlib.Path` or `None`, Default: `~/.cache/checkpoints`)\
+    Base directory for disk-based checkpoints (only for `"pickle"` storage).
+
+* **`when`** (Type: `bool`, Default: `True`)\
+    Enable or disable checkpointing dynamically, useful for environment-based toggling.
+
+* **`capture`** (Type: `bool`, Default: `False`)\
+    If `True`, includes global variables referenced by the function in call hashes (except those excluded via `NoHash`).
+
+* **`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.
+
+* **`fn_hash_from`** (Type: `Any`, Default: `None`)\
+    Override the computed function identity hash with any hashable object you provide (e.g., version strings, config IDs). This gives you explicit control over the function's version and when its cache should be invalidated.
+
+* **`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).
+
+## 🔬 Customize Argument Hashing
+
+You can customize how arguments are hashed without modifying the actual argument values to improve cache hit rates or speed up hashing.
+
+* **`Annotated[T, HashBy[fn]]`**:\
+    Transform the argument via `fn(argument)` before hashing. Useful for normalization (e.g., sorting lists) or optimized hashing for complex inputs.
+
+* **`NoHash[T]`**:\
+    Exclude the argument from hashing completely, so changes to it won't trigger cache invalidation.
+
+**Example:**
+
+```python
+from typing import Annotated
+from checkpointer import checkpoint, HashBy, NoHash
+from pathlib import Path
+import logging
+
+def file_bytes(path: Path) -> bytes:
+    return path.read_bytes()
+
+@checkpoint
+def process(
+    numbers: Annotated[list[int], HashBy[sorted]],   # Hash by sorted list
+    data_file: Annotated[Path, HashBy[file_bytes]],  # Hash by file content
+    log: NoHash[logging.Logger],                     # Exclude logger from hashing
+):
+    ...
+```
+
+In this example, the hash for `numbers` ignores order, `data_file` is hashed based on its contents rather than path, and changes to `log` don't affect caching.
+
+## 🎯 Capturing Global Variables
+
+`checkpointer` can include **captured global variables** in call hashes - these are globals your function reads during execution that may affect results.
+
+Use `capture=True` on `@checkpoint` to capture **all** referenced globals (except those explicitly excluded with `NoHash`).
+
+Alternatively, you can **opt-in selectively** by annotating globals with:
+
+* **`CaptureMe[T]`**:\
+    Capture the variable on every call (triggers invalidation on changes).
+
+* **`CaptureMeOnce[T]`**:\
+    Capture once per Python session (for expensive, immutable globals).
+
+You can also combine these with `HashBy` to customize how captured variables are hashed (e.g., hash by subset of attributes).
+
+**Example:**
+
+```python
+from typing import Annotated
+from checkpointer import checkpoint, CaptureMe, CaptureMeOnce, HashBy
+from pathlib import Path
+
+def file_bytes(path: Path) -> bytes:
+    return path.read_bytes()
+
+captured_data: CaptureMe[Annotated[Path, HashBy[file_bytes]]] = Path("data.txt")
+session_config: CaptureMeOnce[dict] = {"mode": "prod"}
+
+@checkpoint
+def process():
+    # `captured_data` is included in the call hash on every call, hashed by file content
+    # `session_config` is hashed once per session
+    ...
+```
+
+## 🗄️ Custom Storage Backends
+
+Implement your own storage backend by subclassing `checkpointer.Storage` and overriding required methods.
+
+Within storage methods, `call_hash` identifies calls by arguments. Use `self.fn_id()` to get function identity (name + hash/version), important for organizing checkpoints.
+
+**Example:**
+
+```python
+from checkpointer import checkpoint, Storage
+from datetime import datetime
+
+class MyCustomStorage(Storage):
+    def exists(self, call_hash):
+        fn_dir = self.checkpointer.directory / self.fn_id()
+        return (fn_dir / call_hash).exists()
+
+    def store(self, call_hash, data):
+        ...  # Store serialized data
+        return data  # Must return data to checkpointer
+
+    def checkpoint_date(self, call_hash): ...
+    def load(self, call_hash): ...
+    def delete(self, call_hash): ...
+
+@checkpoint(storage=MyCustomStorage)
+def custom_cached_function(x: int):
+    return x ** 2
+```
+
+## ⚡ Async Support
+
+`checkpointer` works 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():
+    result1 = await async_compute_sum(3, 7)
+    print(f"Result 1: {result1}")
+
+    result2 = await async_compute_sum(3, 7)
+    print(f"Result 2: {result2}")
+
+    result3 = async_compute_sum.get(3, 7)
+    print(f"Result 3 (from cache): {result3}")
+
+asyncio.run(main())
+```

checkpointer-2.13.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+checkpointer/__init__.py,sha256=l14EbRTgmkPlJUJc-5uAjWmB4dQr6kXXOPAjHcqbKK8,890
+checkpointer/checkpoint.py,sha256=Ylf0Yel9WiyHg7EoP355b2huS_yh0hgBUx2l3bOyI_c,10149
+checkpointer/fn_ident.py,sha256=mZfGPSIidlZVHsG3Kc6jk8rTNDoN_k2tCkJmbSKRhdg,6921
+checkpointer/fn_string.py,sha256=R1evcaBKoVP9SSDd741O1FoaC9SiaA3-kfn6QLxd9No,2532
+checkpointer/import_mappings.py,sha256=ESqWvZTzYAmaVnJ6NulUvn3_8CInOOPmEKUXO2WD_WA,1794
+checkpointer/object_hash.py,sha256=NXlhME87iA9rrMRjF_Au4SKXFVc14j-SiSEsGhH7M8s,8327
+checkpointer/print_checkpoint.py,sha256=uUQ493fJCaB4nhp4Ox60govSCiBTIPbBX15zt2QiRGo,1356
+checkpointer/types.py,sha256=GFqbGACdDxzQX3bb2LmF9UxQVWOEisGvdtobnqCBAOA,1129
+checkpointer/utils.py,sha256=FEabT0jp7Bx2KN-uco0QDAsBJ6hgauKwEjKR4B8IKzk,2977
+checkpointer/storages/__init__.py,sha256=p-r4YrPXn505_S3qLrSXHSlsEtb13w_DFnCt9IiUomk,296
+checkpointer/storages/memory_storage.py,sha256=aQRSOmAfS0UudubCpv8cdfu2ycM8mlsO9tFMcD2kmgo,1133
+checkpointer/storages/pickle_storage.py,sha256=je1LM2lTSs5yzm25Apg5tJ9jU9T6nXCgD9SlqQRIFaM,1652
+checkpointer/storages/storage.py,sha256=9CZquRjw9lWpcCVCiU7E6P-eJxGBUVbNKWncsTRwmoc,916
+checkpointer-2.13.0.dist-info/METADATA,sha256=vyBK4qpjq4c3S2yCCxjHTF2C5QtuQ3WDTWhEj-etz6U,10925
+checkpointer-2.13.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+checkpointer-2.13.0.dist-info/licenses/ATTRIBUTION.md,sha256=WF6L7-sD4s9t9ytVJOhjhpDoZ6TrWpqE3_bMdDIeJxI,1078
+checkpointer-2.13.0.dist-info/licenses/LICENSE,sha256=drXs6vIb7uW49r70UuMz2A1VtOCl626kiTbcmrar1Xo,1072
+checkpointer-2.13.0.dist-info/RECORD,,

checkpointer-2.13.0.dist-info/licenses/ATTRIBUTION.md

@@ -0,0 +1,33 @@
+# Attribution and License Notices
+
+This project includes code copied or adapted from third-party open-source projects. The following acknowledges the original sources and complies with their licensing requirements.
+
+---
+
+## Third-Party Code
+
+### more-itertools
+- **Source:** https://github.com/more-itertools/more-itertools
+- **Author:** Erik Rose
+- **Copyright:** (c) 2012 Erik Rose
+- **License:** MIT (https://github.com/more-itertools/more-itertools/blob/master/LICENSE)
+
+### colored
+- **Source:** https://gitlab.com/dslackw/colored
+- **Author:** Dimitris Zlatanidis
+- **Copyright:** (c) 2014-2025 Dimitris Zlatanidis
+- **License:** MIT (https://gitlab.com/dslackw/colored/-/blob/master/LICENSE.txt)
+
+---
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for details.
+
+---
+
+## Notes
+
+- Third-party code is included under their original MIT licenses.
+- This file documents those license notices, fulfilling attribution obligations.
+- Source files with copied code may omit individual license headers in favor of this centralized attribution.

{checkpointer-2.11.2.dist-info → checkpointer-2.13.0.dist-info}/licenses/LICENSE

@@ -1,3 +1,5 @@
+MIT 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:

checkpointer/test_checkpointer.py

@@ -1,168 +0,0 @@
-import asyncio
-import pytest
-from checkpointer import CheckpointError, checkpoint
-from .utils import AttrDict
-
-def global_multiply(a: int, b: int) -> int:
-  return a * b
-
-@pytest.fixture(autouse=True)
-def run_before_and_after_tests(tmpdir):
-  global checkpoint
-  checkpoint = checkpoint(root_path=tmpdir)
-  yield
-
-def test_basic_caching():
-  @checkpoint
-  def square(x: int) -> int:
-    return x ** 2
-
-  result1 = square(4)
-  result2 = square(4)
-
-  assert result1 == result2 == 16
-
-def test_cache_invalidation():
-  @checkpoint
-  def multiply(a: int, b: int):
-    return a * b
-
-  @checkpoint
-  def helper(x: int):
-    return multiply(x + 1, 2)
-
-  @checkpoint
-  def compute(a: int, b: int):
-    return helper(a) + helper(b)
-
-  result1 = compute(3, 4)
-  assert result1 == 18
-
-def test_layered_caching():
-  dev_checkpoint = checkpoint(when=True)
-
-  @checkpoint(format="memory")
-  @dev_checkpoint
-  def expensive_function(x: int):
-    return x ** 2
-
-  assert expensive_function(4) == 16
-  assert expensive_function(4) == 16
-
-def test_recursive_caching1():
-  @checkpoint
-  def fib(n: int) -> int:
-    return fib(n - 1) + fib(n - 2) if n > 1 else n
-
-  assert fib(10) == 55
-  assert fib.get(10) == 55
-  assert fib.get(5) == 5
-
-def test_recursive_caching2():
-  @checkpoint
-  def fib(n: int) -> int:
-    return fib.fn(n - 1) + fib.fn(n - 2) if n > 1 else n
-
-  assert fib(10) == 55
-  assert fib.get(10) == 55
-  with pytest.raises(CheckpointError):
-    fib.get(5)
-
-@pytest.mark.asyncio
-async def test_async_caching():
-  @checkpoint(format="memory")
-  async def async_square(x: int) -> int:
-    await asyncio.sleep(0.1)
-    return x ** 2
-
-  result1 = await async_square(3)
-  result2 = await async_square(3)
-  result3 = async_square.get(3)
-
-  assert result1 == result2 == result3 == 9
-
-def test_force_recalculation():
-  @checkpoint
-  def square(x: int) -> int:
-    return x ** 2
-
-  assert square(5) == 25
-  square.rerun(5)
-  assert square.get(5) == 25
-
-def test_multi_layer_decorator():
-  @checkpoint(format="memory")
-  @checkpoint(format="pickle")
-  def add(a: int, b: int) -> int:
-    return a + b
-
-  assert add(2, 3) == 5
-  assert add.get(2, 3) == 5
-
-def test_capture():
-  item_dict = AttrDict({"a": 1, "b": 1})
-
-  @checkpoint(capture=True)
-  def test_whole():
-    return item_dict
-
-  @checkpoint(capture=True)
-  def test_a():
-    return item_dict.a + 1
-
-  init_hash_a = test_a.ident.captured_hash
-  init_hash_whole = test_whole.ident.captured_hash
-  item_dict.b += 1
-  test_whole.reinit()
-  test_a.reinit()
-  assert test_whole.ident.captured_hash != init_hash_whole
-  assert test_a.ident.captured_hash == init_hash_a
-  item_dict.a += 1
-  test_a.reinit()
-  assert test_a.ident.captured_hash != init_hash_a
-
-def test_depends():
-  def multiply_wrapper(a: int, b: int) -> int:
-    return global_multiply(a, b)
-
-  def helper(a: int, b: int) -> int:
-    return multiply_wrapper(a + 1, b + 1)
-
-  @checkpoint
-  def test_a(a: int, b: int) -> int:
-    return helper(a, b)
-
-  @checkpoint
-  def test_b(a: int, b: int) -> int:
-    return test_a(a, b) + multiply_wrapper(a, b)
-
-  assert set(test_a.depends) == {test_a.fn, helper, multiply_wrapper, global_multiply}
-  assert set(test_b.depends) == {test_b.fn, test_a, multiply_wrapper, global_multiply}
-
-def test_lazy_init_1():
-  @checkpoint
-  def fn1(x: object) -> object:
-    return fn2(x)
-
-  @checkpoint
-  def fn2(x: object) -> object:
-    return fn1(x)
-
-  assert set(fn1.depends) == {fn1.fn, fn2}
-  assert set(fn2.depends) == {fn1, fn2.fn}
-
-def test_lazy_init_2():
-  @checkpoint
-  def fn1(x: object) -> object:
-    return fn2(x)
-
-  assert set(fn1.depends) == {fn1.fn}
-
-  @checkpoint
-  def fn2(x: object) -> object:
-    return fn1(x)
-
-  assert set(fn1.depends) == {fn1.fn}
-  fn1.reinit()
-  assert set(fn1.depends) == {fn1.fn, fn2}
-  assert set(fn2.depends) == {fn1, fn2.fn}