def _initialize_dummy_block(block, block_n):

Modify block object to get the behaviour for a missing block

"""

block._key = block_n.find('key')

block.is_dummy_block = lambda: True

block.is_valid = lambda: False

for param_n in block_n.findall('param'):

if param_n['key'] not in block.get_param_keys():

new_param_n = odict({'key': param_n['key'], 'name': param_n['key'], 'type': 'string'})

def _dummy_block_add_port(block, key, dir):

port_n = odict({'name': '?', 'key': key, 'type': ''})

port = block.get_parent().get_parent().Port(block=block, n=port_n, dir=dir)

if port.is_source():

class FlowGraph(Element):

def __init__(self, platform):

"""

Make a flow graph from the arguments.

Returns:

the flow graph object

"""

Element.__init__(self, platform)

self._elements = []

self._timestamp = time.ctime()

self.import_data()

self.n = {}

"""

index = 0

while True:

index += 1

if not filter(lambda b: b.get_id() == id, self.get_blocks()): return id

def __str__(self):

def get_complexity(self):

dbal = 0

block_list = self.get_blocks()

for block in block_list:

Returns:

the resultant object

"""

my_hash = hash(code) ^ namespace_hash

self._eval_cache[my_hash] = eval(code, namespace, namespace)

return self._eval_cache[my_hash]

def get_hier_block_stream_io(self, direction):

for i in bussink:

for j in i.get_params():

if j.get_name() == 'On/Off' and j.get_value() == 'on':

return False

def get_bussrc(self):

for i in bussrc:

for j in i.get_params():

if j.get_name() == 'On/Off' and j.get_value() == 'on':

return False

def get_bus_structure_sink(self):

bussink = filter(lambda b: _bus_struct_sink_searcher.search(b.get_key()), self.get_enabled_blocks())

return bussink

def get_bus_structure_src(self):

bussrc = filter(lambda b: _bus_struct_src_searcher.search(b.get_key()), self.get_enabled_blocks())

return bussrc

def iter_enabled_blocks(self):

Returns:

the new block or None if not found

"""

block = self.get_parent().get_new_block(self, key)

if block._bussify_sink:

if block._bussify_source:

def connect(self, porta, portb):

"""

If the element is a block, remove its connections.

If the element is a connection, just remove the connection.

"""

if element.is_port():

element = element.get_parent()

if element.is_block():

for port in element.get_ports():

map(self.remove_element, port.get_connections())

if element.is_bus():

cons_list = []

for i in map(lambda a: a.get_connections(), element.get_source().get_associated_ports()):

self.get_elements().remove(element)

def get_option(self, key):

"""

return self._options_block.get_param(key).get_evaluated()

##############################################

##############################################

def get_block(self, id):

for block in self.iter_blocks():

get_children = get_elements

def rewrite(self):

"""

Flag the namespace to be renewed.

for block in self.get_blocks():

if 'bus' in map(lambda a: a.get_type(), block.get_sources_gui()):

for i in range(len(block.get_sources_gui())):

if len(block.get_sources_gui()[i].get_connections()) > 0:

source = block.get_sources_gui()[i]

sink = []

for j in range(len(source.get_connections())):

for elt in source.get_connections():

for j in sink:

self._renew_eval_ns = True

def refactor_bus_structure():

for block in self.get_blocks():

for direc in ['source', 'sink']:

if direc == 'source':

else:

get_p_gui = block.get_sinks_gui

if 'bus' in map(lambda a: a.get_type(), get_p_gui()):

if len(get_p_gui()) > len(bus_structure):

for i in times:

for connect in get_p_gui()[-1].get_connections():

elif len(get_p_gui()) < len(bus_structure):

if True in map(lambda a: isinstance(a.get_nports(), int), get_p()):

for i in times:

refactor_bus_structure()

def evaluate(self, expr):

"""

"""

if self._renew_eval_ns:

self._renew_eval_ns = False

n = dict()

for code in self.get_imports():

for id, code in self.get_python_modules():

try:

except:

pass

np = dict()

for parameter in self.get_parameters():

try:

e = eval(parameter.get_param('value').to_code(), n, n)

np[parameter.get_id()] = e

for variable in self.get_variables():

try:

e = eval(variable.get_var_value(), n, n)

n[variable.get_id()] = e

self.n = n

self.n_hash = hash(str(n))

e = self._eval(expr, self.n, self.n_hash)

return e

return block

##############################################

##############################################

def export_data(self):

"""

self.connect(source_port, sink_port)

except LookupError as e:

Messages.send_error_load(

source_block_id, source_key, sink_block_id, sink_key, e))

errors = True

@staticmethod

def _update_old_message_port_keys(source_key, sink_key, source_block, sink_block):

Message ports use their names as key (like in the 'connect' method).

Flowgraph files from former versions still have numeric keys stored for

@staticmethod

def _guess_file_format_1(n):

try:

has_non_numeric_message_keys = any(not (

connection_n.find('source_key').isdigit() and