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

"""

def back_ofthe_bus(self, portlist):

portlist.sort(key=lambda a: a.get_type() == 'bus');

buslist = [i for i in ports if i.get_type() == 'bus'];

if len(buslist) == 0:

return ports;

def get_enabled(self):

"""

Get the enabled state of the block.

Returns:

true for enabled

"""

def set_enabled(self, enabled):

"""

Set the enabled state of the block.

Args:

enabled: true for enabled

"""

def get_param_keys(self): return _get_keys(self._params)

def get_param(self, key): return _get_elem(self._params, key)

def get_params(self): return self._params

return False;

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

def get_source_keys(self): return _get_keys(self._sources)

def get_source(self, key): return _get_elem(self._sources, key)

def get_sources(self): return self._sources

def get_connections(self):

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

def resolve_dependencies(self, tmpl):

"""

Resolve a paramater dependency with cheetah templates.

Args:

tmpl: the string with dependencies

Returns:

the resolved value

"""

def type_controller_modify(self, direction):

"""

Change the type controller.

Args:

direction: +1 or -1

Returns:

true for change

"""

def port_controller_modify(self, direction):

"""

Change the port controller.

Args:

direction: +1 or -1

Returns:

true for change

"""

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

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

structlet = [];

last = 0;

last = structlet[-1] + 1;

struct = [structlet];

if bus_structure:

struct = bus_structure

self.current_bus_structure[direc] = struct;

for connect in elt.get_connections():

self.get_parent().remove_element(connect);

if (not 'bus' in map(lambda a: a.get_type(), get_p())) and len(get_p()) > 0:

self.current_bus_structure[direc] = struct;

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

n['nports'] = str(1);

for i in range(len(struct)):

n['key'] = str(len(get_p()));

n = odict(n);

port = self.get_parent().get_parent().Port(block=self, n=n, dir=direc);

get_p().append(port);

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

for elt in get_p_gui():

get_p().remove(elt);

def export_data(self):

"""

Export this block's params to nested data.

Returns:

a nested data odict

"""

call rewrite, and repeat the load until the params stick.

This call to rewrite will also create any dynamic ports

that are needed for the connections creation phase.

Args:

n: the nested data odict

"""

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

"""

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

def get_enabled(self):

"""

Get the enabled state of this connection.

Returns:

true if source and sink blocks are enabled

"""

def export_data(self):

"""

Export this connection's info.

Returns:

a nested data odict

"""

def is_valid(self):

"""

Is this element valid?

Returns:

true when the element is enabled and has no error messages

"""

def add_error_message(self, msg):

"""

Add an error message to the list of errors.

Args:

msg: the error message string

"""

Get the list of error messages from this element and all of its children.

Do not include the error messages from disabled children.

Cleverly indent the children error messages for printing purposes.

Returns:

a list of error message strings

"""

def __init__(self, platform):

"""

Make a flow graph from the arguments.

Args:

platform: a platforms with blocks and contrcutors

Returns:

the flow graph object

"""

def _get_unique_id(self, base_id=''):

"""

Get a unique id starting with the base id.

Args:

base_id: the id starts with this and appends a count

Returns:

a unique id

"""

def __str__(self): return 'FlowGraph - %s(%s)'%(self.get_option('title'), self.get_option('id'))

def rewrite(self):

def refactor_bus_structure():

for block in self.get_blocks():

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

if direc == 'source':

get_p = block.get_sinks;

get_p_gui = block.get_sinks_gui

bus_structure = block.form_bus_structure('sink');

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

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

times = range(len(bus_structure), len(get_p_gui()));

for i in times:

n = {'name':'bus','type':'bus'};

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

n['nports'] = str(1);

for i in times:

n['key'] = str(len(get_p()));

n = odict(n);

port = block.get_parent().get_parent().Port(block=block, n=n, dir=direc);

get_p().append(port);

for child in self.get_children(): child.rewrite()

refactor_bus_structure();

"""

Get the option for a given key.

The option comes from the special options block.

Args:

key: the param key for the options block

Returns:

the value held by that param

"""

"""

Get a list of all the elements.

Always ensure that the options block is in the list (only once).

Returns:

the element list

"""

def get_enabled_blocks(self):

