import collections

import itertools

from UserDict import UserDict

from . Constants import (

from . odict import odict

from . FlowGraph import _variable_matcher

from . Element import Element

class TemplateArg(UserDict):

def _get_elem(lst, key):

class Block(Element):

# Build the block

Element.__init__(self, flow_graph)

params = n.findall('param')

sources = n.findall('source')

sinks = n.findall('sink')

self._bussify_source = n.find('bus_source')

self._var_value = n.find('var_value') or '$value'

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]

self._params = list()

self.get_params().append(self.get_parent().get_parent().Param(

block=self,

n=odict({

))

for param in itertools.imap(lambda n: self.get_parent().get_parent().Param(block=self, n=n), params):

key = param.get_key()

if key in self.get_param_keys():

self.get_params().append(param)

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()

if key in self.get_source_keys():

self.get_sources().append(source)

self.back_ofthe_bus(self.get_sources())

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()

if key in self.get_sink_keys():

self.get_sinks().append(sink)

self.back_ofthe_bus(self.get_sinks())

# Virtual source/sink and pad source/sink blocks are

# indistinguishable from normal GR blocks. Make explicit

'type': 'string',

'hide': 'part',

'tab': ADVANCED_PARAM_TAB

))

if (len(sources) or len(sinks)) and not is_virtual_or_pad:

})

))

self._epy_source_hash = -1 # for epy blocks

self._epy_reload_error = None

def get_bus_structure(self, direction):

if direction == 'source':

else:

try:

clean_bus_structure = self.get_parent().evaluate(bus_structure)

return clean_bus_structure

def validate(self):

"""

Evaluate the checks: each check must evaluate to True.

"""

Element.validate(self)

for check in self._checks:

check_res = self.resolve_dependencies(check)

try:

if not self.get_parent().evaluate(check_res):

if _variable_matcher.match(self.get_key()) and self._var_value != '$value':

value = self._var_value

try:

value = self.get_var_value()

self.get_parent().evaluate(value)

except Exception as err:

# check if this is a GUI block and matches the selected generate option

current_generate_option = self.get_parent().get_option('generate_options')

self.get_name().upper().startswith(label)

)

if block_requires_mode and current_generate_option not in valid_options:

check_generate_mode('WX GUI', BLOCK_FLAG_NEED_WX_GUI, ('wx_gui',))

check_generate_mode('QT GUI', BLOCK_FLAG_NEED_QT_GUI, ('qt_gui', 'hb_qt_gui'))

# Check and run any custom rewrite function for this block

getattr(self, 'rewrite_' + self._key, lambda: None)()

for ports in (self.get_sources(), self.get_sinks()):

for i, master_port in enumerate(ports):

nports = master_port.get_nports() or 1

if master_port.get_hide():

for connection in master_port.get_connections():

self.get_parent().remove_element(connection)

continue

for port in master_port.get_clones()[nports-1:]:

for connection in port.get_connections():

self.get_parent().remove_element(connection)

master_port.remove_clone(port)

ports.remove(port)

for j in range(num_ports, nports):

port = master_port.add_clone()

ports.insert(ports.index(master_port) + j, port)

self.back_ofthe_bus(ports)

domain_specific_port_index = collections.defaultdict(int)

for port in filter(lambda p: p.get_key().isdigit(), ports):

domain = port.get_domain()

true for change

"""

changed = False

nports_str = ' '.join([port._nports for port in self.get_ports()])

for param in self.get_params():

try:

value = param.get_evaluated()

value = value + direction

if 0 < value:

param.set_value(value)

changed = True

return changed

def get_doc(self):

"""

def make_callback(callback):

callback = self.resolve_dependencies(callback)

return map(make_callback, self._callbacks)

def is_virtual_sink(self):

except Exception as e:

self._epy_reload_error = ValueError(str(e))

blk_io = epy_block_io.BlockIO(*eval(param_blk.get_value()))

except:

return

else:

param_blk.set_value(repr(tuple(blk_io)))

# print "Rewriting embedded python block {!r}".format(self.get_id())

update_ports('out', self.get_sources(), blk_io.sources, 'source')

self.rewrite()

def back_ofthe_bus(self, portlist):

portlist.sort(key=lambda p: p._type == 'bus')

BYPASSED - 1

DISABLED - 2

