1 files changed, 106 insertions, 319 deletions
diff --git a/grc/core/Param.py b/grc/core/Param.py
index d0af9792b8..31393b1d79 100644
--- a/grc/core/Param.py
+++ b/grc/core/Param.py
@@ -17,20 +17,19 @@ 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 ast
-import weakref
 import re
+import collections
+
+from six.moves import builtins, filter, map, range, zip
 
 from . import Constants
-from .Constants import VECTOR_TYPES, COMPLEX_TYPES, REAL_TYPES, INT_TYPES
-from .Element import Element
-from .utils import odict
+from .Element import Element, nop_write
 
 # Blacklist certain ids, its not complete, but should help
-import __builtin__
-
-
-ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'math', 'firdes'] + dir(__builtin__)
+ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'math', 'firdes'] + dir(builtins)
 try:
     from gnuradio import gr
     ID_BLACKLIST.extend(attr for attr in dir(gr.top_block()) if not attr.startswith('_'))
@@ -41,86 +40,6 @@ _check_id_matcher = re.compile('^[a-z|A-Z]\w*$')
 _show_id_matcher = re.compile('^(variable\w*|parameter|options|notebook)$')
 
 
-def _get_keys(lst):
-    return [elem.get_key() for elem in lst]
-
-
-def _get_elem(lst, key):
-    try:
-        return lst[_get_keys(lst).index(key)]
-    except ValueError:
-        raise ValueError('Key "{}" not found in {}.'.format(key, _get_keys(lst)))
-
-
-def num_to_str(num):
-    """ Display logic for numbers """
-    def eng_notation(value, fmt='g'):
-        """Convert a number to a string in engineering notation.  E.g., 5e-9 -> 5n"""
-        template = '{:' + fmt + '}{}'
-        magnitude = abs(value)
-        for exp, symbol in zip(range(9, -15-1, -3), 'GMk munpf'):
-            factor = 10 ** exp
-            if magnitude >= factor:
-                return template.format(value / factor, symbol.strip())
-        return template.format(value, '')
-
-    if isinstance(num, COMPLEX_TYPES):
-        num = complex(num)  # Cast to python complex
-        if num == 0:
-            return '0'
-        output = eng_notation(num.real) if num.real else ''
-        output += eng_notation(num.imag, '+g' if output else 'g') + 'j' if num.imag else ''
-        return output
-    else:
-        return str(num)
-
-
-class Option(Element):
-
-    def __init__(self, param, n):
-        Element.__init__(self, param)
-        self._name = n.find('name')
-        self._key = n.find('key')
-        self._opts = dict()
-        opts = n.findall('opt')
-        # Test against opts when non enum
-        if not self.get_parent().is_enum() and opts:
-            raise Exception('Options for non-enum types cannot have sub-options')
-        # Extract opts
-        for opt in opts:
-            # Separate the key:value
-            try:
-                key, value = opt.split(':')
-            except:
-                raise Exception('Error separating "{}" into key:value'.format(opt))
-            # Test against repeated keys
-            if key in self._opts:
-                raise Exception('Key "{}" already exists in option'.format(key))
-            # Store the option
-            self._opts[key] = value
-
-    def __str__(self):
-        return 'Option {}({})'.format(self.get_name(), self.get_key())
-
-    def get_name(self):
-        return self._name
-
-    def get_key(self):
-        return self._key
-
-    ##############################################
-    # Access Opts
-    ##############################################
-    def get_opt_keys(self):
-        return self._opts.keys()
-
-    def get_opt(self, key):
-        return self._opts[key]
-
-    def get_opts(self):
-        return self._opts.values()
-
-
 class TemplateArg(object):
     """
     A cheetah template argument created from a param.
@@ -130,10 +49,12 @@ class TemplateArg(object):
     """
 
     def __init__(self, param):
-        self._param = weakref.proxy(param)
+        self._param = param
 
     def __getitem__(self, item):
-        return str(self._param.get_opt(item)) if self._param.is_enum() else NotImplemented
+        param = self._param
+        opts = param.options_opts[param.get_value()]
+        return str(opts[item]) if param.is_enum() else NotImplemented
 
     def __str__(self):
         return str(self._param.to_code())
@@ -146,181 +67,66 @@ class Param(Element):
 
     is_param = True
 
