cachetools 7.3.0__tar.gz → 8.0.0__tar.gz

cachetools-8.0.0/AGENTS.md

@@ -0,0 +1,99 @@
+# cachetools
+
+Memoizing collections and decorators, including `functools.lru_cache` variants. Pure
+Python ≥ 3.11, no runtime dependencies, `src/` layout, inline type stubs (`*.pyi`,
+`py.typed`). Single maintainer; `master` is the release branch, `dev/vX.Y.Z` branches
+prepare bugfix releases and `develop` (the 8.0 line) is rebased onto the latest one.
+Code reviews follow `.github/copilot-instructions.md`.
+
+## Commands
+
+Run everything through `tox`, never bare `pytest`, `ruff` or `pyright`:
+
+```bash
+tox -p auto                                # all environments, as CI does
+tox -e py -- tests/test_ttl.py -k expire   # tests; posargs go to pytest
+tox -e pyright,ruff,ruff-format,docs,doctest   # stubs, lint, format, docs
+```
+
+CI (GitHub Actions on `tkem/cachetools`, every push) runs CPython 3.11–3.15,
+free-threaded 3.13t–3.15t and PyPy 3.11; without `gh`, check runs via
+`https://api.github.com/repos/tkem/cachetools/actions/runs?branch=<branch>`. Branch
+coverage is 100 %; on 3.13+ only the pre-3.13 `@classmethod` line in
+`_MethodDescriptor.__get__` is uncovered.
+
+## Code Style
+
+- No annotations in `.py` files; types live in the `.pyi` stubs. Decorator
+  `@overload`s come in the order keyword-only `info: Literal[True]`,
+  `info: Literal[False] = ...` (default), positional `Literal[True]`.
+- Prefer clarity and performance over DRY: one wrapper class per lock/condition/info
+  combination in `_decorator.py`, `_cached.py` and `_cachedmethod.py`, and the key
+  functions in `keys.py` are written out in full. Apply a change to **all** variants.
+- Keep hot paths free of avoidable Python-level calls. Look links and items up with
+  `.get()` and test for `None` instead of catching `KeyError` per new key (~200 ns).
+- Wrapper `__call__` methods, `_Unbound.__call__`, `_MethodDescriptor.__call__` and
+  the key functions take their receiver positional-only (`self, /`), so wrapped
+  callables may take a keyword argument named `self`; keep it that way everywhere.
+- Stubs: never annotate `self` in an `__init__` overload with class-scoped type
+  variables (pyright warns, and `tox` does not fail on warnings, so check for
+  `0 warnings`); an overload without `timer` relies on the `_TT` default instead.
+- Unsupported use raises `TypeError` before anything is cached, chained `from None`;
+  a store that fails with `ValueError` (value too large) is swallowed and the
+  computed value returned.
+- Docs (`docs/index.rst`, doctested): wrap prose at column 70, two spaces after a
+  sentence, single backticks for parameters and `:meth:`/`:func:`/`:exc:` roles. Keep
+  `README.rst` examples in sync with it.
+
+## Architecture Constraints
+
+- A value's size must not change after insertion. With the default `getsizeof` the
+  size dict is `None` and `getsizeof()` is never called: keep that fast path.
+- Cache subclasses override `__setitem__`, `__delitem__`, `popitem()`, `clear()` and
+  optionally `__getitem__`; after the parent `__getitem__`, check the subclass's own
+  bookkeeping, not `key in self`, since `__missing__` may not store the item.
+  `popitem()` evicts via `del self[key]`, so `__delitem__` overrides see evictions.
+- `items()` and `values()` read through `__getitem__` and count as a use of every item;
+  inspect state with `list(cache)`. `LFUCache` ties discard the least recently used key
+  (documented since 7.3) in O(1): keep the `OrderedDict` per use count (#461).
+- Timed caches expire lazily (`__len__`, `__repr__` and `currsize` call `expire()`,
+  `clear()` does not); every insert and `popitem()` must keep calling that hook.
+- Decorator wrappers are objects, not functions; `_WrapperBase` runs
+  `update_wrapper()` *before* setting its public attributes (stacked decorators).
+- A `condition` passed with a separate `lock` must be created with that lock
+  (`Condition(lock)`), as `wait()` and `notify_all()` run under `lock`; not checked.
+- `@cachedmethod` stores per-instance wrappers in `obj.__dict__`; `super()` lookups and
+  lookups after `del Cls.method` use `obj.__dict__["__cachetools_cachedmethods"]`.
+  `cache_key` is `partial(key, obj)`, not `types.MethodType`, which on PyPy accepts a
+  non-callable `key`. Pickling and deep-copying such objects (#417) and
+  `create_autospec()` on their classes (#443) must keep working;
+  `_MethodDescriptor._lookup` must stay importable.
+- Key functions return plain tuples, `args` itself without kwargs; `_HashedTuple`
+  survives only as the kwargs separator and to load keys pickled by 7.x.
+
+## Testing
+
+- New behavior needs tests under `tests/`; user-visible features need docs in
+  `docs/index.rst`. One `TestCase` per cache type on `CacheTestMixin`; TTL tests use a
+  manual `Timer`. Objects pickled by name must be reachable from module level.
+- Stub checks need concrete annotated tests without `# type: ignore`, since
+  `test_func.py` calls decorators via `Callable[..., Any]`.
+- Threading tests use real `Lock`/`Condition` objects (`WaitCondition(lock)` forces a
+  contended `wait()`), join with `TIMEOUT` and assert the thread finished.
+- Performance: `timeit`, best of 7, on a pinned core (`taskset`), never in a VM,
+  against a git worktree of the previous release. Never trade documented subclass
+  hooks or semantics for speed.
+
+## Boundaries
+
+- Never edit `CHANGELOG.rst` or bump `__version__`; both are release-only.
+- Never promise cross-version pickle compatibility or build on the byte format; any
+  release, even a bugfix, may change it.
+- Do not re-raise the *Maintainer Decisions* in `.github/copilot-instructions.md`.
+
+## Git
+
+- PRs reference an open issue (except trivial fixes), in separate commits:
+  `Fix #123: ...`, `Tests for #123: ...`, `Docs for #123: ...`.
+- Run `tox -p auto` before pushing. Update this file in the same PR that changes a
+  convention, and keep it under 100 lines.

{cachetools-7.3.0 → cachetools-8.0.0}/CHANGELOG.rst

@@ -1,3 +1,36 @@
+v8.0.0 (2026-11-06)
+===================
+
+- Drop Python 3.10 support (breaking change).
+
+- Drop support for deprecated ``@cachedmethod`` features (breaking
+  change).
+
+- Drop support for ``@cached(cache=None)`` (breaking change).
+
+- Require custom cache classes to support ``__len__`` when used with
+  ``info=True`` (breaking change).
+
+- Refactor ``_CacheInfo`` and make it public as ``CacheInfo``
+  (potentially breaking change).
+
+- Return callable objects instead of functions from ``@cached`` and
+  the ``cachetools.func`` decorators (potentially breaking change).
+
+- Do not set ``cache_info`` to ``None`` on ``@cached`` wrappers if
+  ``info`` is not set (potentially breaking change).
+
+- Raise ``TypeError`` for ``@cachedmethod`` descriptors assigned
+  after class creation, i.e. without ``__set_name__`` being called
+  (potentially breaking change).
+
+- Various performance improvements.
+
+- Various documentation improvements.
+
+- Various test improvements.
+
+
 v7.3.0 (2026-11-05)
 ===================
 

{cachetools-7.3.0/src/cachetools.egg-info → cachetools-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cachetools
-Version: 7.3.0
+Version: 8.0.0
 Summary: Extensible memoizing collections and decorators
 Author-email: Thomas Kemmer <tkemmer@computer.org>
 Maintainer-email: Thomas Kemmer <tkemmer@computer.org>
@@ -16,14 +16,13 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
 Dynamic: license-file
@@ -67,14 +66,18 @@ function decorator.
    # cache least recently used Python Enhancement Proposals
    @cached(cache=LRUCache(maxsize=32))
    def get_pep(num):
-       url = 'http://www.python.org/dev/peps/pep-%04d/' % num
-       with urllib.request.urlopen(url) as s:
+       from urllib.request import urlopen
+       url = 'https://peps.python.org/pep-%04d/' % num
+       with urlopen(url) as s:
            return s.read()
 
-   # cache weather data for no longer than ten minutes
+   # cache PyOWM weather data for no longer than ten minutes
+   from pyowm.owm import OWM
+   owm = OWM('your-free-api-key')
+
    @cached(cache=TTLCache(maxsize=1024, ttl=600))
    def get_weather(place):
-       return owm.weather_at_place(place).get_weather()
+       return owm.weather_manager().weather_at_place(place).weather
 
 For the purpose of this module, a *cache* is a mutable_ mapping_ of a
 fixed maximum size.  When the cache is full, i.e. by adding another
@@ -124,8 +127,8 @@ Licensed under the `MIT License`_.
 
 
 .. _@lru_cache: https://docs.python.org/3/library/functools.html#functools.lru_cache
-.. _mutable: https://docs.python.org/dev/glossary.html#term-mutable
-.. _mapping: https://docs.python.org/dev/glossary.html#term-mapping
+.. _mutable: https://docs.python.org/3/glossary.html#term-mutable
+.. _mapping: https://docs.python.org/3/glossary.html#term-mapping
 .. _cache algorithm: https://en.wikipedia.org/wiki/Cache_algorithms
 
 .. _PyPI: https://pypi.org/project/cachetools/

{cachetools-7.3.0 → cachetools-8.0.0}/README.rst

@@ -37,14 +37,18 @@ function decorator.
    # cache least recently used Python Enhancement Proposals
    @cached(cache=LRUCache(maxsize=32))
    def get_pep(num):
-       url = 'http://www.python.org/dev/peps/pep-%04d/' % num
-       with urllib.request.urlopen(url) as s:
+       from urllib.request import urlopen
+       url = 'https://peps.python.org/pep-%04d/' % num
+       with urlopen(url) as s:
            return s.read()
 
-   # cache weather data for no longer than ten minutes
+   # cache PyOWM weather data for no longer than ten minutes
+   from pyowm.owm import OWM
+   owm = OWM('your-free-api-key')
+
    @cached(cache=TTLCache(maxsize=1024, ttl=600))
    def get_weather(place):
-       return owm.weather_at_place(place).get_weather()
+       return owm.weather_manager().weather_at_place(place).weather
 
 For the purpose of this module, a *cache* is a mutable_ mapping_ of a
 fixed maximum size.  When the cache is full, i.e. by adding another
@@ -94,8 +98,8 @@ Licensed under the `MIT License`_.
 
 
 .. _@lru_cache: https://docs.python.org/3/library/functools.html#functools.lru_cache
-.. _mutable: https://docs.python.org/dev/glossary.html#term-mutable
-.. _mapping: https://docs.python.org/dev/glossary.html#term-mapping
+.. _mutable: https://docs.python.org/3/glossary.html#term-mutable
+.. _mapping: https://docs.python.org/3/glossary.html#term-mapping
 .. _cache algorithm: https://en.wikipedia.org/wiki/Cache_algorithms
 
 .. _PyPI: https://pypi.org/project/cachetools/

{cachetools-7.3.0 → cachetools-8.0.0}/docs/index.rst

@@ -44,15 +44,15 @@ calls :meth:`self.popitem()` repeatedly until there is enough room for
 the item to be added.
 
 In general, a cache's size is the total size of its items' values.
-Therefore, :class:`Cache` provides a :meth:`~Cache.getsizeof` method, which
-returns the size of a given `value`.  The default implementation of
-:meth:`~Cache.getsizeof` returns :const:`1` irrespective of its argument,
-making the cache's size equal to the number of its items, or
+Therefore, :class:`Cache` provides a :meth:`~Cache.getsizeof` method,
+which returns the size of a given `value`.  The default implementation
+of :meth:`~Cache.getsizeof` returns :const:`1` irrespective of its
+argument, making the cache's size equal to the number of its items, or
 `len(cache)`.  For convenience, all cache classes accept an optional
 named constructor parameter `getsizeof`, which may specify a callable
-``getsizeof(value)`` returning a non-negative number as the size of
-an item's value.  An item whose size exceeds :attr:`~Cache.maxsize` cannot be
-stored, and trying to do so raises :exc:`ValueError`.
+``getsizeof(value)`` returning a non-negative number as the size of an
+item's value.  An item whose size exceeds :attr:`~Cache.maxsize`
+cannot be stored, and trying to do so raises :exc:`ValueError`.
 
 The values of a :class:`Cache` are mutable by default, as are e.g. the
 values of a :class:`dict`.  It is the user's responsibility to take
@@ -78,6 +78,16 @@ inserted into the cache.
    additionally need to override :meth:`__getitem__`,
    :meth:`__setitem__` and :meth:`__delitem__`.
 
+   .. note::
+
+      Even though :class:`Cache` and the subclasses provided by this
+      module can generally be `pickled`_, the byte stream format is an
+      implementation detail that *any* release may change, even a
+      bugfix release.  Therefore, do not rely on being able to
+      unpickle a cache, e.g. one stored in a file or database, with a
+      different :mod:`cachetools` version than the one it was pickled
+      with.
+
 .. autoclass:: FIFOCache(maxsize, getsizeof=None)
    :members: popitem
 
@@ -404,9 +414,10 @@ often called with the same arguments:
       get_pep.cache_clear()
 
    If `info` is set to :const:`True`, the wrapped function is
-   instrumented with a :func:`cache_info()` function that returns a
-   named tuple showing `hits`, `misses`, `maxsize` and `currsize`, to
-   help measure the effectiveness of the cache.
+   instrumented with a :meth:`cache_info()` function that returns a
+   :class:`CacheInfo` instance, a named tuple with fields `hits`,
+   `misses`, `maxsize` and `currsize`, to help measure the
+   effectiveness of the cache.
 
    .. note::
 
@@ -540,12 +551,10 @@ often called with the same arguments:
       >>> foo(1)
       >>> foo(a=1)
 
-   .. deprecated:: 7.2
+   .. versionchanged:: 8.0
 
-      Passing :const:`None` as `cache` parameter is deprecated, and
-      support will be removed in the next major version.  This is
-      mainly for consistency with :func:`cachedmethod`, which no
-      longer supports returning :const:`None` from `cache(self)`.
+      Passing :const:`None` as the `cache` parameter is no longer
+      supported, and now raises a :exc:`TypeError`.
 
 
 .. decorator:: cachedmethod(cache, key=cachetools.keys.methodkey, lock=None, condition=None, info=False)
@@ -631,6 +640,17 @@ often called with the same arguments:
    e.g. :func:`cachetools.keys.hashkey`, if you need `self` to be part
    of the cache key.
 
+   Accessing a decorated method through its class, e.g.
+   ``Cls.method``, yields a callable that takes the instance as its
+   first positional argument, or as a keyword argument named after the
+   wrapped method's first parameter.  Unlike the method of an
+   instance, this callable does not provide the :attr:`cache`,
+   :attr:`cache_lock`, etc. attributes or the :meth:`cache_clear()`
+   and :meth:`cache_info()` functions, so this usage pattern is not
+   encouraged.  Note also that pickling or deep-copying an instance
+   restores its methods with fresh :meth:`cache_info()` statistics,
+   i.e. with the hit and miss counts reset to zero.
+
    When using a shared cache for multiple methods, be aware that
    different cache keys must be created for each method even when
    function arguments are the same, just as with the :func:`cached`
@@ -674,7 +694,8 @@ often called with the same arguments:
 
    Note how keyword arguments are used with :func:`functools.partial`
    to create distinct cache keys, to avoid issues with
-   :func:`~cachetools.keys.methodkey` skipping its initial `self` argument.
+   :func:`~cachetools.keys.methodkey` skipping its initial `self`
+   argument.
 
    .. versionchanged:: 7.0
 
@@ -688,23 +709,38 @@ often called with the same arguments:
       Require :attr:`__dict__` to be a mutable mapping to support
       per-instance :meth:`cache_info()`.
 
-      Returning :const:`None` from `cache(self)` is no longer supported.
+      Returning :const:`None` from `cache(self)` is no longer
+      supported.
 
-   .. deprecated:: 7.0
+   .. versionchanged:: 8.0
 
-      Using :func:`cachedmethod` with :func:`classmethod` is
-      deprecated, and support will be removed in the next major
-      version.  This is mostly due to the fact that chaining
-      descriptors, i.e. using descriptors with :func:`classmethod`,
-      was deprecated in Python 3.11 and removed in Python 3.13.  When
-      using :func:`cache_info()`, an instance method is already
-      required.
+      Using :func:`cachedmethod` with :func:`classmethod` is no longer
+      supported, and now raises a :exc:`TypeError`.  This is mostly
+      due to the fact that chaining descriptors, i.e. using
+      descriptors with :func:`classmethod`, was deprecated in Python
+      3.11 and removed in Python 3.13.
 
       Using :func:`cachedmethod` with an instance that does not
-      provide a mutable :attr:`__dict__` attribute is deprecated, and
-      may inflict a noticeable performance penalty.  When using
-      :func:`cache_info()`, :attr:`__dict__` already has to be a
-      mutable mapping.
+      provide a mutable :attr:`__dict__` attribute is no longer
+      supported, and now raises a :exc:`TypeError`.
+
+.. autoclass:: CacheInfo
+
+   A named tuple with the fields `hits`, `misses`, `maxsize` and
+   `currsize`, as returned by the :meth:`cache_info()` function of the
+   :func:`cached` and :func:`cachedmethod` decorators.  If the
+   decorator's `cache` is a :class:`Cache` instance, `maxsize` and
+   `currsize` report its :attr:`~Cache.maxsize` and
+   :attr:`~Cache.currsize` properties.  For any other mutable mapping,
+   `maxsize` is :const:`None` and `currsize` is `len(cache)`, so
+   custom cache classes used with `info=True` must support
+   :func:`len`.
+
+   .. versionchanged:: 8.0
+
+      :class:`CacheInfo` is now part of the public API.  Cache objects
+      that are not :class:`Cache` instances must support :func:`len`
+      when used with `info=True`.
 
 
 *****************************************************************
@@ -853,4 +889,5 @@ all the decorators in this module are thread-safe.
 .. _context manager: https://docs.python.org/3/glossary.html#term-context-manager
 .. _mapping: https://docs.python.org/3/glossary.html#term-mapping
 .. _mutable: https://docs.python.org/3/glossary.html#term-mutable
+.. _pickled: https://docs.python.org/3/library/pickle.html
 .. _thread-safe: https://en.wikipedia.org/wiki/Thread_safety

{cachetools-7.3.0 → cachetools-8.0.0}/pyproject.toml

@@ -15,14 +15,13 @@ maintainers = [
 readme = "README.rst"
 license = "MIT"
 license-files = ["LICENSE"]
-requires-python = ">= 3.10"
+requires-python = ">= 3.11"
 classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Operating System :: OS Independent",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",

{cachetools-7.3.0 → cachetools-8.0.0}/src/cachetools/__init__.py

@@ -2,6 +2,7 @@
 
 __all__ = (
     "Cache",
+    "CacheInfo",
     "FIFOCache",
     "LFUCache",
     "LRUCache",
@@ -12,7 +13,7 @@ __all__ = (
     "cachedmethod",
 )
 
-__version__ = "7.3.0"
+__version__ = "8.0.0"
 
 import collections
 import collections.abc
@@ -740,11 +741,17 @@ class TLRUCache(_TimedCache):
             cache_delitem(self, key)
 
 
-# note that the runtime __name__ is "CacheInfo", as in stdlib:
-# https://github.com/python/cpython/blob/3.14/Lib/functools.py#L520
-_CacheInfo = collections.namedtuple(
-    "CacheInfo", ["hits", "misses", "maxsize", "currsize"]
-)
+class CacheInfo(collections.namedtuple("CacheInfo", "hits misses maxsize currsize")):
+    """Named tuple holding cache statistics."""
+
+    __slots__ = ()
+
+    @classmethod
+    def _make_info(cls, cache, hits, misses):
+        if isinstance(cache, Cache):
+            return cls(hits, misses, cache.maxsize, cache.currsize)
+        else:
+            return cls(hits, misses, None, len(cache))
 
 
 def cached(cache, key=keys.hashkey, lock=None, condition=None, info=False):
@@ -754,26 +761,12 @@ def cached(cache, key=keys.hashkey, lock=None, condition=None, info=False):
     """
     from ._cached import _wrapper
 
-    def decorator(func):
-        if info:
-            if isinstance(cache, Cache):
-
-                def make_info(hits, misses):
-                    return _CacheInfo(hits, misses, cache.maxsize, cache.currsize)
-
-            elif isinstance(cache, collections.abc.Mapping):
-
-                def make_info(hits, misses):
-                    return _CacheInfo(hits, misses, None, len(cache))
+    if cache is None:  # no longer supported since v8.0.0
+        raise TypeError("cache must not be None")
 
-            else:
-
-                def make_info(hits, misses):
-                    return _CacheInfo(hits, misses, 0, 0)
-
-            return _wrapper(func, cache, key, lock, condition, info=make_info)
-        else:
-            return _wrapper(func, cache, key, lock, condition)
+    def decorator(func):
+        make_info = CacheInfo._make_info if info else None
+        return _wrapper(func, cache, key, lock, condition, make_info)
 
     return decorator
 
@@ -786,18 +779,7 @@ def cachedmethod(cache, key=keys.methodkey, lock=None, condition=None, info=Fals
     from ._cachedmethod import _wrapper
 
     def decorator(method):
-        if info:
-
-            def make_info(cache, hits, misses):
-                if isinstance(cache, Cache):
-                    return _CacheInfo(hits, misses, cache.maxsize, cache.currsize)
-                elif isinstance(cache, collections.abc.Mapping):
-                    return _CacheInfo(hits, misses, None, len(cache))
-                else:
-                    raise TypeError("cache(self) must return a mutable mapping")
-
-            return _wrapper(method, cache, key, lock, condition, info=make_info)
-        else:
-            return _wrapper(method, cache, key, lock, condition)
+        make_info = CacheInfo._make_info if info else None
+        return _wrapper(method, cache, key, lock, condition, make_info)
 
     return decorator

{cachetools-7.3.0 → cachetools-8.0.0}/src/cachetools/__init__.pyi

@@ -17,6 +17,7 @@ from typing import (
 
 __all__: Final = (
     "Cache",
+    "CacheInfo",
     "FIFOCache",
     "LFUCache",
     "LRUCache",
@@ -138,7 +139,7 @@ class TLRUCache(_TimedCache[_KT, _VT, _TT]):
     def ttu(self) -> Callable[[_KT, _VT, _TT], _TT]: ...
     def expire(self, time: _TT | None = None) -> list[tuple[_KT, _VT]]: ...
 
-class _CacheInfo(NamedTuple):
+class CacheInfo(NamedTuple):
     hits: int
     misses: int
     maxsize: float | None
@@ -159,7 +160,7 @@ class _cached_wrapper(Generic[_P, _R]):
     __name__: str
     __qualname__: str
     __doc__: str | None
-    cache: MutableMapping[Any, Any] | None
+    cache: MutableMapping[Any, Any]
     cache_key: Callable[..., Any] = ...
     cache_lock: AbstractContextManager[Any] | None = None
     cache_condition: _AbstractCondition | None = None
@@ -198,28 +199,28 @@ class _cached_wrapper_info(_cached_wrapper[_P, _R]):
     def __get__(  # pyright: ignore[reportIncompatibleMethodOverride]
         self, obj: object, objtype: type | None = None
     ) -> _cached_wrapper_info[_P, _R]: ...
-    def cache_info(self) -> _CacheInfo: ...
+    def cache_info(self) -> CacheInfo: ...
 
 @overload
 def cached(
-    cache: MutableMapping[_KT, Any] | None,
+    cache: MutableMapping[_KT, Any],
     key: Callable[..., _KT] = ...,
     lock: AbstractContextManager[Any] | None = None,
     condition: _AbstractCondition | None = None,
-    info: Literal[False] = ...,
-) -> Callable[[Callable[_P, _R]], _cached_wrapper[_P, _R]]: ...
+    *,
+    info: Literal[True],
+) -> Callable[[Callable[_P, _R]], _cached_wrapper_info[_P, _R]]: ...
 @overload
 def cached(
-    cache: MutableMapping[_KT, Any] | None,
+    cache: MutableMapping[_KT, Any],
     key: Callable[..., _KT] = ...,
     lock: AbstractContextManager[Any] | None = None,
     condition: _AbstractCondition | None = None,
-    *,
-    info: Literal[True],
-) -> Callable[[Callable[_P, _R]], _cached_wrapper_info[_P, _R]]: ...
+    info: Literal[False] = ...,
+) -> Callable[[Callable[_P, _R]], _cached_wrapper[_P, _R]]: ...
 @overload
 def cached(
-    cache: MutableMapping[_KT, Any] | None,
+    cache: MutableMapping[_KT, Any],
     key: Callable[..., _KT],
     lock: AbstractContextManager[Any] | None,
     condition: _AbstractCondition | None,
@@ -240,11 +241,7 @@ class _cachedmethod_unbound(Generic[_P, _R]):
     def __get__(
         self, obj: Any, objtype: type | None = None
     ) -> _cachedmethod_wrapper[_P, _R]: ...
-    @overload
     def __call__(self, obj: Any, /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
-    # deprecated @classmethod use
-    @overload
-    def __call__(self, /, *args: _P.args, **kwargs: _P.kwargs) -> _R: ...
 
 @type_check_only
 class _cachedmethod_wrapper(Generic[_P, _R]):
@@ -278,7 +275,7 @@ class _cachedmethod_wrapper_info(_cachedmethod_wrapper[_P, _R]):
     def __get__(
         self, obj: Any, objtype: type | None = None
     ) -> _cachedmethod_wrapper_info[_P, _R]: ...
-    def cache_info(self) -> _CacheInfo: ...
+    def cache_info(self) -> CacheInfo: ...
 
 @overload
 def cachedmethod(
@@ -286,19 +283,19 @@ def cachedmethod(
     key: Callable[..., _KT] = ...,
     lock: Callable[[Any], AbstractContextManager[Any]] | None = None,
     condition: Callable[[Any], _AbstractCondition] | None = None,
-    info: Literal[False] = ...,
-) -> Callable[[Callable[Concatenate[Any, _P], _R]], _cachedmethod_wrapper[_P, _R]]: ...
+    *,
+    info: Literal[True],
+) -> Callable[
+    [Callable[Concatenate[Any, _P], _R]], _cachedmethod_wrapper_info[_P, _R]
+]: ...
 @overload
 def cachedmethod(
     cache: Callable[[Any], MutableMapping[_KT, Any]],
     key: Callable[..., _KT] = ...,
     lock: Callable[[Any], AbstractContextManager[Any]] | None = None,
     condition: Callable[[Any], _AbstractCondition] | None = None,
-    *,
-    info: Literal[True],
-) -> Callable[
-    [Callable[Concatenate[Any, _P], _R]], _cachedmethod_wrapper_info[_P, _R]
-]: ...
+    info: Literal[False] = ...,
+) -> Callable[[Callable[Concatenate[Any, _P], _R]], _cachedmethod_wrapper[_P, _R]]: ...
 @overload
 def cachedmethod(
     cache: Callable[[Any], MutableMapping[_KT, Any]],