Refine the implementation of cached_method

Thanks to feedback from @jaraco, this adjustment makes the public
interface for `cached_method` a function which is responsible for the
argument management, rather than trying to use `__call__` on the
descriptor itself.

This frees up `__call__` to lookup the relevant LRU-cached function and
invoke it, which makes the `_cached_method` descriptor suitable for use
as a `property.fget` callable.

Tests are updated to indicate that a decorator can be prepared and then
used repeatedly (which was previously an explicit error), and can be used
under a property decorator.

Author: sirosen

Lib/functools.py

@@ -1202,7 +1202,7 @@ def wrapped(*args, **kwargs):
     return wrapped
 
 
-class cached_method:
+class _cached_method:
     """
     A caching decorator for use on instance methods.
 
@@ -1215,35 +1215,31 @@ class cached_method:
     By default, this provides an infinite sized cache similar to functools.cache. Use
     *maxsize* and *typed* to set these attributes of the underlying LRU cache.
     """
-    def __init__(self, func=None, /, maxsize=None, typed=False):
-        self.func = None
-        self._maxsize = maxsize
-        self._typed = typed
+    def __init__(self, func, /, maxsize=None, typed=False):
         self._function_table = {}
         # we need a lock when initializing per-instance caches
         self._cache_init_lock = RLock()
 
-        if func is not None:
-            self.func = func
-            update_wrapper(self, func)
+        self._maxsize = maxsize
+        self._typed = typed
 
-    def __call__(self, func):
-        if self.func is not None:
-            raise TypeError(
-                "Each cached_method decorator can only apply to one function."
-            )
         self.func = func
         update_wrapper(self, func)
-        return self
+
+    def __call__(self, instance, *args, **kwargs):
+        cached_func = self._get_or_create_cached_func(instance)
+        return cached_func(*args, **kwargs)
 
     def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        return self._get_or_create_cached_func(instance)
+
+    def _get_or_create_cached_func(self, instance):
         # similar to singledispatch(), we want to defer use of weakref until/unless it
         # is needed
         import weakref
 
-        if instance is None:
-            return self
-
         instance_id = id(instance)
 
         # first try to retrieve the cached func without locking (thus avoiding any
@@ -1269,3 +1265,12 @@ def __get__(self, instance, owner=None):
                     self._function_table[instance_id] = ref, cached_func
 
         return cached_func
+
+
+def cached_method(func=None, /, maxsize=None, typed=False):
+    if func is None:
+        def decorator(func):
+            return _cached_method(func, maxsize=maxsize, typed=typed)
+        return decorator
+    else:
+        return _cached_method(func, maxsize=maxsize, typed=typed)

Lib/test/test_functools.py

@@ -3843,21 +3843,31 @@ def test_cache_info(self):
         self.assertEqual(one.add.cache_info(),
             self.module._CacheInfo(hits=0, misses=0, maxsize=None, currsize=0))
 
-    def test_reapplication_causes_type_error(self):
-        with self.assertRaisesRegex(
-            TypeError,
-            r"Each cached_method decorator can only apply to one function\.",
-        ):
-            decorator = py_functools.cached_method()
+    def test_reapplication_is_allowed(self):
+        decorator = py_functools.cached_method(maxsize=10)
 
-            class MyObject:
-                @decorator
-                def a(self):
-                    return None
+        class MyObject:
+            @decorator
+            def a(self):
+                return 1
+
+            @decorator
+            def b(self):
+                return 2
+
+        x = MyObject()
+        self.assertEqual(x.a(), 1)
+        self.assertEqual(x.b(), 2)
+
+    def test_cached_method_under_property(self):
+        class MyObject:
+            @property
+            @py_functools.cached_method
+            def foo(self):
+                return 1
 
-                @decorator
-                def b(self):
-                    return None
+        x = MyObject()
+        self.assertEqual(x.foo, 1)
 
 
 if __name__ == '__main__':