Package openmdao.gui

This package contains a graphical user interface for the openmdao framework.

consoleserver.py

class openmdao.gui.consoleserver.ConsoleServer(name='', host='', publish_updates=True)

Bases: cmd.Cmd

Object which knows how to load a model and provides a command line interface and various methods to access and modify that model.

add_component(*args, **kwargs)

add_file(filename, contents)

add file

add_subscriber(pathname, publish)

publish the specified topic

cleanup()

Cleanup various resources.

commit_project(comment='')

save the current project macro and commit to the project repo

default(line)

Called on an input line when the command prefix is not recognized. In that case we execute the line as Python code.

delete_file(filename)

delete file from project returns False if file was not found, otherwise returns True

do_trace(arg)

print remembered trace from last exception

emptyline()

ensure_dir(dirname)

create directory (does nothing if directory already exists)

execfile(*args, **kwargs)

file_has_instances(filename)

Returns True if the given file (assumed to be a file in the project) has classes that have been instantiated in the current process. Note that this doesn’t keep track of removes/deletions, so if an instance was created earlier and then deleted, it will still be reported.

get_JSON()

return current state as JSON

get_attributes(pathname)

get_components()

get hierarchical dictionary of openmdao objects

get_connections(pathname, src_name, dst_name)

get list of source variables, destination variables and the connections between them

get_container(pathname, report=True)

get the container with the specified pathname returns the container and the name of the root object

get_current_project()

Get current project name.

get_dataflow(pathname)

get the structure of the specified assembly, or of the global namespace if no pathname is specified, consisting of the list of components and the connections between them (i.e. the dataflow)

get_file(filename)

get contents of a file returns None if file was not found

get_files()

get a nested dictionary of files

get_history()

Return this server’s _hist.

get_pid()

Return this server’s pid.

get_project()

Return the current model as a project archive.

get_recorded_cmds()

Return this server’s _recorded_cmds.

get_types()

get_value(pathname)

get the value of the object with the given pathname

get_workflow(pathname)

install_addon(url, distribution)

load_project(*args, **kwargs)

onecmd(*args, **kwargs)

parseline(line)

Have to override this because base class version strips the lines, making multi-line Python commands impossible.

precmd(line)

This method is called after the line has been input but before it has been interpreted. If you want to modify the input line before execution (for example, variable substitution) do it here.

publish_components()

publish the current component tree and subscribed components

replace_component(*args, **kwargs)

revert_project(*args, **kwargs)

run(*args, **kwargs)

send_pub_msg(msg, topic)

publish the given message with the given topic

set_current_project(path)

Set current project name.

write_file(filename, contents)

write contents to file

openmdao.gui.consoleserver.modifies_model(target)

decorator for methods that may have modified the model performs maintenance on root level containers/assemblies and publishes the potentially updated components

filemanager.py

class openmdao.gui.filemanager.FileManager(name, path, publish_updates=False)

Bases: object

Object that keeps track of a collection of files (i.e. a directory) and optionally publishes an update when the collection is modified

add_file(filename, contents)

add file to working directory if it’s a zip file, unzip it

cleanup()

Stop observer and cleanup the file directory.

delete_file(filename)

delete file in working directory returns False if file was not found, otherwise returns True

ensure_dir(dirname)

create directory in working directory (does nothing if directory already exists)

get_file(filename)

get contents of file in working directory returns None if file was not found

get_files(root=None)

get a nested dictionary of files in the working directory

publish_files()

publish the current file collection

write_file(filename, contents)

write contents to file in working directory

class openmdao.gui.filemanager.FilesPublisher(files)

Bases: watchdog.events.FileSystemEventHandler

publishes file collection when ANY file system event occurs

dispatch(event)

just publish the updated file collection

handlers.py

class openmdao.gui.handlers.ExitHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

shut it down, try to close the browser window

get()

class openmdao.gui.handlers.LoginHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

lets users log into the application simply by specifying a nickname, which is then saved in a cookie.

get()

post()

class openmdao.gui.handlers.LogoutHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

lets users log out of the application simply by deleting the nickname cookie

get()

post()

class openmdao.gui.handlers.PluginDocsHandler(application, request, **kwargs)

Bases: tornado.web.StaticFileHandler