"""

Get a list of all blocks that are enabled.

Returns:

a list of blocks

"""

def get_enabled_connections(self):

"""

Get a list of all connections that are enabled.

Returns:

a list of connections

"""

"""

Get a new block of the specified key.

Add the block to the list of elements.

Args:

key: the block key

Returns:

the new block or None if not found

"""

def connect(self, porta, portb):

"""

Create a connection between porta and portb.

Args:

porta: a port

portb: another port

@throw Exception bad connection

Returns:

the new connection

"""

def evaluate(self, expr):

"""

Evaluate the expression.

Args:

expr: the string expression

@throw NotImplementedError

"""

Export this flow graph to nested data.

Export all block and connection data.

Returns:

a nested data odict

"""

Import blocks and connections into this flow graph.

Clear this flowgraph of all previous blocks and connections.

Any blocks or connections in error will be ignored.

Args:

n: the nested data odict

"""

def __init__(self, block, n):

"""

Make a new param from nested data.

Args:

block: the parent element

n: the nested odict

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

Just return the value (special case enum).

Derived classes can handle complex formatting.

Returns:

the string representation

"""

def export_data(self):

"""

Export this param's key/value.

Returns:

a nested data odict

"""

def validate_dtd(xml_file, dtd_file=None):

"""

Validate an xml file against its dtd.

Args:

xml_file: the xml file

dtd_file: the optional dtd file

def from_file(xml_file):

"""

Create nested data from an xml file using the from xml helper.

Args:

xml_file: the xml file path

Returns:

the nested data

"""

def _from_file(xml):

"""

Recursivly parse the xml tree into nested data format.

Args:

xml: the xml tree

Returns:

the nested data

"""

def to_file(nested_data, xml_file):

"""

Write an xml file and use the to xml helper method to load it.

Args:

nested_data: the nested data

xml_file: the xml file path

def _to_file(nested_data):

"""

Recursivly parse the nested data into xml tree format.

Args:

nested_data: the nested data

Returns:

the xml tree filled with child nodes

"""

license='', website=None, colors=None):

"""

Make a platform from the arguments.

Args:

name: the platform name

version: the version string

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

"""

"""

Parse a saved flow graph file.

Ensure that the file exists, and passes the dtd check.

Args:

flow_graph_file: the flow graph file

Returns:

nested data

@throws exception if the validation fails

Load a block tree with categories and blocks.

Step 1: Load all blocks from the xml specification.

Step 2: Load blocks with builtin category specifications.

Args:

block_tree: the block tree object

"""

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

"""

Make a new port from nested data.

Args:

block: the parent element

n: the nested odict

number = ''

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

busses = filter(lambda a: a._dir == self._dir, self.get_parent().get_ports_gui());

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

return self._name + number

def get_connections(self):

"""

Get all connections that use this port.

Returns:

a list of connection objects

"""

def get_enabled_connections(self):

"""

Get all enabled connections that use this port.

Returns:

a list of connection objects

"""

get_p = self.get_parent().get_sinks;

bus_structure = self.get_parent().current_bus_structure['sink'];

direc = 'sink'

ports = [i for i in get_p() if not i.get_type() == 'bus'];

if bus_structure:

busses = [i for i in get_p() if i.get_type() == 'bus'];

"""

Insert the new key, value entry after the entry given by the position key.

If the positional key is None, insert at the end.

Args:

pos_key: the positional key

key: the key for the new entry

"""

Insert the new key, value entry before the entry given by the position key.

If the positional key is None, insert at the begining.

Args:

pos_key: the positional key

key: the key for the new entry

def find(self, key):

"""

Get the value for this key if exists.

Args:

key: the key to search for

Returns:

the value or None

"""

def findall(self, key):

"""

Get a list of values for this key.

Args:

key: the key to search for

Returns:

a list of values or empty list