"""

def set_state(self, state):

"""

return False

return True

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

# Access Params

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

def has_param(self, key):

try:

except:

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

# Access Sinks

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

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

# Access Sources

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

def get_connections(self):

return sum([port.get_connections() for port in self.get_ports()], [])

the resolved value

"""

tmpl = str(tmpl)

n = dict((p.get_key(), TemplateArg(p)) for p in self.get_params())

try:

return str(Template(tmpl, n))

except Exception as err:

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

# Controller Modify

type_param = None

for param in filter(lambda p: p.is_enum(), self.get_params()):

children = self.get_ports() + self.get_params()

if param.get_key() in ' '.join(map(lambda p: p._type, children)): type_param = param

if type_param:

try:

keys = type_param.get_option_keys()

old_index = keys.index(type_param.get_value())

type_param.set_value(keys[new_index])

changed = True

return changed

def form_bus_structure(self, direc):

struct = [range(len(get_p()))]

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

for j in [i.get_nports() for i in get_p() if isinstance(i.get_nports(), int)]:

structlet.extend(map(lambda a: a+last, range(j)))

last = structlet[-1] + 1

def bussify(self, n, direc):

if direc == 'source':

else:

get_p_gui = self.get_sinks_gui

for elt in get_p():

for connect in elt.get_connections():

if get_p()[0].get_nports():

for i in range(len(struct)):

elif 'bus' in map(lambda a: a.get_type(), get_p()):

for elt in get_p_gui():

self.current_bus_structure[direc] = ''

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

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

def export_data(self):

"""

n['key'] = self.get_key()

n['param'] = map(lambda p: p.export_data(), sorted(self.get_params(), key=str))

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

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

return n

def import_data(self, n):

"""

Import this block's params from nested data.

Args:

n: the nested data odict

"""

my_hash = 0

params_n = n.findall('param')

for param_n in params_n:

key = param_n.find('key')

value = param_n.find('value')

if key in self.get_param_keys():

self.get_param(key).set_value(value)

self.rewrite()

if len(bussinks) > 0 and not self._bussify_sink:

elif len(bussinks) > 0:

if len(bussrcs) > 0 and not self._bussify_source:

elif len(bussrcs) > 0:

from .Element import Element

from .odict import odict

class Connection(Element):

def __init__(self, flow_graph, porta, portb):

"""

Element.__init__(self, flow_graph)

source = sink = None

for port in (porta, portb):

if not len(source.get_associated_ports()) == len(sink.get_associated_ports()):

for connection in self.get_parent().get_connections():

if connection.get_source() is source and connection.get_sink() is sink:

raise LookupError('This connection between source and sink is not unique.')

self._sink = sink

if source.get_type() == 'bus':

for i in range(len(sources)):

try:

except:

pass

def __str__(self):

self.get_source().get_parent(),

self.get_source(),

self.get_sink().get_parent(),

source_domain = self.get_source().get_domain()

sink_domain = self.get_sink().get_domain()

if (source_domain, sink_domain) not in platform.get_connection_templates():

too_many_other_sinks = (

source_domain in platform.get_domains() and

not platform.get_domain(key=source_domain)['multiple_sinks'] and

)

if too_many_other_sinks:

self.add_error_message(

if too_many_other_sources:

self.add_error_message(

source_size = Constants.TYPE_TO_SIZEOF[self.get_source().get_type()] * self.get_source().get_vlen()

sink_size = Constants.TYPE_TO_SIZEOF[self.get_sink().get_type()] * self.get_sink().get_vlen()

if source_size != sink_size:

def get_enabled(self):

"""

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

# Access Ports

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

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

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

def export_data(self):

