git.gag.com Git - debian/gnuradio/blob - grc/python/Param.py

   1 """
   2 Copyright 2008, 2009 Free Software Foundation, Inc.
   3 This file is part of GNU Radio
   4
   5 GNU Radio Companion is free software; you can redistribute it and/or
   6 modify it under the terms of the GNU General Public License
   7 as published by the Free Software Foundation; either version 2
   8 of the License, or (at your option) any later version.
   9
  10 GNU Radio Companion is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
  18 """
  19
  20 import expr_utils
  21 from .. base.Param import Param as _Param, EntryParam
  22 import Constants
  23 import numpy
  24 import os
  25 import pygtk
  26 pygtk.require('2.0')
  27 import gtk
  28 from gnuradio import eng_notation
  29 import re
  30 from gnuradio import gr
  31
  32 _check_id_matcher = re.compile('^[a-z|A-Z]\w*$')
  33 _show_id_matcher = re.compile('^(variable\w*|parameter|options|notebook)$')
  34
  35 class FileParam(EntryParam):
  36         """Provide an entry box for filename and a button to browse for a file."""
  37
  38         def __init__(self, *args, **kwargs):
  39                 EntryParam.__init__(self, *args, **kwargs)
  40                 input = gtk.Button('...')
  41                 input.connect('clicked', self._handle_clicked)
  42                 self.pack_start(input, False)
  43
  44         def _handle_clicked(self, widget=None):
  45                 """
  46                 If the button was clicked, open a file dialog in open/save format.
  47                 Replace the text in the entry with the new filename from the file dialog.
  48                 """
  49                 #get the paths
  50                 file_path = self.param.is_valid() and self.param.get_evaluated() or ''
  51                 (dirname, basename) = os.path.isfile(file_path) and os.path.split(file_path) or (file_path, '')
  52                 if not os.path.exists(dirname): dirname = os.getcwd() #fix bad paths
  53                 #build the dialog
  54                 if self.param.get_type() == 'file_open':
  55                         file_dialog = gtk.FileChooserDialog('Open a Data File...', None,
  56                                 gtk.FILE_CHOOSER_ACTION_OPEN, ('gtk-cancel',gtk.RESPONSE_CANCEL,'gtk-open',gtk.RESPONSE_OK))
  57                 elif self.param.get_type() == 'file_save':
  58                         file_dialog = gtk.FileChooserDialog('Save a Data File...', None,
  59                                 gtk.FILE_CHOOSER_ACTION_SAVE, ('gtk-cancel',gtk.RESPONSE_CANCEL, 'gtk-save',gtk.RESPONSE_OK))
  60                         file_dialog.set_do_overwrite_confirmation(True)
  61                         file_dialog.set_current_name(basename) #show the current filename
  62                 file_dialog.set_current_folder(dirname) #current directory
  63                 file_dialog.set_select_multiple(False)
  64                 file_dialog.set_local_only(True)
  65                 if gtk.RESPONSE_OK == file_dialog.run(): #run the dialog
  66                         file_path = file_dialog.get_filename() #get the file path
  67                         self.entry.set_text(file_path)
  68                         self._handle_changed()
  69                 file_dialog.destroy() #destroy the dialog
  70
  71 #blacklist certain ids, its not complete, but should help
  72 import __builtin__
  73 ID_BLACKLIST = ['self', 'options', 'gr', 'blks2', 'wxgui', 'wx', 'math', 'forms', 'firdes'] + \
  74         filter(lambda x: not x.startswith('_'), dir(gr.top_block())) + dir(__builtin__)
  75 #define types, native python + numpy
  76 VECTOR_TYPES = (tuple, list, set, numpy.ndarray)
  77 COMPLEX_TYPES = [complex, numpy.complex, numpy.complex64, numpy.complex128]
  78 REAL_TYPES = [float, numpy.float, numpy.float32, numpy.float64]
  79 INT_TYPES = [int, long, numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.uint64,
  80         numpy.uint, numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64]
  81 #cast to tuple for isinstance, concat subtypes
  82 COMPLEX_TYPES = tuple(COMPLEX_TYPES + REAL_TYPES + INT_TYPES)
  83 REAL_TYPES = tuple(REAL_TYPES + INT_TYPES)
  84 INT_TYPES = tuple(INT_TYPES)
  85
  86 class Param(_Param):
  87
  88         _init = False
  89         _hostage_cells = list()
  90
  91         ##possible param types
  92         TYPES = _Param.TYPES + [
  93                 'complex', 'real', 'int',
  94                 'complex_vector', 'real_vector', 'int_vector',
  95                 'hex', 'string', 'bool',
  96                 'file_open', 'file_save',
  97                 'id',
  98                 'grid_pos', 'notebook',
  99                 'import',
 100         ]
 101
 102         def __repr__(self):
 103                 """
 104                 Get the repr (nice string format) for this param.
 105                 @return the string representation
 106                 """
 107                 if not self.is_valid(): return self.get_value()
 108                 if self.get_value() in self.get_option_keys(): return self.get_option(self.get_value()).get_name()
 109                 ##################################################
 110                 # display logic for numbers
 111                 ##################################################
 112                 def num_to_str(num):
 113                         if isinstance(num, COMPLEX_TYPES):
 114                                 num = complex(num) #cast to python complex
 115                                 if num == 0: return '0' #value is zero
 116                                 elif num.imag == 0: return '%s'%eng_notation.num_to_str(num.real) #value is real
 117                                 elif num.real == 0: return '%sj'%eng_notation.num_to_str(num.imag) #value is imaginary
 118                                 elif num.imag < 0: return '%s-%sj'%(eng_notation.num_to_str(num.real), eng_notation.num_to_str(abs(num.imag)))
 119                                 else: return '%s+%sj'%(eng_notation.num_to_str(num.real), eng_notation.num_to_str(num.imag))
 120                         else: return str(num)
 121                 ##################################################
 122                 # split up formatting by type
 123                 ##################################################
 124                 truncate = 0 #default center truncate
 125                 max_len = max(27 - len(self.get_name()), 3)
 126                 e = self.get_evaluated()
 127                 t = self.get_type()
 128                 if isinstance(e, bool): return str(e)
 129                 elif isinstance(e, COMPLEX_TYPES): dt_str = num_to_str(e)
 130                 elif isinstance(e, VECTOR_TYPES): #vector types
 131                         if len(e) > 8:
 132                                 dt_str = self.get_value() #large vectors use code
 133                                 truncate = 1
 134                         else: dt_str = ', '.join(map(num_to_str, e)) #small vectors use eval
 135                 elif t in ('file_open', 'file_save'):
 136                         dt_str = self.get_value()
 137                         truncate = -1
 138                 else: dt_str = str(e) #other types
 139                 ##################################################
 140                 # truncate
 141                 ##################################################
 142                 if len(dt_str) > max_len:
 143                         if truncate < 0: #front truncate
 144                                 dt_str = '...' + dt_str[3-max_len:]
 145                         elif truncate == 0: #center truncate
 146                                 dt_str = dt_str[:max_len/2 -3] + '...' + dt_str[-max_len/2:]
 147                         elif truncate > 0: #rear truncate
 148                                 dt_str = dt_str[:max_len-3] + '...'
 149                 return dt_str
 150
 151         def get_input_class(self):
 152                 if self.get_type() in ('file_open', 'file_save'): return FileParam
 153                 return _Param.get_input_class(self)
 154
 155         def get_color(self):
 156                 """
 157                 Get the color that represents this param's type.
 158                 @return a hex color code.
 159                 """
 160                 try:
 161                         return {
 162                                 #number types
 163                                 'complex': Constants.COMPLEX_COLOR_SPEC,
 164                                 'real': Constants.FLOAT_COLOR_SPEC,
 165                                 'int': Constants.INT_COLOR_SPEC,
 166                                 #vector types
 167                                 'complex_vector': Constants.COMPLEX_VECTOR_COLOR_SPEC,
 168                                 'real_vector': Constants.FLOAT_VECTOR_COLOR_SPEC,
 169                                 'int_vector': Constants.INT_VECTOR_COLOR_SPEC,
 170                                 #special
 171                                 'bool': Constants.INT_COLOR_SPEC,
 172                                 'hex': Constants.INT_COLOR_SPEC,
 173                                 'string': Constants.BYTE_VECTOR_COLOR_SPEC,
 174                                 'id': Constants.ID_COLOR_SPEC,
 175                                 'grid_pos': Constants.INT_VECTOR_COLOR_SPEC,
 176                                 'notebook': Constants.INT_VECTOR_COLOR_SPEC,
 177                                 'raw': Constants.WILDCARD_COLOR_SPEC,
 178                         }[self.get_type()]
 179                 except: return _Param.get_color(self)
 180
 181         def get_hide(self):
 182                 """
 183                 Get the hide value from the base class.
 184                 Hide the ID parameter for most blocks. Exceptions below.
 185                 If the parameter controls a port type, vlen, or nports, return part.
 186                 If the parameter is an empty grid position, return part.
 187                 These parameters are redundant to display in the flow graph view.
 188                 @return hide the hide property string
 189                 """
 190                 hide = _Param.get_hide(self)
 191                 if hide: return hide
 192                 #hide ID in non variable blocks
 193                 if self.get_key() == 'id' and not _show_id_matcher.match(self.get_parent().get_key()): return 'part'
 194                 #hide port controllers for type and nports
 195                 if self.get_key() in ' '.join(map(
 196                         lambda p: ' '.join([p._type, p._nports]), self.get_parent().get_ports())
 197                 ): return 'part'
 198                 #hide port controllers for vlen, when == 1
 199                 if self.get_key() in ' '.join(map(
 200                         lambda p: p._vlen, self.get_parent().get_ports())
 201                 ):
 202                         try:
 203                                 assert int(self.get_evaluated()) == 1
 204                                 return 'part'
 205                         except: pass
 206                 #hide empty grid positions
 207                 if self.get_key() in ('grid_pos', 'notebook') and not self.get_value(): return 'part'
 208                 return hide
 209
 210         def validate(self):
 211                 """
 212                 Validate the param.
 213                 A test evaluation is performed
 214                 """
 215                 _Param.validate(self) #checks type
 216                 self._evaluated = None
 217                 try: self._evaluated = self.evaluate()
 218                 except Exception, e: self.add_error_message(str(e))
 219
 220         def get_evaluated(self): return self._evaluated
 221
 222         def evaluate(self):
 223                 """
 224                 Evaluate the value.
 225                 @return evaluated type
 226                 """
 227                 self._init = True
 228                 self._lisitify_flag = False
 229                 self._stringify_flag = False
 230                 self._hostage_cells = list()
 231                 def eval_string(v):
 232                         try:
 233                                 e = self.get_parent().get_parent().evaluate(v)
 234                                 assert isinstance(e, str)
 235                                 return e
 236                         except:
 237                                 self._stringify_flag = True
 238                                 return v
 239                 t = self.get_type()
 240                 v = self.get_value()
 241                 #########################
 242                 # Enum Type
 243                 #########################
 244                 if self.is_enum(): return v
 245                 #########################
 246                 # Numeric Types
 247                 #########################
 248                 elif t in ('raw', 'complex', 'real', 'int', 'complex_vector', 'real_vector', 'int_vector', 'hex', 'bool'):
 249                         #raise exception if python cannot evaluate this value
 250                         try: e = self.get_parent().get_parent().evaluate(v)
 251                         except Exception, e: raise Exception, 'Value "%s" cannot be evaluated: %s'%(v, e)
 252                         #raise an exception if the data is invalid
 253                         if t == 'raw': return e
 254                         elif t == 'complex':
 255                                 try: assert isinstance(e, COMPLEX_TYPES)
 256                                 except AssertionError: raise Exception, 'Expression "%s" is invalid for type complex.'%str(e)
 257                                 return e
 258                         elif t == 'real':
 259                                 try: assert isinstance(e, REAL_TYPES)
 260                                 except AssertionError: raise Exception, 'Expression "%s" is invalid for type real.'%str(e)
 261                                 return e
 262                         elif t == 'int':
 263                                 try: assert isinstance(e, INT_TYPES)
 264                                 except AssertionError: raise Exception, 'Expression "%s" is invalid for type integer.'%str(e)
 265                                 return e
 266                         #########################
 267                         # Numeric Vector Types
 268                         #########################
 269                         elif t == 'complex_vector':
 270                                 if not isinstance(e, VECTOR_TYPES):
 271                                         self._lisitify_flag = True
 272                                         e = [e]
 273                                 try:
 274                                         for ei in e: assert isinstance(ei, COMPLEX_TYPES)
 275                                 except AssertionError: raise Exception, 'Expression "%s" is invalid for type complex vector.'%str(e)
 276                                 return e
 277                         elif t == 'real_vector':
 278                                 if not isinstance(e, VECTOR_TYPES):
 279                                         self._lisitify_flag = True
 280                                         e = [e]
 281                                 try:
 282                                         for ei in e: assert isinstance(ei, REAL_TYPES)
 283                                 except AssertionError: raise Exception, 'Expression "%s" is invalid for type real vector.'%str(e)
 284                                 return e
 285                         elif t == 'int_vector':
 286                                 if not isinstance(e, VECTOR_TYPES):
 287                                         self._lisitify_flag = True
 288                                         e = [e]
 289                                 try:
 290                                         for ei in e: assert isinstance(ei, INT_TYPES)
 291                                 except AssertionError: raise Exception, 'Expression "%s" is invalid for type integer vector.'%str(e)
 292                                 return e
 293                         elif t == 'hex': return hex(e)
 294                         elif t == 'bool':
 295                                 try: assert isinstance(e, bool)
 296                                 except AssertionError: raise Exception, 'Expression "%s" is invalid for type bool.'%str(e)
 297                                 return e
 298                         else: raise TypeError, 'Type "%s" not handled'%t
 299                 #########################
 300                 # String Types
 301                 #########################
 302                 elif t in ('string', 'file_open', 'file_save'):
 303                         #do not check if file/directory exists, that is a runtime issue
 304                         e = eval_string(v)
 305                         return str(e)
 306                 #########################
 307                 # Unique ID Type
 308                 #########################
 309                 elif t == 'id':
 310                         #can python use this as a variable?
 311                         try: assert _check_id_matcher.match(v)
 312                         except AssertionError: raise Exception, 'ID "%s" must begin with a letter and may contain letters, numbers, and underscores.'%v
 313                         params = self.get_all_params('id')
 314                         keys = [param.get_value() for param in params]
 315                         try: assert keys.count(v) <= 1 #id should only appear once, or zero times if block is disabled
 316                         except: raise Exception, 'ID "%s" is not unique.'%v
 317                         try: assert v not in ID_BLACKLIST
 318                         except: raise Exception, 'ID "%s" is blacklisted.'%v
 319                         return v
 320                 #########################
 321                 # Grid Position Type
 322                 #########################
 323                 elif t == 'grid_pos':
 324                         if not v: return '' #allow for empty grid pos
 325                         e = self.get_parent().get_parent().evaluate(v)
 326                         try:
 327                                 assert isinstance(e, (list, tuple)) and len(e) == 4
 328                                 for ei in e: assert isinstance(ei, int)
 329                         except AssertionError: raise Exception, 'A grid position must be a list of 4 integers.'
 330                         row, col, row_span, col_span = e
 331                         #check row, col
 332                         try: assert row >= 0 and col >= 0
 333                         except AssertionError: raise Exception, 'Row and column must be non-negative.'
 334                         #check row span, col span
 335                         try: assert row_span > 0 and col_span > 0
 336                         except AssertionError: raise Exception, 'Row and column span must be greater than zero.'
 337                         #get hostage cell parent
 338                         try: my_parent = self.get_parent().get_param('notebook').evaluate()
 339                         except: my_parent = ''
 340                         #calculate hostage cells
 341                         for r in range(row_span):
 342                                 for c in range(col_span):
 343                                         self._hostage_cells.append((my_parent, (row+r, col+c)))
 344                         #avoid collisions
 345                         params = filter(lambda p: p is not self, self.get_all_params('grid_pos'))
 346                         for param in params:
 347                                 for parent, cell in param._hostage_cells:
 348                                         if (parent, cell) in self._hostage_cells:
 349                                                 raise Exception, 'Another graphical element is using parent "%s", cell "%s".'%(str(parent), str(cell))
 350                         return e
 351                 #########################
 352                 # Notebook Page Type
 353                 #########################
 354                 elif t == 'notebook':
 355                         if not v: return '' #allow for empty notebook
 356                         #get a list of all notebooks
 357                         notebook_blocks = filter(lambda b: b.get_key() == 'notebook', self.get_parent().get_parent().get_enabled_blocks())
 358                         #check for notebook param syntax
 359                         try: notebook_id, page_index = map(str.strip, v.split(','))
 360                         except: raise Exception, 'Bad notebook page format.'
 361                         #check that the notebook id is valid
 362                         try: notebook_block = filter(lambda b: b.get_id() == notebook_id, notebook_blocks)[0]
 363                         except: raise Exception, 'Notebook id "%s" is not an existing notebook id.'%notebook_id
 364                         #check that page index exists
 365                         try: assert int(page_index) in range(len(notebook_block.get_param('labels').get_evaluated()))
 366                         except: raise Exception, 'Page index "%s" is not a valid index number.'%page_index
 367                         return notebook_id, page_index
 368                 #########################
 369                 # Import Type
 370                 #########################
 371                 elif t == 'import':
 372                         n = dict() #new namespace
 373                         try: exec v in n
 374                         except ImportError: raise Exception, 'Import "%s" failed.'%v
 375                         except Exception: raise Exception, 'Bad import syntax: "%s".'%v
 376                         return filter(lambda k: str(k) != '__builtins__', n.keys())
 377                 #########################
 378                 else: raise TypeError, 'Type "%s" not handled'%t
 379
 380         def to_code(self):
 381                 """
 382                 Convert the value to code.
 383                 @return a string representing the code
 384                 """
 385                 #run init tasks in evaluate
 386                 #such as setting flags
 387                 if not self._init: self.evaluate()
 388                 v = self.get_value()
 389                 t = self.get_type()
 390                 if t in ('string', 'file_open', 'file_save'): #string types
 391                         if self._stringify_flag: return '"%s"'%v.replace('"', '\"')
 392                         else: return v
 393                 elif t in ('complex_vector', 'real_vector', 'int_vector'): #vector types
 394                         if self._lisitify_flag: return '(%s, )'%v
 395                         else: return '(%s)'%v
 396                 else: return v
 397
 398         def get_all_params(self, type):
 399                 """
 400                 Get all the params from the flowgraph that have the given type.
 401                 @param type the specified type
 402                 @return a list of params
 403                 """
 404                 return sum([filter(lambda p: p.get_type() == type, block.get_params()) for block in self.get_parent().get_parent().get_enabled_blocks()], [])