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 try: assert self.get_parent().is_enum() or not opts except AssertionError: 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 "%s" into key:value' % opt # test against repeated keys try: assert not self._opts.has_key(key) except AssertionError: raise Exception, 'Key "%s" already exists in option' % key # store the option self._opts[key] = value
def __init__(self): """ Block contructor. Add graphics related params to the block. """ self.W = 0 self.H = 0 #add the position param self.get_params().append(self.get_parent().get_parent().Param( block=self, n=odict({ 'name': 'GUI Coordinate', 'key': '_coordinate', 'type': 'raw', 'value': '(0, 0)', 'hide': 'all', }) )) self.get_params().append(self.get_parent().get_parent().Param( block=self, n=odict({ 'name': 'GUI Rotation', 'key': '_rotation', 'type': 'raw', 'value': '0', 'hide': 'all', }) )) Element.__init__(self) self._comment_pixmap = None self.has_busses = [False, False] # source, sink
def __init__(self, id, name, label, help='', type='text', **kwds): Element.__init__(self, tag='input', cls="formfield", id=id, name=name, type=type, **kwds) self.label = label self.help = help return
def __init__(self): """ FlowGraph contructor. Create a list for signal blocks and connections. Connect mouse handlers. """ Element.__init__(self) #when is the flow graph selected? (used by keyboard event handler) self.is_selected = lambda: bool(self.get_selected_elements()) #important vars dealing with mouse event tracking self.element_moved = False self.mouse_pressed = False self.unselect() self.press_coor = (0, 0) #selected ports self._old_selected_port = None self._new_selected_port = None #context menu self._context_menu = gtk.Menu() for action in [ Actions.BLOCK_CUT, Actions.BLOCK_COPY, Actions.BLOCK_PASTE, Actions.ELEMENT_DELETE, Actions.BLOCK_ROTATE_CCW, Actions.BLOCK_ROTATE_CW, Actions.BLOCK_ENABLE, Actions.BLOCK_DISABLE, Actions.BLOCK_PARAM_MODIFY, ]: self._context_menu.append(action.create_menu_item())
def __init__(self): """ Block contructor. Add graphics related params to the block. """ # add the position param self.get_params().append( self.get_parent() .get_parent() .Param( block=self, n=odict( {"name": "GUI Coordinate", "key": "_coordinate", "type": "raw", "value": "(0, 0)", "hide": "all"} ), ) ) self.get_params().append( self.get_parent() .get_parent() .Param( block=self, n=odict({"name": "GUI Rotation", "key": "_rotation", "type": "raw", "value": "0", "hide": "all"}), ) ) Element.__init__(self)
def __init__(self, flow_graph, porta, portb): """ Make a new connection given the parent and 2 ports. Args: flow_graph: the parent of this element porta: a port (any direction) portb: a port (any direction) @throws Error cannot make connection Returns: a new connection """ Element.__init__(self, flow_graph) source = sink = None #separate the source and sink for port in (porta, portb): if port.is_source(): source = port if port.is_sink(): sink = port if not source: raise ValueError('Connection could not isolate source') if not sink: raise ValueError('Connection could not isolate sink') #ensure that this connection (source -> sink) is unique for connection in self.get_parent().get_connections(): if connection.get_source() is source and connection.get_sink() is sink: raise Exception('This connection between source and sink is not unique.') self._source = source self._sink = sink
def __init__(self, name, version, key, block_paths, block_dtd, default_flow_graph, generator, license='', website=None, colors=[]): """ Make a platform from the arguments. @param name the platform name @param version the version string @param key the unique platform key @param block_paths the file paths to blocks in this platform @param block_dtd the dtd validator for xml block wrappers @param default_flow_graph the default flow graph file path @param generator the generator class for this platform @param colors a list of title, color_spec tuples @param license a multi-line license (first line is copyright) @param website the website url for this platform @return a platform object """ _Element.__init__(self) self._name = name self._version = version self._key = key self._license = license self._website = website self._block_paths = block_paths self._block_dtd = block_dtd self._default_flow_graph = default_flow_graph self._generator = generator self._colors = colors #create a dummy flow graph for the blocks self._flow_graph = _Element(self) #search for *.xml files in the given search path self.loadblocks();
def __init__(self): """ Port contructor. Create list of connector coordinates. """ Element.__init__(self) self.connector_coordinates = dict()
def __init__(self): """ Block contructor. Add graphics related params to the block. """ #add the position param self.get_params().append(self.get_parent().get_parent().Param( block=self, n=odict({ 'name': 'GUI Coordinate', 'key': '_coordinate', 'type': 'raw', 'value': '(0, 0)', 'hide': 'all', }) )) self.get_params().append(self.get_parent().get_parent().Param( block=self, n=odict({ 'name': 'GUI Rotation', 'key': '_rotation', 'type': 'raw', 'value': '0', 'hide': 'all', }) )) Element.__init__(self)
def __init__(self, flow_graph, n): """ Make a new block from nested data. @param flow graph the parent element @param n the nested odict @return block a new block """ # 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") self._category = n.find("category") or "" self._grc_source = n.find("grc_source") or "" self._block_wrapper_path = n.find("block_wrapper_path") # 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 map(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 "%s" already exists in params' % 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 "%s" already exists in sources' % key # store the port self.get_sources().append(source) # 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 "%s" already exists in sinks' % key # store the port self.get_sinks().append(sink)
def __init__(self, title=u'', subtitle=u'', x=0.0, y=0.0, width=100.0, height=50.0, id=u'', classes=(), titleid=u'', titleclasses=(), subtitleid=u'', subtitleclasses=(), border=False, borderid=u'', borderclasses=()): """ @param title: The text of the title @type title: string @param subtitle: The text of the subtitle @type subtitle: string or None @param x: The x coordinate to draw the title element at @param y: The y coordinate to draw the title element at @param width: The width of the title element (used for centering) @param height: The height of the title element (used for centering) @param id: The unique ID to be used in the SVG document @type id: string @param classes: Classnames to be used in the SVG document @type classes: string or sequence of strings @param titleid: The SVG document ID of the title text @type titleid: string @param titleclasses: Classnames to be applied to the title text @type titleclasses: string or sequence of strings @param subtitleid: The SVG document ID of the subtitle text @type subtitleid: string @param subtitleclasses: Classnames to be applied to the subtitle text @type subtitleclasses: string or sequence of strings @param border: Flag designating whether or not to draw a border @type border: boolean @param borderid: The SVG document ID of the title element's border @type borderid: string @param borderclasses: Classnames to be applied to the title element's border @type borderclasses: string or sequence of strings """ Element.__init__(self) self.title = title self.subtitle = subtitle self.x = x self.y = y self.width = width self.height = height self.id = id self.classes = classes self.titleid = titleid self.titleclasses = titleclasses self.subtitleid = subtitleid self.subtitleclasses = subtitleclasses self.border = border self.borderid = borderid self.borderclasses = borderclasses
def __init__(self): """ Port contructor. Create list of connector coordinates. """ Element.__init__(self) self.W = self.H = self.w = self.h = 0 self._connector_coordinate = (0,0) self._connector_length = 0 self._label_hidden = True
def __init__(self, platform): """ Make a flow graph from the arguments. @param platform a platforms with blocks and contrcutors @return the flow graph object """ #initialize Element.__init__(self, platform) #inital blank import self.import_data()
def __init__(self, description, type='', target='', tip='', icon='', **kwds): Element.__init__(self, 'a', **kwds) self.description = description self.type = type self.target = target self.tip = tip self.icon = icon return
def __init__(self, block, n): """ Make a new param from nested data. 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 not self._tab_label 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() 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 "%s" already exists in options'%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 "%s" are not unique.'%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 "%s" are not identical across all options.'%opt_keys #if a value is specified, it must be in the options keys self._value = value if value or value in self.get_option_keys() else self.get_option_keys()[0] if self.get_value() not in self.get_option_keys(): raise Exception, 'The value "%s" is not in the possible values of "%s".'%(self.get_value(), self.get_option_keys()) else: self._value = value or '' self._default = value
def __init__(self, entries=(), x=0.0, y=0.0, width=1.0, height=1.0, entryheight=12.0, title=u'Legend', titlesize=12.0, id=u'', classes=(), titleid=u'', titleclasses=(), border=False, borderid=u'', borderclasses=()): """ @param entries: The legend entries. A sequence of dictionaries in the format {'shape': Shape, 'text': string} @param x: The x coordinate of the legend @param y: The y coordinate of the legend @param width: The width of the legend @param height: The height of the legend @param entryheight: The height of each legend entry @param title: The title of the legend @type title: string or None @param titlesize: The size of the title text @param id: The unique ID to be used in the SVG document @type id: string @param classes: Classnames to be used in the SVG document @type classes: string or sequence of strings @param titleid: The SVG document ID of the title element @type titleid: string @param titleclasses: Classnames to be applied to the title element @type titleclasses: string or sequence of strings @param border: Flag designating whether or not to draw a border @type border: boolean @param borderid: The SVG document ID of the border element @type borderid: string @param borderclasses: Classnames to be applied to the border element @type borderclasses: string or sequence of strings """ Element.__init__(self, id=id, classes=classes) self.entries = entries self.x = x self.y = y self.width = width self.height = height self.title = title self.titlesize = titlesize self.entryheight = entryheight self.titleid = titleid self.titleclasses = titleclasses self.border = border self.borderid = borderid self.borderclasses = borderclasses self.entrymargin = 2.0
def __init__(self, block, n): """ Make a new param from nested data. @param block the parent element @param n the nested odict """ # grab the data self._name = n.find("name") self._key = n.find("key") value = n.find("value") or "" self._type = n.find("type") self._hide = n.find("hide") or "" # build the param Element.__init__(self, block) # create the Option objects from the n data self._options = list() for option in map(lambda o: Option(param=self, n=o), n.findall("option")): key = option.get_key() # test against repeated keys try: assert key not in self.get_option_keys() except AssertionError: raise Exception, 'Key "%s" already exists in options' % key # store the option self.get_options().append(option) # test the enum options if self.is_enum(): # test against options with identical keys try: assert len(set(self.get_option_keys())) == len(self.get_options()) except AssertionError: raise Exception, 'Options keys "%s" are not unique.' % 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(): try: assert set(opt_keys) == set(option.get_opt_keys()) except AssertionError: raise Exception, 'Opt keys "%s" are not identical across all options.' % opt_keys # if a value is specified, it must be in the options keys self._value = value if value or value in self.get_option_keys() else self.get_option_keys()[0] try: assert self.get_value() in self.get_option_keys() except AssertionError: raise Exception, 'The value "%s" is not in the possible values of "%s".' % ( self.get_value(), self.get_option_keys(), ) else: self._value = value or ""
def __init__(self, block, n, dir): """ Make a new port from nested data. @param block the parent element @param n the nested odict @param dir the direction source or sink """ #build the port Element.__init__(self, block) #grab the data self._name = n['name'] self._key = n['key'] self._type = n['type'] self._dir = dir
def __init__(self, platform): """ Make a flow graph from the arguments. Args: platform: a platforms with blocks and contrcutors Returns: the flow graph object """ # initialize Element.__init__(self, platform) self._elements = [] self._timestamp = time.ctime() # inital blank import self.import_data()
def __init__(self, block, n): """ Make a new port from nested data. @param block the parent element @param n the nested odict @return a new port """ #grab the data name = n['name'] key = n['key'] type = n['type'] #build the port Element.__init__(self, block) self._name = name self._key = key self._type = type
def __init__(self, *args, **kwargs): """ FlowGraph contructor. Create a list for signal blocks and connections. Connect mouse handlers. """ Element.__init__(self) # when is the flow graph selected? (used by keyboard event handler) self.is_selected = lambda: bool(self.get_selected_elements()) # important vars dealing with mouse event tracking self.element_moved = False self.mouse_pressed = False self.unselect() self.press_coor = (0, 0) # selected ports self._old_selected_port = None self._new_selected_port = None
def __init__(self, name, version, key, block_paths, block_dtd, default_flow_graph, generator, license='', website=None, colors=None): """ Make a platform from the arguments. Args: name: the platform name version: the version string key: the unique platform key block_paths: the file paths to blocks in this platform block_dtd: the dtd validator for xml block wrappers default_flow_graph: the default flow graph file path generator: the generator class for this platform colors: a list of title, color_spec tuples license: a multi-line license (first line is copyright) website: the website url for this platform Returns: a platform object """ _Element.__init__(self) self._name = name # Save the verion string to the first self._version = version[0] self._version_major = version[1] self._version_api = version[2] self._version_minor = version[3] self._version_short = version[1] + "." + version[2] + "." + version[3] self._key = key self._license = license self._website = website self._block_paths = list(set(block_paths)) self._block_dtd = block_dtd self._default_flow_graph = default_flow_graph self._generator = generator self._colors = colors or [] #create a dummy flow graph for the blocks self._flow_graph = _Element(self) self._blocks = None self._blocks_n = None self._category_trees_n = None self._domains = dict() self._connection_templates = dict() self.load_blocks()
def __init__( self, name, shape = None, children = None, **attributes): Element.__init__(self, name, shape, **attributes) from IdGenerator import IdGenerator self._idGenerator = IdGenerator() #containers self._elements = [] self._id2element = {} self._name2element = {} self._name2id = {} #add children if children is None: children = [] for child in children: self.addElement( child ) return
def __init__(self, block, n, dir): """ Make a new port from nested data. Args: block: the parent element n: the nested odict dir: the direction source or sink """ #build the port Element.__init__(self, block) #grab the data self._name = n['name'] self._key = n['key'] self._type = n['type'] self._hide = n.find('hide') or '' self._dir = dir
def __init__(self, flow_graph, porta, portb): """ Make a new connection given the parent and 2 ports. Args: flow_graph: the parent of this element porta: a port (any direction) portb: a port (any direction) @throws Error cannot make connection Returns: a new connection """ Element.__init__(self, flow_graph) source = sink = None #separate the source and sink for port in (porta, portb): if port.is_source(): source = port if port.is_sink(): sink = port if not source: raise ValueError('Connection could not isolate source') if not sink: raise ValueError('Connection could not isolate sink') busses = len(filter(lambda a: a.get_type() == 'bus', [source, sink]))%2 if not busses == 0: raise ValueError('busses must get with busses') if not len(source.get_associated_ports()) == len(sink.get_associated_ports()): raise ValueError('port connections must have same cardinality'); #ensure that this connection (source -> sink) is unique for connection in self.get_parent().get_connections(): if connection.get_source() is source and connection.get_sink() is sink: raise Exception('This connection between source and sink is not unique.') self._source = source self._sink = sink if source.get_type() == 'bus': sources = source.get_associated_ports(); sinks = sink.get_associated_ports(); for i in range(len(sources)): try: flow_graph.connect(sources[i], sinks[i]); except: pass
def __init__(self, block, n, dir): """ Make a new port from nested data. Args: block: the parent element n: the nested odict dir: the direction source or sink """ # build the port Element.__init__(self, block) # grab the data self._name = n["name"] self._key = n["key"] self._type = n["type"] self._domain = n["domain"] self._hide = n.find("hide") or "" self._dir = dir self._hide_evaluated = False # updated on rewrite()
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 "%s" into key:value'%opt #test against repeated keys if self._opts.has_key(key): raise Exception, 'Key "%s" already exists in option'%key #store the option self._opts[key] = value
def __init__(self, block, n, dir): """ Make a new port from nested data. Args: block: the parent element n: the nested odict dir: the direction source or sink """ #build the port Element.__init__(self, block) #grab the data self._name = n['name'] self._key = n['key'] self._type = n['type'] self._domain = n['domain'] self._hide = n.find('hide') or '' self._dir = dir self._type_evaluated = None # updated on rewrite() self._hide_evaluated = False # updated on rewrite()
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 "%s" into key:value' % opt #test against repeated keys if self._opts.has_key(key): raise Exception, 'Key "%s" already exists in option' % key #store the option self._opts[key] = value
def __init__(self): """ FlowGraph constructor. Create a list for signal blocks and connections. Connect mouse handlers. """ Element.__init__(self) #when is the flow graph selected? (used by keyboard event handler) self.is_selected = lambda: bool(self.get_selected_elements()) #important vars dealing with mouse event tracking self.element_moved = False self.mouse_pressed = False self.unselect() self.press_coor = (0, 0) #selected ports self._old_selected_port = None self._new_selected_port = None # current mouse hover element self.element_under_mouse = None #context menu self._context_menu = Bars.ContextMenu() self.get_context_menu = lambda: self._context_menu
def __init__(self, block, n): """ Make a new param from nested data. Args: block: the parent element n: the nested odict """ #grab the data self._name = n.find('name') self._key = n.find('key') value = n.find('value') or '' self._type = n.find('type') self._hide = n.find('hide') or '' #build the param Element.__init__(self, block) #create the Option objects from the n data self._options = list() 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 "%s" already exists in options'%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 "%s" are not unique.'%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 "%s" are not identical across all options.'%opt_keys #if a value is specified, it must be in the options keys self._value = value if value or value in self.get_option_keys() else self.get_option_keys()[0] if self.get_value() not in self.get_option_keys(): raise Exception, 'The value "%s" is not in the possible values of "%s".'%(self.get_value(), self.get_option_keys()) else: self._value = value or ''
def __init__(self, n, d, p, c, nb): """ :param n : name :param d : depth :param p : parent :param c : model container :param nb : nb_instances """ Element.__init__(self, n, d) if nb.values[0] is not None: self.__check_nb_instances(nb.values[0]) self.__nb_instances = nb self.__constraints = {} self.__parent = p self.__is_done = False self.__containers = [] if c is None: self.__containers.append(Container()) else: self.__containers.append(c)
def __init__(self, flow_graph, porta, portb): """ Make a new connection given the parent and 2 ports. @param flow_graph the parent of this element @param porta a port (any direction) @param portb a port (any direction) @throws Error cannot make connection @return a new connection """ Element.__init__(self, flow_graph) source = sink = None #separate the source and sink for port in (porta, portb): if port.is_source(): source = port if port.is_sink(): sink = port assert (source and sink) #ensure that this connection (source -> sink) is unique for connection in self.get_parent().get_connections(): assert not (connection.get_source() is source and connection.get_sink() is sink) self._source = source self._sink = sink
def __init__(self): """ FlowGraph constructor. Create a list for signal blocks and connections. Connect mouse handlers. """ Element.__init__(self) #when is the flow graph selected? (used by keyboard event handler) self.is_selected = lambda: bool(self.get_selected_elements()) #important vars dealing with mouse event tracking self.element_moved = False self.mouse_pressed = False self.unselect() self.press_coor = (0, 0) #selected ports self._old_selected_port = None self._new_selected_port = None # current mouse hover element self.element_under_mouse = None #context menu self._context_menu = gtk.Menu() for action in [ Actions.BLOCK_CUT, Actions.BLOCK_COPY, Actions.BLOCK_PASTE, Actions.ELEMENT_DELETE, None, Actions.BLOCK_ROTATE_CCW, Actions.BLOCK_ROTATE_CW, Actions.BLOCK_ENABLE, Actions.BLOCK_DISABLE, None, Actions.BLOCK_CREATE_HIER, Actions.OPEN_HIER, Actions.BUSSIFY_SOURCES, Actions.BUSSIFY_SINKS, None, Actions.BLOCK_PARAM_MODIFY ]: self._context_menu.append(action.create_menu_item() if action else gtk.SeparatorMenuItem()) self.get_context_menu = lambda: self._context_menu
def __init__(self, name, version, key, block_paths, block_dtd, default_flow_graph, generator, license='', website=None, colors=None): """ Make a platform from the arguments. Args: name: the platform name version: the version string key: the unique platform key block_paths: the file paths to blocks in this platform block_dtd: the dtd validator for xml block wrappers default_flow_graph: the default flow graph file path generator: the generator class for this platform colors: a list of title, color_spec tuples license: a multi-line license (first line is copyright) website: the website url for this platform Returns: a platform object """ _Element.__init__(self) self._name = name self._version = version self._key = key self._license = license self._website = website self._block_paths = block_paths self._block_dtd = block_dtd self._default_flow_graph = default_flow_graph self._generator = generator self._colors = colors or [] #create a dummy flow graph for the blocks self._flow_graph = _Element(self) self._blocks = None self._blocks_n = None self._category_trees_n = None self.load_blocks()
def __init__(self, block, n): """ Make a new param from nested data. @param block the parent element @param n the nested odict """ #grab the data self._name = n.find('name') self._key = n.find('key') value = n.find('value') or '' self._type = n.find('type') self._hide = n.find('hide') or '' #build the param Element.__init__(self, block) #create the Option objects from the n data self._options = list() 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 "%s" already exists in options'%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 "%s" are not unique.'%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 "%s" are not identical across all options.'%opt_keys #if a value is specified, it must be in the options keys self._value = value if value or value in self.get_option_keys() else self.get_option_keys()[0] if self.get_value() not in self.get_option_keys(): raise Exception, 'The value "%s" is not in the possible values of "%s".'%(self.get_value(), self.get_option_keys()) else: self._value = value or ''
def __init__(self, n, d, p, e, t=[], q=[], r=[]): """ :param n : name :param d : depth :param p : parent :param e : expressions :param t : types :param q : quantifiers :param r : ranges """ Element.__init__(self, n, d) self.__parent = p self.__var_depth = -1 self.__basic_checks(e) self.__raw_expressions = e self.__quantifiers = [] for i, n in enumerate(q): self.__quantifiers.append(Quantifier(n, r[i][0], r[i][1], t[i])) self.__expressions = [] self.__variables = {}
def __init__(self, id, name, label, value='', embeddedText='', help='', error='', type='button', **kwds): Element.__init__(self, tag='button', id=id, name=name, type=type, value=value, **kwds) self.label = label self.embeddedText = embeddedText self.help = help self.error = error return
def __init__(self, flow_graph, n): """ Make a new block from nested data. @param flow graph the parent element @param n the nested odict @return block a new block """ #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') self._category = n.find('category') or '' self._block_wrapper_path = n.find('block_wrapper_path') #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 map( 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 "%s" already exists in params' % 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 "%s" already exists in sources' % key #store the port self.get_sources().append(source) #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 "%s" already exists in sinks' % key #store the port self.get_sinks().append(sink)
def __init__(self): Element.__init__(self, 'div', cls='portletContent') self.content = None return
def __init__(self, name, version, key, block_paths, block_dtd, default_flow_graph, generator, license='', website=None, colors=[]): """ Make a platform from the arguments. @param name the platform name @param version the version string @param key the unique platform key @param block_paths the file paths to blocks in this platform @param block_dtd the dtd validator for xml block wrappers @param default_flow_graph the default flow graph file path @param generator the generator class for this platform @param colors a list of title, color_spec tuples @param license a multi-line license (first line is copyright) @param website the website url for this platform @return a platform object """ _Element.__init__(self) self._name = name self._version = version self._key = key self._license = license self._website = website self._block_paths = block_paths self._block_dtd = block_dtd self._default_flow_graph = default_flow_graph self._generator = generator self._colors = colors #create a dummy flow graph for the blocks self._flow_graph = _Element(self) #search for *.xml files in the given search path xml_files = list() for block_path in self._block_paths: if os.path.isfile(block_path): xml_files.append(block_path) elif os.path.isdir(block_path): for dirpath, dirnames, filenames in os.walk(block_path): for filename in sorted( filter(lambda f: f.endswith('.xml'), filenames)): xml_files.append(os.path.join(dirpath, filename)) #load the blocks self._blocks = odict() self._blocks_n = odict() self._block_tree_files = list() for xml_file in xml_files: try: #try to add the xml file as a block wrapper ParseXML.validate_dtd(xml_file, self._block_dtd) n = ParseXML.from_file(xml_file).find('block') #inject block wrapper path n['block_wrapper_path'] = xml_file block = self.Block(self._flow_graph, n) key = block.get_key() #test against repeated keys if key in self.get_block_keys(): print >> sys.stderr, 'Warning: Block with key "%s" already exists.\n\tIgnoring: %s' % ( key, xml_file) #store the block else: self._blocks[key] = block self._blocks_n[key] = n except ParseXML.XMLSyntaxError, e: try: #try to add the xml file as a block tree ParseXML.validate_dtd(xml_file, BLOCK_TREE_DTD) self._block_tree_files.append(xml_file) except ParseXML.XMLSyntaxError, e: print >> sys.stderr, 'Warning: Block validation failed:\n\t%s\n\tIgnoring: %s' % ( e, xml_file)
def __init__(self, value): Element.__init__(self) self.value = int(value) self.symbol = str(value)
def __init__(self): Element.__init__(self) def get_input(self, *args, **kwargs):
def __init__(self, **kwds): Element.__init__(self, 'link', **kwds) return
def __init__(self, title): Element.__init__(self, 'title') self.title = title return
def __init__(self, **kwds): Element.__init__(self, 'style', **kwds) self.style = [] return
def __init__(self, **kwds): Element.__init__(self, 'pre', **kwds) self.text = [] return
def __init__(self): Element.__init__(self)
def __init__(self, control=None): Element.__init__(self, tag='div', cls="formfield") self.control = control return
def __init__(self, url): Element.__init__(self, 'base', href=url) return
def __init__(self, symbol, value=None): Element.__init__(self) self.value = value self.symbol = str(symbol)
def __init__(self, prefs_file): Element.__init__(self) self._prefs_file = prefs_file
def __init__(self, flow_graph, n): """ Make a new block from nested data. Args: flow: graph the parent element n: the nested odict Returns: block a new block """ #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') self._category = n.find('category') or '' 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' # 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 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 "%s" already exists in params'%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 "%s" already exists in sources'%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 "%s" already exists in sinks'%key #store the port self.get_sinks().append(sink) self.back_ofthe_bus(self.get_sinks()) self.current_bus_structure = {'source':'','sink':''}; # 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. is_not_virtual_or_pad = ((self._key != "virtual_source") \ and (self._key != "virtual_sink") \ and (self._key != "pad_source") \ and (self._key != "pad_sink")) is_variable = self._key.startswith('variable') if is_not_virtual_or_pad and not is_variable: 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 is_not_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 is_not_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 }) ))
def __init__(self, url, **kwds): Element.__init__(self, 'style', **kwds) self.url = url return
def __init__(self, tag, **attributes): Element.__init__(self, tag, **attributes) self.contents = [] return
def __init__(self, **kwds): Element.__init__(self, 'script', **kwds) self.script = [] return
def __init__(self, name=_defaults['name'], value=_defaults['value'], scale=_defaults['scale'], min=_defaults['min'], max=_defaults['max'], free=_defaults['free'], dom=None, *args, **kwargs): """Initialize this Parameter. Parameters: self: This object. name: (string) Name of the Parameter. value: (float) Value of the Parameter. scale: (float) Scale factor for the Parameter value. min: (float) Minimum valid value of the Parameter. If None, no minimum checking is performed. max: (float) Maximum valid value of the Parameter. If None, no maximum checking is performed. free: (Boolean) True if the Parameter value can be adjusted by the likelihood estimator, False otherwise. dom (xml.dom.minidom.Element): DOM element to convert to this Parameter. If this parameter is specified, the other parameters are ignored. Return value: None. Description: Initialize this Parameter. All data attributes are set from the corresponding parameters. If a DOM element is provided, use the attribute nodes of that DOM element to set the data attributes of this Parameter. """ # Initialize the parent class. Do not pass the dom parameter, # since it will be used if needed when fromDom() is called # below. Element.__init__(self, Parameter._tagName, *args, **kwargs) # Set attributes. if dom: if isinstance(dom, xml.dom.minidom.Element): self.fromDom(dom) else: raise TypeError('Not a DOM element (%s)!' % dom) else: self.setName(name) self.setMin(min) # Set min, max before value to allow self.setMax(max) # range checking when setValue() is called. self.setValue(value) self.setScale(scale) self.setFree(free)
def __init__(self): Element.__init__(self) # can't use Colors.CONNECTION_ENABLED_COLOR here, might not be defined (grcc) self._bg_color = self._arrow_color = self._color = None