retrieve docs for a plugin

get(path, include_body=True)

initialize(route)

class openmdao.gui.handlers.ReqHandler(application, request, **kwargs)

Bases: tornado.web.RequestHandler

override the get_current_user() method in your request handlers to determine the current user based on the value of a cookie.

delete_server()

get_current_user()

get_project_dir()

get_server()

get_sessionid()

initialize()

handlers_projectdb.py

class openmdao.gui.handlers_projectdb.AddHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

Add a project to the project database. This extracts the project file into a directory under the users projects directory.

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_projectdb.DeleteHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

delete a project

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_projectdb.DetailHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

get/set project details

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_projectdb.DownloadHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

download a copy of the project

get(*args, **kwargs)

Browser download of a project file

class openmdao.gui.handlers_projectdb.IndexHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

get project list

get(*args, **kwargs)

class openmdao.gui.handlers_projectdb.NewHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

create a new (empty) project

get(*args, **kwargs)

handlers_workspace.py

class openmdao.gui.handlers_workspace.AddOnsHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

addon installation utility Eventually we will probably wrap the OpenMDAO plugin functions to work through here.

get(*args, **kwargs)

show available plugins, prompt for plugin to be installed

post(*args, **kwargs)

easy_install the POSTed addon

addons_url = 'http://openmdao.org/dists'

class openmdao.gui.handlers_workspace.CloseHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.CommandHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get the command, send it to the cserver, return response

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.ComponentHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

add, get, or remove a component

delete(*args, **kwargs)

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.ComponentsHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.ConnectionsHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get connections between two components in an assembly

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.DataflowHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get the structure of the specified assembly, or of the global namespace if no pathname is specified, consisting of the list of components and the connections between them (i.e. the dataflow)

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.EditorHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get(*args, **kwargs)

Code Editor

class openmdao.gui.handlers_workspace.ExecHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

if a filename is POSTed, have the cserver execute the file otherwise just run() the project

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.FileHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get/set the specified file/folder

delete(*args, **kwargs)

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.FilesHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get a list of the users files in JSON format

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.GeometryHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get(*args, **kwargs)

geometry viewer

class openmdao.gui.handlers_workspace.ModelHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

POST: get a new model (delete existing console server) GET: get JSON representation of the model

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.ObjectHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get the data for a slotable object (including components)

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.OutstreamHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

return the url of the zmq outstream server,

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.PlotHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: open a websocket server to supply updated valaues for the specified variable

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.ProjectHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: start up an empty workspace and prepare to load a project.

POST: commit the current project

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.ProjectLoadHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: load model fom the given project archive, or reload remembered project for session if no file given

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.ProjectRevertHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

POST: revert back to the most recent commit of the project

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.PublishHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: tell the server to publish the specified topic/variable

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.PubstreamHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

return the url of the zmq publisher server

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.ReplaceHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

replace a component

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.ReqHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

render the base template

get(*args, **kwargs)

post(*args, **kwargs)

render the base template with the posted content

class openmdao.gui.handlers_workspace.TestHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

initialize the server manager & render the workspace

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.TypesHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get hierarchy of package/types to populate the Palette

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.UploadHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

file upload utility

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.ValueHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: get a value for the given pathname TODO: combine with ComponentHandler? handle Containers as well?

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.VariableHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get a command to set a variable, send it to the cserver, return response

get(*args, **kwargs)

post(*args, **kwargs)

class openmdao.gui.handlers_workspace.WorkflowHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

get(*args, **kwargs)

class openmdao.gui.handlers_workspace.WorkspaceHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers_workspace.ReqHandler

render the workspace

get(*args, **kwargs)

omg.py

OpenMDAO GUI

This graphical user interface for OpenMDAO is implemented as a web application.

Running this file will start a tornado web server on a local port and open a browser on that port. An up-to-date version of Chrome or Firefox with support for WebSockets is required.

class openmdao.gui.omg.App(secret=None)

Bases: tornado.web.Application

openmdao web application extends tornado web app with URL mappings, settings and server manager

exit()

class openmdao.gui.omg.AppServer(options)

Bases: object

openmdao web application server wraps tornado web app, runs http server and opens browser

static get_argument_parser()

create a parser for command line arguments

serve()