"""

<name>Bus Sink</name>

<key>bus_sink</key>

<make>$yesno.yesno</make>

<param>

<name>On/Off</name>

<key>yesno</key>

<type>enum</type>

<option>

<key>on</key>

<opt>yesno:True</opt>

</option>

<key>off</key>

<opt>yesno:False</opt>

</option>

</block>

<name>Bus Source</name>

<key>bus_source</key>

<make>$yesno.yesno</make>

<param>

<name>On/Off</name>

<key>yesno</key>

<type>enum</type>

<option>

<key>on</key>

<opt>yesno:True</opt>

</option>

<key>off</key>

<opt>yesno:False</opt>

</option>

</block>

<name>Bus Sink Structure</name>

<key>bus_structure_sink</key>

<make>None</make>

<param>

<name>Structure</name>

<key>struct</key>

<value></value>

<type>raw</type>

</block>

<name>Bus Source Structure</name>

<key>bus_structure_source</key>

<make>None</make>

<param>

<name>Structure</name>

<key>struct</key>

<value></value>

<type>raw</type>

</block>

<value>1</value>

<type>int</type>

</param>

<param>

<name>Num Streams</name>

<key>num_streams</key>

def __init__(self, type='BER', win_size=default_win_size, bits_per_symbol=2):

"""

Error rate constructor.

Args:

type: a string 'BER' or 'SER'

win_size: the number of samples to calculate over

def __init__(self, samples_per_symbol, bits_per_symbol, preamble='', access_code='', pad_for_usrp=True):

"""

packet_mod constructor.

Args:

samples_per_symbol: number of samples per symbol

bits_per_symbol: number of bits per symbol

def send_pkt(self, payload):

"""

Wrap the payload in a packet and push onto the message queue.

Args:

payload: string, data to send

"""

def __init__(self, access_code='', threshold=-1, callback=None):

"""

packet_demod constructor.

Args:

access_code: AKA sync vector

threshold: detect access_code with up to threshold bits wrong (0 -> use default)

def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index):

"""

Selector constructor.

Args:

item_size: the size of the gr data stream in bytes

num_inputs: the number of inputs (integer)

def _indexes_valid(self):

"""

Are the input and output indexes within range of the number of inputs and outputs?

Returns:

true if input index and output index are in range

"""

def set_input_index(self, input_index):

"""

Change the block to the new input index if the index changed.

Args:

input_index: the new input index

"""

def set_output_index(self, output_index):

"""

Change the block to the new output index if the index changed.

Args:

output_index: the new output index

"""

def __init__(self, item_size, open):

"""

Constructor for valve.

Args:

item_size: the size of the gr data stream in bytes

open: true if initial valve state is open

def set_open(self, open):

"""

Callback to set open state.

Args:

open: true to set valve state to open

"""

Get the file descriptor for the socket.

As a client, block on connect, dup the socket descriptor.

As a server, block on accept, dup the client descriptor.

Args:

addr: the ip address string

port: the tcp port number

server: true for server mode, false for client mode

Returns:

the file descriptor number

"""

ActionHandler constructor.

Create the main window, setup the message handler, import the preferences,

and connect all of the action handlers. Finally, enter the gtk main loop and block.

Args:

file_paths: a list of flow graph file passed from command line

platform: platform module

* some keys are ignored by the accelerators like the direction keys,

* some keys are not registered to any accelerators but are still used.

When not in focus, gtk and the accelerators handle the the key press.

Returns:

false to let gtk handle the key action

"""

Handle the delete event from the main window.

Generated by pressing X to close, alt+f4, or right click+close.

This method in turns calls the state handler to quit.

Returns:

true

"""

self.get_page().get_state_cache().save_new_state(self.get_flow_graph().export_data())

self.get_page().set_saved(False)

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

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

elif action == Actions.BLOCK_CREATE_HIER:

# keeping track of coordinates for pasting later

coords = self.get_flow_graph().get_selected_blocks()[0].get_coordinate()

x,y = coords

y_min = y

pads = [];

# If a block parameter exists that is a parameter, create a parameter for it

if param.get_value() == flow_param.get_id():

params.append(param.get_value())

(x,y) = block.get_coordinate()

if x < x_min:

x_min = x

# Get id of connected blocks

source_id = connection.get_source().get_parent().get_id()

sink_id = connection.get_sink().get_parent().get_id()

if self.get_flow_graph().get_block(source_id) not in self.get_flow_graph().get_selected_blocks():

pads.append({'key': connection.get_sink().get_key(), 'coord': connection.get_source().get_coordinate(), 'block_id' : block.get_id(), 'direction': 'source'})

# Remove the default samp_rate variable block that is created

remove_me = self.get_flow_graph().get_block("samp_rate")

# Add the param blocks along the top of the window

# Connect the pad to the proper sinks

new_connection = self.get_flow_graph().connect(pad_source,sink)

self.get_flow_graph().update()

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

# Move/Rotate/Delete/Create

self.get_flow_graph()._old_selected_port = None

self.get_flow_graph()._new_selected_port = None

Actions.ELEMENT_CREATE()

elif action == Actions.BUSSIFY_SINKS:

n = {'name':'bus', 'type':'bus'}

for b in self.get_flow_graph().get_selected_blocks():

def __init__ (self, action_handler):

"""

