Eliminate circular references (#4368)

holoviews/core/data/__init__.py

@@ -7,8 +7,10 @@
 
 import types
 import copy
+
 import numpy as np
 import param
+
 from param.parameterized import add_metaclass, ParameterizedMetaclass
 
 from .. import util
@@ -320,6 +322,16 @@ def __init__(self, data, kdims=None, vdims=None, **kwargs):
         input_transforms = kwargs.pop('transforms', None)
 
         if isinstance(data, Element):
+            if 'kdims' in kwargs:
+                kwargs['kdims'] = [
+                    data.get_dimension(kd) if isinstance(kd, util.basestring) else kd
+                    for kd in kwargs['kdims']
+                ]
+            if 'kdims' in kwargs:
+                kwargs['vdims'] = [
+                    data.get_dimension(vd) if isinstance(vd, util.basestring) else vd
+                    for vd in kwargs['vdims']
+                ]
             pvals = util.get_param_values(data)
             kwargs.update([(l, pvals[l]) for l in ['group', 'label']
                            if l in pvals and l not in kwargs])
@@ -341,16 +353,14 @@ def __init__(self, data, kdims=None, vdims=None, **kwargs):
         super(Dataset, self).__init__(data, **dict(kwargs, **dict(dims, **extra_kws)))
         self.interface.validate(self, validate_vdims)
 
-        self.redim = Redim(self, mode='dataset')
-
         # Handle _pipeline property
         if input_pipeline is None:
             input_pipeline = chain_op.instance()
 
         init_op = factory.instance(
             output_type=type(self),
             args=[],
-            kwargs=kwargs,
+            kwargs=dict(kwargs, kdims=self.kdims, vdims=self.vdims),
         )
         self._pipeline = input_pipeline.instance(
             operations=input_pipeline.operations + [init_op],
@@ -359,27 +369,35 @@ def __init__(self, data, kdims=None, vdims=None, **kwargs):
         self._transforms = input_transforms or []
 
         # Handle initializing the dataset property.
-        self._dataset = None
-        if input_dataset is not None:
-            self._dataset = input_dataset.clone(dataset=None, pipeline=None)
-        elif isinstance(input_data, Dataset) and not dataset_provided:
-            self._dataset = input_data._dataset
-        elif type(self) is Dataset:
-            self._dataset = self
+        self._dataset = input_dataset
+        if self._dataset is None and isinstance(input_data, Dataset) and not dataset_provided:
+            if input_data.data is self.data:
+                self._dataset = {'kdims': input_data.kdims, 'vdims': input_data.vdims}
+            else:
+                self._dataset = Dataset(input_data, dataset=None, pipeline=None,
+                                        transforms=None, _validate_vdims=False)
+
+    @property
+    def redim(self):
+        return Redim(self, mode='dataset')
 
     @property
     def dataset(self):
         """
         The Dataset that this object was created from
         """
         if self._dataset is None:
+            if type(self) is Dataset:
+                return self
             datatype = list(util.unique_iterator(self.datatype+Dataset.datatype))
             dataset = Dataset(self, _validate_vdims=False, datatype=datatype)
             if hasattr(self, '_binned'):
                 dataset._binned = self._binned
             return dataset
-        else:
-            return self._dataset
+        elif not isinstance(self._dataset, Dataset):
+            return Dataset(self, _validate_vdims=False, **self._dataset)
+        return self._dataset
+
 
     @property
     def pipeline(self):

holoviews/core/dimension.py

@@ -853,10 +853,18 @@ def __init__(self, data, kdims=None, vdims=None, **params):
         self._settings = None
 
         # Instantiate accessors
-        self.apply = Apply(self)
-        self.opts = Opts(self)
-        self.redim = Redim(self)
 
+    @property
+    def apply(self):
+        return Apply(self)
+
+    @property
+    def opts(self):
+        return Opts(self)
+
+    @property
+    def redim(self):
+        return Redim(self)
 
     def _valid_dimensions(self, dimensions):
         """Validates key dimension input

holoviews/core/operation.py

@@ -134,13 +134,14 @@ def _apply(self, element, key=None):
             ret = hook(self, ret, **kwargs)
 
         if (self._propagate_dataset and isinstance(ret, Dataset)
-                and isinstance(element, Dataset)):
-            ret._dataset = element.dataset.clone()
+            and isinstance(element, Dataset)):
+            ret._dataset = element.dataset
             ret._pipeline = element_pipeline.instance(
                 operations=element_pipeline.operations + [
                     self.instance(**self.p)
                 ],
             )
+            ret._transforms = element._transforms
         return ret
 
 

holoviews/core/spaces.py

@@ -39,8 +39,10 @@ class HoloMap(UniformNdMapping, Overlayable):
 
     def __init__(self, initial_items=None, kdims=None, group=None, label=None, **params):
         super(HoloMap, self).__init__(initial_items, kdims, group, label, **params)
-        self.opts = Opts(self, mode='holomap')
 
+    @property
+    def opts(self):
+        return Opts(self, mode='holomap')
 
     def overlay(self, dimensions=None, **kwargs):
         """Group by supplied dimension(s) and overlay each group
@@ -892,8 +894,6 @@ def __init__(self, callback, initial_items=None, streams=None, **params):
 
         super(DynamicMap, self).__init__(initial_items, callback=callback, streams=valid, **params)
 
-        self.opts = Opts(self, mode='dynamicmap')
-
         if self.callback.noargs:
             prefix = 'DynamicMaps using generators (or callables without arguments)'
             if self.kdims:
@@ -911,9 +911,16 @@ def __init__(self, callback, initial_items=None, streams=None, **params):
         for stream in self.streams:
             if stream.source is None:
                 stream.source = self
-        self.redim = Redim(self, mode='dynamic')
         self.periodic = periodic(self)
 
+    @property
+    def opts(self):
+        return Opts(self, mode='dynamicmap')
+
+    @property
+    def redim(self):
+        return Redim(self, mode='dynamic')
+
     @property
     def unbounded(self):
         """

holoviews/element/graphs.py

@@ -156,7 +156,11 @@ def __init__(self, data, kdims=None, vdims=None, **params):
         if node_info is not None:
             self._add_node_info(node_info)
         self._validate()
-        self.redim = RedimGraph(self, mode='dataset')
+
+
+    @property
+    def redim(self):
+        return RedimGraph(self, mode='dataset')
 
 
     def _add_node_info(self, node_info):
@@ -797,7 +801,6 @@ def __init__(self, data, kdims=None, vdims=None, compute=True, **params):
                                 % type(edgepaths))
             self._edgepaths = edgepaths
         self._validate()
-        self.redim = RedimGraph(self, mode='dataset')
 
 
     @property

holoviews/element/sankey.py

@@ -11,7 +11,7 @@
 from ..core.data import Dataset
 from ..core.operation import Operation
 from ..core.util import OrderedDict, unique_array, RecursionError, get_param_values
-from .graphs import Graph, Nodes, EdgePaths, redim_graph
+from .graphs import Graph, Nodes, EdgePaths
 from .util import quadratic_bezier
 
 
@@ -361,7 +361,6 @@ def __init__(self, data, kdims=None, vdims=None, **params):
             self._edgepaths = edgepaths
             self._sankey = sankey_graph
         self._validate()
-        self.redim = redim_graph(self, mode='dataset')
 
     def clone(self, data=None, shared_data=True, new_type=None, link=True,
               *args, **overrides):

holoviews/operation/element.py

@@ -210,13 +210,14 @@ class chain(Operation):
 
     operations = param.List(default=[], class_=Operation, doc="""
        A list of Operations (or Operation instances)
-       that are applied on the input from left to right..""")
+       that are applied on the input from left to right.""")
 
     def _process(self, view, key=None):
         processed = view
-        for operation in self.p.operations:
-            processed = operation.process_element(processed, key,
-                                                  input_ranges=self.p.input_ranges)
+        for i, operation in enumerate(self.p.operations):
+            processed = operation.process_element(
+                processed, key, input_ranges=self.p.input_ranges
+            )
 
         if not self.p.group:
             return processed