start server listening on port, launch browser if requested and start the ioloop

openmdao.gui.omg.DEBUG(msg)

openmdao.gui.omg.get_argument_parser()

shortcut to AppServer argument parser

openmdao.gui.omg.get_user_dir()

openmdao.gui.omg.main()

process command line arguments and run

openmdao.gui.omg.run(parser=None, options=None, args=None)

launch the gui with specified options

outstream.py

class openmdao.gui.outstream.OutStream(pub_socket, name)

Bases: object

A file like object that publishes the stream to a 0MQ PUB socket. (Borrowed from IPython, but stripped down a bit...)

close()

flush()

isatty()

next()

read(size=-1)

readline(size=-1)

write(string)

writelines(sequence)

class openmdao.gui.outstream.OutStreamRedirector(name, addr, filename='sys.stdout')

Bases: multiprocessing.process.Process

listen for output on the given port and dump it to a file

run()

terminate()

projdirfactory.py

class openmdao.gui.projdirfactory.ProjDirFactory(watchdir, use_observer=True, observer=None)

Bases: openmdao.main.factory.Factory

A Factory that watches a Project directory and dynamically keeps the set of available types up-to-date as project files change.

cleanup()

If this factory is removed from the FactoryManager during execution, this function will stop the watchdog observer thread.

create(typ, version=None, server=None, res_desc=None, **ctor_args)

Create and return an instance of the specified type, or None if this Factory can’t satisfy the request.

get_available_types(groups=None)

Return a list of available types.

on_deleted(fpath, deleted_set)

on_modified(fpath, added_set, changed_set, deleted_set)

publish_updates(added_set, changed_set, deleted_set)

projectdb.py

The Projects object provides a basic interface for interacting with the project database used by the GUI.

class openmdao.gui.projectdb.Projects(pathname=None)

Bases: object

create()

Create a new clean database for the GUI user.

exists()

Does the database exist?

get(project_id)

Get a dictionary containing the fields for a project id.

project_id: int

unique id for requested project.

get_by_path(path)

Get a dictionary containing the fields that belong to a project with a specific path.

path: str (valid path)

path for requested project

list_projects()

Return a list of dictionaries for all projects owned by the user. Each dictionary contains all fields for that project id.

modified(project_id)

Update metadate modification time-stamp for project_id, setting ‘modified’ to the current time/date.

project_id: int

unique id for requested project.

new(data)

Insert a new row into the project database.

data: dict

Dictionary containing all fields for the new entry.

predict_next_rowid()

Predict what the next auto-inserted rowid will be. This is here because the GUI handlers need to know the project_id even before the row is inserted.

remove(project_id)

Remove a project from the database

project_id: int

unique id for requested project.

set(project_id, field, value)

Set a single field in the project db

project_id: int

unique id for requested project.

field: str

Name of field to set

value: various

Value of field to set

openmdao.gui.projectdb.get_user_dir()

session.py

Ref: http://caines.ca/blog/programming/sessions-in-tornado (27 OCT/09)

In case anyone’s interested, here’s my sessions.py that I use for doing a pickle-based session (stored as a file in a directory of your choosing) in Tornado. Feel free to use it however you please. If I write something more scalable one day, I’ll post it too.

Usage: In your application script, settings[“session_secret”] = ‘some secret password!!’ settings[“session_dir”] = ‘sessions’ # the directory to store sessions in application.session_manager = session.TornadoSessionManager(settings[“session_secret”], settings[“session_dir”])

In your RequestHandler (probably in __init__), self.session = session.TornadoSession(self.application.session_manager, self)

After that, you can use it like this (in get(), post(), etc): self.session[‘blah’] = 1234 self.save() blah = self.session[‘blah’]

etc.

the basic session mechanism is this: * take some data, pickle it, store it somewhere. * assign an id to it. run that id through a HMAC (NOT just a hash function) to prevent tampering. * put the id and HMAC output in a cookie. * when you get a request, load the id, verify the HMAC. if it matches, load the data from wherever you put it and depickle it.

exception openmdao.gui.session.InvalidSessionException

Bases: exceptions.Exception

class openmdao.gui.session.Session(session_id, hmac_digest)

Bases: dict

A Session is basically a dict with a session_id and an hmac_digest string to verify access rights