ExecFlowGraphThread constructor.

Args:

action_handler: an instance of an ActionHandler

"""

"""

Call the action associated with the key press event.

Both the key value and the mask must have a match.

Args:

event: a gtk key press event

Returns:

true if handled

"""

def get_coordinate(self):

"""

Get the coordinate from the position param.

Returns:

the coordinate tuple (x, y) or (0, 0) if failure

"""

def set_coordinate(self, coor):

"""

Set the coordinate into the position param.

Args:

coor: the coordinate tuple (x, y)

"""

def get_rotation(self):

"""

Get the rotation from the position param.

Returns:

the rotation in degrees or 0 if failure

"""

def set_rotation(self, rot):

"""

Set the rotation into the position param.

Args:

rot: the rotation in degrees

"""

self.H = max(*(

[self.label_height+2*BLOCK_LABEL_PADDING] + [2*PORT_BORDER_SEPARATION + \

sum([port.H + PORT_SEPARATION for port in ports]) - PORT_SEPARATION

[4*PORT_BORDER_SEPARATION + \

sum([(port.H) + PORT_SEPARATION for port in ports]) - PORT_SEPARATION

for ports in ([i for i in self.get_sources_gui() if i.get_type() == 'bus'], [i for i in self.get_sinks_gui() if i.get_type() == 'bus'])]

def draw(self, gc, window):

"""

Draw the signal block with label and inputs/outputs.

Args:

gc: the graphics context

window: the gtk window to draw on

def what_is_selected(self, coor, coor_m=None):

"""

Get the element that is selected.

Args:

coor: the (x,y) tuple

coor_m: the (x_m, y_m) tuple

Returns:

this block, a port, or None

"""

"""

Get the 0,0 coordinate.

Coordinates are irrelevant in connection.

Returns:

0, 0

"""

"""

Get the 0 degree rotation.

Rotations are irrelevant in connection.

Returns:

0

"""

def draw(self, gc, window):

"""

Draw the connection.

Args:

gc: the graphics context

window: the gtk window to draw on

def __init__(self, text=''):

"""

TextDisplay constructor.

Args:

text: the text to display (string)

"""

def MessageDialogHelper(type, buttons, title=None, markup=None):

"""

Create a modal message dialog and run it.

Args:

type: the type of message: gtk.MESSAGE_INFO, gtk.MESSAGE_WARNING, gtk.MESSAGE_QUESTION or gtk.MESSAGE_ERROR

buttons: the predefined set of buttons to use:

gtk.BUTTONS_NONE, gtk.BUTTONS_OK, gtk.BUTTONS_CLOSE, gtk.BUTTONS_CANCEL, gtk.BUTTONS_YES_NO, gtk.BUTTONS_OK_CANCEL

Args:

tittle: the title of the window (string)

markup: the message text with pango markup

Returns:

the gtk response from run()

"""

"""

DrawingArea contructor.

Connect event handlers.

Args:

main_window: the main_window containing all flow graphs

"""

"""

Is this element horizontal?

If rotation is None, use this element's rotation.

Args:

rotation: the optional rotation

Returns:

true if rotation is horizontal

"""

"""

Is this element vertical?

If rotation is None, use this element's rotation.

Args:

rotation: the optional rotation

Returns:

true if rotation is vertical

"""

def draw(self, gc, window, border_color, bg_color):

"""

Draw in the given window.

Args:

gc: the graphics context

window: the gtk window to draw on

def rotate(self, rotation):

"""

Rotate all of the areas by 90 degrees.

Args:

rotation: multiple of 90 degrees

"""

