def __init__(self, flow_graph, n):

"""

Make a new block from nested data.

"""

#grab the data

self._doc = n.find('doc') or ''

def port_controller_modify(self, direction):

"""

Change the port controller.

"""

changed = False

#concat the nports string from the private nports settings of all ports

Split each import statement at newlines.

Combine all import statments into a list.

Filter empty imports.

"""

return filter(lambda i: i, sum(map(lambda i: self.resolve_dependencies(i).split('\n'), self._imports), []))

def get_callbacks(self):

"""

Get a list of function callbacks for this block.

"""

def make_callback(callback):

callback = self.resolve_dependencies(callback)

def _eval(self, code, namespace, namespace_hash):

"""

Evaluate the code with the given namespace.

"""

if not code: raise Exception, 'Cannot evaluate empty statement.'

my_hash = hash(code) ^ namespace_hash

def get_io_signaturev(self, direction):

"""

Get a list of io signatures for this flow graph.

"""

sorted_pads = {

'in': self.get_pad_sources(),

def get_pad_sources(self):

"""

Get a list of pad source blocks sorted by id order.

"""

pads = filter(lambda b: b.get_key() == 'pad_source', self.get_enabled_blocks())

return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))

def get_pad_sinks(self):

"""

Get a list of pad sink blocks sorted by id order.

"""

pads = filter(lambda b: b.get_key() == 'pad_sink', self.get_enabled_blocks())

return sorted(pads, lambda x, y: cmp(x.get_id(), y.get_id()))

def get_imports(self):

"""

Get a set of all import statments in this flow graph namespace.

"""

imports = sum([block.get_imports() for block in self.get_enabled_blocks()], [])

imports = sorted(set(imports))

"""

Get a list of all variables in this flow graph namespace.

Exclude paramterized variables.

"""

variables = filter(lambda b: _variable_matcher.match(b.get_key()), self.get_enabled_blocks())

return expr_utils.sort_objects(variables, lambda v: v.get_id(), lambda v: v.get_var_make())

def get_parameters(self):

"""

Get a list of all paramterized variables in this flow graph namespace.

"""

parameters = filter(lambda b: _parameter_matcher.match(b.get_key()), self.get_enabled_blocks())

return parameters

def evaluate(self, expr):

"""

Evaluate the expression.

@throw Exception bad expression

"""

if self._renew_eval_ns:

self._renew_eval_ns = False

"""

Initialize the generator object.

Determine the file to generate.

"""

self._flow_graph = flow_graph

self._generate_options = self._flow_graph.get_option('generate_options')

def get_popen(self):

"""

Execute this python flow graph.

"""

#extract the path to the python executable

python_exe = sys.executable

def __str__(self):

"""

Convert the flow graph to python code.

"""

title = self._flow_graph.get_option('title') or self._flow_graph.get_option('id').replace('_', ' ').title()

imports = self._flow_graph.get_imports()

def __repr__(self):

"""

Get the repr (nice string format) for this param.

"""

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

# truncate helper method

def get_color(self):

"""

Get the color that represents this param's type.

"""

try:

return {

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.

"""

hide = _Param.get_hide(self)

if hide: return hide

def evaluate(self):

"""

Evaluate the value.

"""

self._init = True

self._lisitify_flag = False

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.

"""

v = self.get_value()

t = self.get_type()

def get_all_params(self, type):

"""

Get all the params from the flowgraph that have the given type.

"""

return sum([filter(lambda p: p.get_type() == type, block.get_params()) for block in self.get_parent().get_parent().get_enabled_blocks()], [])

def __init__(self, block, n, dir):

"""

Make a new port from nested data.

"""

self._n = n

if n['type'] == 'msg': n['key'] = 'msg'

"""

Get the vector length.

If the evaluation of vlen cannot be cast to an integer, return 1.

"""

vlen = self.get_parent().resolve_dependencies(self._vlen)

try: return int(self.get_parent().get_parent().evaluate(vlen))

Get the number of ports.

If already blank, return a blank

If the evaluation of nports cannot be cast to an integer, return 1.

"""

nports = self.get_parent().resolve_dependencies(self._nports)

#return blank if nports is blank

"""

Get the color that represents this port's type.

Codes differ for ports where the vec length is 1 or greater than 1.

"""

try:

color = Constants.TYPE_TO_COLOR[self.get_type()]

Split up an expression by non alphanumeric characters, including underscore.

Leave strings in-tact.

#TODO ignore escaped quotes, use raw strings.

"""

toks = list()

tok = ''

def expr_replace(expr, replace_dict):

"""

Search for vars in the expression and add the prepend.

"""

expr_splits = expr_split(expr)

for i, es in enumerate(expr_splits):

def get_variable_dependencies(expr, vars):

"""

Return a set of variables used in this expression.

"""

expr_toks = expr_split(expr)

return set(filter(lambda v: v in expr_toks, vars))

def get_graph(exprs):

"""

Get a graph representing the variable dependencies

"""

vars = exprs.keys()

#get dependencies for each expression, load into graph

def sort_variables(exprs):

"""

Get a list of variables in order of dependencies.

@throws Exception circular dependencies

"""

var_graph = get_graph(exprs)

def sort_objects(objects, get_id, get_expr):

"""

Sort a list of objects according to their expressions.

"""

id2obj = dict([(get_id(obj), obj) for obj in objects])

#map obj id to expression code

"""

Extract the documentation from the python __doc__ strings.

If multiple modules match, combine the docs.

"""

#extract matches

try:

def extract(key):

"""

Call the private extract and cache the result.

"""

if not _docs_cache.has_key(key):

_docs_cache[key] = _extract(key)