def __init__(self, flow_graph, n):

"""

Make a new block from nested data.

"""

#build the block

Element.__init__(self, flow_graph)

def get_enabled(self):

"""

Get the enabled state of the block.

"""

try: return eval(self.get_param('_enabled').get_value())

except: return True

def set_enabled(self, enabled):

"""

Set the enabled state of the block.

"""

self.get_param('_enabled').set_value(str(enabled))

def resolve_dependencies(self, tmpl):

"""

Resolve a paramater dependency with cheetah templates.

"""

tmpl = str(tmpl)

if '$' not in tmpl: return tmpl

def type_controller_modify(self, direction):

"""

Change the type controller.

"""

changed = False

type_param = None

def port_controller_modify(self, direction):

"""

Change the port controller.

"""

return False

def export_data(self):

"""

Export this block's params to nested data.

"""

n = odict()

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

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.

"""

get_hash = lambda: hash(tuple(map(hash, self.get_params())))

my_hash = 0

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

"""

Make a new connection given the parent and 2 ports.

@throws Error cannot make connection

"""

Element.__init__(self, flow_graph)

source = sink = None

def get_enabled(self):

"""

Get the enabled state of this connection.

"""

return self.get_source().get_parent().get_enabled() and \

self.get_sink().get_parent().get_enabled()

def export_data(self):

"""

Export this connection's info.

"""

n = odict()

n['source_block_id'] = self.get_source().get_parent().get_id()

def is_valid(self):

"""

Is this element valid?

"""

return not self.get_error_messages() or not self.get_enabled()

def add_error_message(self, msg):

"""

Add an error message to the list of errors.

"""

self._error_messages.append(msg)

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.

"""

error_messages = list(self._error_messages) #make a copy

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

def __init__(self, platform):

"""

Make a flow graph from the arguments.

"""

#initialize

Element.__init__(self, platform)

def _get_unique_id(self, base_id=''):

"""

Get a unique id starting with the base id.

"""

index = 0

while True:

"""

Get the option for a given key.

The option comes from the special options block.

"""

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

"""

Get a list of all the elements.

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

"""

options_block_count = self._elements.count(self._options_block)

if not options_block_count:

def get_enabled_blocks(self):

"""

Get a list of all blocks that are enabled.

"""

return filter(lambda b: b.get_enabled(), self.get_blocks())

def get_enabled_connections(self):

"""

Get a list of all connections that are enabled.

"""

return filter(lambda c: c.get_enabled(), self.get_connections())

"""

Get a new block of the specified key.

Add the block to the list of elements.

"""

if key not in self.get_parent().get_block_keys(): return None

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

def connect(self, porta, portb):

"""

Create a connection between porta and portb.

@throw Exception bad connection

"""

connection = self.get_parent().Connection(flow_graph=self, porta=porta, portb=portb)

self.get_elements().append(connection)

def evaluate(self, expr):

"""

Evaluate the expression.

@throw NotImplementedError

"""

raise NotImplementedError

"""

Export this flow graph to nested data.

Export all block and connection data.

"""

import time

n = 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.

"""

#remove previous elements

self._elements = list()

def __init__(self, block, n):

"""

Make a new param from nested data.

"""

#grab the data

self._name = n.find('name')

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

Just return the value (special case enum).

Derived classes can handle complex formatting.

"""

if self.is_enum(): return self.get_option(self.get_value()).get_name()

return self.get_value()

def export_data(self):

"""

Export this param's key/value.

"""

n = odict()

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

def validate_dtd(xml_file, dtd_file=None):

"""

Validate an xml file against its dtd.

@throws Exception validation fails

"""

#perform parsing, use dtd validation if dtd file is not specified

def from_file(xml_file):

"""

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

"""

xml = etree.parse(xml_file).getroot()

return _from_file(xml)

def _from_file(xml):

"""

Recursivly parse the xml tree into nested data format.

"""

tag = xml.tag

if not len(xml):

def to_file(nested_data, xml_file):

"""

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

"""

xml = _to_file(nested_data)[0]

open(xml_file, 'w').write(etree.tostring(xml, xml_declaration=True, pretty_print=True))

def _to_file(nested_data):

"""

Recursivly parse the nested data into xml tree format.

"""

nodes = list()

for key, values in nested_data.iteritems():

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

"""

Make a platform from the arguments.

"""

_Element.__init__(self)

self._name = name

"""

Parse a saved flow graph file.

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

@throws exception if the validation fails

"""