def set_coordinate(self, coor):

"""

Set the reference coordinate.

Args:

coor: the coordinate tuple (x,y)

"""

def get_parent(self):

"""

Get the parent of this element.

Returns:

the parent

"""

def set_highlighted(self, highlighted):

"""

Set the highlight status.

Args:

highlighted: true to enable highlighting

"""

def is_highlighted(self):

"""

Get the highlight status.

Returns:

true if highlighted

"""

def get_coordinate(self):

"""Get the coordinate.

Returns:

the coordinate tuple (x,y)

"""

def move(self, delta_coor):

"""

Move the element by adding the delta_coor to the current coordinate.

Args:

delta_coor: (delta_x,delta_y) tuple

"""

A positive width is to the right of the coordinate.

A positive height is above the coordinate.

The area is associated with a rotation.

Args:

rel_coor: (x,y) offset from this element's coordinate

area: (width,height) tuple

A line is defined by 2 relative coordinates.

Lines must be horizontal or vertical.

The line is associated with a rotation.

Args:

rel_coor1: relative (x1,y1) tuple

rel_coor2: relative (x2,y2) tuple

Both coordinates specified:

Is this element within the rectangular region defined by both coordinates?

ie: do any area corners or line endpoints fall within the region?

Args:

coor: the selection coordinate, tuple x, y

coor_m: an additional selection coordinate.

Returns:

self if one of the areas/lines encompasses coor, else None.

"""

def get_rotation(self):

"""

Get the rotation in degrees.

Returns:

the rotation

"""

def set_rotation(self, rotation):

"""

Set the rotation in degrees.

Args:

rotation: the rotation"""

if rotation not in POSSIBLE_ROTATIONS:

FileDialogHelper contructor.

Create a save or open dialog with cancel and ok buttons.

Use standard settings: no multiple selection, local files only, and the * filter.

Args:

action: gtk.FILE_CHOOSER_ACTION_OPEN or gtk.FILE_CHOOSER_ACTION_SAVE

title: the title of the dialog (string)

def __init__(self, current_file_path=''):

"""

FileDialog constructor.

Args:

current_file_path: the current directory or path to the open flow graph

"""

def add_and_set_filter(self, filter):

"""

Add the gtk file filter to the list of filters and set it as the default file filter.

Args:

filter: a gtk file filter.

"""

If this is a save dialog and the file name is missing the extension, append the file extension.

If the file name with the extension already exists, show a overwrite dialog.

If this is an open dialog, return a list of filenames.

Returns:

the complete file path

"""

def run(self):

"""

Get the filename and destroy the dialog.

Returns:

the filename or None if a close/cancel occured.

"""

def add_new_block(self, key, coor=None):

"""

Add a block of the given key to this flow graph.

Args:

key: the block key

coor: an optional coordinate or None for random

def copy_to_clipboard(self):

"""

Copy the selected blocks and connections into the clipboard.

Returns:

the clipboard

"""

def paste_from_clipboard(self, clipboard):

"""

Paste the blocks and connections from the clipboard.

Args:

clipboard: the nested data of blocks, connections

"""

def type_controller_modify_selected(self, direction):

"""

Change the registered type controller for the selected signal blocks.

Args:

direction: +1 or -1

Returns:

true for change

"""

def port_controller_modify_selected(self, direction):

"""

Change port controller for the selected signal blocks.

Args:

direction: +1 or -1

Returns:

true for changed

"""

def enable_selected(self, enable):

"""

Enable/disable the selected blocks.

Args:

enable: true to enable

Returns:

true if changed

"""

def move_selected(self, delta_coordinate):

"""

Move the element and by the change in coordinates.

Args:

delta_coordinate: the change in coordinates

"""

def rotate_selected(self, rotation):

"""

Rotate the selected blocks by multiples of 90 degrees.

Args:

rotation: the rotation in degrees

Returns:

true if changed, otherwise false.

"""

def remove_selected(self):

"""

Remove selected elements

Returns:

true if changed.

"""

Iterate though the elements backwards since top elements are at the end of the list.

If an element is selected, place it at the end of the list so that is is drawn last,

and hence on top. Update the selected port information.

Args:

coor: the coordinate of the mouse click

coor_m: the coordinate for multi select

Returns:

the selected blocks and connections or an empty list

"""