-    def __init__(self, block, n):
-        """
-        Make a new param from nested data.
+    def __init__(self, parent, key, name, type='raw', value='', **n):
+        """Make a new param from nested data"""
+        super(Param, self).__init__(parent)
+        self.key = key
+        self._name = name
+        self.value = self.default = value
+        self._type = type
 
-        Args:
-            block: the parent element
-            n: the nested odict
-        """
-        # If the base key is a valid param key, copy its data and overlay this params data
-        base_key = n.find('base_key')
-        if base_key and base_key in block.get_param_keys():
-            n_expanded = block.get_param(base_key)._n.copy()
-            n_expanded.update(n)
-            n = n_expanded
-        # Save odict in case this param will be base for another
-        self._n = n
-        # Parse the data
-        self._name = n.find('name')
-        self._key = n.find('key')
-        value = n.find('value') or ''
-        self._type = n.find('type') or 'raw'
-        self._hide = n.find('hide') or ''
-        self._tab_label = n.find('tab') or block.get_param_tab_labels()[0]
-        if self._tab_label not in block.get_param_tab_labels():
-            block.get_param_tab_labels().append(self._tab_label)
-        # Build the param
-        Element.__init__(self, block)
-        # Create the Option objects from the n data
-        self._options = list()
+        self._hide = n.get('hide', '')
+        self.tab_label = n.get('tab', Constants.DEFAULT_PARAM_TAB)
         self._evaluated = None
-        for option in map(lambda o: Option(param=self, n=o), n.findall('option')):
-            key = option.get_key()
-            # Test against repeated keys
-            if key in self.get_option_keys():
-                raise Exception('Key "{}" already exists in options'.format(key))
-            # Store the option
-            self.get_options().append(option)
-        # Test the enum options
-        if self.is_enum():
-            # Test against options with identical keys
-            if len(set(self.get_option_keys())) != len(self.get_options()):
-                raise Exception('Options keys "{}" are not unique.'.format(self.get_option_keys()))
-            # Test against inconsistent keys in options
-            opt_keys = self.get_options()[0].get_opt_keys()
-            for option in self.get_options():
-                if set(opt_keys) != set(option.get_opt_keys()):
-                    raise Exception('Opt keys "{}" are not identical across all options.'.format(opt_keys))
-            # If a value is specified, it must be in the options keys
-            if value or value in self.get_option_keys():
-                self._value = value
-            else:
-                self._value = self.get_option_keys()[0]
-            if self.get_value() not in self.get_option_keys():
-                raise Exception('The value "{}" is not in the possible values of "{}".'.format(self.get_value(), self.get_option_keys()))
-        else:
-            self._value = value or ''
-        self._default = value
+
+        self.options = []
+        self.options_names = []
+        self.options_opts = {}
+        self._init_options(options_n=n.get('option', []))
+
         self._init = False
         self._hostage_cells = list()
         self.template_arg = TemplateArg(self)
 
-    def get_types(self):
-        return (
-            'raw', 'enum',
-            'complex', 'real', 'float', 'int',
-            'complex_vector', 'real_vector', 'float_vector', 'int_vector',
-            'hex', 'string', 'bool',
-            'file_open', 'file_save', '_multiline', '_multiline_python_external',
-            'id', 'stream_id',
-            'gui_hint',
-            'import',
-        )
-
-    def __repr__(self):
-        """
-        Get the repr (nice string format) for this param.
-
-        Returns:
-            the string representation
-        """
-        ##################################################
-        # Truncate helper method
-        ##################################################
-        def _truncate(string, style=0):
-            max_len = max(27 - len(self.get_name()), 3)
-            if len(string) > max_len:
-                if style < 0:  # Front truncate
-                    string = '...' + string[3-max_len:]
-                elif style == 0:  # Center truncate
-                    string = string[:max_len/2 - 3] + '...' + string[-max_len/2:]
-                elif style > 0:  # Rear truncate
-                    string = string[:max_len-3] + '...'
-            return string
-
-        ##################################################
-        # Simple conditions
-        ##################################################
-        if not self.is_valid():
-            return _truncate(self.get_value())
-        if self.get_value() in self.get_option_keys():
-            return self.get_option(self.get_value()).get_name()
-
-        ##################################################
-        # Split up formatting by type
-        ##################################################
-        # Default center truncate
-        truncate = 0
-        e = self.get_evaluated()
-        t = self.get_type()
-        if isinstance(e, bool):
-            return str(e)
-        elif isinstance(e, COMPLEX_TYPES):
-            dt_str = num_to_str(e)
-        elif isinstance(e, VECTOR_TYPES):
-            # Vector types
-            if len(e) > 8:
-                # Large vectors use code
-                dt_str = self.get_value()
-                truncate = 1
-            else:
-                # Small vectors use eval
-                dt_str = ', '.join(map(num_to_str, e))
-        elif t in ('file_open', 'file_save'):
-            dt_str = self.get_value()
-            truncate = -1
-        else:
-            # Other types
-            dt_str = str(e)
-
-        # Done
-        return _truncate(dt_str, truncate)
-
-    def __repr2__(self):
-        """
-        Get the repr (nice string format) for this param.
+    def _init_options(self, options_n):
+        """Create the Option objects from the n data"""
+        option_keys = set()
+        for option_n in options_n:
+            key, name = option_n['key'], option_n['name']
+            # Test against repeated keys
+            if key in option_keys:
+                raise KeyError('Key "{}" already exists in options'.format(key))
+            option_keys.add(key)
+            # Store the option
+            self.options.append(key)
+            self.options_names.append(name)
 
-        Returns:
-            the string representation
-        """
         if self.is_enum():
