1 files changed, 249 insertions, 281 deletions
diff --git a/grc/core/Block.py b/grc/core/Block.py
index 8a683a2b6b..9fff5afcb7 100644
--- a/grc/core/Block.py
+++ b/grc/core/Block.py
@@ -17,12 +17,16 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 """
 
+from __future__ import absolute_import
+
 import collections
 import itertools
 
+from six.moves import map, range
+
 from Cheetah.Template import Template
 
-from .utils import epy_block_io, odict
+from .utils import epy_block_io
 from . Constants import (
     BLOCK_FLAG_NEED_QT_GUI, BLOCK_FLAG_NEED_WX_GUI,
     ADVANCED_PARAM_TAB, DEFAULT_PARAM_TAB,
@@ -59,184 +63,111 @@ class Block(Element):
         Returns:
             block a new block
         """
-        # Grab the data
-        self._doc = (n.find('doc') or '').strip('\n').replace('\\\n', '')
-        self._imports = map(lambda i: i.strip(), n.findall('import'))
-        self._make = n.find('make')
-        self._var_make = n.find('var_make')
-        self._checks = n.findall('check')
-        self._callbacks = n.findall('callback')
-        self._bus_structure_source = n.find('bus_structure_source') or ''
-        self._bus_structure_sink = n.find('bus_structure_sink') or ''
-        self.port_counters = [itertools.count(), itertools.count()]
+        Element.__init__(self, parent=flow_graph)
+
+        self._name = n['name']
+        self._key = n['key']
+        self.category = [cat.strip() for cat in n.get('category', '').split('/') if cat.strip()]
+        self._flags = n.get('flags', '')
+        self._doc = n.get('doc', '').strip('\n').replace('\\\n', '')
 
-        # Build the block
-        Element.__init__(self, flow_graph)
-
-        # Grab the data
-        params = n.findall('param')
-        sources = n.findall('source')
-        sinks = n.findall('sink')
-        self._name = n.find('name')
-        self._key = n.find('key')
-        category = (n.find('category') or '').split('/')
-        self.category = [cat.strip() for cat in category if cat.strip()]
-        self._flags = n.find('flags') or ''
         # Backwards compatibility
-        if n.find('throttle') and BLOCK_FLAG_THROTTLE not in self._flags:
+        if n.get('throttle') and BLOCK_FLAG_THROTTLE not in self._flags:
             self._flags += BLOCK_FLAG_THROTTLE
-        self._grc_source = n.find('grc_source') or ''
-        self._block_wrapper_path = n.find('block_wrapper_path')
-        self._bussify_sink = n.find('bus_sink')
-        self._bussify_source = n.find('bus_source')
-        self._var_value = n.find('var_value') or '$value'
+
+        self._imports = [i.strip() for i in n.get('import', [])]
+        self._make = n.get('make')
+        self._var_make = n.get('var_make')
+        self._var_value = n.get('var_value', '$value')
+        self._checks = n.get('check', [])
+        self._callbacks = n.get('callback', [])
+
+        self._grc_source = n.get('grc_source', '')
+        self._block_wrapper_path = n.get('block_wrapper_path')
+
+        params_n = n.get('param', [])
+        sources_n = n.get('source', [])
+        sinks_n = n.get('sink', [])
 
         # Get list of param tabs