"""

_gr_prefs = gr.prefs()

PATH_SEP = {'/': ':', '\\': ';'}[os.path.sep]

HIER_BLOCKS_LIB_DIR = os.environ.get('GRC_HIER_PATH', expanduser('~/.grc_gnuradio'))

]).split(PATH_SEP),

) + [HIER_BLOCKS_LIB_DIR]

DATA_DIR = os.path.dirname(__file__)

FLOW_GRAPH_DTD = os.path.join(DATA_DIR, 'flow_graph.dtd')

BLOCK_TREE_DTD = os.path.join(DATA_DIR, 'block_tree.dtd')

# 0: undefined / legacy

# 1: non-numeric message port keys (label is used instead)

FLOW_GRAPH_FILE_FORMAT_VERSION = 1

BLOCK_ENABLED = 1

BLOCK_BYPASSED = 2

XTERM_EXECUTABLE = _gr_prefs.get_string('grc', 'xterm_executable', 'xterm')

HIER_BLOCK_FILE_MODE = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH

DATA_DIR = os.path.dirname(__file__)

FLOW_GRAPH_TEMPLATE = os.path.join(DATA_DIR, 'flow_graph.tmpl')

BLOCK_DTD = os.path.join(DATA_DIR, 'block.dtd')

DEFAULT_FLOW_GRAPH = os.path.join(DATA_DIR, 'default_flow_graph.grc')

VECTOR_TYPES = (tuple, list, set, numpy.ndarray)

COMPLEX_TYPES = [complex, numpy.complex, numpy.complex64, numpy.complex128]

REAL_TYPES = [float, numpy.float, numpy.float32, numpy.float64]

INT_TYPES = [int, long, numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.uint64,

COMPLEX_TYPES = tuple(COMPLEX_TYPES + REAL_TYPES + INT_TYPES)

REAL_TYPES = tuple(REAL_TYPES + INT_TYPES)

INT_TYPES = tuple(INT_TYPES)

GRC_COLOR_GREY = '#BDBDBD'

GRC_COLOR_WHITE = '#FFFFFF'

CORE_TYPES = ( # name, key, sizeof, color

('Complex Float 64', 'fc64', 16, GRC_COLOR_BROWN),

('Complex Float 32', 'fc32', 8, GRC_COLOR_BLUE),

)

ALIAS_TYPES = {

}

TYPE_TO_COLOR = dict()

TYPE_TO_SIZEOF = dict()

for name, key, sizeof, color in CORE_TYPES:

TYPE_TO_COLOR[key] = color

TYPE_TO_SIZEOF[key] = sizeof

for key, (sizeof, color) in ALIAS_TYPES.iteritems():

TYPE_TO_COLOR[key] = color

TYPE_TO_SIZEOF[key] = sizeof

COMPLEX_COLOR_SPEC = '#3399FF'

FLOAT_COLOR_SPEC = '#FF8C69'

INT_COLOR_SPEC = '#00FF99'

Returns:

a list of error message strings

"""

for child in filter(lambda c: c.get_enabled(), self.get_children()):

for msg in child.get_error_messages():

return error_messages

def rewrite(self):

return True

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

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

def get_parent(self):

return self._parent

def get_children(self):

return list()

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

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

def is_element(self):

return True

def is_block(self):

return False

def is_dummy_block(self):

return False

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

"""

This file is part of GNU Radio

GNU Radio Companion is free software; you can redistribute it and/or

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

self._mode = TOP_BLOCK_FILE_MODE

dirname = self._dirname = os.path.dirname(file_path)

if not os.access(dirname, os.W_OK):

dirname = tempfile.gettempdir()

filename = self._flow_graph.get_option('id') + '.py'

def write(self):

"""generate output and write it to files"""

throttling_blocks = filter(lambda b: b.throtteling(), self._flow_graph.get_enabled_blocks())

if not throttling_blocks and not self._generate_options.startswith('hb'):

Messages.send_warning("This flow graph may not have flow control: "

"e.g. a hardware source or sink. "

"This is usually undesired. Consider "

"removing the throttle block.")

for filename, data in self._build_python_code_from_template():

with codecs.open(filename, 'w', encoding='utf-8') as fp:

fp.write(data)

except Exception as e:

raise ValueError("Can't parse run command {!r}: {}".format(run_command, e))

xterm_executable = find_executable(XTERM_EXECUTABLE)

if self._generate_options == 'no_gui' and xterm_executable:

run_command_args = [xterm_executable, '-e', run_command]

parameters = fg.get_parameters()

monitors = fg.get_monitors()

def _get_block_sort_text(block):

code = block.get_make().replace(block.get_id(), ' ')

try:

except:

pass

try:

except:

pass

return code

output.append((file_path, src))

# Filter out virtual sink connections

connections = filter(cf, fg.get_enabled_connections())

# Get the virtual blocks and resolve their connections

for block in bypassed_blocks:

# Get the upstream connection (off of the sink ports)

# Use *connections* not get_connections()

# The source connection should never have more than one element.

assert (len(source_connection) == 1)

source_port = source_connection[0].get_source()

# Loop through all the downstream connections

if not sink.get_enabled():

# Ignore disabled connections

continue

connection_templates = fg.get_parent().get_connection_templates()

msgs = filter(lambda c: c.is_msg(), fg.get_enabled_connections())

var_ids = [var.get_id() for var in parameters + variables]

replace_dict = dict([(var_id, 'self.%s' % var_id) for var_id in var_ids])

callbacks = [

expr_utils.expr_replace(cb, replace_dict)

for cb in sum([block.get_callbacks() for block in fg.get_enabled_blocks()], [])

]

var_id2cbs = dict([

(var_id, filter(lambda c: expr_utils.get_variable_dependencies(c, [var_id]), callbacks))

for var_id in var_ids

])

namespace = {

'title': title,

'imports': imports,

'generate_options': self._generate_options,

'var_id2cbs': var_id2cbs,

}

t = Template(open(FLOW_GRAPH_TEMPLATE, 'r').read(), namespace)

output.append((self.get_file_path(), str(t)))

return output

Returns:

a xml node tree

"""

