[ENH] Pythagorean tree and Pythagorean forest widgets

Orange/misc/cache.py

@@ -1,16 +1,60 @@
-def single_cache(f):
+"""Common caching methods, using `lru_cache` sometimes has its downsides."""
+from functools import wraps, lru_cache
+import weakref
+
+
+def single_cache(func):
+    """Cache with size 1."""
     last_args = ()
     last_kwargs = set()
     last_result = None
 
-    def cached(*args, **kwargs):
+    @wraps(func)
+    def _cached(*args, **kwargs):
         nonlocal last_args, last_kwargs, last_result
         if len(last_args) != len(args) or \
                 not all(x is y for x, y in zip(args, last_args)) or \
                 last_kwargs != set(kwargs) or \
                 any(last_kwargs[k] != kwargs[k] for k in last_kwargs):
-            last_result = f(*args, **kwargs)
+            last_result = func(*args, **kwargs)
             last_args, last_kwargs = args, kwargs
         return last_result
 
-    return cached
+    return _cached
+
+
+def memoize_method(*lru_args, **lru_kwargs):
+    """Memoize methods without keeping reference to `self`.
+
+    Parameters
+    ----------
+    lru_args
+    lru_kwargs
+
+    Returns
+    -------
+
+    See Also
+    --------
+    https://stackoverflow.com/questions/33672412/python-functools-lru-cache-with-class-methods-release-object
+
+    """
+    def _decorator(func):
+
+        @wraps(func)
+        def _wrapped_func(self, *args, **kwargs):
+            self_weak = weakref.ref(self)
+            # We're storing the wrapped method inside the instance. If we had
+            # a strong reference to self the instance would never die.
+
+            @wraps(func)
+            @lru_cache(*lru_args, **lru_kwargs)
+            def _cached_method(*args, **kwargs):
+                return func(self_weak(), *args, **kwargs)
+
+            setattr(self, func.__name__, _cached_method)
+            return _cached_method(*args, **kwargs)
+
+        return _wrapped_func
+
+    return _decorator

Orange/tests/test_misc.py

@@ -0,0 +1,30 @@
+import unittest
+
+from Orange.misc.cache import memoize_method, single_cache
+
+
+class Calculator:
+    @memoize_method()
+    def my_sum(self, *nums):
+        return sum(nums)
+
+
+@single_cache
+def my_sum(*nums):
+    return sum(nums)
+
+
+class TestCache(unittest.TestCase):
+
+    def test_single_cache(self):
+        self.assertEqual(my_sum(1, 2, 3, 4, 5), 15)
+        self.assertEqual(my_sum(1, 2, 3, 4, 5), 15)
+        # Make sure different args produce different results
+        self.assertEqual(my_sum(1, 2, 3, 4), 10)
+
+    def test_memoize_method(self):
+        calc = Calculator()
+        self.assertEqual(calc.my_sum(1, 2, 3, 4, 5), 15)
+        self.assertEqual(calc.my_sum(1, 2, 3, 4, 5), 15)
+        # Make sure different args produce different results
+        self.assertEqual(calc.my_sum(1, 2, 3, 4), 10)