flow_graph_file = flow_graph_file or self._default_flow_graph

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.

"""

#recursive function to load categories and blocks

def load_category(cat_n, parent=[]):

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

"""

Make a new port from nested data.

"""

#build the port

Element.__init__(self, block)

def get_connections(self):

"""

Get all connections that use this port.

"""

connections = self.get_parent().get_parent().get_connections()

connections = filter(lambda c: c.get_source() is self or c.get_sink() is self, connections)

def get_enabled_connections(self):

"""

Get all enabled connections that use this port.

"""

return filter(lambda c: c.get_enabled(), self.get_connections())

"""

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

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

"""

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

if key in self._keys: raise KeyError('Cannot insert, key "%s" already exists'%str(key))

"""

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

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

"""

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

if key in self._keys: raise KeyError('Cannot insert, key "%s" already exists'%str(key))

def find(self, key):

"""

Get the value for this key if exists.

"""

if self.has_key(key): return self[key]

return None

def findall(self, key):

"""

Get a list of values for this key.

"""

obj = self.find(key)

if obj is None: obj = list()

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

"""

Error rate constructor.

"""

#init

gr.hier_block2.__init__(

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

"""

packet_mod constructor.

"""

#setup parameters

self._samples_per_symbol = samples_per_symbol

def send_pkt(self, payload):

"""

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

"""

packet = packet_utils.make_packet(

payload,

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

"""

packet_demod constructor.

"""

#access code

if not access_code: #get access code

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

"""

Selector constructor.

"""

gr.hier_block2.__init__(

self, 'selector',

def _indexes_valid(self):

"""

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

"""

return self.input_index in range(self.num_inputs) and self.output_index in range(self.num_outputs)

def set_input_index(self, input_index):

"""

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

"""

if self.input_index != input_index:

self.lock()

def set_output_index(self, output_index):

"""

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

"""

if self.output_index != output_index:

self.lock()

def __init__(self, item_size, open):

"""

Constructor for valve.

"""

if open: output_index = -1

else: output_index = 0

def set_open(self, open):

"""

Callback to set open state.

"""

if open: output_index = -1

else: output_index = 0

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.

"""

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

if server:

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.

"""

self.clipboard = None

for action in Actions.get_all_actions(): action.connect('activate', self._handle_action)

* 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.

"""

if not self.get_focus_flag(): return False

return Actions.handle_key_press(event)

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.

"""

Actions.APPLICATION_QUIT()

return True

def __init__ (self, action_handler):

"""

ExecFlowGraphThread constructor.

"""

Thread.__init__(self)

self.update_exec_stop = action_handler.update_exec_stop

"""

Call the action associated with the key press event.

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

"""

_used_mods_mask = reduce(lambda x, y: x | y, [mod_mask for keyval, mod_mask in _actions_keypress_dict], NO_MODS_MASK)

#extract the key value and the consumed modifiers

def __init__(self, keypresses=(), name=None, label=None, tooltip=None, stock_id=None):

"""

Create a new Action instance.

"""

if name is None: name = label

gtk.Action.__init__(self,

def get_coordinate(self):

"""

Get the coordinate from the position param.

"""

try: #should evaluate to tuple

coor = eval(self.get_param('_coordinate').get_value())

def set_coordinate(self, coor):

"""

Set the coordinate into the position param.

"""

self.get_param('_coordinate').set_value(str(coor))

def get_rotation(self):

"""

Get the rotation from the position param.

"""

try: #should evaluate to dict

rotation = eval(self.get_param('_rotation').get_value())

def set_rotation(self, rot):

"""

Set the rotation into the position param.

"""

self.get_param('_rotation').set_value(str(rot))

def draw(self, gc, window):

"""

Draw the signal block with label and inputs/outputs.

"""

x, y = self.get_coordinate()

#draw main block

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

"""

Get the element that is selected.

"""

for port in self.get_ports():

port_selected = port.what_is_selected(coor, coor_m)

Create a tree view of the possible blocks in the platform.

The tree view nodes will be category names, the leaves will be block names.

A mouse double click or button press action will trigger the add block event.

"""

gtk.VBox.__init__(self)

self.platform = platform

"""

Add a block with category to this selection window.

Add only the category when block is None.

"""

if isinstance(category, str): category = category.split('/')

category = tuple(filter(lambda x: x, category)) #tuple is hashable

def _get_selected_block_key(self):

"""

Get the currently selected block key.

"""

selection = self.treeview.get_selection()