block_key = self._flow_graph.get_option('id')

parameters = self._flow_graph.get_parameters()

return "$"+name

return name

block_n = odict()

block_n['name'] = self._flow_graph.get_option('title') or \

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

block_n['category'] = self._flow_graph.get_option('category')

block_n['import'] = "from {0} import {0} # grc-generated hier_block".format(

self._flow_graph.get_option('id'))

if parameters:

block_n['make'] = '{cls}(\n {kwargs},\n)'.format(

cls=block_key,

)

else:

block_n['make'] = '{cls}()'.format(cls=block_key)

block_n['callback'] = [

'set_{key}(${key})'.format(key=param.get_id()) for param in parameters

]

param_n['type'] = 'raw'

block_n['param'].append(param_n)

if self._flow_graph.get_bussink():

block_n['bus_sink'] = '1'

if self._flow_graph.get_bussrc():

block_n['bus_source'] = '1'

for direction in ('sink', 'source'):

block_n[direction] = list()

for port in self._flow_graph.get_hier_block_io(direction):

port_n['optional'] = '1'

block_n[direction].append(port_n)

bus_struct_sink = self._flow_graph.get_bus_structure_sink()

if bus_struct_sink:

block_n['bus_structure_sink'] = bus_struct_sink[0].get_param('struct').get_value()

if bus_struct_src:

block_n['bus_structure_source'] = bus_struct_src[0].get_param('struct').get_value()