def get_selected_connections(self):

"""

Get a group of selected connections.

Returns:

sub set of connections in this flow graph

"""

def get_selected_blocks(self):

"""

Get a group of selected blocks.

Returns:

sub set of blocks in this flow graph

"""

def get_selected_block(self):

"""

Get the selected block when a block or port is selected.

Returns:

a block or None

"""

def get_selected_elements(self):

"""

Get the group of selected elements.

Returns:

sub set of elements in this flow graph

"""

def get_selected_element(self):

"""

Get the selected element.

Returns:

a block, port, or connection or None

"""

Handle the delete event from the main window.

Generated by pressing X to close, alt+f4, or right click+close.

This method in turns calls the state handler to quit.

Returns:

true

"""

Handle a page change. When the user clicks on a new tab,

reload the flow graph to update the vars window and

call handle states (select nothing) to update the buttons.

Args:

notebook: the notebook

page: new page

def add_report_line(self, line):

"""

Place line at the end of the text buffer, then scroll its window all the way down.

Args:

line: the new text

"""

"""

Create a new notebook page.

Set the tab to be selected.

Args:

file_path: optional file to load into the flow graph

show: true if the page should be shown after loading

def close_pages(self):

"""

Close all the pages in this notebook.

Returns:

true if all closed

"""

Close the current page.

If the notebook becomes empty, and ensure is true,

call new page upon exit to ensure that at least one page exists.

Args:

ensure: boolean

"""

Set the title of the main window.

Set the titles on the page tabs.

Show/hide the reports window.

Args:

title: the window title

"""

def get_page(self):

"""

Get the selected page.

Returns:

the selected page

"""

def get_flow_graph(self):

"""

Get the selected flow graph.

Returns:

the selected flow graph

"""

def _set_page(self, page):

"""

Set the current page.

Args:

page: the page widget

"""

def _save_changes(self):

"""

Save changes to flow graph?

Returns:

true if yes

"""

def _get_files(self):

"""

Get the file names for all the pages, in order.

Returns:

list of file paths

"""

def _get_pages(self):

"""

Get a list of all pages in the notebook.

Returns:

list of pages

"""

def register_messenger(messenger):

"""

Append the given messenger to the list of messengers.

Args:

messenger: a method thats takes a string

"""

def send(message):

"""

Give the message to each of the messengers.

Args:

message: a message string

"""

def __init__(self, main_window, flow_graph, file_path=''):

"""

Page constructor.

Args:

main_window: main window

file_path: path to a flow graph file

def get_generator(self):

"""

Get the generator object for this flow graph.

Returns:

generator

"""

"""

The button was clicked.

Make the current page selected, then close.

Args:

the: button

"""

def set_markup(self, markup):

"""

Set the markup in this label.

Args:

markup: the new markup text

"""

def get_tab(self):

"""

Get the gtk widget for this page's tab.

Returns:

gtk widget

"""

def get_proc(self):

"""

Get the subprocess for the flow graph.

Returns:

the subprocess object

"""

def set_proc(self, process):

"""

Set the subprocess object.

Args:

process: the new subprocess

"""

def get_flow_graph(self):

"""

Get the flow graph.

Returns:

the flow graph

"""

"""

Get the read-only state of the file.

Always false for empty path.

Returns:

true for read-only

"""

def get_file_path(self):

"""

Get the file path for the flow graph.

Returns:

the file path or ''

"""

def set_file_path(self, file_path=''):

"""

Set the file path, '' for no file path.

Args:

file_path: file path string

"""

def get_saved(self):

"""

Get the saved status for the flow graph.

Returns:

true if saved

"""

def set_saved(self, saved=True):

"""

Set the saved status.

Args:

saved: boolean status

"""

def get_state_cache(self):

"""

Get the state cache for the flow graph.

Returns:

the state cache

"""

An enum requires and combo parameter.

A non-enum with options gets a combined entry/combo parameter.

All others get a standard entry parameter.

Returns:

gtk input class

"""

def get_markup(self):

"""

Get the markup for this param.

Returns:

a pango markup string

"""