class openmdao.gui.session.SessionManager(secret, session_dir='')

Bases: object

SessionManager handles the cookie and file read/writes for a Session

get(session_id=None, hmac_digest=None)

set(session)

class openmdao.gui.session.TornadoSession(tornado_session_manager, request_handler)

Bases: openmdao.gui.session.Session

A TornadoSession is a Session object for use in Tornado

save()

class openmdao.gui.session.TornadoSessionManager(secret, session_dir='')

Bases: openmdao.gui.session.SessionManager

A TornadoSessionManager is a SessionManager that is specifically for use in Tornado, using Tornado’s cookies

get(requestHandler=None)

set(requestHandler, session)

util.py

utility functions used by openmdao gui

openmdao.gui.util.ensure_dir(d)

create directory if it doesn’t exist

openmdao.gui.util.filedict(path)

create a nested dictionary for a file structure with names relative to the starting directory.

openmdao.gui.util.get_executable_path(executable_names)

Look for an executable given a list of the possible names

openmdao.gui.util.launch_browser(port, preferred_browser=None)

launch web browser on specified port try to use preferred browser if specified, fall back to default (chrome will launch in “app mode”)

openmdao.gui.util.makenode(doc, path)

Return a document node contains a directory tree for the path. modified version of: http://code.activestate.com/recipes/305313-xml-directory-tree/

openmdao.gui.util.packagedict(types)

create a nested dict for a package structure

openmdao.gui.util.print_dict(dict)

print the contents of a dictionary

openmdao.gui.util.print_json(data)

pretty print json data

openmdao.gui.util.print_list(list)

print the contents of a list

openmdao.gui.util.unique_shortnames(names)

Return a dict containing full name vs. short name where short name is still unique within the given list. Each entry in the initial list of dotted names is assumed to be unique.

zmqserver.py

class openmdao.gui.zmqserver.ZMQServer(options)

Bases: object

wraps an an openmdao object with ZMQ and runs it as a server

static get_options_parser()

create a parser for command line arguments

serve()

static spawn_server(classpath, rep_url, pub_url, out_url)

run server in it’s own process

openmdao.gui.zmqserver.DEBUG(msg)

openmdao.gui.zmqserver.main()

process command line arguments, create server and start it up

zmqservermanager.py

class openmdao.gui.zmqservermanager.ZMQServerManager(classpath)

Bases: object

creates and keeps track of ZMQ servers for the given class

cleanup()

delete all servers

delete_server(server_id)

delete the server(s) associated with an id

get_out_server_url(server_id, ws_url)

get the output socket web server for the server associated with an id, create one if none exists

get_out_socket_url(server_id)

get the url of the output socket for the server associated with an id

get_pub_server_url(server_id, ws_url)

get the publisher socket web server for the server associated with an id, create one if none exists

get_pub_socket_url(server_id)

get the url of the publisher socket for the server associated with an id

server(server_id)

get server associated with an id, create one if none exists

openmdao.gui.zmqservermanager.DEBUG(msg)

zmqstreamserver.py

class openmdao.gui.zmqstreamserver.ZMQStreamApp(zmqstream_addr, websocket_url)

Bases: tornado.web.Application

a web application that serves a ZMQStream over a WebSocket

class openmdao.gui.zmqstreamserver.ZMQStreamHandler(application, request, **kwargs)

Bases: tornado.websocket.WebSocketHandler

a handler that forwards output from a ZMQStream to a WebSocket

initialize(addr)

on_close()

on_message(message)

open()

class openmdao.gui.zmqstreamserver.ZMQStreamServer(options)

Bases: object

runs an http server that serves a ZMQStream over a WebSocket

static get_options_parser()

create a parser for command line arguments

serve()

start server listening on port & start the ioloop

static spawn_process(zmq_url, ws_port, ws_url='/')

run zmqstreamserver in it’s own process, mapping a zmq stream to a websocket

args: zmq_url the url of the ZMQStream ws_port the port to serve the WebSocket on ws_url the url to map to the WebSocket

openmdao.gui.zmqstreamserver.DEBUG(msg)

openmdao.gui.zmqstreamserver.main()

process command line arguments, create server and start it up

openmdao.gui.zmqstreamserver.make_unicode(content)