block_n['doc'] = "\n".join(field for field in (

self._flow_graph.get_option('author'),

self._flow_graph.get_option('description'),

import Constants

from Constants import VECTOR_TYPES, COMPLEX_TYPES, REAL_TYPES, INT_TYPES

from .odict import odict

from .Element import Element

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 _get_elem(lst, key):

def num_to_str(num):

""" Display logic for numbers """

if isinstance(num, COMPLEX_TYPES):

class Option(Element):

self._key = n.find('key')

self._opts = dict()

opts = n.findall('opt')

if not self.get_parent().is_enum() and opts:

for opt in opts:

self._opts[key] = value

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

# Access Opts

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

class Param(Element):

block: the parent element

n: the nested odict

"""

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

self._n = n

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]

block.get_param_tab_labels().append(self._tab_label)

Element.__init__(self, block)

self._options = list()

self._evaluated = None

for option in map(lambda o: Option(param=self, n=o), n.findall('option')):

key = option.get_key()

if key in self.get_option_keys():

self.get_options().append(option)

if self.is_enum():

if len(set(self.get_option_keys())) != len(self.get_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()):

if self.get_value() not in self.get_option_keys():

else:

self._value = value or ''

self._default = value

the string representation

"""

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

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

def _truncate(string, style=0):

max_len = max(27 - len(self.get_name()), 3)

if len(string) > max_len:

string = '...' + string[3-max_len:]

string = string[:max_len-3] + '...'

return string

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

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

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

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

e = self.get_evaluated()

t = self.get_type()

if len(e) > 8:

truncate = 1

elif t in ('file_open', 'file_save'):

dt_str = self.get_value()

truncate = -1

return _truncate(dt_str, truncate)

def __repr2__(self):

return self.get_option(self.get_value()).get_name()

return self.get_value()

def get_color(self):

"""

"""

try:

return {

'complex': Constants.COMPLEX_COLOR_SPEC,

'real': Constants.FLOAT_COLOR_SPEC,

'float': Constants.FLOAT_COLOR_SPEC,

'int': Constants.INT_COLOR_SPEC,

'complex_vector': Constants.COMPLEX_VECTOR_COLOR_SPEC,

'real_vector': Constants.FLOAT_VECTOR_COLOR_SPEC,

'int_vector': Constants.INT_VECTOR_COLOR_SPEC,

'bool': Constants.INT_COLOR_SPEC,

'hex': Constants.INT_COLOR_SPEC,

'string': Constants.BYTE_VECTOR_COLOR_SPEC,

hide the hide property string

"""

hide = self.get_parent().resolve_dependencies(self._hide).strip()

if self.get_key() in ' '.join(map(

lambda p: p._vlen, self.get_parent().get_ports())

):

try:

return hide

def validate(self):

"""

Element.validate(self)

if self.get_type() not in self.get_types():

self._evaluated = None

def evaluate(self):

"""

self._hostage_cells = list()

t = self.get_type()

v = self.get_value()

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

# Enum Type

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

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

# Numeric Types

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

elif t in ('raw', 'complex', 'real', 'float', 'int', 'hex', 'bool'):

elif t == 'complex':

if not isinstance(e, COMPLEX_TYPES):

return e

elif t == 'real' or t == 'float':

if not isinstance(e, REAL_TYPES):

return e

elif t == 'int':

if not isinstance(e, INT_TYPES):

return e

elif t == 'bool':

if not isinstance(e, bool):

return e

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

# Numeric Vector Types

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

elif t in ('complex_vector', 'real_vector', 'float_vector', 'int_vector'):

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]):

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]):

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]):

return e

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

# String Types

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

elif t in ('string', 'file_open', 'file_save', '_multiline', '_multiline_python_external'):

try:

e = self.get_parent().get_parent().evaluate(v)

if not isinstance(e, str):

self._stringify_flag = True

e = str(v)

if t == '_multiline_python_external':

return e

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

# Unique ID Type

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

elif t == 'id':

if not _check_id_matcher.match(v):

ids = [param.get_value() for param in self.get_all_params(t)]

if v in ID_BLACKLIST:

return v

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

# Stream ID Type

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

elif t == 'stream_id':

ids = [param.get_value() for param in filter(

lambda p: p.get_parent().is_virtual_sink(),

self.get_all_params(t),

)]

if self.get_parent().is_virtual_sink():

if self.get_parent().is_virtual_source():

if v not in ids:

return v

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

# GUI Position/Hint

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

elif t == 'gui_hint':

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)',

class GuiHint(object):

def __init__(self, ws):

self._ws = ws

# Grid Position Type

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

elif t == '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]):

row, col, row_span, col_span = e

if row < 0 or col < 0:

if row_span <= 0 or col_span <= 0:

for r in range(row_span):

for c in range(col_span):

self._hostage_cells.append((my_parent, (row+r, col+c)))

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:

return e

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

# Notebook Page Type

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

elif t == 'notebook':

notebook_blocks = filter(lambda b: b.get_key() == 'notebook', self.get_parent().get_parent().get_enabled_blocks())

if int(page_index) not in range(len(notebook_block.get_param('labels').evaluate())):

return notebook_id, page_index

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

# Import Type

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

elif t == 'import':

return filter(lambda k: str(k) != '__builtins__', n.keys())

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

def to_code(self):

"""

"""

v = self.get_value()

t = self.get_type()

def get_all_params(self, 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 get_value(self):

value = self._value

self.set_value(value)

return value

def value_is_default(self):

return self._default == self._value

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

# Access Options

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

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

# Access Opts

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

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

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

def export_data(self):

"""

"""

This file is part of GNU Radio

GNU Radio Companion is free software; you can redistribute it and/or

dtd_file: the optional dtd file

@throws Exception validation fails

"""

parser = etree.XMLParser(dtd_validation=not dtd_file)

try:

xml = etree.parse(xml_file, parser=parser)

if parser.error_log:

raise XMLSyntaxError(parser.error_log)

if not dtd_file:

return

try:

nested_data = odict()

for elem in xml:

key, value = _from_file(elem).items()[0]

for key, values in nested_data.iteritems():

if len(values) == 1:

nested_data[key] = values[0]

"""

xml_data = ""

instructions = nested_data.pop('_instructions', None)

xml_data += etree.tostring(etree.ProcessingInstruction(

'grc', ' '.join(

"{0}='{1}'".format(*item) for item in instructions.iteritems())

"""

nodes = list()

for key, values in nested_data.iteritems():

if not isinstance(values, (list, set, tuple)):

values = [values]

for value in values:

website: the website url for this platform

"""

if not os.path.exists(HIER_BLOCKS_LIB_DIR):

os.mkdir(HIER_BLOCKS_LIB_DIR)

if not os.path.exists(os.path.dirname(PREFS_FILE)):

self._default_flow_graph = DEFAULT_FLOW_GRAPH

self._generator = Generator

self._colors = [(name, color) for name, key, sizeof, color in CORE_TYPES]

self._flow_graph = Element(self)

self._blocks = None

try:

flow_graph = self.get_new_flow_graph()

flow_graph.grc_file_path = file_path

flow_graph.import_data(self.parse_flow_graph(file_path))

flow_graph.rewrite()

flow_graph.validate()

if not flow_graph.is_valid():

raise Exception('Flowgraph invalid')

except Exception as e:

return False

finally:

self._auto_hier_block_generate_chain.discard(file_path)

Messages.set_indent(len(self._auto_hier_block_generate_chain))

try:

generator = self.get_generator()(flow_graph, file_path)

generator.write()

except Exception as e:

return False

self.load_block_xml(generator.get_file_path_xml())

return True

def _load_blocks(self):

"""load the blocks and block tree from the search paths"""

self._blocks = odict()

self._blocks_n = odict()

self._category_trees_n = list()

self._domains.clear()

self._connection_templates.clear()

ParseXML.xml_failures.clear()

for xml_file in self.iter_xml_files():

try:

if xml_file.endswith("block_tree.xml"):

def iter_xml_files(self):

"""Iterator for block descriptions and category trees"""

if os.path.isfile(block_path):

yield block_path

elif os.path.isdir(block_path):

def _load_block_xml(self, xml_file):

"""Load block description from xml file"""

ParseXML.validate_dtd(xml_file, self._block_dtd)

n = ParseXML.from_file(xml_file).find('block')

n['block_wrapper_path'] = xml_file # inject block wrapper path

block = self.Block(self._flow_graph, n)

key = block.get_key()

if key in self._blocks:

self._blocks[key] = block

self._blocks_n[key] = n

return block

key = n.find('key')

if not key:

return

if key in self.get_domains(): # test against repeated keys

return

color = n.find('color') or ''

try:

gtk.gdk.color_parse(color)

except (ValueError, ImportError):

if color: # no color is okay, default set in GUI

color = None

self._domains[key] = dict(

for connection_n in n.findall('connection'):

key = (connection_n.find('source_domain'), connection_n.find('sink_domain'))

if not all(key):

elif key in self._connection_templates:

else:

self._connection_templates[key] = connection_n.find('make') or ''

@throws exception if the validation fails

"""

flow_graph_file = flow_graph_file or self._default_flow_graph

ParseXML.validate_dtd(flow_graph_file, FLOW_GRAPH_DTD)

return ParseXML.from_file(flow_graph_file)

Args:

block_tree: the block tree object

"""

def load_category(cat_n, parent=None):

parent = (parent or []) + [cat_n.find('name')]

block_tree.add_block(parent)

map(lambda c: load_category(c, parent), cat_n.findall('cat'))

for block_key in cat_n.findall('block'):

if block_key not in self.get_block_keys():

continue

block = self.get_block(block_key)

if not block.get_category():

block.set_category(parent)

for category_tree_n in self._category_trees_n:

load_category(category_tree_n)

for block in self.get_blocks():

block_tree.add_block(block.get_category(), block)

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

# Access Blocks

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

def get_new_block(self, flow_graph, key):

return self.Block(flow_graph, n=self._blocks_n[key])

Resolve the source port that is connected to the given virtual sink port.

Use the get source from virtual source to recursively resolve subsequent ports.

"""

def _get_source_from_virtual_source_port(vsp, traversed=[]):

Recursively resolve source ports over the virtual connections.

Keep track of traversed sources to avoid recursive loops.

"""

def _get_sink_from_virtual_source_port(vsp):

Resolve the sink port that is connected to the given virtual source port.

Use the get sink from virtual sink to recursively resolve subsequent ports.

"""

def _get_sink_from_virtual_sink_port(vsp, traversed=[]):

Recursively resolve sink ports over the virtual connections.

Keep track of traversed sinks to avoid recursive loops.

"""

class Port(Element):

n['domain'] = DEFAULT_DOMAIN

elif n['domain'] == GR_MESSAGE_DOMAIN:

n['key'] = n['name']

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

n['key'] = 'msg'

if not n.find('key'):

n['key'] = str(next(block.port_counters[dir == 'source']))

Element.__init__(self, block)

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._nports = n.find('nports') or ''

self._vlen = n.find('vlen') or ''

self._optional = bool(n.find('optional'))

def __str__(self):

if self.is_source():

if self.is_sink():

def validate(self):

Element.validate(self)

if self.get_type() not in self.get_types():

platform = self.get_parent().get_parent().get_parent()

if self.get_domain() not in platform.get_domains():

if not self.get_enabled_connections() and not self.get_optional():

self.add_error_message('Port is not connected.')

if self.get_type() == 'msg':

if self.get_nports():

self.add_error_message('A port of type "msg" cannot have "nports" set.')

Handle the port cloning for virtual blocks.

"""

if self.is_type_empty():

source = self.resolve_empty_type()

self._type = str(source.get_type())

self._vlen = str(source.get_vlen())

self._type = ''

self._vlen = ''

Element.rewrite(self)

hide = self.get_parent().resolve_dependencies(self._hide).strip().lower()

self._hide_evaluated = False if hide in ('false', 'off', '0') else bool(hide)

type_ = self.get_type()

if self._domain == GR_STREAM_DOMAIN and type_ == "message":

self._domain = GR_MESSAGE_DOMAIN

self._key = self._name

if self._domain == GR_MESSAGE_DOMAIN and type_ != "message":

self._domain = GR_STREAM_DOMAIN

def resolve_virtual_source(self):

def resolve_empty_type(self):

if self.is_sink():

try:

src = _get_source_from_virtual_sink_port(self)

sink = _get_sink_from_virtual_sink_port(self)

if self.is_source():

try:

src = _get_source_from_virtual_source_port(self)

sink = _get_sink_from_virtual_source_port(self)

def get_vlen(self):

"""

the vector length or 1

"""

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

def get_nports(self):

"""

Returns:

the number of ports or 1

"""

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

try:

except:

return 1

def get_color(self):

"""

try:

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

vlen = self.get_vlen()

color_val = int(color[1:], 16)

r = (color_val >> 16) & 0xff

g = (color_val >> 8) & 0xff

r = max(r-dark, 0)

g = max(g-dark, 0)

b = max(b-dark, 0)

except:

return '#FFFFFF'

Returns:

the cloned port

"""

if not self._clones:

self._name = self._n['name'] + '0'

self._key = self._name

# Prepare a copy of the odict for the clone

n = self._n.copy()

n['name'] = self._n['name'] + str(len(self._clones) + 1)

self._clones.append(port)

return port

Remove the index 0 of the master port name (and key9 if there are no more clones left

"""

self._clones.remove(port)

if not self._clones:

self._name = self._n['name']

self._key = self._name

def get_name(self):

number = str(busses.index(self)) + '#' + str(len(self.get_associated_ports()))

return self._name + number

def get_connections(self):

"""

import string

VAR_CHARS = string.letters + string.digits + '_'

class graph(object):

"""

Simple graph structure held in a dictionary.

def __str__(self): return str(self._graph)

def add_node(self, node_key):

self._graph[node_key] = set()

def remove_node(self, node_key):

for edges in self._graph.values():

self._graph.pop(node_key)

def add_edge(self, src_node_key, dest_node_key):

def remove_edge(self, src_node_key, dest_node_key):

self._graph[src_node_key].remove(dest_node_key)

def expr_split(expr):

"""

quote = ''

for char in expr:

if quote or char in VAR_CHARS:

tok += char

elif char in ("'", '"'):

toks.append(tok)

toks.append(tok)

return filter(lambda t: t, toks)

def expr_replace(expr, replace_dict):

"""

Search for vars in the expression and add the prepend.

expr_splits[i] = replace_dict[es]

return ''.join(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

a graph of variable deps

"""

vars = exprs.keys()

var_graph = graph()

for var, expr in exprs.iteritems():

for dep in get_variable_dependencies(expr, vars):

return var_graph

def sort_variables(exprs):

"""

Get a list of variables in order of dependencies.

"""

var_graph = get_graph(exprs)

sorted_vars = list()

while var_graph.get_nodes():

indep_vars = filter(lambda var: not var_graph.get_edges(var), var_graph.get_nodes())

sorted_vars.extend(sorted(indep_vars))

return reversed(sorted_vars)

def sort_objects(objects, get_id, get_expr):

"""

Sort a list of objects according to their expressions.

a list of sorted objects

"""

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

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

sorted_ids = sort_variables(id2expr)

return [id2obj[id] for id in sorted_ids]

if __name__ == '__main__':

"""

This file is part of GNU Radio

GNU Radio Companion is free software; you can redistribute it and/or

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

def docstring_guess_from_key(key):

By guessing module and constructor names from key

Args:

else:

return doc_strings

for match in filter(pattern.match, dir(module)):

try:

doc_strings[match] = getattr(module, match).__doc__

def docstring_from_make(key, imports, make):

By importing it and checking a truncated make

Args:

blk_cls = make.partition('(')[0].strip()

if '$' in blk_cls:

raise ValueError('Not an identifier')

ns = dict()

for _import in imports:

exec(_import.strip(), ns)

blk = eval(blk_cls, ns)

doc_strings = {key: blk.__doc__}

except (ImportError, AttributeError, SyntaxError, ValueError):

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

class SubprocessLoader(object):

Manages subprocess and handles RPC.

"""

BOOTSTRAP = "import runpy; runpy.run_path({!r}, run_name='__worker__')"

AUTH_CODE = random.random() # sort out unwanted output of worker process

RESTART = 5 # number of worker restarts before giving up

self._last_cmd = None

def start(self):

if self._thread is not None:

return

self._shutdown.clear()

thread.start()

def run_worker(self):

for _ in range(self.RESTART):

if self._shutdown.is_set():

break

self.callback_finished()

def _handle_worker(self):

assert '1' == self._worker.stdout.read(1)

for cmd, args in iter(self._queue.get, self.DONE):

self._last_cmd = cmd, args

self._handle_response(cmd, args)

def _send(self, cmd, args):

fd = self._worker.stdin

json.dump((self.AUTH_CODE, cmd, args), fd)

fd.write('\n'.encode())

def _receive(self):

for line in iter(self._worker.stdout.readline, ''):

try:

key, cmd, args = json.loads(line, encoding='utf-8')

raise IOError("Can't read worker response")

def _handle_response(self, cmd, args):

if cmd == 'result':

key, docs = args

self.callback_query_result(key, docs)

print >> sys.stderr, "Unknown response:", cmd, args

def query(self, key, imports=None, make=None):

if self._thread is None:

self.start()

if imports and make:

self._queue.put(('query_key_only', (key,)))

def finish(self):

self._queue.put(self.DONE)

def wait(self):

if self._thread:

self._thread.join()

def terminate(self):

self._shutdown.set()

try:

self._worker.terminate()

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

def worker_main():

Manages RPC with main process through.

Runs a docstring extraction for each key it read on stdin.

"""

"""

This file is part of GNU Radio

GNU Radio Companion is free software; you can redistribute it and/or

from UserDict import DictMixin

class odict(DictMixin):

def __init__(self, d={}):

val: the value for the new entry

"""

index = (pos_key is None) and len(self._keys) or self._keys.index(pos_key)

self._keys.insert(index+1, key)

self._data[key] = val

val: the value for the new entry

"""

index = (pos_key is not None) and self._keys.index(pos_key) or 0

self._keys.insert(index, key)

self._data[key] = val

Returns:

the value or None

"""

return None

def findall(self, key):

a list of values or empty list

"""

obj = self.find(key)

return [obj]