self._connector_length = CONNECTOR_EXTENSION_MINIMAL + CONNECTOR_EXTENSION_INCREMENT*index

def modify_height(self, start_height):

type_dict = {'bus':(lambda a: a * 3)};

if self.get_type() in type_dict:

return type_dict[self.get_type()](start_height);

else:

def draw(self, gc, window):

"""

Draw the socket with a label.

Args:

gc: the graphics context

window: the gtk window to draw on

def get_connector_coordinate(self):

"""

Get the coordinate where connections may attach to.

Returns:

the connector coordinate (x, y) tuple

"""

Get the direction that the socket points: 0,90,180,270.

This is the rotation degree if the socket is an output or

the rotation degree + 180 if the socket is an input.

Returns:

the direction in degrees

"""

"""

Get the length of the connector.

The connector length increases as the port index changes.

Returns:

the length in pixels

"""

def get_rotation(self):

"""

Get the parent's rotation rather than self.

Returns:

the parent's rotation

"""

def move(self, delta_coor):

"""

Move the parent rather than self.

Args:

delta_corr: the (delta_x, delta_y) tuple

"""

def rotate(self, direction):

"""

Rotate the parent rather than self.

Args:

direction: degrees to rotate

"""

def get_coordinate(self):

"""

Get the parent's coordinate rather than self.

Returns:

the parents coordinate

"""

def set_highlighted(self, highlight):

"""

Set the parent highlight rather than self.

Args:

highlight: true to enable highlighting

"""

def is_highlighted(self):

"""

Get the parent's is highlight rather than self.

Returns:

the parent's highlighting status

"""

"""

Get a title label for the params window.

The title will be bold, underlined, and left justified.

Args:

title: the text of the title

Returns:

a gtk object

"""

def __init__(self, block):

"""

Properties dialog constructor.

Args:

block: a block instance

"""

To the props dialog, the hide setting of 'none' and 'part' are identical.

Therefore, the props dialog only cares if the hide setting is/not 'all'.

Make a hash that uniquely represents the params' state.

Returns:

true if changed

"""

"""

Handle key presses from the keyboard.

Call the ok response when enter is pressed.

Returns:

false to forward the keypress

"""

def run(self):

"""

Run the dialog and get its response.

Returns:

true if the response was accept

"""

def __init__(self, initial_state):

"""

StateCache constructor.

Args:

initial_state: the intial state (nested data)

"""

"""

Save a new state.

Place the new state at the next index and add one to the number of previous states.

Args:

state: the new state

"""

def get_current_state(self):

"""

Get the state at the current index.

Returns:

the current state (nested data)

"""

def get_prev_state(self):

"""

Get the previous state and decrement the current index.

Returns:

the previous state or None

"""

def get_next_state(self):

"""

Get the nest state and increment the current index.

Returns:

the next state or None

"""

Load the destination pixmap with a rotated version of the source pixmap.

The source pixmap will be loaded into a pixbuf, rotated, and drawn to the destination pixmap.

The pixbuf is a client-side drawable, where a pixmap is a server-side drawable.

Args:

gc: the graphics context

src_pixmap: the source pixmap

def get_rotated_coordinate(coor, rotation):

"""

Rotate the coordinate by the given rotation.

Args:

coor: the coordinate x, y tuple

rotation: the angle in degrees

Returns:

the rotated coordinates

"""

def get_angle_from_coordinates((x1,y1), (x2,y2)):

"""

Given two points, calculate the vector direction from point1 to point2, directions are multiples of 90 degrees.

Args:

(x1,y1): the coordinate of point 1

(x2,y2): the coordinate of point 2

Returns:

the direction in degrees

"""

"""

Parse the template string with the given args.

Pass in the xml encode method for pango escape chars.

Args:

tmpl_str: the template as a string

Returns:

a string of the parsed template

"""

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

"""

bus_structure = self._bus_structure_source;

else:

bus_structure = self._bus_structure_sink;

bus_structure = self.resolve_dependencies(bus_structure);

if not bus_structure: return ''

try:

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

return clean_bus_structure

except: return ''

def throttle(self): return bool(self._throttle)

def port_controller_modify(self, direction):

"""

Change the port controller.

Args:

direction: +1 or -1

Returns:

true for change

"""

Split each import statement at newlines.