-            return self.get_option(self.get_value()).get_name()
-        return self.get_value()
-
-    def __str__(self):
-        return 'Param - {}({})'.format(self.get_name(), self.get_key())
+            self._init_enum(options_n)
 
-    def get_color(self):
-        """
-        Get the color that represents this param's type.
+    def _init_enum(self, options_n):
+        opt_ref = None
+        for option_n in options_n:
+            key, opts_raw = option_n['key'], option_n.get('opt', [])
+            try:
+                self.options_opts[key] = opts = dict(opt.split(':') for opt in opts_raw)
+            except TypeError:
+                raise ValueError('Error separating opts into key:value')
+
+            if opt_ref is None:
+                opt_ref = set(opts.keys())
+            elif opt_ref != set(opts):
+                raise ValueError('Opt keys ({}) are not identical across all options.'
+                                 ''.format(', '.join(opt_ref)))
+        if not self.value:
+            self.value = self.default = self.options[0]
+        elif self.value not in self.options:
+            self.value = self.default = self.options[0]  # TODO: warn
+            # raise ValueError('The value {!r} is not in the possible values of {}.'
+            #                  ''.format(self.get_value(), ', '.join(self.options)))
 
-        Returns:
-            a hex color code.
-        """
-        try:
-            return {
-                # Number types
-                'complex': Constants.COMPLEX_COLOR_SPEC,
-                'real': Constants.FLOAT_COLOR_SPEC,
-                'float': Constants.FLOAT_COLOR_SPEC,
-                'int': Constants.INT_COLOR_SPEC,
-                # Vector types
-                'complex_vector': Constants.COMPLEX_VECTOR_COLOR_SPEC,
-                'real_vector': Constants.FLOAT_VECTOR_COLOR_SPEC,
-                'float_vector': Constants.FLOAT_VECTOR_COLOR_SPEC,
-                'int_vector': Constants.INT_VECTOR_COLOR_SPEC,
-                # Special
-                'bool': Constants.INT_COLOR_SPEC,
-                'hex': Constants.INT_COLOR_SPEC,
-                'string': Constants.BYTE_VECTOR_COLOR_SPEC,
-                'id': Constants.ID_COLOR_SPEC,
-                'stream_id': Constants.ID_COLOR_SPEC,
-                'raw': Constants.WILDCARD_COLOR_SPEC,
-            }[self.get_type()]
-        except:
-            return '#FFFFFF'
+    def __str__(self):
+        return 'Param - {}({})'.format(self.name, self.key)
 
     def get_hide(self):
         """
@@ -333,20 +139,17 @@ class Param(Element):
         Returns:
             hide the hide property string
         """
-        hide = self.get_parent().resolve_dependencies(self._hide).strip()
+        hide = self.parent.resolve_dependencies(self._hide).strip()
         if hide:
             return hide
         # Hide ID in non variable blocks
-        if self.get_key() == 'id' and not _show_id_matcher.match(self.get_parent().get_key()):
+        if self.key == 'id' and not _show_id_matcher.match(self.parent.key):
             return 'part'
         # Hide port controllers for type and nports
