wrapt 2.2.2rc1__tar.gz → 2.2.2rc3__tar.gz

{wrapt-2.2.2rc1/src/wrapt.egg-info → wrapt-2.2.2rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapt
-Version: 2.2.2rc1
+Version: 2.2.2rc3
 Summary: Module for decorators, wrappers and monkey patching.
 Author-email: Graham Dumpleton <Graham.Dumpleton@gmail.com>
 License-Expression: BSD-2-Clause

{wrapt-2.2.2rc1 → wrapt-2.2.2rc3}/src/wrapt/__init__.py

@@ -13,7 +13,7 @@ def _format_version(parts):
     )
 
 
-__version_info__ = ("2", "2", "2", "rc1")
+__version_info__ = ("2", "2", "2", "rc3")
 __version__ = _format_version(__version_info__)
 
 from .__wrapt__ import (

{wrapt-2.2.2rc1 → wrapt-2.2.2rc3}/src/wrapt/caching.py

@@ -9,7 +9,7 @@ methods a single shared cache is used, matching ``functools.lru_cache``.
 from functools import lru_cache as _functools_lru_cache
 from functools import partial
 
-from .__wrapt__ import BoundFunctionWrapper, FunctionWrapper
+from .__wrapt__ import BaseObjectProxy, BoundFunctionWrapper, FunctionWrapper
 from .decorators import decorator
 from .synchronization import synchronized
 
@@ -71,7 +71,19 @@ class _BoundLRUCacheFunctionWrapper(BoundFunctionWrapper):
                         self.__wrapped__
                     )
 
-                    setattr(instance, cache_attr, cache)
+                    # If the instance the method is bound to is a wrapt
+                    # object proxy, a plain setattr() would fall through and
+                    # store the cache on the wrapped object rather than the
+                    # proxy. Use type() rather than isinstance() so the check
+                    # sees the real proxy type and is not fooled by the proxy
+                    # overriding __class__ to report the wrapped object's
+                    # type. Proxies expose __self_setattr__() which stores the
+                    # attribute on the proxy itself.
+
+                    if issubclass(type(instance), BaseObjectProxy):
+                        instance.__self_setattr__(cache_attr, cache)
+                    else:
+                        setattr(instance, cache_attr, cache)
 
         return cache(*args, **kwargs)
 