Combine all import statments into a list.

Filter empty imports.

Returns:

a list of import statements

"""

def get_callbacks(self):

"""

Get a list of function callbacks for this block.

Returns:

a list of strings

"""

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

"""

Evaluate the code with the given namespace.

Args:

code: a string with python code

namespace: a dict representing the namespace

namespace_hash: a unique hash for the namespace

Returns:

the resultant object

"""

def get_io_signaturev(self, direction):

"""

Get a list of io signatures for this flow graph.

Args:

direction: a string of 'in' or 'out'

Returns:

a list of dicts with: type, label, vlen, size

"""

def get_pad_sources(self):

"""

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

Returns:

a list of pad source blocks in this flow graph

"""

def get_pad_sinks(self):

"""

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

Returns:

a list of pad sink blocks in this flow graph

"""

def get_imports(self):

"""

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

Returns:

a set of import statements

"""

"""

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

Exclude paramterized variables.

Returns:

a sorted list of variable blocks in order of dependency (indep -> dep)

"""

def get_parameters(self):

"""

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

Returns:

a list of paramterized variables

"""

def get_bussink(self):

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

for i in bussink:

for j in i.get_params():

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

return True;

return False

def get_bussrc(self):

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

for j in i.get_params():

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

return True;

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 rewrite(self):

"""

"""

def reconnect_bus_blocks():

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

sink.append(source.get_connections()[j].get_sink());

for elt in source.get_connections():

self.remove_element(elt);

for j in sink:

def evaluate(self, expr):

"""

Evaluate the expression.

Args:

expr: the string expression

@throw Exception bad expression

Returns:

the evaluated data

"""

"""

Initialize the generator object.

Determine the file to generate.

Args:

flow_graph: the flow graph object

file_path: the path to write the file to

def get_popen(self):

"""

Execute this python flow graph.

Returns:

a popen object

"""

def __str__(self):

"""

Convert the flow graph to python code.

Returns:

a string of python code

"""

def __repr__(self):

"""

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

Returns:

the string representation

"""

def get_color(self):

"""

Get the color that represents this param's type.

Returns:

a hex color code.

"""

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.

Returns:

hide the hide property string

"""

def evaluate(self):

"""

Evaluate the value.

Returns:

evaluated type

"""

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.

Returns:

a string representing the code

"""

def get_all_params(self, type):

"""

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

Args:

type: the specified type

Returns:

a list of params

"""

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

"""

Make a new port from nested data.

Args:

block: the parent element

n: the nested odict

"""

Get the vector length.

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

Returns:

the vector length or 1

"""

Get the number of ports.

If already blank, return a blank

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

Returns:

the number of ports or 1

"""

"""

Get the color that represents this port's type.

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

Returns:

a hex color code.

"""

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

Leave strings in-tact.

#TODO ignore escaped quotes, use raw strings.

Args:

expr: an expression string

Returns:

a list of string tokens that form expr

"""

def expr_replace(expr, replace_dict):

"""

Search for vars in the expression and add the prepend.

Args:

expr: an expression string

replace_dict: a dict of find:replace

Returns:

a new expression with the prepend

"""

def get_variable_dependencies(expr, vars):

"""

Return a set of variables used in this expression.

Args:

expr: an expression string

vars: a list of variable names

Returns:

a subset of vars used in the expression

"""

def get_graph(exprs):

"""

Get a graph representing the variable dependencies

Args:

exprs: a mapping of variable name to expression

Returns:

a graph of variable deps

"""

def sort_variables(exprs):

"""

Get a list of variables in order of dependencies.

Args:

exprs: a mapping of variable name to expression

Returns:

a list of variable names

@throws Exception circular dependencies

def sort_objects(objects, get_id, get_expr):

"""

Sort a list of objects according to their expressions.

Args:

objects: the list of objects to sort

get_id: the function to extract an id from the object

get_expr: the function to extract an expression from the object

Returns:

a list of sorted objects

"""

"""

Extract the documentation from the python __doc__ strings.

If multiple modules match, combine the docs.

Args:

key: the block key

Returns:

a string with documentation

"""

def extract(key):

"""

Call the private extract and cache the result.

Args:

key: the block key

Returns:

a string with documentation

"""