-        if self.get_key() in ' '.join(map(lambda p: ' '.join([p._type, p._nports]),
-                                          self.get_parent().get_ports())):
+        if self.key in ' '.join([' '.join([p._type, p._nports]) for p in self.parent.get_ports()]):
             return 'part'
         # Hide port controllers for vlen, when == 1
-        if self.get_key() in ' '.join(map(
-            lambda p: p._vlen, self.get_parent().get_ports())
-        ):
+        if self.key in ' '.join(p._vlen for p in self.parent.get_ports()):
             try:
                 if int(self.get_evaluated()) == 1:
                     return 'part'
@@ -360,13 +163,13 @@ class Param(Element):
         The value must be evaluated and type must a possible type.
         """
         Element.validate(self)
-        if self.get_type() not in self.get_types():
+        if self.get_type() not in Constants.PARAM_TYPE_NAMES:
             self.add_error_message('Type "{}" is not a possible type.'.format(self.get_type()))
 
         self._evaluated = None
         try:
             self._evaluated = self.evaluate()
-        except Exception, e:
+        except Exception as e:
             self.add_error_message(str(e))
 
     def get_evaluated(self):
@@ -398,22 +201,22 @@ class Param(Element):
         elif t in ('raw', 'complex', 'real', 'float', 'int', 'hex', 'bool'):
             # Raise exception if python cannot evaluate this value
             try:
-                e = self.get_parent().get_parent().evaluate(v)
-            except Exception, e:
+                e = self.parent_flowgraph.evaluate(v)
+            except Exception as e:
                 raise Exception('Value "{}" cannot be evaluated:\n{}'.format(v, e))
             # Raise an exception if the data is invalid
             if t == 'raw':
                 return e
             elif t == 'complex':
-                if not isinstance(e, COMPLEX_TYPES):
+                if not isinstance(e, Constants.COMPLEX_TYPES):
                     raise Exception('Expression "{}" is invalid for type complex.'.format(str(e)))
                 return e
             elif t == 'real' or t == 'float':
-                if not isinstance(e, REAL_TYPES):
+                if not isinstance(e, Constants.REAL_TYPES):
                     raise Exception('Expression "{}" is invalid for type float.'.format(str(e)))
                 return e
             elif t == 'int':
-                if not isinstance(e, INT_TYPES):
+                if not isinstance(e, Constants.INT_TYPES):
                     raise Exception('Expression "{}" is invalid for type integer.'.format(str(e)))
                 return e
             elif t == 'hex':
@@ -433,29 +236,29 @@ class Param(Element):
                 v = '()'
             # Raise exception if python cannot evaluate this value
             try:
-                e = self.get_parent().get_parent().evaluate(v)
-            except Exception, e:
+                e = self.parent.parent.evaluate(v)
+            except Exception as e:
                 raise Exception('Value "{}" cannot be evaluated:\n{}'.format(v, e))
             # Raise an exception if the data is invalid
             if t == 'complex_vector':
-                if not isinstance(e, VECTOR_TYPES):
+                if not isinstance(e, Constants.VECTOR_TYPES):
                     self._lisitify_flag = True
                     e = [e]
-                if not all([isinstance(ei, COMPLEX_TYPES) for ei in e]):
+                if not all([isinstance(ei, Constants.COMPLEX_TYPES) for ei in e]):
                     raise Exception('Expression "{}" is invalid for type complex vector.'.format(str(e)))
                 return e
             elif t == 'real_vector' or t == 'float_vector':
-                if not isinstance(e, VECTOR_TYPES):
+                if not isinstance(e, Constants.VECTOR_TYPES):
                     self._lisitify_flag = True
                     e = [e]
-                if not all([isinstance(ei, REAL_TYPES) for ei in e]):
+                if not all([isinstance(ei, Constants.REAL_TYPES) for ei in e]):
                     raise Exception('Expression "{}" is invalid for type float vector.'.format(str(e)))
                 return e
             elif t == 'int_vector':
-                if not isinstance(e, VECTOR_TYPES):
+                if not isinstance(e, Constants.VECTOR_TYPES):
                     self._lisitify_flag = True
                     e = [e]
-                if not all([isinstance(ei, INT_TYPES) for ei in e]):
+                if not all([isinstance(ei, Constants.INT_TYPES) for ei in e]):
                     raise Exception('Expression "{}" is invalid for type integer vector.'.format(str(e)))
                 return e
         #########################
@@ -464,7 +267,7 @@ class Param(Element):
         elif t in ('string', 'file_open', 'file_save', '_multiline', '_multiline_python_external'):
             # Do not check if file/directory exists, that is a runtime issue
             try:
-                e = self.get_parent().get_parent().evaluate(v)
+                e = self.parent.parent.evaluate(v)
                 if not isinstance(e, str):
                     raise Exception()
             except:
@@ -495,16 +298,16 @@ class Param(Element):
         elif t == 'stream_id':
             # Get a list of all stream ids used in the virtual sinks
             ids = [param.get_value() for param in filter(
-                lambda p: p.get_parent().is_virtual_sink(),
+                lambda p: p.parent.is_virtual_sink(),
                 self.get_all_params(t),
             )]
             # Check that the virtual sink's stream id is unique
-            if self.get_parent().is_virtual_sink():
+            if self.parent.is_virtual_sink():
                 # Id should only appear once, or zero times if block is disabled
                 if ids.count(v) > 1:
                     raise Exception('Stream ID "{}" is not unique.'.format(v))
             # Check that the virtual source's steam id is found
-            if self.get_parent().is_virtual_source():
+            if self.parent.is_virtual_source():
                 if v not in ids:
                     raise Exception('Stream ID "{}" is not found.'.format(v))
             return v
@@ -552,12 +355,12 @@ class Param(Element):
             # New namespace
             n = dict()
             try:
-                exec v in n
+                exec(v, n)
             except ImportError:
                 raise Exception('Import "{}" failed.'.format(v))
             except Exception:
                 raise Exception('Bad import syntax: "{}".'.format(v))
-            return filter(lambda k: str(k) != '__builtins__', n.keys())
+            return [k for k in list(n.keys()) if str(k) != '__builtins__']
 
         #########################
         else:
@@ -601,62 +404,46 @@ class Param(Element):
         Returns:
             a list of params
         """
