@@ -19,18 +19,17 @@
     get_neurodata_types,
     get_nwb_version,
     ignore_benign_pynwb_warnings,
-    memoize_source,
     metadata_cache,
-    metadata_cache_tokens,
     nwb_has_external_links,
+    readable_fingerprint,
 )
 from ..utils import find_parent_directory_containing
 
 lgr = get_logger()
 
 
 # Disable this for clean hacking
-@memoize_source(metadata_cache, metadata_cache_tokens)
+@metadata_cache.memoize_path(content_fingerprint=readable_fingerprint)
 def get_metadata(
     path: str | Path | Readable, digest: Digest | None = None
 ) -> dict[str, Any]:
 
@@ -294,8 +294,9 @@ def get_fingerprint(self) -> str | None:
         Two resources with equal fingerprints must have identical bytes: the
         fingerprint is what lets results derived from the content (metadata,
         validation results) be cached and reused across instances, see
-        `dandi.pynwb_utils.memoize_source`.  With the default of `None`, such
-        results are never cached for the resource.
+        `dandi.pynwb_utils.readable_fingerprint`.  With the default of `None`, such
+        results are only cached for a path-like resource (by the ``stat()`` of
+        its path), never for others.
         """
         return None
 
 
@@ -12,9 +12,8 @@
 from __future__ import annotations
 
 from collections import Counter
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from datetime import timedelta
-from functools import wraps
 import inspect
 import os
 import os.path as op
@@ -64,95 +63,31 @@
     get_module_version(hdmf),
     get_module_version(h5py),
 ]
-metadata_cache_tokens = dandi_cache_tokens
 metadata_cache = PersistentCache(
-    name="dandi-metadata", tokens=metadata_cache_tokens, envvar="DANDI_CACHE"
+    name="dandi-metadata", tokens=dandi_cache_tokens, envvar="DANDI_CACHE"
 )
-validate_cache_tokens = dandi_cache_tokens + [get_module_version(dandischema)]
 validate_cache = PersistentCache(
-    name="dandi-validate", tokens=validate_cache_tokens, envvar="DANDI_CACHE"
+    name="dandi-validate",
+    tokens=dandi_cache_tokens + [get_module_version(dandischema)],
+    envvar="DANDI_CACHE",
 )
 
-F = TypeVar("F", bound=Callable[..., Any])
 
-
-def memoize_source(cache: PersistentCache, tokens: Sequence[Any]) -> Callable[[F], F]:
+def readable_fingerprint(source: Any) -> tuple[str, str] | None:
     """