treestore, iter = selection.get_selected()

"""

Get the 0,0 coordinate.

Coordinates are irrelevant in connection.

"""

return (0, 0)

"""

Get the 0 degree rotation.

Rotations are irrelevant in connection.

"""

return 0

def draw(self, gc, window):

"""

Draw the connection.

"""

sink = self.get_sink()

source = self.get_source()

def __init__(self, text=''):

"""

TextDisplay constructor.

"""

text_buffer = gtk.TextBuffer()

text_buffer.set_text(text)

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

"""

Create a modal message dialog and run it.

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

"""

message_dialog = gtk.MessageDialog(None, gtk.DIALOG_MODAL, type, buttons)

if title: message_dialog.set_title(title)

"""

DrawingArea contructor.

Connect event handlers.

"""

self.ctrl_mask = False

self._flow_graph = flow_graph

"""

Is this element horizontal?

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

"""

rotation = rotation or self.get_rotation()

return rotation in (0, 180)

"""

Is this element vertical?

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

"""

rotation = rotation or self.get_rotation()

return rotation in (90, 270)

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

"""

Draw in the given window.

"""

X,Y = self.get_coordinate()

for (rX,rY),(W,H) in self._areas_list:

def rotate(self, rotation):

"""

Rotate all of the areas by 90 degrees.

"""

self.set_rotation((self.get_rotation() + rotation)%360)

def set_coordinate(self, coor):

"""

Set the reference coordinate.

"""

self.coor = coor

def get_parent(self):

"""

Get the parent of this element.

"""

return self.parent

def set_highlighted(self, highlighted):

"""

Set the highlight status.

"""

self.highlighted = highlighted

def is_highlighted(self):

"""

Get the highlight status.

"""

return self.highlighted

def get_coordinate(self):

"""Get the coordinate.

"""

return self.coor

def move(self, delta_coor):

"""

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

"""

deltaX, deltaY = delta_coor

X, Y = self.get_coordinate()

A positive width is to the right of the coordinate.

A positive height is above the coordinate.

The area is associated with a rotation.

"""

self._areas_list.append((rel_coor, area))

A line is defined by 2 relative coordinates.

Lines must be horizontal or vertical.

The line is associated with a rotation.

"""

self._lines_list.append((rel_coor1, rel_coor2))

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?

"""

#function to test if p is between a and b (inclusive)

in_between = lambda p, a, b: p >= min(a, b) and p <= max(a, b)

def get_rotation(self):

"""

Get the rotation in degrees.

"""

return self.rotation

def set_rotation(self, rotation):

"""

Set the rotation in degrees.

if rotation not in POSSIBLE_ROTATIONS:

raise Exception('"%s" is not one of the possible rotations: (%s)'%(rotation, POSSIBLE_ROTATIONS))

self.rotation = rotation

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.

"""

ok_stock = {gtk.FILE_CHOOSER_ACTION_OPEN : 'gtk-open', gtk.FILE_CHOOSER_ACTION_SAVE : 'gtk-save'}[action]

gtk.FileChooserDialog.__init__(self, title, None, action, ('gtk-cancel', gtk.RESPONSE_CANCEL, ok_stock, gtk.RESPONSE_OK))

def __init__(self, current_file_path=''):

"""

FileDialog constructor.

"""

if not current_file_path: current_file_path = path.join(DEFAULT_FILE_PATH, NEW_FLOGRAPH_TITLE + Preferences.file_extension())

if self.type == 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.

"""

self.add_filter(filter)