-        return sum([filter(lambda p: p.get_type() == type, block.get_params()) for block in self.get_parent().get_parent().get_enabled_blocks()], [])
+        params = []
+        for block in self.parent_flowgraph.get_enabled_blocks():
+            params.extend(p for p in block.params.values() if p.get_type() == type)
+        return params
 
     def is_enum(self):
         return self._type == 'enum'
 
     def get_value(self):
-        value = self._value
-        if self.is_enum() and value not in self.get_option_keys():
-            value = self.get_option_keys()[0]
+        value = self.value
+        if self.is_enum() and value not in self.options:
+            value = self.options[0]
             self.set_value(value)
         return value
 
     def set_value(self, value):
         # Must be a string
-        self._value = str(value)
+        self.value = str(value)
 
     def set_default(self, value):
-        if self._default == self._value:
+        if self.default == self.value:
             self.set_value(value)
-        self._default = str(value)
+        self.default = str(value)
 
     def get_type(self):
-        return self.get_parent().resolve_dependencies(self._type)
+        return self.parent.resolve_dependencies(self._type)
 
     def get_tab_label(self):
-        return self._tab_label
-
-    def get_name(self):
-        return self.get_parent().resolve_dependencies(self._name).strip()
+        return self.tab_label
 
-    def get_key(self):
-        return self._key
+    @nop_write
+    @property
+    def name(self):
+        return self.parent.resolve_dependencies(self._name).strip()
 
     ##############################################
     # Access Options
     ##############################################
-    def get_option_keys(self):
-        return _get_keys(self.get_options())
-
-    def get_option(self, key):
-        return _get_elem(self.get_options(), key)
-
-    def get_options(self):
-        return self._options
-
-    ##############################################
-    # Access Opts
-    ##############################################
-    def get_opt_keys(self):
-        return self.get_option(self.get_value()).get_opt_keys()
-
-    def get_opt(self, key):
-        return self.get_option(self.get_value()).get_opt(key)
-
-    def get_opts(self):
-        return self.get_option(self.get_value()).get_opts()
+    def opt_value(self, key):
+        return self.options_opts[self.get_value()][key]
 
     ##############################################
     # Import/Export Methods
@@ -668,7 +455,7 @@ class Param(Element):
         Returns:
             a nested data odict
         """
-        n = odict()
-        n['key'] = self.get_key()
+        n = collections.OrderedDict()
+        n['key'] = self.key
         n['value'] = self.get_value()
         return n