checkpointer 2.14.6__tar.gz → 2.14.8__tar.gz

{checkpointer-2.14.6 → checkpointer-2.14.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: checkpointer
-Version: 2.14.6
+Version: 2.14.8
 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
@@ -11,6 +11,7 @@ Keywords: async,cache,caching,data analysis,data processing,fast,hashing,invalid
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 

{checkpointer-2.14.6 → checkpointer-2.14.8}/checkpointer/checkpoint.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import asyncio
 import re
 from datetime import datetime, timedelta
 from functools import cached_property, update_wrapper
@@ -13,7 +14,7 @@ from .object_hash import ObjectHash
 from .print_checkpoint import print_checkpoint
 from .storages import STORAGE_MAP, Storage, StorageType
 from .types import AwaitableValue, C, Coro, Fn, P, R, T, hash_by_from_annotation
-from .utils import flatten, to_coroutine
+from .utils import flatten, is_asyncio, to_coroutine
 
 DEFAULT_DIR = Path.home() / ".cache/checkpoints"
 
@@ -161,7 +162,7 @@ class CachedFunction(Generic[Fn]):
   def cleanup(self):
     return self.storage.cleanup
 
-  def reinit(self, recursive=True) -> CachedFunction[Fn]:
+  def reinit(self, recursive=True) -> Self:
     depend_idents = list(self.ident.deep_idents()) if recursive else [self.ident]
     for ident in depend_idents: ident.reset()
     for ident in depend_idents: ident.fn_hash
@@ -191,28 +192,32 @@ class CachedFunction(Generic[Fn]):
     return self._get_call_hash(args, kw)
 
   async def _store_coroutine(self, call_hash: str, coroutine: Coroutine):
-    return self.storage.store(call_hash, AwaitableValue(await coroutine)).value
+    if is_asyncio():
+      data = await asyncio.to_thread(self.storage.store, call_hash, AwaitableValue(await coroutine))
+      return data.value
+    else:
+      return self.storage.store(call_hash, AwaitableValue(await coroutine)).value
 
-  def _call(self: CachedFunction[Callable[P, R]], args: tuple, kw: dict, rerun=False) -> R:
+  def is_expired(self, call_hash: str) -> bool:
+    return not self.storage.exists(call_hash) or self.storage.expired(call_hash)
+
+  def _call(self: CachedFunction[Callable[P, R]], args: tuple, kw: dict, rerun=False, cached=False) -> R:
     full_args = self.bound + args
     params = self.ident.checkpointer
-    storage = self.storage
-    if not params.when:
+    if not params.when and not cached:
       return self.fn(*full_args, **kw)
-
     call_hash = self._get_call_hash(args, kw)
-    call_id = f"{storage.fn_id()}/{call_hash}"
-    refresh = rerun or not storage.exists(call_hash) or storage.expired(call_hash)
+    call_id = f"{self.storage.fn_id()}/{call_hash}"
 
-    if refresh:
+    if rerun or self.is_expired(call_hash):
       print_checkpoint(params.verbosity >= 1, "MEMORIZING", call_id, "blue")
       data = self.fn(*full_args, **kw)
       if iscoroutine(data):
         return self._store_coroutine(call_hash, data)
-      return storage.store(call_hash, data)
+      return self.storage.store(call_hash, data)
 
     try:
-      data = storage.load(call_hash)
+      data = self.storage.load(call_hash)
       print_checkpoint(params.verbosity >= 2, "REMEMBERED", call_id, "green")
       if isinstance(data, AwaitableValue):
         return to_coroutine(data.value)  # type: ignore
@@ -220,18 +225,21 @@ class CachedFunction(Generic[Fn]):
     except (EOFError, FileNotFoundError):
       pass
     print_checkpoint(params.verbosity >= 1, "CORRUPTED", call_id, "yellow")
-    return self._call(args, kw, True)
+    return self._call(args, kw, True, cached)
 
   def __call__(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
     return self._call(args, kw)
 
+  def cached(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
+    return self._call(args, kw, False, True)
+
   def rerun(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> R:
-    return self._call(args, kw, True)
+    return self._call(args, kw, True, True)
 
   def exists(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> bool:
     return self.storage.exists(self._get_call_hash(args, kw))
 
-  def delete(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs):
+  def delete(self: CachedFunction[Callable[P, R]], *args: P.args, **kw: P.kwargs) -> None:
     self.storage.delete(self._get_call_hash(args, kw))
 
   @overload
@@ -267,6 +275,5 @@ class CachedFunction(Generic[Fn]):
     self.set(AwaitableValue(value), *args, **kw)
 
   def __repr__(self) -> str:
-    initialized = "fn_hash" in self.ident.__dict__
-    fn_hash = self.ident.fn_hash[:6] if initialized else "- uninitialized"
-    return f"<CachedFunction {self.fn.__name__} {fn_hash}>"
+    ident = self.ident.__dict__.get("fn_hash", "")[:6] or "- uninitialized"
+    return f"<CachedFunction {self.fn.__name__} {ident}>"

{checkpointer-2.14.6 → checkpointer-2.14.8}/checkpointer/fn_ident.py

@@ -69,9 +69,10 @@ def extract_scope_values(code: CodeType, scope_vars: dict) -> Iterable[tuple[Att
   scope_vars = {**scope_vars, **{k: {**scope_vars[k], **v} for k, v in classvars.items()}}
   instructs = seekable(dis.get_instructions(code))
   for instruct in instructs:
-    if instruct.opname in scope_vars:
+    opname = instruct.opname.replace("LOAD_FAST_BORROW", "LOAD_FAST")
+    if opname in scope_vars:
       attrs = takewhile((x.opname in ("LOAD_ATTR", "LOAD_METHOD"), x.argval) for x in instructs)
-      attr_path = AttrPath((instruct.opname, instruct.argval, *attrs))
+      attr_path = AttrPath((opname, instruct.argval, *attrs))
       parent_path = attr_path[:-1]
       instructs.step(-1)
       obj = get_at(scope_vars, *attr_path)

{checkpointer-2.14.6 → checkpointer-2.14.8}/checkpointer/object_hash.py

@@ -1,17 +1,15 @@
 import ctypes
 import hashlib
-import inspect
-import io
 import re
 import sys
-import tokenize
 import sysconfig
+import tokenize
 from collections import OrderedDict
 from collections.abc import Iterable
 from contextlib import nullcontext, suppress
 from decimal import Decimal
-from io import StringIO
-from inspect import getfile
+from inspect import getfile, getsource
+from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, StringIO, TextIOWrapper
 from itertools import chain
 from pathlib import Path
 from pickle import HIGHEST_PROTOCOL as PICKLE_PROTOCOL
@@ -146,7 +144,7 @@ class ObjectHash:
       case GeneratorType():
         self.header("generator", obj.__qualname__)._update_iterator(obj)
 
-      case io.TextIOWrapper() | io.FileIO() | io.BufferedRandom() | io.BufferedWriter() | io.BufferedReader():
+      case TextIOWrapper() | FileIO() | BufferedRandom() | BufferedWriter() | BufferedReader():
         self.header("file", encode_type_of(obj)).update(obj.name, obj.mode, obj.tell())
 
       case type():
@@ -228,7 +226,7 @@ class ObjectHash:
 
 def get_fn_body(fn: Callable) -> str:
   try:
-    source = inspect.getsource(fn)
+    source = getsource(fn)
   except OSError:
     return ""
   tokens = tokenize.generate_tokens(StringIO(source).readline)

{checkpointer-2.14.6 → checkpointer-2.14.8}/checkpointer/storages/pickle_storage.py

@@ -8,7 +8,7 @@ from .storage import Storage
 
 try:
   import polars as pl
-except:
+except Exception:
   pl = None
 
 def filedate(path: Path) -> datetime:
@@ -51,18 +51,18 @@ class PickleStorage(Storage):
     version_path = self.fn_dir()
     fn_path = version_path.parent
     if invalidated and fn_path.exists():
-      old_dirs = [path for path in fn_path.iterdir() if path.is_dir() and path != version_path]
-      for path in old_dirs:
-        for pkl_path in path.glob("**/*.pkl"):
-          pkl_path.unlink(missing_ok=True)
-      if old_dirs:
-        print(f"Removed {len(old_dirs)} invalidated directories for {self.cached_fn.__qualname__}")
+      invalidated_dirs = [path for path in fn_path.iterdir() if path.is_dir() and path != version_path]
+      pkls = [pkl for path in invalidated_dirs for pkl in path.glob("**/*.pkl")]
+      for pkl in pkls:
+        pkl.unlink(missing_ok=True)
+      if pkls:
+        print(f"Removed {len(pkls)} checkpoints from {len(invalidated_dirs)} invalidated directories for {self.cached_fn.__qualname__}")
     if expired and self.checkpointer.expiry:
       count = 0
-      for pkl_path in fn_path.glob("**/*.pkl"):
-        if self.expired_dt(filedate(pkl_path)):
+      for pkl in fn_path.glob("**/*.pkl"):
+        if self.expired_dt(filedate(pkl)):
           count += 1
-          pkl_path.unlink(missing_ok=True)
+          pkl.unlink(missing_ok=True)
       if count:
         print(f"Removed {count} expired checkpoints for {self.cached_fn.__qualname__}")
     clear_directory(fn_path)

{checkpointer-2.14.6 → checkpointer-2.14.8}/checkpointer/storages/storage.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Protocol
 
 if TYPE_CHECKING:
   from ..checkpoint import CachedFunction, Checkpointer
 
-class Storage:
+class Storage(Protocol):
   checkpointer: Checkpointer
-  ident: CachedFunction
+  cached_fn: CachedFunction
 
   def __init__(self, cached_fn: CachedFunction):
     self.checkpointer = cached_fn.ident.checkpointer

{checkpointer-2.14.6 → checkpointer-2.14.8}/checkpointer/types.py

@@ -45,5 +45,5 @@ class AwaitableValue(Generic[T]):
     self.value = value
 
   def __await__(self):
-    yield
+    yield from ()
     return self.value

{checkpointer-2.14.6 → checkpointer-2.14.8}/checkpointer/utils.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+import asyncio
 import inspect
 from contextlib import contextmanager, suppress
 from itertools import chain, islice
@@ -10,6 +11,13 @@ from .types import T
 cwd = Path.cwd().resolve()
 flatten = chain.from_iterable
 
+def is_asyncio() -> bool:
+  try:
+    loop = asyncio.get_running_loop()
+    return isinstance(loop, asyncio.AbstractEventLoop)
+  except Exception:
+    return False
+
 async def to_coroutine(value: T) -> T:
   return value
 

{checkpointer-2.14.6 → checkpointer-2.14.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "checkpointer"
-version = "2.14.6"
+version = "2.14.8"
 requires-python = ">=3.11"
 dependencies = []
 authors = [
@@ -14,6 +14,7 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
 ]
 keywords = [
   "data processing",
@@ -39,10 +40,10 @@ dev = [
   "omg>=1.3.9",
   "poethepoet>=0.30.0",
   "polars>=1.31.0",
-  "pytest>=8.3.5",
-  "pytest-asyncio>=0.26.0",
+  "pytest>=9.0.0",
+  "pytest-asyncio>=1.3.0",
   "rich>=14.0.0",
-  "torch>=2.6.0",
+  "torch>=2.9.1",
 ]
 
 [tool.poe.tasks]