-        n_tabs = n.find('param_tab_order') or None
-        self._param_tab_labels = n_tabs.findall('tab') if n_tabs is not None else [DEFAULT_PARAM_TAB]
-
-        # Create the param objects
-        self._params = list()
-
-        # Add the id param
-        self.get_params().append(self.get_parent().get_parent().Param(
-            block=self,
-            n=odict({
-                'name': 'ID',
-                'key': 'id',
-                'type': 'id',
-            })
-        ))
-        self.get_params().append(self.get_parent().get_parent().Param(
-            block=self,
-            n=odict({
-                'name': 'Enabled',
-                'key': '_enabled',
-                'type': 'raw',
-                'value': 'True',
-                'hide': 'all',
-            })
-        ))
-        for param in itertools.imap(lambda n: self.get_parent().get_parent().Param(block=self, n=n), params):
-            key = param.get_key()
-            # Test against repeated keys
-            if key in self.get_param_keys():
-                raise Exception('Key "{}" already exists in params'.format(key))
-            # Store the param
-            self.get_params().append(param)
-        # Create the source objects
-        self._sources = list()
-        for source in map(lambda n: self.get_parent().get_parent().Port(block=self, n=n, dir='source'), sources):
-            key = source.get_key()
-            # Test against repeated keys
-            if key in self.get_source_keys():
-                raise Exception('Key "{}" already exists in sources'.format(key))
-            # Store the port
-            self.get_sources().append(source)
-        self.back_ofthe_bus(self.get_sources())
-        # Create the sink objects
-        self._sinks = list()
-        for sink in map(lambda n: self.get_parent().get_parent().Port(block=self, n=n, dir='sink'), sinks):
-            key = sink.get_key()
-            # Test against repeated keys
-            if key in self.get_sink_keys():
-                raise Exception('Key "{}" already exists in sinks'.format(key))
-            # Store the port
-            self.get_sinks().append(sink)
-        self.back_ofthe_bus(self.get_sinks())
-        self.current_bus_structure = {'source': '', 'sink': ''}
+        self._param_tab_labels = n.get('param_tab_order', {}).get('tab') or [DEFAULT_PARAM_TAB]
+        self._params = []
+        self._init_params(
+            params_n=params_n,
+            has_sinks=len(sinks_n),
+            has_sources=len(sources_n)
+        )
+
+        self.port_counters = [itertools.count(), itertools.count()]
+        self._sources = self._init_ports(sources_n, direction='source')
+        self._sinks = self._init_ports(sinks_n, direction='sink')
+
+        self._epy_source_hash = -1  # for epy blocks
+        self._epy_reload_error = None
+
+        self._init_bus_ports(n)
+
+    def _add_param(self, key, name, value='', type='raw', **kwargs):
+        n = {'key': key, 'name': name, 'value': value, 'type': type}
+        n.update(kwargs)
+        param = self.parent_platform.Param(block=self, n=n)
+        self._params.append(param)
+
+    def _init_params(self, params_n, has_sources, has_sinks):
+        self._add_param(key='id', name='ID', type='id')
+        self._add_param(key='_enabled', name='Enabled', value='True', type='raw', hide='all')
 
         # Virtual source/sink and pad source/sink blocks are
         # indistinguishable from normal GR blocks. Make explicit
         # checks for them here since they have no work function or
         # buffers to manage.
