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 an OpenMDAO project and provides a command line interface and methods to interact with that project.

add_file(*args, **kargs)

add_object(*args, **kargs)

add_subscriber(pathname, publish)

Publish the specified topic.

cleanup()

Cleanup various resources.

commit_project(*args, **kargs)

default(line)

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

delete_file(*args, **kargs)

do_trace(arg)

Print remembered trace from last exception.

emptyline()

ensure_dir(*args, **kargs)

execfile(*args, **kargs)

file_forces_reload(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 or if the file is a macro file. 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_attributes(pathname)

Get the attributes of the specified object.

get_available_events(pathname)

Serve a list of events that are available to a driver.

get_components()

Get hierarchical dictionary of openmdao objects.

get_connections(pathname, src_name, dst_name)

For the assembly with the given pathname, get a list of the outputs from the component src_name (sources), the inputs to the component dst_name (destinations), and the connections between them.

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; consists of the list of components and the connections between them (i.e., the dataflow).

get_file(filename)

Get contents of a file. Returns a tuple of (file contents, mimetype, encoding). Tuple values will be None if file was not found.

get_files()

Get a nested dictionary of files.

get_history()

Return this server’s _hist.

get_object(pathname, report=True)

Get the container with the specified pathname. Returns the container and the name of the root object.

get_passthroughs(pathname)

Get the inputs and outputs of the assembly’s child components and indicate for each whether or not it is a passthrough variable.

get_pid()

Return this server’s pid.

get_project()

Return the current project.

get_recorded_cmds()

Return this server’s _recorded_cmds.

get_signature(classname)

Get constructor argument signature for classname.

get_types()

Get a dictionary of types available for creation.

get_value(pathname)

Get the value of the object with the given pathname.

get_workflow(pathname)

Get the workflow for the specified driver or assembly. If no driver or assembly is specified, get the workflows for all of the top-level assemblies.

install_addon(url, distribution)

is_macro(filename)

load_project(*args, **kwargs)

onecmd(*args, **kargs)

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.

put_object(pathname, classname, args=None)

Create or replace object with the given pathname with a new object of the specified type.

rename_file(*args, **kargs)

replace_object(*args, **kargs)

revert_project(*args, **kargs)

run(*args, **kargs)

send_pub_msg(msg, topic)

Publish the given message with the given topic.

set_current_project(path)

Set current project name.

write_file(*args, **kargs)

openmdao.gui.consoleserver.modifies_project(target)

Decorator for methods that update the project (or might do so) via adding, removing or updating files in the project. This includes the issuing of commands that end up in the default macro file. (TODO: should be able to due this directly through the FileManager)

Updates the timestamp of the project _settings.cfg file so that it can be used to determine when the project was ‘last saved’.

openmdao.gui.consoleserver.modifies_state(target)

Decorator for methods that modify the session state (or might do so). 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.

rename_file(oldpath, newname)

Rename last component of oldpath to newname.

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

Currently we support a single user, the current user. This hook is for potential future development using Credentials.

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)

regex = <_sre.SRE_Pattern object at 0x1066c2060>

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

Bases: tornado.web.RequestHandler

Override the get_current_user() method in 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.DeleteHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

Delete a project.

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.ImportHandler(application, request, **kwargs)

Bases: openmdao.gui.handlers.ReqHandler

Get/set project details.

get(*args, **kwargs)

post(*args, **kwargs)

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

Add a project to the project database. This extracts the project file into a directory under the project’s directory of users.

post(*args, **kwargs)

handlers_workspace.py

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

Bases: openmdao.gui.handlers.ReqHandler

Add-on installation utility. (TODO: Wrap the OpenMDAO plugin functions to work through here....)

GET: Render the addon installation utility template.

POST: Install the POSTed addon.

get(*args, **kwargs)

post(*args, **kwargs)

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

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

POST: Execute a command and return the console-like response; required arguments are:

command: Command to execute

post(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

code editor utility

GET: Render the code editor; arguments are:

filename: Full pathname of file to edit (optional).

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get the contents of file filename.

PUT: Write contents to file filename.

DELETE: Delete file filename.

POST: Rename file filename if rename argument is provided;

otherwise execute file filename. Arguments are:

rename: New name for file filename (optional).

delete(*args, **kwargs)

get(*args, **kwargs)

post(*args, **kwargs)

put(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get heirarchical list of files in the current project.

DELETE: Delete files; arguments are:

filepaths - full pathnames of files to delete (required)

returns ‘True’ if all files were successfully deleted

delete(*args, **kwargs)

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

geometry viewer utility

GET: Render the geometry viewer; arguments are:

path: Full path name of geometry object or file.

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

image viewer utility

GET: Render the image viewer.

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get the attributes of object pathname;

attr is optional and can specify one of the following:

dataflow

workflow

events

passthroughs

connections

PUT: Create or replace object pathname; arguments are:

type: The type of the new object (required)

args: Arguments required to create the new object (optional).

POST: Execute object pathname

DELETE: Delete object pathname

delete(*args, **kwargs)

get(*args, **kwargs)

post(*args, **kwargs)

put(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get heirarchical list of objects in the current project. (NOTE: currently only lists ‘Component’ objects...)

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.

(Loading a project is a two-step process. The first step is when the server is initialized and the workspace is loaded. After the workspace is loaded and websockets are connected, the next step should be a POST to project/load that will actually load the project into the server.)

POST: Perform the specified action on the current project; arguments are:

action: One of the following (required)

load: Load project into the current server;

if no project path is given, get from session cookie.

additional args: projpath (optional)

commit: Commit the current project.

additional args: comment (optional)

revert: Revert back to the most recent commit of the project.

additional args: commit_id (optional)

close: Close the current project

get(*args, **kwargs)

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)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get the url of the websocket server for stream stream_name.

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get a subscription to topic.

(Messages will be published via the pub websocket.)

DELETE: Remove a subscription to topic.

delete(*args, **kwargs)

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get attributes of type typename; attr is required and must be one of:

signature: Arguments required to create an instance of typename

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get the list of available types.

get(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

file upload utility

GET: Render the upload form.

POST: Add the POSTed files to the current project.

get(*args, **kwargs)

post(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: Get the value of variable pathname.

PUT: Set the value of variable pathname.

get(*args, **kwargs)

post(*args, **kwargs)

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

Bases: openmdao.gui.handlers_workspace.ReqHandler

GET: 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, external=False)

Bases: tornado.web.Application

Openmdao web application. Extends tornado web app with URL mappings, settings and server manager.

exit()

Shutdown.

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

Return user’s GUI directory.

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.

get_signature(typname, version=None)

Return constructor argument signature for typname, using the specified package version. The return value is a dictionary.

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 Project’s 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 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)

From Gregg Caines blog:

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 and uses 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.find_chrome()

Find the Chrome executable.

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 containing 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 its 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, external=False)

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_websocket_url(server_id, stream_name, target_url)

Get the url of the websocket for the specified stream of the specified server; if websocket server does not exist, start it.

server_id: The id of the server.

stream_name: The name of the stream (‘out’ or ‘pub’).

target_url: The relative url at which to serve the websocket.

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='/', external=False)

Run zmqstreamserver in its 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)