-    Decorator caching the results of a function of a local path or a `Readable`
-
-    For a path argument (`str` or `Path`), this is exactly ``cache.memoize_path``:
-    the result is cached under the file's location, a fingerprint of the file
-    (mtime, ctime, size, ...), and ``tokens``.  A `Readable` cannot be
-    fingerprinted that way, so `PersistentCache.memoize_path` leaves calls on
-    one uncached; here, a `Readable` whose `~Readable.get_fingerprint` returns
-    a value is cached under its file name, that fingerprint, and ``tokens``
-    instead.  A `Readable` without a fingerprint is still never cached.
-
-    ``tokens`` should be the ones ``cache`` was created with (versions of the
-    software producing the results): `PersistentCache.memoize`, unlike
-    `~PersistentCache.memoize_path`, does not add them by itself.
+    Content fingerprint of ``source`` for ``PersistentCache.memoize_path``
+
+    Pass it as ``content_fingerprint`` to cache the results of a function of a
+    local path or a `Readable`.  Paths keep being cached under their location
+    and ``stat()``; a `Readable` cannot be fingerprinted that way, so one whose
+    `~Readable.get_fingerprint` returns a value is cached under its file name
+    and that fingerprint instead.  A `Readable` without a fingerprint is handled
+    as without this: cached by its path if it is path-like (as
+    `LocalReadableFile` is), not cached at all otherwise.
     """
-
-    def decorator(f: F) -> F:
-        sig = inspect.signature(f)
-        if any(p.kind is p.VAR_POSITIONAL for p in sig.parameters.values()):
-            raise TypeError(f"memoize_source: {f.__qualname__}() must not take *args")
-        by_path = cache.memoize_path(f)
-
-        def by_fingerprint(
-            filename: str,
-            fingerprint: str,
-            cache_tokens: tuple[Any, ...],
-            *,
-            _source: Readable,
-            **kwargs: Any,
-        ) -> Any:
-            return f(_source, **kwargs)
-
-        # Give it an identity of its own under `f`'s module, so that joblib
-        # keeps its results in a per-function directory next to `by_path`'s
-        by_fingerprint.__module__ = f.__module__
-        by_fingerprint.__name__ = f"{f.__name__}__by_fingerprint"
-        by_fingerprint.__qualname__ = f"{f.__qualname__}__by_fingerprint"
-        # fscacher >= 0.4 calls the argument `exclude_kwargs`, older ones `ignore`
-        ignore_kwarg = (
-            "exclude_kwargs"
-            if "exclude_kwargs" in inspect.signature(cache.memoize).parameters
-            else "ignore"
-        )
-        cached_by_fingerprint = cache.memoize(
-            by_fingerprint, **{ignore_kwarg: ["_source"]}
-        )
-
-        @wraps(f)
-        def wrapper(source: Any, *args: Any, **kwargs: Any) -> Any:
-            if not isinstance(source, Readable):
-                return by_path(source, *args, **kwargs)
-            fingerprint = source.get_fingerprint()
-            if fingerprint is None:
-                return f(source, *args, **kwargs)
-            # Pass `f`'s other arguments by name (defaults included), so that the
-            # cache key does not depend on how they were passed, and so that
-            # joblib < 1.4 does not mistake positional ones for `_source`
-            bound = sig.bind(source, *args, **kwargs)
-            bound.apply_defaults()
-            others: dict[str, Any] = {}
-            for name, value in list(bound.arguments.items())[1:]:
-                if sig.parameters[name].kind is inspect.Parameter.VAR_KEYWORD:
-                    others.update(value)
-                else:
-                    others[name] = value
-            return cached_by_fingerprint(
-                source.get_filename(),
-                fingerprint,
-                tuple(tokens),
-                _source=source,
-                **others,
-            )
-
-        return cast(F, wrapper)
-
-    return decorator
+    if isinstance(source, Readable) and (fp := source.get_fingerprint()) is not None:
+        return (source.get_filename(), fp)
+    return None
 
 
 def _sanitize_nwb_version(
@@ -276,7 +211,7 @@ def get_neurodata_types_to_modalities_map() -> dict[str, str]:
     return ndtypes
 
 
-@memoize_source(metadata_cache, metadata_cache_tokens)
+@metadata_cache.memoize_path(content_fingerprint=readable_fingerprint)
 def get_neurodata_types(filepath: str | Path | Readable) -> list[str]:
     with open_readable(filepath) as fp, h5py.File(fp, "r") as h5file:
         all_pairs = _scan_neurodata_types(h5file)
@@ -890,7 +825,7 @@ def copy_nwb_file(src: str | Path, dest: str | Path) -> str:
     return str(dest)
 
 
-@memoize_source(metadata_cache, metadata_cache_tokens)
+@metadata_cache.memoize_path(content_fingerprint=readable_fingerprint)
 def nwb_has_external_links(filepath: str | Path | Readable) -> bool:
     with open_readable(filepath) as f, h5py.File(f, "r") as fp:
         visited = set()
 
@@ -22,9 +22,9 @@
 from ..pynwb_utils import (
     _rename_pose_estimation_original_videos,
     _sanitize_nwb_version,
-    memoize_source,
     nwb_has_external_links,
     open_readable,
+    readable_fingerprint,
     rename_nwb_external_files,
 )
 
@@ -241,93 +241,56 @@ def test_nwb_has_external_links(tmp_path):
 
 
 @pytest.mark.ai_generated
-def test_memoize_source(tmp_path: Path, simple1_nwb: Path) -> None:
+def test_readable_fingerprint(tmp_path: Path, simple1_nwb: Path) -> None:
+    assert readable_fingerprint(simple1_nwb) is None
+    assert readable_fingerprint(str(simple1_nwb)) is None
+    assert readable_fingerprint(FingerprintedReadable(simple1_nwb, None)) is None
+    assert readable_fingerprint(FingerprintedReadable(simple1_nwb, "A")) == (
+        simple1_nwb.name,
+        "A",
+    )
+
+
+@pytest.mark.ai_generated
+def test_memoize_path_readable_fingerprint(tmp_path: Path, simple1_nwb: Path) -> None:
     cache = PersistentCache(path=tmp_path / "cache", tokens=["t1"])
     calls: list[Any] = []
 
+    @cache.memoize_path(content_fingerprint=readable_fingerprint)
     def size(source: str | Path | Readable, flag: bool = False) -> str:
         calls.append(source)
         with open_readable(source) as fp:
             return f"{len(fp.read())}:{flag}"
 
-    cached = memoize_source(cache, ["t1"])(size)
-    nbytes = simple1_nwb.stat().st_size
-    expected = f"{nbytes}:False"
+    expected = f"{simple1_nwb.stat().st_size}:False"
 
-    # A path is cached the memoize_path way (which skips a file modified "just
+    # A path is still cached by its stat() (which skips a file modified "just
     # now", as the session-wide fixture may well have been: age a copy)
     nwb = tmp_path / simple1_nwb.name
     shutil.copyfile(simple1_nwb, nwb)
     hour_ago = time.time() - 3600
     os.utime(nwb, (hour_ago, hour_ago))
-    assert cached(nwb) == expected
-    assert cached(nwb) == expected
+    assert size(nwb) == expected
+    assert size(nwb) == expected
     assert len(calls) == 1
 
-    # A Readable without a fingerprint is never cached
-    assert cached(FingerprintedReadable(simple1_nwb, None)) == expected
-    assert cached(FingerprintedReadable(simple1_nwb, None)) == expected
-    assert len(calls) == 3
+    # A Readable without a fingerprint is handled as before: a local one is
+    # path-like, so it is cached by the stat() of its path, sharing the entry
+    local = FingerprintedReadable(nwb, None)
+    assert size(local) == expected
+    assert local.opened == 0
+    assert len(calls) == 1
 
     # A Readable with a fingerprint is cached by it: its twin is served from
     # the cache without being read (it could not be)
     first = FingerprintedReadable(simple1_nwb, "A")
-    assert cached(first) == expected
+    assert size(first) == expected
     assert first.opened == 1
     twin = FingerprintedReadable(tmp_path / "gone" / simple1_nwb.name, "A")
-    assert cached(twin) == expected
+    assert size(twin) == expected
     assert twin.opened == 0
-    assert len(calls) == 4
+    assert len(calls) == 2
 
-    # The file name, the other arguments, and the tokens are part of the key
+    # ... but the file name is part of the key
     with pytest.raises(FileNotFoundError):
-        cached(FingerprintedReadable(tmp_path / "gone" / "other.nwb", "A"))
-    assert cached(FingerprintedReadable(simple1_nwb, "B")) == expected
-    assert (
-        cached(FingerprintedReadable(simple1_nwb, "A"), flag=True) == f"{nbytes}:True"
-    )
-    assert len(calls) == 7
-    # ... however those other arguments are passed
-    assert cached(FingerprintedReadable(simple1_nwb, "A"), True) == f"{nbytes}:True"
-    assert len(calls) == 7
-    other_tokens = memoize_source(cache, ["t2"])(size)
-    assert other_tokens(FingerprintedReadable(simple1_nwb, "A")) == expected
-    assert len(calls) == 8
-
-    # Different functions of the same cache do not share entries
-    def name(source: str | Path | Readable, flag: bool = False) -> str:
-        return source.get_filename() if isinstance(source, Readable) else str(source)
-
-    cached_name = memoize_source(cache, ["t1"])(name)
-    assert cached_name(FingerprintedReadable(simple1_nwb, "A")) == simple1_nwb.name
-    assert cached(FingerprintedReadable(simple1_nwb, "A")) == expected
-    assert len(calls) == 8
-
-    # The other arguments are keyed by name, so `f` must not take *args
-    def varargs(source: str | Path | Readable, *args: Any) -> None:
-        pass
-
-    with pytest.raises(TypeError, match="must not take"):
-        memoize_source(cache, ["t1"])(varargs)
-
-
-@pytest.mark.ai_generated
-def test_memoize_source_ignored_cache(
-    tmp_path: Path, simple1_nwb: Path, monkeypatch: pytest.MonkeyPatch
-) -> None:
-    monkeypatch.setenv("DANDI_TEST_CACHE", "ignore")
-    cache = PersistentCache(
-        path=tmp_path / "cache", tokens=["t1"], envvar="DANDI_TEST_CACHE"
-    )
-    calls = 0
-
-    def count(source: str | Path | Readable) -> int:
-        nonlocal calls
-        calls += 1
-        return calls
-
-    cached = memoize_source(cache, ["t1"])(count)
-    assert cached(FingerprintedReadable(simple1_nwb, "A")) == 1
-    assert cached(FingerprintedReadable(simple1_nwb, "A")) == 2
-    assert cached(simple1_nwb) == 3
-    assert cached(simple1_nwb) == 4
+        size(FingerprintedReadable(tmp_path / "gone" / "other.nwb", "A"))
@@ -53,7 +53,9 @@ dependencies = [
     "dandischema >= 0.12.0, != 0.13.0, < 0.15.0",
     "etelemetry >= 0.2.2",
     "fasteners >= 0.19",
-    "fscacher >= 0.3.0",
+    # TEMPORARY until con/fscacher#113 (memoize_path(content_fingerprint=...))
+    # is released: then replace with "fscacher >= <that release>"
+    "fscacher @ git+https://github.com/con/fscacher@claude/content-fingerprint",
     # Floor raised to what `py3-lowest` actually resolves: modern pynwb pins
     # hdmf >= 4, so declared floor is now the tested floor.
     "hdmf >= 4.1.0",