-        self.is_virtual_or_pad = self._key in (
+        self.is_virtual_or_pad = is_virtual_or_pad = self._key in (
             "virtual_source", "virtual_sink", "pad_source", "pad_sink")
-        self.is_variable = self._key.startswith('variable')
+        self.is_variable = is_variable = self._key.startswith('variable')
         self.is_import = (self._key == 'import')
 
         # Disable blocks that are virtual/pads or variables
         if self.is_virtual_or_pad or self.is_variable:
             self._flags += BLOCK_FLAG_DISABLE_BYPASS
 
-        if not (self.is_virtual_or_pad or self.is_variable or self._key == 'options'):
-            self.get_params().append(self.get_parent().get_parent().Param(
-                block=self,
-                n=odict({'name': 'Block Alias',
-                         'key': 'alias',
-                         'type': 'string',
-                         'hide': 'part',
-                         'tab': ADVANCED_PARAM_TAB
-                         })
-            ))
-
-        if (len(sources) or len(sinks)) and not self.is_virtual_or_pad:
-            self.get_params().append(self.get_parent().get_parent().Param(
-                    block=self,
-                    n=odict({'name': 'Core Affinity',
-                             'key': 'affinity',
-                             'type': 'int_vector',
-                             'hide': 'part',
-                             'tab': ADVANCED_PARAM_TAB
-                             })
-                    ))
-        if len(sources) and not self.is_virtual_or_pad:
-            self.get_params().append(self.get_parent().get_parent().Param(
-                    block=self,
-                    n=odict({'name': 'Min Output Buffer',
-                             'key': 'minoutbuf',
-                             'type': 'int',
-                             'hide': 'part',
-                             'value': '0',
-                             'tab': ADVANCED_PARAM_TAB
-                             })
-                    ))
-            self.get_params().append(self.get_parent().get_parent().Param(
-                    block=self,
-                    n=odict({'name': 'Max Output Buffer',
-                             'key': 'maxoutbuf',
-                             'type': 'int',
-                             'hide': 'part',
-                             'value': '0',
-                             'tab': ADVANCED_PARAM_TAB
-                             })
-                    ))
-
-        self.get_params().append(self.get_parent().get_parent().Param(
-                block=self,
-                n=odict({'name': 'Comment',
-                         'key': 'comment',
-                         'type': '_multiline',
-                         'hide': 'part',
-                         'value': '',
-                         'tab': ADVANCED_PARAM_TAB
-                         })
-                ))
+        if not (is_virtual_or_pad or is_variable or self._key == 'options'):
+            self._add_param(key='alias', name='Block Alias', type='string',
+                            hide='part', tab=ADVANCED_PARAM_TAB)
 
-        self._epy_source_hash = -1  # for epy blocks
-        self._epy_reload_error = None
+        if not is_virtual_or_pad and (has_sources or has_sinks):
+            self._add_param(key='affinity', name='Core Affinity', type='int_vector',
+                            hide='part', tab=ADVANCED_PARAM_TAB)
 
-        if self._bussify_sink:
-            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
-        if self._bussify_source:
-            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
+        if not is_virtual_or_pad and has_sources:
+            self._add_param(key='minoutbuf', name='Min Output Buffer', type='int',
+                            hide='part', value='0', tab=ADVANCED_PARAM_TAB)
+            self._add_param(key='maxoutbuf', name='Max Output Buffer', type='int',
+                            hide='part', value='0', tab=ADVANCED_PARAM_TAB)
 
-    def get_bus_structure(self, direction):
-        if direction == 'source':
-            bus_structure = self._bus_structure_source
-        else:
-            bus_structure = self._bus_structure_sink
-
-        bus_structure = self.resolve_dependencies(bus_structure)
-
-        if not bus_structure:
-            return ''  # TODO: Don't like empty strings. should change this to None eventually
+        param_keys = set(param.get_key() for param in self._params)
+        for param_n in params_n:
+            param = self.parent_platform.Param(block=self, n=param_n)
+            key = param.get_key()
+            if key in param_keys:
+                raise Exception('Key "{}" already exists in params'.format(key))
+            param_keys.add(key)
+            self.get_params().append(param)
 
-        try:
-            clean_bus_structure = self.get_parent().evaluate(bus_structure)
-            return clean_bus_structure
-        except:
-            return ''
+        self._add_param(key='comment', name='Comment', type='_multiline', hide='part',
+                        value='', tab=ADVANCED_PARAM_TAB)
+
+    def _init_ports(self, ports_n, direction):
+        port_cls = self.parent_platform.Port
+        ports = []
+        port_keys = set()
+        for port_n in ports_n:
+            port = port_cls(block=self, n=port_n, dir=direction)
+            key = port.get_key()
+            if key in port_keys:
+                raise Exception('Key "{}" already exists in {}'.format(key, direction))
+            port_keys.add(key)
+            ports.append(port)
+        return ports
 
     def validate(self):
         """
@@ -249,7 +180,7 @@ class Block(Element):
         for check in self._checks:
             check_res = self.resolve_dependencies(check)
             try:
-                if not self.get_parent().evaluate(check_res):
+                if not self.parent.evaluate(check_res):
                     self.add_error_message('Check "{}" failed.'.format(check))
             except:
                 self.add_error_message('Check "{}" did not evaluate.'.format(check))
@@ -259,12 +190,12 @@ class Block(Element):
             value = self._var_value
             try:
                 value = self.get_var_value()
-                self.get_parent().evaluate(value)
+                self.parent.evaluate(value)
             except Exception as err:
                 self.add_error_message('Value "{}" cannot be evaluated:\n{}'.format(value, err))
 
         # check if this is a GUI block and matches the selected generate option
-        current_generate_option = self.get_parent().get_option('generate_options')
+        current_generate_option = self.parent.get_option('generate_options')
 
         def check_generate_mode(label, flag, valid_options):
             block_requires_mode = (
@@ -295,14 +226,14 @@ class Block(Element):
                 num_ports = 1 + len(master_port.get_clones())
                 if master_port.get_hide():
                     for connection in master_port.get_connections():
-                        self.get_parent().remove_element(connection)
+                        self.parent.remove_element(connection)
                 if not nports and num_ports == 1:  # Not a master port and no left-over clones
                     continue
                 # Remove excess cloned ports
                 for port in master_port.get_clones()[nports-1:]:
                     # Remove excess connections
                     for connection in port.get_connections():
-                        self.get_parent().remove_element(connection)
+                        self.parent.remove_element(connection)
                     master_port.remove_clone(port)
                     ports.remove(port)
                 # Add more cloned ports
@@ -313,42 +244,13 @@ class Block(Element):
             self.back_ofthe_bus(ports)
             # Renumber non-message/message ports
             domain_specific_port_index = collections.defaultdict(int)
-            for port in filter(lambda p: p.get_key().isdigit(), ports):
+            for port in [p for p in ports if p.get_key().isdigit()]:
                 domain = port.get_domain()
                 port._key = str(domain_specific_port_index[domain])
                 domain_specific_port_index[domain] += 1
 
-    def port_controller_modify(self, direction):
-        """
-        Change the port controller.
-
-        Args:
-            direction: +1 or -1
-
-        Returns:
-            true for change
-        """
-        changed = False
-        # Concat the nports string from the private nports settings of all ports
-        nports_str = ' '.join([port._nports for port in self.get_ports()])
-        # Modify all params whose keys appear in the nports string
-        for param in self.get_params():
-            if param.is_enum() or param.get_key() not in nports_str:
-                continue
-            # Try to increment the port controller by direction
-            try:
-                value = param.get_evaluated()
-                value = value + direction
-                if 0 < value:
-                    param.set_value(value)
-                    changed = True
-            except:
-                pass
-        return changed
-
     def get_doc(self):
-        platform = self.get_parent().get_parent()
-        documentation = platform.block_docstrings.get(self._key, {})
+        documentation = self.parent_platform.block_docstrings.get(self._key, {})
         from_xml = self._doc.strip()
         if from_xml:
             documentation[''] = from_xml
@@ -366,7 +268,8 @@ class Block(Element):
         """
         if raw:
             return self._imports
-        return filter(lambda i: i, sum(map(lambda i: self.resolve_dependencies(i).split('\n'), self._imports), []))
+        return [i for i in sum((self.resolve_dependencies(i).split('\n')
+                                for i in self._imports), []) if i]
 
     def get_make(self, raw=False):
         if raw:
@@ -391,7 +294,7 @@ class Block(Element):
             if 'self.' in callback:
                 return callback
             return 'self.{}.{}'.format(self.get_id(), callback)
-        return map(make_callback, self._callbacks)
+        return [make_callback(c) for c in self._callbacks]
 
     def is_virtual_sink(self):
         return self.get_key() == 'virtual_sink'
@@ -404,8 +307,8 @@ class Block(Element):
     ###########################################################################
 
     def rewrite_epy_block(self):
-        flowgraph = self.get_parent()
-        platform = flowgraph.get_parent()
+        flowgraph = self.parent_flowgraph
+        platform = self.parent_block
         param_blk = self.get_param('_io_cache')
         param_src = self.get_param('_source_code')
 
@@ -452,7 +355,7 @@ class Block(Element):
                 param.set_default(value)
             except KeyError:  # need to make a new param
                 name = key.replace('_', ' ').title()
-                n = odict(dict(name=name, key=key, type='raw', value=value))
+                n = dict(name=name, key=key, type='raw', value=value)
                 param = platform.Param(block=self, n=n)
                 setattr(param, '__epy_param__', True)
             self._params.append(param)
@@ -472,7 +375,7 @@ class Block(Element):
                     ports_to_remove.remove(port_current)
                     port, port_current = port_current, next(iter_ports, None)
                 else:
-                    n = odict(dict(name=label + str(key), type=port_type, key=key))
+                    n = dict(name=label + str(key), type=port_type, key=key)
                     if port_type == 'message':
                         n['name'] = key
                         n['optional'] = '1'
@@ -490,13 +393,6 @@ class Block(Element):
         update_ports('out', self.get_sources(), blk_io.sources, 'source')
         self.rewrite()
 
-    def back_ofthe_bus(self, portlist):
-        portlist.sort(key=lambda p: p._type == 'bus')
-
-    def filter_bus_port(self, ports):
-        buslist = [p for p in ports if p._type == 'bus']
-        return buslist or ports
-
     # Main functions to get and set the block state
     # Also kept get_enabled and set_enabled to keep compatibility
     def get_state(self):
@@ -651,9 +547,6 @@ class Block(Element):
     ##############################################
     # Access Sinks
     ##############################################
-    def get_sink_keys(self):
-        return _get_keys(self._sinks)
-
     def get_sink(self, key):
         return _get_elem(self._sinks, key)
 
@@ -666,9 +559,6 @@ class Block(Element):
     ##############################################
     # Access Sources
     ##############################################
-    def get_source_keys(self):
-        return _get_keys(self._sources)
-
     def get_source(self, key):
         return _get_elem(self._sources, key)
 
@@ -681,6 +571,10 @@ class Block(Element):
     def get_connections(self):
         return sum([port.get_connections() for port in self.get_ports()], [])
 
+    ##############################################
+    # Resolve
+    ##############################################
+
     def resolve_dependencies(self, tmpl):
         """
         Resolve a paramater dependency with cheetah templates.
@@ -716,10 +610,10 @@ class Block(Element):
         """
         changed = False
         type_param = None
-        for param in filter(lambda p: p.is_enum(), self.get_params()):
+        for param in [p for p in self.get_params() if p.is_enum()]:
             children = self.get_ports() + self.get_params()
             # Priority to the type controller
-            if param.get_key() in ' '.join(map(lambda p: p._type, children)): type_param = param
+            if param.get_key() in ' '.join([p._type for p in children]): type_param = param
             # Use param if type param is unset
             if not type_param:
                 type_param = param
@@ -735,6 +629,128 @@ class Block(Element):
                 pass
         return changed
 
+    def port_controller_modify(self, direction):
+        """
+        Change the port controller.
+
+        Args:
+            direction: +1 or -1
+
+        Returns:
+            true for change
+        """
+        changed = False
+        # Concat the nports string from the private nports settings of all ports
+        nports_str = ' '.join([port._nports for port in self.get_ports()])
+        # Modify all params whose keys appear in the nports string
+        for param in self.get_params():
+            if param.is_enum() or param.get_key() not in nports_str:
+                continue
+            # Try to increment the port controller by direction
+            try:
+                value = param.get_evaluated()
+                value = value + direction
+                if 0 < value:
+                    param.set_value(value)
+                    changed = True
+            except:
+                pass
+        return changed
+
+    ##############################################
+    # Import/Export Methods
+    ##############################################
+    def export_data(self):
+        """
+        Export this block's params to nested data.
+
+        Returns:
+            a nested data odict
+        """
+        n = collections.OrderedDict()
+        n['key'] = self.get_key()
+        n['param'] = [p.export_data() for p in sorted(self.get_params(), key=str)]
+        if 'bus' in [a.get_type() for a in self.get_sinks()]:
+            n['bus_sink'] = str(1)
+        if 'bus' in [a.get_type() for a in self.get_sources()]:
+            n['bus_source'] = str(1)
+        return n
+
+    def import_data(self, n):
+        """
+        Import this block's params from nested data.
+        Any param keys that do not exist will be ignored.
+        Since params can be dynamically created based another param,
+        call rewrite, and repeat the load until the params stick.
+        This call to rewrite will also create any dynamic ports
+        that are needed for the connections creation phase.
+
+        Args:
+            n: the nested data odict
+        """
+        params_n = n.get('param', [])
+        params = dict((param.get_key(), param) for param in self._params)
+
+        def get_hash():
+            return hash(tuple(map(hash, self._params)))
+
+        my_hash = 0
+        while get_hash() != my_hash:
+            for param_n in params_n:
+                key = param_n['key']
+                value = param_n['value']
+                try:
+                    params[key].set_value(value)
+                except KeyError:
+                    continue
+            # Store hash and call rewrite
+            my_hash = get_hash()
+            self.rewrite()
+
+        self._import_bus_stuff(n)
+
+    ##############################################
+    # Bus ports stuff
+    ##############################################
+
+    def get_bus_structure(self, direction):
+        if direction == 'source':
+            bus_structure = self._bus_structure_source
+        else:
+            bus_structure = self._bus_structure_sink
+
+        bus_structure = self.resolve_dependencies(bus_structure)
+
+        if not bus_structure:
+            return ''  # TODO: Don't like empty strings. should change this to None eventually
+
+        try:
+            clean_bus_structure = self.parent.evaluate(bus_structure)
+            return clean_bus_structure
+        except:
+            return ''
+
+    def back_ofthe_bus(self, portlist):
+        portlist.sort(key=lambda p: p._type == 'bus')
+
+    def filter_bus_port(self, ports):
+        buslist = [p for p in ports if p._type == 'bus']
+        return buslist or ports
+
+    def _import_bus_stuff(self, n):
+        bussinks = n.get('bus_sink', [])
+        if len(bussinks) > 0 and not self._bussify_sink:
+            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
+        elif len(bussinks) > 0:
+            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
+            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
+        bussrcs = n.get('bus_source', [])
+        if len(bussrcs) > 0 and not self._bussify_source:
+            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
+        elif len(bussrcs) > 0:
+            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
+            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
+
     def form_bus_structure(self, direc):
         if direc == 'source':
             get_p = self.get_sources
@@ -745,12 +761,12 @@ class Block(Element):
             get_p_gui = self.get_sinks_gui
             bus_structure = self.get_bus_structure('sink')
 
-        struct = [range(len(get_p()))]
-        if True in map(lambda a: isinstance(a.get_nports(), int), get_p()):
+        struct = [list(range(len(get_p())))]
+        if True in [isinstance(a.get_nports(), int) for a in get_p()]:
             structlet = []
             last = 0
             for j in [i.get_nports() for i in get_p() if isinstance(i.get_nports(), int)]:
-                structlet.extend(map(lambda a: a+last, range(j)))
+                structlet.extend([a+last for a in range(j)])
                 last = structlet[-1] + 1
                 struct = [structlet]
         if bus_structure:
@@ -764,17 +780,15 @@ class Block(Element):
         if direc == 'source':
             get_p = self.get_sources
             get_p_gui = self.get_sources_gui
-            bus_structure = self.get_bus_structure('source')
         else:
             get_p = self.get_sinks
             get_p_gui = self.get_sinks_gui
-            bus_structure = self.get_bus_structure('sink')
 
         for elt in get_p():
             for connect in elt.get_connections():
-                self.get_parent().remove_element(connect)
+                self.parent.remove_element(connect)
 
-        if ('bus' not in map(lambda a: a.get_type(), get_p())) and len(get_p()) > 0:
+        if ('bus' not in [a.get_type() for a in get_p()]) and len(get_p()) > 0:
             struct = self.form_bus_structure(direc)
             self.current_bus_structure[direc] = struct
             if get_p()[0].get_nports():
@@ -782,69 +796,23 @@ class Block(Element):
 
             for i in range(len(struct)):
                 n['key'] = str(len(get_p()))
-                n = odict(n)
-                port = self.get_parent().get_parent().Port(block=self, n=n, dir=direc)
+                n = dict(n)
+                port = self.parent.parent.Port(block=self, n=n, dir=direc)
                 get_p().append(port)
-        elif 'bus' in map(lambda a: a.get_type(), get_p()):
+        elif 'bus' in [a.get_type() for a in get_p()]:
             for elt in get_p_gui():
                 get_p().remove(elt)
             self.current_bus_structure[direc] = ''
 
-    ##############################################
-    # Import/Export Methods
-    ##############################################
-    def export_data(self):
-        """
-        Export this block's params to nested data.
-
-        Returns:
-            a nested data odict
-        """
-        n = odict()
-        n['key'] = self.get_key()
-        n['param'] = map(lambda p: p.export_data(), sorted(self.get_params(), key=str))
-        if 'bus' in map(lambda a: a.get_type(), self.get_sinks()):
-            n['bus_sink'] = str(1)
-        if 'bus' in map(lambda a: a.get_type(), self.get_sources()):
-            n['bus_source'] = str(1)
-        return n
-
-    def get_hash(self):
-        return hash(tuple(map(hash, self.get_params())))
-
-    def import_data(self, n):
-        """
-        Import this block's params from nested data.
-        Any param keys that do not exist will be ignored.
-        Since params can be dynamically created based another param,
-        call rewrite, and repeat the load until the params stick.
-        This call to rewrite will also create any dynamic ports
-        that are needed for the connections creation phase.
-
-        Args:
-            n: the nested data odict
-        """
-        my_hash = 0
-        while self.get_hash() != my_hash:
-            params_n = n.findall('param')
-            for param_n in params_n:
-                key = param_n.find('key')
-                value = param_n.find('value')
-                # The key must exist in this block's params
-                if key in self.get_param_keys():
-                    self.get_param(key).set_value(value)
-            # Store hash and call rewrite
-            my_hash = self.get_hash()
-            self.rewrite()
-        bussinks = n.findall('bus_sink')
-        if len(bussinks) > 0 and not self._bussify_sink:
-            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
-        elif len(bussinks) > 0:
-            self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
+    def _init_bus_ports(self, n):
+        self.back_ofthe_bus(self._sources)
+        self.back_ofthe_bus(self._sinks)
+        self.current_bus_structure = {'source': '', 'sink': ''}
+        self._bus_structure_source = n.get('bus_structure_source', '')
+        self._bus_structure_sink = n.get('bus_structure_sink', '')
+        self._bussify_sink = n.get('bus_sink')
+        self._bussify_source = n.get('bus_source')
+        if self._bussify_sink:
             self.bussify({'name': 'bus', 'type': 'bus'}, 'sink')
-        bussrcs = n.findall('bus_source')
-        if len(bussrcs) > 0 and not self._bussify_source:
-            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
-        elif len(bussrcs) > 0:
-            self.bussify({'name': 'bus', 'type': 'bus'}, 'source')
+        if self._bussify_source:
             self.bussify({'name': 'bus', 'type': 'bus'}, 'source')