From 36af320d43c726d9bf71eb871737bdd647ff60ef Mon Sep 17 00:00:00 2001
From: Sebastian Koslowski <koslowski@kit.edu>
Date: Fri, 20 Nov 2015 17:39:59 +0100
Subject: grc-refactor: clean-up grc directory

---
 grc/python/Param.py | 429 ----------------------------------------------------
 1 file changed, 429 deletions(-)
 delete mode 100644 grc/python/Param.py

(limited to 'grc/python/Param.py')

diff --git a/grc/python/Param.py b/grc/python/Param.py
deleted file mode 100644
index b627e5eec8..0000000000
--- a/grc/python/Param.py
+++ /dev/null
@@ -1,429 +0,0 @@
-"""
-Copyright 2008-2011 Free Software Foundation, Inc.
-This file is part of GNU Radio
-
-GNU Radio Companion is free software; you can redistribute it and/or
-modify it under the terms of the GNU General Public License
-as published by the Free Software Foundation; either version 2
-of the License, or (at your option) any later version.
-
-GNU Radio Companion is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
-"""
-
-import ast
-
-import re
-from gnuradio import eng_notation
-from gnuradio import gr
-
-import Constants
-from Constants import VECTOR_TYPES, COMPLEX_TYPES, REAL_TYPES, INT_TYPES
-from .base.Param import Param as _Param
-
-_check_id_matcher = re.compile('^[a-z|A-Z]\w*$')
-_show_id_matcher = re.compile('^(variable\w*|parameter|options|notebook|epy_module)$')
-
-
-#blacklist certain ids, its not complete, but should help
-import __builtin__
-ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'wxgui', 'wx', 'math', 'forms', 'firdes'] + \
-    filter(lambda x: not x.startswith('_'), dir(gr.top_block())) + dir(__builtin__)
-
-
-def num_to_str(num):
-    """ Display logic for numbers """
-    if isinstance(num, COMPLEX_TYPES):
-        num = complex(num) #cast to python complex
-        if num == 0: return '0' #value is zero
-        elif num.imag == 0: return '%s'%eng_notation.num_to_str(num.real) #value is real
-        elif num.real == 0: return '%sj'%eng_notation.num_to_str(num.imag) #value is imaginary
-        elif num.imag < 0: return '%s-%sj'%(eng_notation.num_to_str(num.real), eng_notation.num_to_str(abs(num.imag)))
-        else: return '%s+%sj'%(eng_notation.num_to_str(num.real), eng_notation.num_to_str(num.imag))
-    else: return str(num)
-
-
-class Param(_Param):
-
-    def __init__(self, **kwargs):
-        _Param.__init__(self, **kwargs)
-        self._init = False
-        self._hostage_cells = list()
-
-    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',
-        'grid_pos', 'notebook', '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
-        ##################################################
-        truncate = 0 #default center truncate
-        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:
-                dt_str = self.get_value() #large vectors use code
-                truncate = 1
-            else: dt_str = ', '.join(map(num_to_str, e)) #small vectors use eval
-        elif t in ('file_open', 'file_save'):
-            dt_str = self.get_value()
-            truncate = -1
-        else: dt_str = str(e) #other types
-        ##################################################
-        # done
-        ##################################################
-        return _truncate(dt_str, truncate)
-
-    def get_color(self):
-        """
-        Get the color that represents this param's type.
-
-        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,
-                'grid_pos': Constants.INT_VECTOR_COLOR_SPEC,
-                'notebook': Constants.INT_VECTOR_COLOR_SPEC,
-                'raw': Constants.WILDCARD_COLOR_SPEC,
-            }[self.get_type()]
-        except: return _Param.get_color(self)
-
-    def get_hide(self):
-        """
-        Get the hide value from the base class.
-        Hide the ID parameter for most blocks. Exceptions below.
-        If the parameter controls a port type, vlen, or nports, return part.
-        If the parameter is an empty grid position, return part.
-        These parameters are redundant to display in the flow graph view.
-
-        Returns:
-            hide the hide property string
-        """
-        hide = _Param.get_hide(self)
-        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()): 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())
-        ): 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())
-        ):
-            try:
-                if int(self.get_evaluated()) == 1: return 'part'
-            except: pass
-        #hide empty grid positions
-        if self.get_key() in ('grid_pos', 'notebook') and not self.get_value(): return 'part'
-        return hide
-
-    def validate(self):
-        """
-        Validate the param.
-        A test evaluation is performed
-        """
-        _Param.validate(self) #checks type
-        self._evaluated = None
-        try: self._evaluated = self.evaluate()
-        except Exception, e: self.add_error_message(str(e))
-
-    def get_evaluated(self): return self._evaluated
-
-    def evaluate(self):
-        """
-        Evaluate the value.
-
-        Returns:
-            evaluated type
-        """
-        self._init = True
-        self._lisitify_flag = False
-        self._stringify_flag = False
-        self._hostage_cells = list()
-        t = self.get_type()
-        v = self.get_value()
-        #########################
-        # Enum Type
-        #########################
-        if self.is_enum(): return v
-        #########################
-        # Numeric Types
-        #########################
-        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: raise Exception, 'Value "%s" cannot be evaluated:\n%s'%(v, e)
-            #raise an exception if the data is invalid
-            if t == 'raw': return e
-            elif t == 'complex':
-                if not isinstance(e, COMPLEX_TYPES):
-                    raise Exception, 'Expression "%s" is invalid for type complex.'%str(e)
-                return e
-            elif t == 'real' or t == 'float':
-                if not isinstance(e, REAL_TYPES):
-                    raise Exception, 'Expression "%s" is invalid for type float.'%str(e)
-                return e
-            elif t == 'int':
-                if not isinstance(e, INT_TYPES):
-                    raise Exception, 'Expression "%s" is invalid for type integer.'%str(e)
-                return e
-            elif t == 'hex': return hex(e)
-            elif t == 'bool':
-                if not isinstance(e, bool):
-                    raise Exception, 'Expression "%s" is invalid for type bool.'%str(e)
-                return e
-            else: raise TypeError, 'Type "%s" not handled'%t
-        #########################
-        # Numeric Vector Types
-        #########################
-        elif t in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'):
-            if not v: v = '()' #turn a blank string into an empty list, so it will eval
-            #raise exception if python cannot evaluate this value
-            try: e = self.get_parent().get_parent().evaluate(v)
-            except Exception, e: raise Exception, 'Value "%s" cannot be evaluated:\n%s'%(v, e)
-            #raise an exception if the data is invalid
-            if t == 'complex_vector':
-                if not isinstance(e, VECTOR_TYPES):
-                    self._lisitify_flag = True
-                    e = [e]
-                if not all([isinstance(ei, COMPLEX_TYPES) for ei in e]):
-                    raise Exception, 'Expression "%s" is invalid for type complex vector.'%str(e)
-                return e
-            elif t == 'real_vector' or t == 'float_vector':
-                if not isinstance(e, VECTOR_TYPES):
-                    self._lisitify_flag = True
-                    e = [e]
-                if not all([isinstance(ei, REAL_TYPES) for ei in e]):
-                    raise Exception, 'Expression "%s" is invalid for type float vector.'%str(e)
-                return e
-            elif t == 'int_vector':
-                if not isinstance(e, VECTOR_TYPES):
-                    self._lisitify_flag = True
-                    e = [e]
-                if not all([isinstance(ei, INT_TYPES) for ei in e]):
-                    raise Exception, 'Expression "%s" is invalid for type integer vector.'%str(e)
-                return e
-        #########################
-        # String Types
-        #########################
-        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)
-                if not isinstance(e, str):
-                    raise Exception()
-            except:
-                self._stringify_flag = True
-                e = str(v)
-            if t == '_multiline_python_external':
-                ast.parse(e)  # raises SyntaxError
-            return e
-        #########################
-        # Unique ID Type
-        #########################
-        elif t == 'id':
-            #can python use this as a variable?
-            if not _check_id_matcher.match(v):
-                raise Exception, 'ID "%s" must begin with a letter and may contain letters, numbers, and underscores.'%v
-            ids = [param.get_value() for param in self.get_all_params(t)]
-            if ids.count(v) > 1: #id should only appear once, or zero times if block is disabled
-                raise Exception, 'ID "%s" is not unique.'%v
-            if v in ID_BLACKLIST:
-                raise Exception, 'ID "%s" is blacklisted.'%v
-            return v
-        #########################
-        # Stream ID Type
-        #########################
-        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(),
-                self.get_all_params(t),
-            )]
-            #check that the virtual sink's stream id is unique
-            if self.get_parent().is_virtual_sink():
-                if ids.count(v) > 1: #id should only appear once, or zero times if block is disabled
-                    raise Exception, 'Stream ID "%s" is not unique.'%v
-            #check that the virtual source's steam id is found
-            if self.get_parent().is_virtual_source():
-                if v not in ids:
-                    raise Exception, 'Stream ID "%s" is not found.'%v
-            return v
-        #########################
-        # GUI Position/Hint
-        #########################
-        elif t == 'gui_hint':
-            if ':' in v: tab, pos = v.split(':')
-            elif '@' in v: tab, pos = v, ''
-            else: tab, pos = '', v
-
-            if '@' in tab: tab, index = tab.split('@')
-            else: index = '?'
-
-            widget_str = ({
-                (True, True): 'self.%(tab)s_grid_layout_%(index)s.addWidget(%(widget)s, %(pos)s)',
-                (True, False): 'self.%(tab)s_layout_%(index)s.addWidget(%(widget)s)',
-                (False, True): 'self.top_grid_layout.addWidget(%(widget)s, %(pos)s)',
-                (False, False): 'self.top_layout.addWidget(%(widget)s)',
-            }[bool(tab), bool(pos)])%{'tab': tab, 'index': index, 'widget': '%s', 'pos': pos}
-
-            # FIXME: Move replace(...) into the make template of the qtgui blocks and return a string here
-            class GuiHint(object):
-                def __init__(self, ws):
-                    self._ws = ws
-
-                def __call__(self, w):
-                    return (self._ws.replace('addWidget', 'addLayout') if 'layout' in w else self._ws) % w
-
-                def __str__(self):
-                    return self._ws
-            return GuiHint(widget_str)
-        #########################
-        # Grid Position Type
-        #########################
-        elif t == 'grid_pos':
-            if not v: return '' #allow for empty grid pos
-            e = self.get_parent().get_parent().evaluate(v)
-            if not isinstance(e, (list, tuple)) or len(e) != 4 or not all([isinstance(ei, int) for ei in e]):
-                raise Exception, 'A grid position must be a list of 4 integers.'
-            row, col, row_span, col_span = e
-            #check row, col
-            if row < 0 or col < 0:
-                raise Exception, 'Row and column must be non-negative.'
-            #check row span, col span
-            if row_span <= 0 or col_span <= 0:
-                raise Exception, 'Row and column span must be greater than zero.'
-            #get hostage cell parent
-            try: my_parent = self.get_parent().get_param('notebook').evaluate()
-            except: my_parent = ''
-            #calculate hostage cells
-            for r in range(row_span):
-                for c in range(col_span):
-                    self._hostage_cells.append((my_parent, (row+r, col+c)))
-            #avoid collisions
-            params = filter(lambda p: p is not self, self.get_all_params('grid_pos'))
-            for param in params:
-                for parent, cell in param._hostage_cells:
-                    if (parent, cell) in self._hostage_cells:
-                        raise Exception, 'Another graphical element is using parent "%s", cell "%s".'%(str(parent), str(cell))
-            return e
-        #########################
-        # Notebook Page Type
-        #########################
-        elif t == 'notebook':
-            if not v: return '' #allow for empty notebook
-            #get a list of all notebooks
-            notebook_blocks = filter(lambda b: b.get_key() == 'notebook', self.get_parent().get_parent().get_enabled_blocks())
-            #check for notebook param syntax
-            try: notebook_id, page_index = map(str.strip, v.split(','))
-            except: raise Exception, 'Bad notebook page format.'
-            #check that the notebook id is valid
-            try: notebook_block = filter(lambda b: b.get_id() == notebook_id, notebook_blocks)[0]
-            except: raise Exception, 'Notebook id "%s" is not an existing notebook id.'%notebook_id
-            #check that page index exists
-            if int(page_index) not in range(len(notebook_block.get_param('labels').evaluate())):
-                raise Exception, 'Page index "%s" is not a valid index number.'%page_index
-            return notebook_id, page_index
-        #########################
-        # Import Type
-        #########################
-        elif t == 'import':
-            n = dict() #new namespace
-            try: exec v in n
-            except ImportError: raise Exception, 'Import "%s" failed.'%v
-            except Exception: raise Exception, 'Bad import syntax: "%s".'%v
-            return filter(lambda k: str(k) != '__builtins__', n.keys())
-        #########################
-        else: raise TypeError, 'Type "%s" not handled'%t
-
-    def to_code(self):
-        """
-        Convert the value to code.
-        For string and list types, check the init flag, call evaluate().
-        This ensures that evaluate() was called to set the xxxify_flags.
-
-        Returns:
-            a string representing the code
-        """
-        v = self.get_value()
-        t = self.get_type()
-        if t in ('string', 'file_open', 'file_save', '_multiline', '_multiline_python_external'):  # string types
-            if not self._init: self.evaluate()
-            if self._stringify_flag: return '"%s"'%v.replace('"', '\"')
-            else: return v
-        elif t in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'): #vector types
-            if not self._init: self.evaluate()
-            if self._lisitify_flag: return '(%s, )'%v
-            else: return '(%s)'%v
-        else: return v
-
-    def get_all_params(self, type):
-        """
-        Get all the params from the flowgraph that have the given type.
-
-        Args:
-            type: the specified type
-
-        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()], [])
-- 
cgit v1.2.3