Add memoization to dynamic Callable class

holoviews/core/spaces.py

@@ -404,7 +404,10 @@ class Callable(param.Parameterized):
     allowing their inputs (and in future outputs) to be defined.
     This makes it possible to wrap DynamicMaps with streams and
     makes it possible to traverse the graph of operations applied
-    to a DynamicMap.
+    to a DynamicMap. Additionally a Callable will memoize the last
+    returned value based on the arguments to the function and the
+    state of all streams on its inputs, avoiding calling the function
+    unncessarily.
     """
 
     callable_function = param.Callable(default=lambda x: x, doc="""
@@ -413,8 +416,22 @@ class Callable(param.Parameterized):
     inputs = param.List(default=[], doc="""
          The list of inputs the callable function is wrapping.""")
 
+    def __init__(self, **params):
+        super(Callable, self).__init__(**params)
+        self._memoized = {}
+
     def __call__(self, *args, **kwargs):
-        return self.callable_function(*args, **kwargs)
+        inputs = [inp for inp in self.inputs if isinstance(inp, DynamicMap)]
+        streams = [s for inp in inputs for s in get_nested_streams(inp)]
+        values = tuple(tuple(sorted(s.contents.items())) for s in streams)
+        key = args + tuple(sorted(kwargs.items())) + values
+
+        if key in self._memoized:
+            return self._memoized[key]
+        else:
+            ret = self.callable_function(*args, **kwargs)
+            self._memoized = {key : ret}
+            return ret
 
 
 def get_nested_streams(dmap):
@@ -500,6 +517,8 @@ class DynamicMap(HoloMap):
        """)
 
     def __init__(self, callback, initial_items=None, **params):
+        if not isinstance(callback, Callable) and not isinstance(callback, types.GeneratorType):
+            callback = Callable(callable_function=callback)
         super(DynamicMap, self).__init__(initial_items, callback=callback, **params)
 
         # Set source to self if not already specified
@@ -514,7 +533,6 @@ def __init__(self, callback, initial_items=None, **params):
 
         self.call_mode = self._validate_mode()
         self.mode = 'bounded' if self.call_mode == 'key' else 'open'
-        self._dimensionless_cache = False
 
 
     def _initial_key(self):
@@ -762,7 +780,7 @@ def __getitem__(self, key):
         try:
             dimensionless = util.dimensionless_contents(get_nested_streams(self),
                                                         self.kdims, no_duplicates=False)
-            if (dimensionless and not self._dimensionless_cache):
+            if dimensionless:
                 raise KeyError('Using dimensionless streams disables DynamicMap cache')
             cache = super(DynamicMap,self).__getitem__(key)
             # Return selected cache items in a new DynamicMap

holoviews/core/traversal.py

@@ -128,29 +128,3 @@ def hierarchical(keys):
                 store1[v2].append(v1)
         hierarchies.append(store2 if hierarchy else {})
     return hierarchies
-
-
-class dimensionless_cache(object):
-    """
-    Context manager which temporarily enables lookup of frame in the
-    cache on a DynamicMap with dimensionless streams. Allows passing
-    any Dimensioned object which might contain a DynamicMap and
-    whether to enable the cache. This allows looking up an item
-    without triggering the callback. Useful when the object is looked
-    up multiple times as part of some processing pipeline.
-    """
-
-    def __init__(self, obj, allow_cache_lookup=True):
-        self.obj = obj
-        self._allow_cache_lookup = allow_cache_lookup
-
-    def __enter__(self):
-        self.set_cache_flag(self._allow_cache_lookup)
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        self.set_cache_flag(False)
-
-    def set_cache_flag(self, value):
-        self.obj.traverse(lambda x: setattr(x, '_dimensionless_cache', value),
-                          ['DynamicMap'])
-

holoviews/plotting/plot.py

@@ -18,7 +18,6 @@
 from ..core.options import Store, Compositor, SkipRendering
 from ..core.overlay import NdOverlay
 from ..core.spaces import HoloMap, DynamicMap
-from ..core.traversal import dimensionless_cache
 from ..core.util import stream_parameters
 from ..element import Table
 from .util import (get_dynamic_mode, initialize_sampled, dim_axis_label,
@@ -625,8 +624,7 @@ def _get_frame(self, key):
             self.current_key = key
             return self.current_frame
         elif self.dynamic:
-            with dimensionless_cache(self.hmap, not self._force or not self.drawn):
-                key, frame = util.get_dynamic_item(self.hmap, self.dimensions, key)
+            key, frame = util.get_dynamic_item(self.hmap, self.dimensions, key)
             traverse_setter(self, '_force', False)
             if not isinstance(key, tuple): key = (key,)
             key_map = dict(zip([d.name for d in self.hmap.kdims], key))
@@ -977,8 +975,7 @@ def _get_frame(self, key):
                                     if d in item.dimensions('key')], key)
                 self.current_key = tuple(k[1] for k in dim_keys)
             elif item.traverse(lambda x: x, [DynamicMap]):
-                with dimensionless_cache(item, not self._force or not self.drawn):
-                    key, frame = util.get_dynamic_item(item, self.dimensions, key)
+                key, frame = util.get_dynamic_item(item, self.dimensions, key)
                 layout_frame[path] = frame
                 continue
             elif self.uniform:

tests/testdynamic.py

@@ -1,5 +1,6 @@
 import numpy as np
 from holoviews import Dimension, DynamicMap, Image, HoloMap, Scatter, Curve
+from holoviews.streams import PositionXY
 from holoviews.util import Dynamic
 from holoviews.element.comparison import ComparisonTestCase
 
@@ -202,3 +203,26 @@ def test_dynamic_holomap_overlay(self):
         dynamic_overlay = dmap * hmap
         overlaid = Image(sine_array(0,5)) * Image(sine_array(0,10))
         self.assertEqual(dynamic_overlay[5], overlaid)
+
+    def test_dynamic_overlay_memoization(self):
+        """Tests that Callable memoizes unchanged callbacks"""
+        def fn(x, y):
+            return Scatter([(x, y)])
+        dmap = DynamicMap(fn, kdims=[], streams=[PositionXY()])
+
+        counter = [0]
+        def fn2(x, y):
+            counter[0] += 1
+            return Image(np.random.rand(10, 10))
+        dmap2 = DynamicMap(fn2, kdims=[], streams=[PositionXY()])
+
+        overlaid = dmap * dmap2
+        overlay = overlaid[()]
+        self.assertEqual(overlay.Scatter.I, fn(0, 0))
+
+        dmap.event(x=1, y=2)
+        overlay = overlaid[()]
+        # Ensure dmap return value was updated
+        self.assertEqual(overlay.Scatter.I, fn(1, 2))
+        # Ensure dmap2 callback was called only once
+        self.assertEqual(counter[0], 1)