self.set_filter(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.

"""

if gtk.FileChooserDialog.run(self) != gtk.RESPONSE_OK: return None #response was cancel

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

def run(self):

"""

Get the filename and destroy the dialog.

"""

filename = self.get_rectified_filename()

self.destroy()

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

"""

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

"""

id = self._get_unique_id(key)

#calculate the position coordinate

def copy_to_clipboard(self):

"""

Copy the selected blocks and connections into the clipboard.

"""

#get selected blocks

blocks = self.get_selected_blocks()

def paste_from_clipboard(self, clipboard):

"""

Paste the blocks and connections from the clipboard.

"""

selected = set()

(x_min, y_min), blocks_n, connections_n = clipboard

def type_controller_modify_selected(self, direction):

"""

Change the registered type controller for the selected signal blocks.

"""

return any([sb.type_controller_modify(direction) for sb in self.get_selected_blocks()])

def port_controller_modify_selected(self, direction):

"""

Change port controller for the selected signal blocks.

"""

return any([sb.port_controller_modify(direction) for sb in self.get_selected_blocks()])

def enable_selected(self, enable):

"""

Enable/disable the selected blocks.

"""

changed = False

for selected_block in self.get_selected_blocks():

def move_selected(self, delta_coordinate):

"""

Move the element and by the change in coordinates.

"""

for selected_block in self.get_selected_blocks():

selected_block.move(delta_coordinate)

def rotate_selected(self, rotation):

"""

Rotate the selected blocks by multiples of 90 degrees.

"""

if not self.get_selected_blocks(): return False

#initialize min and max coordinates

def remove_selected(self):

"""

Remove selected elements

"""

changed = False

for selected_element in self.get_selected_elements():

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.

"""

selected_port = None

selected = set()

def get_selected_connections(self):

"""

Get a group of selected connections.

"""

selected = set()

for selected_element in self.get_selected_elements():

def get_selected_blocks(self):

"""

Get a group of selected blocks.

"""

selected = set()

for selected_element in self.get_selected_elements():

def get_selected_block(self):

"""

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

"""

return self.get_selected_blocks() and self.get_selected_blocks()[0] or None

def get_selected_elements(self):

"""

Get the group of selected elements.

"""

return self._selected_elements

def get_selected_element(self):

"""

Get the selected element.

"""

return self.get_selected_elements() and self.get_selected_elements()[0] 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.

"""

Actions.APPLICATION_QUIT()

return 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.

"""

self.current_page = self.notebook.get_nth_page(page_num)

Messages.send_page_switch(self.current_page.get_file_path())

def add_report_line(self, line):

"""

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

"""

self.text_display.insert(line)

vadj = self.reports_scrolled_window.get_vadjustment()

"""

Create a new notebook page.

Set the tab to be selected.

"""

#if the file is already open, show the open page and return

if file_path and file_path in self._get_files(): #already open

def close_pages(self):

"""

Close all the pages in this notebook.

"""

open_files = filter(lambda file: file, self._get_files()) #filter blank files

open_file = self.get_page().get_file_path()

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.

"""

if not self.page_to_be_closed: self.page_to_be_closed = self.get_page()

#show the page if it has an executing flow graph or is unsaved

Set the title of the main window.

Set the titles on the page tabs.

Show/hide the reports window.

"""

gtk.Window.set_title(self, Utils.parse_template(MAIN_WINDOW_TITLE_TMPL,

basename=os.path.basename(self.get_page().get_file_path()),

def get_page(self):

"""

Get the selected page.

"""

return self.current_page

def get_flow_graph(self):

"""

Get the selected flow graph.

"""

return self.get_page().get_flow_graph()

def get_focus_flag(self):

"""

Get the focus flag from the current page.

"""

return self.get_page().get_drawing_area().get_focus_flag()

def _set_page(self, page):

"""

Set the current page.

"""

self.current_page = page

self.notebook.set_current_page(self.notebook.page_num(self.current_page))

def _save_changes(self):

"""

Save changes to flow graph?

"""

return MessageDialogHelper(

gtk.MESSAGE_QUESTION, gtk.BUTTONS_YES_NO, 'Unsaved Changes!',

def _get_files(self):

"""

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

"""

return map(lambda page: page.get_file_path(), self._get_pages())

def _get_pages(self):

"""

Get a list of all pages in the notebook.

"""

return [self.notebook.get_nth_page(page_num) for page_num in range(self.notebook.get_n_pages())]

def register_messenger(messenger):

"""

Append the given messenger to the list of messengers.

"""

MESSENGERS_LIST.append(messenger)

def send(message):

"""

Give the message to each of the messengers.

"""

for messenger in MESSENGERS_LIST: messenger(message)

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

"""

Page constructor.

"""

self._flow_graph = flow_graph

self.set_proc(None)

def get_generator(self):

"""

Get the generator object for this flow graph.

"""

return self.get_flow_graph().get_parent().get_generator()(

self.get_flow_graph(),

"""

The button was clicked.

Make the current page selected, then close.

"""

self.main_window.page_to_be_closed = self

Actions.FLOW_GRAPH_CLOSE()

def set_markup(self, markup):

"""

Set the markup in this label.

"""

self.label.set_markup(markup)

def get_tab(self):

"""

Get the gtk widget for this page's tab.

"""

return self.tab

def get_proc(self):

"""

Get the subprocess for the flow graph.

"""

return self.process

def set_proc(self, process):

"""

Set the subprocess object.

"""

self.process = process

def get_flow_graph(self):

"""

Get the flow graph.

"""

return self._flow_graph

"""

Get the read-only state of the file.

Always false for empty path.

"""

if not self.get_file_path(): return False

return os.path.exists(self.get_file_path()) and \

def get_file_path(self):

"""

Get the file path for the flow graph.

"""

return self.file_path

def set_file_path(self, file_path=''):

"""

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

"""

if file_path: self.file_path = os.path.abspath(file_path)

else: self.file_path = ''

def get_saved(self):

"""

Get the saved status for the flow graph.

"""

return self.saved

def set_saved(self, saved=True):

"""

Set the saved status.

"""

self.saved = saved

def get_state_cache(self):

"""

Get the state cache for the flow graph.

"""

return self.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.

"""

if self.is_enum(): return EnumParam(self, *args, **kwargs)

if self.get_options(): return EnumEntryParam(self, *args, **kwargs)

def get_markup(self):

"""

Get the markup for this param.

"""

return Utils.parse_template(PARAM_MARKUP_TMPL, param=self)

def draw(self, gc, window):

"""

Draw the socket with a label.

"""

Element.draw(

self, gc, window, bg_color=self._bg_color,

def get_connector_coordinate(self):

"""

Get the coordinate where connections may attach to.

"""

x,y = self._connector_coordinate

X,Y = self.get_coordinate()

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.

"""

if self.is_source(): return self.get_rotation()

elif self.is_sink(): return (self.get_rotation() + 180)%360

"""

Get the length of the connector.

The connector length increases as the port index changes.

"""

return self._connector_length

def get_rotation(self):

"""

Get the parent's rotation rather than self.

"""

return self.get_parent().get_rotation()

def move(self, delta_coor):

"""

Move the parent rather than self.

"""

self.get_parent().move(delta_coor)

def rotate(self, direction):

"""

Rotate the parent rather than self.

"""

self.get_parent().rotate(direction)

def get_coordinate(self):

"""

Get the parent's coordinate rather than self.

"""

return self.get_parent().get_coordinate()

def set_highlighted(self, highlight):

"""

Set the parent highlight rather than self.

"""

self.get_parent().set_highlighted(highlight)

def is_highlighted(self):

"""

Get the parent's is highlight rather than self.

"""

return self.get_parent().is_highlighted()

"""

Get a title label for the params window.

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

"""

label = gtk.Label()

label.set_markup('\n<b><span underline="low">%s</span>:</b>\n'%title)

def __init__(self, block):

"""

Properties dialog contructor.

"""

self._hash = 0

LABEL_SPACING = 7

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

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

Make a hash that uniquely represents the params' state.

"""

old_hash = self._hash

#create a tuple of things from each param that affects the params box

"""

Handle key presses from the keyboard.

Call the ok response when enter is pressed.

"""

if event.keyval == gtk.keysyms.Return:

self.response(gtk.RESPONSE_ACCEPT)

def run(self):

"""

Run the dialog and get its response.

"""

response = gtk.Dialog.run(self)

self.destroy()

def __init__(self, initial_state):

"""

StateCache constructor.

"""

self.states = [None] * STATE_CACHE_SIZE #fill states

self.current_state_index = 0

"""

Save a new state.

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

"""

self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

self.states[self.current_state_index] = state

def get_current_state(self):

"""

Get the state at the current index.

"""

self.update_actions()

return self.states[self.current_state_index]

def get_prev_state(self):

"""

Get the previous state and decrement the current index.

"""

if self.num_prev_states > 0:

self.current_state_index = (self.current_state_index + STATE_CACHE_SIZE -1)%STATE_CACHE_SIZE

def get_next_state(self):

"""

Get the nest state and increment the current index.

"""

if self.num_next_states > 0:

self.current_state_index = (self.current_state_index + 1)%STATE_CACHE_SIZE

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.

"""

width, height = src_pixmap.get_size()

pixbuf = gtk.gdk.Pixbuf(

def get_rotated_coordinate(coor, rotation):

"""

Rotate the coordinate by the given rotation.

"""

#handles negative angles

rotation = (rotation + 360)%360

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.

"""

if y1 == y2:#0 or 180

if x2 > x1: return 0

"""

Parse the template string with the given args.

Pass in the xml encode method for pango escape chars.

"""

kwargs['encode'] = gobject.markup_escape_text

return str(Template(tmpl_str, kwargs))

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)