{wrapt-2.2.2rc1 → wrapt-2.2.2rc3/src/wrapt.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wrapt
-Version: 2.2.2rc1
+Version: 2.2.2rc3
 Summary: Module for decorators, wrappers and monkey patching.
 Author-email: Graham Dumpleton <Graham.Dumpleton@gmail.com>
 License-Expression: BSD-2-Clause

{wrapt-2.2.2rc1 → wrapt-2.2.2rc3}/tests/core/test_lru_cache.py

@@ -267,6 +267,161 @@ class TestStaticMethod(unittest.TestCase):
         self.assertEqual(info.misses, 1)
 
 
+class OverrideBase:
+    def __init__(self):
+        self.base_calls = 0
+        self.derived_calls = 0
+
+    @wrapt.lru_cache
+    def compute(self, x):
+        self.base_calls += 1
+        return x * 2
+
+
+class OverrideDerived(OverrideBase):
+    @wrapt.lru_cache
+    def compute(self, x):
+        self.derived_calls += 1
+        return super().compute(x) + 1
+
+
+class TestOverriddenMethodWithSuper(unittest.TestCase):
+    def test_super_call_returns_correct_result(self):
+        obj = OverrideDerived()
+        self.assertEqual(obj.compute(10), 21)
+
+    def test_super_call_does_not_recurse(self):
+        # Regression test: a subclass method decorated with lru_cache that
+        # called the base method via super() used to recurse forever because
+        # the base and derived methods shared a single per-instance cache
+        # slot derived from the method name alone.
+        obj = OverrideDerived()
+        try:
+            result = obj.compute(10)
+        except RecursionError:
+            self.fail("super() call recursed instead of reaching base method")
+        self.assertEqual(result, 21)
+
+    def test_both_bodies_execute_once(self):
+        obj = OverrideDerived()
+        obj.compute(10)
+        self.assertEqual(obj.derived_calls, 1)
+        self.assertEqual(obj.base_calls, 1)
+
+    def test_base_and_derived_cached_independently(self):
+        obj = OverrideDerived()
+        obj.compute(10)
+        obj.compute(10)
+        # Second call is served from both caches, so neither body re-runs.
+        self.assertEqual(obj.derived_calls, 1)
+        self.assertEqual(obj.base_calls, 1)
+        info = obj.compute.cache_info()
+        self.assertEqual(info.hits, 1)
+        self.assertEqual(info.misses, 1)
+
+    def test_base_class_instance_unaffected(self):
+        obj = OverrideBase()
+        self.assertEqual(obj.compute(10), 20)
+        self.assertEqual(obj.base_calls, 1)
+        self.assertEqual(obj.derived_calls, 0)
+
+    def test_separate_instances_have_separate_caches(self):
+        obj1 = OverrideDerived()
+        obj2 = OverrideDerived()
+        obj1.compute(10)
+        obj2.compute(10)
+        self.assertEqual(obj1.derived_calls, 1)
+        self.assertEqual(obj2.derived_calls, 1)
+        self.assertEqual(obj1.base_calls, 1)
+        self.assertEqual(obj2.base_calls, 1)
+
+
+class ProxyWrapped:
+    def __init__(self, a):
+        self.a = a
+
+
+class ProxyCached(wrapt.ObjectProxy):
+    @wrapt.lru_cache
+    def compute(self, x):
+        return self.a + x
+
+
+class ProxyCachedWithState(wrapt.ObjectProxy):
+    def __init__(self, wrapped, factor):
+        super().__init__(wrapped)
+        self._self_factor = factor
+
+    @wrapt.lru_cache
+    def compute(self, x):
+        return self._self_factor * x
+
+
+class SlottedWrapped:
+    __slots__ = ("a",)
+
+    def __init__(self, a):
+        self.a = a
+
+
+class TestObjectProxySubclass(unittest.TestCase):
+    def test_returns_correct_result(self):
+        obj = ProxyCached(ProxyWrapped(1))
+        self.assertEqual(obj.compute(10), 11)
+
+    def test_caching(self):
+        obj = ProxyCached(ProxyWrapped(1))
+        obj.compute(10)
+        obj.compute(10)
+        info = obj.compute.cache_info()
+        self.assertEqual(info.hits, 1)
+        self.assertEqual(info.misses, 1)
+
+    def test_cache_not_stored_on_wrapped_object(self):
+        wrapped = ProxyWrapped(1)
+        obj = ProxyCached(wrapped)
+        obj.compute(10)
+        cache_attrs = [k for k in vars(wrapped) if k.startswith("_lru_cache_")]
+        self.assertEqual(cache_attrs, [])
+
+    def test_per_proxy_state_not_shared_for_same_wrapped_object(self):
+        # Two proxies over the same wrapped object must keep independent
+        # per-instance caches keyed to their own proxy state, not a single
+        # cache stored on the shared wrapped object.
+        wrapped = ProxyWrapped(1)
+        obj1 = ProxyCachedWithState(wrapped, 2)
+        obj2 = ProxyCachedWithState(wrapped, 10)
+        self.assertEqual(obj1.compute(5), 10)
+        self.assertEqual(obj2.compute(5), 50)
+
+    def test_proxy_garbage_collected_with_long_lived_wrapped(self):
+        # The cache must be stored on the proxy, not the wrapped object, so
+        # a proxy is not kept alive by a wrapped object that outlives it.
+        registry = []
+
+        def make_and_use():
+            backing = ProxyWrapped(7)
+            registry.append(backing)
+            proxy = ProxyCached(backing)
+            proxy.compute(4)
+            return weakref.ref(proxy)
+
+        ref = make_and_use()
+        gc.collect()
+        self.assertIsNone(ref())
+
+    def test_wrapped_object_without_dict(self):
+        # A wrapped object that does not accept arbitrary attributes (for
+        # example one using __slots__) must not cause the cache storage to
+        # fail, since the cache is stored on the proxy.
+        obj = ProxyCached(SlottedWrapped(1))
+        self.assertEqual(obj.compute(10), 11)
+        self.assertEqual(obj.compute(10), 11)
+        info = obj.compute.cache_info()
+        self.assertEqual(info.hits, 1)
+        self.assertEqual(info.misses, 1)
+
+
 class TestIntrospection(unittest.TestCase):
     def test_function_name(self):
         self.assertEqual(cached_function.__name__, "cached_function")