Package openmdao.util

This package contains a number of utilities that are used inside of openmdao. It does not depend on any other openmdao package.

addreqs.py

A script to add a group of required packages to the current Python environment.

openmdao.util.addreqs.add_reqs(argv=None, default_flink=None)

astutil.py

openmdao.util.astutil.parse_ast(contents, fname, mode='exec')

Wrapper for ast.parse() that cleans the contents of CRs and ensures it ends with a newline.

openmdao.util.astutil.text_to_node(text, lineno=None)

Given a Python source string, return the corresponding AST node. The outer Module node is removed so that the node corresponding to the given text can be added to an existing AST.

debug.py

Routines to help obtain debugging information.

openmdao.util.debug.DEBUG(msg)

openmdao.util.debug.dumpit(obj, stream=<open file '<stdout>', mode 'w' at 0x1002841e0>, recurse=True, ignore_address=True)

Try to dump out the guts of an object, and optionally its children.

openmdao.util.debug.print_funct_call(funct, *args, **kwargs)

openmdao.util.debug.traceit(frame, event, arg)

A function useful for tracing Python execution. Wherever you want the tracing to start, insert a call to sys.settrace(traceit).

decorators.py

Some useful decorators

openmdao.util.decorators.add_delegate(*delegates)

A class decorator that takes delegate classes or (name,delegate) tuples as args. For each tuple, an instance with the given name will be created in the wrapped __init__ method of the class. If only the delegate class is provided, then the instance created in the wrapped __init__ method will be named using an underscore (_) followed by the lower case name of the class. All of the public methods from the delegate classes will be added to the class unless there is an attribute or method in the class with the same name. In that case the delegate method will be ignored.

openmdao.util.decorators.forwarder(cls, fnc, delegatename)

Returns a method that forwards calls on the scoping object to calls on the delegate object. The signature of the delegate method is preserved in the forwarding method.

openmdao.util.decorators.print_timing(func)

openmdao.util.decorators.replace_funct(fnc, body)

Returns a function with a new body that replaces the given function. The signature of the original function is preserved in the new function.

openmdao.util.decorators.stub_if_missing_deps(*deps)

A class decorator that will try to import the specified modules and in the event of failure will stub out the class, raising a RuntimeError that explains the missing dependencies whenever an attempt is made to instantiate the class.

deps: str args

args in deps may have the form a.b.c or a.b.c:attr, where attr would be searched for within the module a.b.c after a.b.c is successfully imported.

dep.py

Routines analyzing dependencies (class and module) in Python source.

class openmdao.util.dep.ClassInfo(name, fname, bases, meta, decorators)

Bases: object

class openmdao.util.dep.PythonSourceFileAnalyser(fname, tree_analyser)

Bases: ast.NodeVisitor

Collects info about imports and class inheritance from a Python file.

update_graph(graph)

Update the inheritance/implements graph.

update_ifaces(graph)

Update our ifaces metadata based on the contents of the inheritance/implements graph.

visit_ClassDef(node)

This executes every time a class definition is parsed.

visit_Import(node)

This executes every time an “import foo” style import statement is parsed.

visit_ImportFrom(node)

This executes every time a “from foo import bar” style import statement is parsed.

class openmdao.util.dep.PythonSourceTreeAnalyser(startdir=None, exclude=None, mod_excludes=None, direxclude=None)

Bases: object

analyze_file(pyfile, use_cache=False)

dump(out, options)

Dumps the contents of this object for debugging purposes.

find_classinfo(cname)

find_inheritors(base)

Returns a list of names of classes that inherit from the given base class.

flush_cache()

get_interfaces(classname)

Returns a set of interfaces for a given class.

remove_file(fname)

openmdao.util.dep.main()

distutils_fix.py

Importing this file will fix problems we’ve found in distutils.

Current fixes are:

Update the library_dir_option function in MSVCCompiler to add quotes around /LIBPATH entries.

doctools.py

A utility to extract Traits information from the code and get it into the Sphinx documentation.

Note

No traits docs will be generated unless the class containing the traits has a doc string!

openmdao.util.doctools.get_traits_info(app, what, name, obj, options, lines)

Gets traits info.

openmdao.util.doctools.setup(app)

Connect the doctools to the process-docstring hook.

dumpdistmeta.py

If run as main, dumpdistmeta.py will print out either a pretty-printed dict full of the metadata found in the specified distribution or just the value of a single piece of metadata if metadata-item is specified on the command line. The distribution can be in the form of an installed egg, a zipped egg, or a gzipped tar file containing a distutils distribution.

usage: dumpdistmeta.py distribution [metadata-item]

Example output:

$ dumpdistmeta.py pyparsing-1.5.1-py2.5.egg
{'SOURCES': ['README',
             'pyparsing.py',
             'setup.py',
             'pyparsing.egg-info/PKG-INFO',
             'pyparsing.egg-info/SOURCES.txt',
             'pyparsing.egg-info/dependency_links.txt',
             'pyparsing.egg-info/top_level.txt'],
 'author': 'Paul McGuire',
 'author-email': 'ptmcg@users.sourceforge.net',
 'classifier': 'Programming Language :: Python',
 'dependency_links': [],
 'description': 'UNKNOWN',
 'download-url': 'http://sourceforge.net/project/showfiles.php?group_id=97203',
 'entry_points': {},
 'home-page': 'http://pyparsing.wikispaces.com/',
 'license': 'MIT License',
 'metadata-version': '1.0',
 'name': 'pyparsing',
 'platform': None,
 'py_version': '2.5',
 'summary': 'Python parsing module',
 'top_level': ['pyparsing'],
 'version': '1.5.1',
 'zip-safe': False}

Example output:

$ dumpdistmeta.py pyparsing-1.5.1-py2.5.egg license
MIT License

openmdao.util.dumpdistmeta.get_dist_metadata(dist, dirname='')

Retrieve metadata from within a distribution. Returns a dict.

openmdao.util.dumpdistmeta.get_metadata(path)

Retrieve metadata from a file or directory specified by path, or from the name of a distribution that happens to be installed. path can be an installed egg, a zipped egg file, or a zipped or unzipped tar file of a Python distutils or setuptools source distribution.

Returns a dict.

openmdao.util.dumpdistmeta.get_resource_files(dist, exList=None, incList=None, dirname='')

A generator that retrieves resource file pathnames from within a distribution.

eggloader.py

Egg loading utilities.

openmdao.util.eggloader.load(instream, fmt=4, package=None, logger=None)

Load object(s) from an input stream (or filename). If instream is a string that is not an existing filename or absolute path, then it is searched for using pkg_resources. Returns the root object.

instream: file or string

Stream or filename to load from.

fmt: int

Format of state data.

package: string

Name of package to use.

logger: Logger

Used for recording progress, etc.

openmdao.util.eggloader.load_from_eggfile(filename, entry_group, entry_name, logger=None, observer=None)

Extracts files in egg to a subdirectory matching the saved object name. Then loads object graph state by invoking the given entry point. Returns the root object.

filename: string

Name of egg file.

entry_group: string

Name of group.

entry_name: string

Name of entry point in group.

logger: Logger

Used for recording progress, etc.

observer: callable

Called via an EggObserver.

openmdao.util.eggloader.load_from_eggpkg(package, entry_group, entry_name, instance_name=None, logger=None, observer=None)

Load object graph state by invoking the given package entry point. Returns the root object.

package: string

Name of package to load from.

entry_group: string

Name of group.

entry_name: string

Name of entry point in group.

instance_name: string

Name for instance loaded.

logger: Logger

Used for recording progress, etc.

observer: callable

Called via an EggObserver.

openmdao.util.eggloader.check_requirements(required, logger=None, indent_level=0)

Display requirements (if logger debug level enabled) and note conflicts. Returns a list of unavailable requirements.

required: list

List of package requirements.

logger: Logger

Used for recording progress, etc.

indent_level: int

Used to improve readability of log messages.

eggobserver.py

class openmdao.util.eggobserver.EggObserver(observer, logger)

Bases: object

Provides a convenient API for calling an observer of egg operations. observer will be called with:

• ('analyze', filename, -1, -1) during module analysis.
• ('add', filename, file_fraction, byte_fraction) while writing files.
• ('copy', filename, file_fraction, byte_fraction) while copying files.
• ('extract', filename, file_fraction, byte_fraction) while extracting files.
• ('complete', egg_name, 1, 1) when complete.
• ('except', message, -1, -1) when an exception occurs.

add(path, file_fraction, byte_fraction)

Observe add of file. If observer returns False, raises RuntimeError.

path: string

Name of file being added.

file_fraction: float

Fraction of total files processed.

byte_fraction: float

Fraction of total bytes processed.

analyze(path)

Observe analysis of file. If observer returns False, raises RuntimeError.

path: string

Name of file being analyzed.

complete(path)

Observe operation complete.

path: string

Name of file saved/loaded.

copy(path, file_fraction, byte_fraction)

Observe copy of file. If observer returns False, raises RuntimeError.

path: string

Name of file being copied.

file_fraction: float

Fraction of total files processed.

byte_fraction: float

Fraction of total bytes processed.

exception(msg)

Observe exception.

msg: string

Exception message.

extract(path, file_fraction, byte_fraction)

Observe extraction of file. If observer returns False, raises RuntimeError.

path: string

Name of file being extracted.

file_fraction: float

Fraction of total files processed.

byte_fraction: float

Fraction of total bytes processed.

eggsaver.py

Egg save utilities.

Note that pickle can’t save references to functions that aren’t defined at the top level of a module, and there doesn’t appear to be a viable workaround. Normally pickle won’t handle instance methods either, but there is code in place to work around that.

When saving to an egg, the module named __main__ changes when reloading. This requires finding the real module name and munging references to __main__. References to old-style class types can’t be restored correctly.

openmdao.util.eggsaver.save(root, outstream, fmt=4, proto=-1, logger=None)

Save the state of root and its children to an output stream (or filename). If outstream is a string, then it is used as a filename. The format can be supplied in case something other than cPickle is needed. For the pickle formats, a proto of -1 means use the highest protocol.

root: object

The root of the object tree to save.

outstream: file or string

Stream or filename to save to.

fmt: int

What format to save the object state in.

proto: int

What protocol to use when pickling.

logger: Logger

Used for recording progress, etc.

openmdao.util.eggsaver.save_to_egg(entry_pts, version=None, py_dir=None, src_dir=None, src_files=None, dst_dir=None, logger=None, observer=None, need_requirements=True)

Save state and other files to an egg. Analyzes the objects saved for distribution dependencies. Modules not found in any distribution are recorded in an egg-info/openmdao_orphans.txt file. Also creates and saves loader scripts for each entry point.

entry_pts: list

List of (obj, obj_name, obj_group) tuples. The first of these specifies the root object and package name.

version: string

Defaults to a timestamp of the form ‘YYYY.MM.DD.HH.mm’.

py_dir: string

The (root) directory for local Python files. It defaults to the current directory.

src_dir: string

The root of all (relative) src_files.

dst_dir: string

The directory to write the egg in.

observer: callable

Will be called via an EggObserver intermediary.

need_requirements: bool

If True, distributions required by the egg will be determined. This can be set False if the egg is just being used for distribution within the local host.

Returns (egg_filename, required_distributions, orphan_modules).

eggwriter.py

Writes Python egg files. Supports what’s needed for saving and loading components/simulations.

openmdao.util.eggwriter.egg_filename(name, version)

Returns name for egg file as generated by setuptools.

name: string

Must be alphanumeric.

version: string

Must be alphanumeric.

openmdao.util.eggwriter.write(name, version, doc, entry_map, src_files, distributions, modules, dst_dir, logger, observer=None, compress=True)

Write egg in the manner of setuptools, with some differences:

• Writes directly to the zip file, avoiding some intermediate copies.
• Doesn’t compile any Python modules.

name: string

Must be an alphanumeric string.

version: string

Must be an alphanumeric string.

doc: string

Used for the Summary and Description entries in the egg’s metadata.

entry_map: dict

A pkg_resources EntryPoint map: a dictionary mapping group names to dictionaries mapping entry point names to EntryPoint objects.

src_files: list

List of non-Python files to include.

distributions: list

List of Distributions this egg depends on. It is used for the Requires entry in the egg’s metadata.

modules: list

List of module names not found in a distribution that this egg depends on. It is used for the Requires entry in the egg’s metadata and is also recorded in the ‘openmdao_orphans.txt’ resource.

dst_dir: string

The directory to write the egg to.

logger: Logger

Used for recording progress, etc.

observer: callable

Will be called via an EggObserver intermediary.

Returns the egg’s filename.

envirodump.py

envirodump.py
USAGE:  "python envirodump.py", text file generated in that spot

TO DO:
  get package VERSIONS
      attempt to use pip freeze if available
  fix aliases problem
  do a WHICH on compilers?
  deal with sys.exit on bad Python version?
X make docstrings consistent
X make Exception handling consistent 
  http://www.opensource.apple.com/source/python/python-3/python/Tools/freeze/modulefinder.py

openmdao.util.envirodump.callit(f, funct)

openmdao.util.envirodump.envdump()

openmdao.util.envirodump.find_compiler(f, name, ext='')

This function will find compilers, print their paths, and reveal their versions.

openmdao.util.envirodump.get_aliases(f)

Gets aliases on Unix/Mac.

openmdao.util.envirodump.get_compiler_info(f)

This function will call out for specific information on each compiler.

openmdao.util.envirodump.get_dump_time(f)

Writes the time and date of the system dump

openmdao.util.envirodump.get_pkg_info(f)

This function will list Python packages found on sys.path

openmdao.util.envirodump.get_platform_info(f)

This function will capture specific platform information, such as OS name, architecture, and linux distro.

openmdao.util.envirodump.get_python_info(f)

This function will capture specific Python information, such as version number, compiler, and build.

openmdao.util.envirodump.get_system_env(f)

This function captures the values of a system’s environment variables at the time of the run, and presents them in alphabetical order.

openmdao.util.envirodump.system_info_dump(f)

This function runs the rest of the utility. It creates an object in which to write and passes it to each separate function. Finally, it writes the value of that object into a dumpfile.

fileutil.py

Misc. file utility routines.

class openmdao.util.fileutil.DirContext(destdir)

Bases: object

Supports using the ‘with’ statement in place of try-finally for entering a directory, executing a block, then returning to the original directory.

openmdao.util.fileutil.build_directory(dct, force=False, topdir='.')

Create a directory structure based on the contents of a nested dict. The directory is created in the specified top directory or in the current working directory if one isn’t specified. If a file being created already exists, a warning will be issued and the file will not be changed if force is False. If force is True, the file will be overwritten.

The structure of the dict is as follows: if the value at a key is a dict, then that key is used to create a directory. Otherwise, the key is used to create a file, and the value stored at that key is written to the file. All keys must be relative names or a RuntimeError will be raised.

openmdao.util.fileutil.clean_filename(name)

Removes special characters from a proposed filename and replaces them with underscores. To be safe, we allow only a limited set of chars.

openmdao.util.fileutil.cleanup(*fnames, **kwargs)

Delete the given files or directories if they exists.

openmdao.util.fileutil.copy(src, dest)

Copy a file or directory.

openmdao.util.fileutil.expand_path(path)

openmdao.util.fileutil.file_md5(fpath)

Return the MD5 digest for the given file

openmdao.util.fileutil.find_files(start, match=None, exclude=None, showdirs=False, dirmatch=None, direxclude=None)

Return filenames (using a generator).

start: str or list of str

Starting directory or list of directories.

match: str or predicate funct

Either a string containing a glob pattern to match or a predicate function that returns True on a match. This is used to match files only.

exclude: str or predicate funct

Either a string containing a glob pattern to exclude or a predicate function that returns True to exclude. This is used to exclude files only.

showdirs: bool

If True, return names of files AND directories.

dirmatch: str or predicate funct

Either a string containing a glob pattern to match or a predicate function that returns True on a match. This is used to match directories only.

direxclude: str or predicate funct

Either a string containing a glob pattern to exclude or a predicate function that returns True to exclude. This is used to exclude directories only.

Walks all subdirectories below each specified starting directory, subject to directory filtering.

openmdao.util.fileutil.find_in_dir_list(fname, dirlist, exts=('', ))

Search the given list of directories for the specified file. Return the absolute path of the file if found, or None otherwise.

fname: str

Base name of file.

dirlist: list of str

List of directory paths, relative or absolute.

exts: tuple of str

Tuple of extensions (including the ‘.’) to apply to fname for loop, e.g., (‘.exe’,’.bat’).

openmdao.util.fileutil.find_in_path(fname, pathvar=None, sep=':', exts=('', ))

Search for a given file in all of the directories given in the pathvar string. Return the absolute path to the file if found, or None otherwise.

fname: str

Base name of file.

pathvar: str

String containing search paths. Defaults to $PATH.

sep: str

Delimiter used to separate paths within pathvar.

exts: tuple of str

Tuple of extensions (including the ‘.’) to apply to fname for loop, e.g., (‘.exe’,’.bat’).

openmdao.util.fileutil.find_module(name, path=None, py=True)

Return the pathname of the Python file corresponding to the given module name, or None if it can’t be found. If path is set, search in path for the file; otherwise, search in sys.path. If py is True, the file must be an uncompiled Python (.py) file.

openmdao.util.fileutil.find_up(name, path=None)

Search upward from the starting path (or the current directory) until the given file or directory is found. The given name is assumed to be a basename, not a path. Returns the absolute path of the file or directory if found, or None otherwise.

name: str

Base name of the file or directory being searched for.

path: str (optional)

Starting directory. If not supplied, current directory is used.

openmdao.util.fileutil.get_ancestor_dir(path, num_levels=1)

Return the name of the directory that is ‘num_levels’ levels above the specified path. If num_levels is larger than the number of members in the path, then the root directory name will be returned.

openmdao.util.fileutil.get_cfg_file()

Attempts to get the /OpenMDAO-Framework/config/testhosts.cfg first; then gets the ~/.openmdao/testhosts.cfg next.

openmdao.util.fileutil.get_module_path(fpath)

Given a module filename, return its full Python name including enclosing packages. (based on existence of __init__.py files)

openmdao.util.fileutil.is_dev_build()

openmdao.util.fileutil.onerror(func, path, exc_info)

Error handler for shutil.rmtree.

If the error is due to an access error (read only file), it attempts to add write permission and then retries.

If the error is for another reason, it re-raises the error.

Usage : shutil.rmtree(path, onerror=onerror)

filewrap.py

A collection of utilities for file wrapping.

Note: This is a work in progress.

class openmdao.util.filewrap.FileParser(end_of_line_comment_char=None, full_line_comment_char=None)

Bases: object

Utility to locate and read data from a file.

mark_anchor(anchor, occurrence=1)

Marks the location of a landmark, which lets you describe data by relative position. Note that a forward search begins at the old anchor location. If you want to restart the search for the anchor at the file beginning, then call reset_anchor() before mark_anchor.

anchor: str

The text you want to search for.

occurrence: integer

Find nth instance of text; default is 1 (first). Use -1 to find last occurrence. Reverse searches always start at the end of the file no matter the state of any previous anchor.

reset_anchor()

Resets anchor to the beginning of the file.

set_delimiters(delimiter)

Lets you change the delimiter that is used to identify field boundaries.

delimiter: str

A string containing characters to be used as delimiters. The default value is ‘ ‘, which means that spaces and tabs are not taken as data but instead mark the boundaries. Note that the parser is smart enough to recognize characters within quotes as non-delimiters.

set_file(filename)

Set the name of the file that will be generated.

filename: str

Name of the input file to be generated.

transfer_2Darray(rowstart, fieldstart, rowend, fieldend=None)

Grabs a 2D array of variables relative to the current anchor. Each line of data is placed in a separate row.

rowstart: integer

Row number to start, relative to the current anchor.

fieldstart: integer

Field number to start.

rowend: integer

Row number to end relative to current anchor.

fieldend: integer (optional)

Field number to end. If not specified, grabs all fields up to the end of the line.

If the delimiter is set to ‘columns’, then the values contained in fieldstart and fieldend should be the column number instead of the field number.

transfer_array(rowstart, fieldstart, rowend=None, fieldend=None)

Grabs an array of variables relative to the current anchor.

rowstart: integer

Row number to start, relative to the current anchor.

fieldstart: integer

Field number to start.

rowend: integer (optional)

Row number to end. If not set, then only one row is grabbed.

Setting the delimiter to ‘columns’ elicits some special behavior from this method. Normally, the extraction process wraps around at the end of a line and continues grabbing each field at the start of a newline. When the delimiter is set to columns, the parameters (rowstart, fieldstart, rowend, fieldend) demark a box, and all values in that box are retrieved. Note that standard whitespace is the secondary delimiter in this case.

transfer_keyvar(key, field, occurrence=1, rowoffset=0)

Searches for a key relative to the current anchor and then grabs a field from that line.

field: integer

Which field to transfer. Field 0 is the key.

occurrence: integer

Find nth instance of text; default is 1 (first value field). Use -1 to find last occurance. Position 0 is the key field, so it should not be used as a value for occurrence.

rowoffset: integer (optional)

Optional row offset from the occurrence of key. This can also be negative.

You can do the same thing with a call to mark_anchor and transfer_var. This function just combines them for convenience.

transfer_line(row)

Returns a whole line, relative to current anchor.

row: integer

Number of lines offset from anchor line (0 is anchor line). This can be negative.

transfer_var(row, field, fieldend=None)

Grabs a single variable relative to the current anchor.

— If the delimiter is a set of chars (e.g., ”, ”) —

row: integer

Number of lines offset from anchor line (0 is anchor line). This can be negative.

field: integer

Which word in line to retrieve.

fieldend - IGNORED

— If the delimiter is “columns” —

row: integer

Number of lines offset from anchor line (0 is anchor line). This can be negative.

field: integer

Character position to start.

fieldend: integer (optional)

Position of last character to return. If omitted, the end of the line is used.

class openmdao.util.filewrap.InputFileGenerator

Bases: object

Utility to generate an input file from a template. Substitution of values is supported. Data is located with a simple API.

clearline(row)

Replace the contents of a row with the newline character.

row: integer

Row number to clear, relative to current anchor.

generate()

Use the template file to generate the input file.

mark_anchor(anchor, occurrence=1)

Marks the location of a landmark, which lets you describe data by relative position. Note that a forward search begins at the old anchor location. If you want to restart the search for the anchor at the file beginning, then call reset_anchor() before mark_anchor.

anchor: str

The text you want to search for.

occurrence: integer

Find nth instance of text; default is 1 (first). Use -1 to find last occurrence. Reverse searches always start at the end of the file no matter the state of any previous anchor.

reset_anchor()

Resets anchor to the beginning of the file.

set_delimiters(delimiter)

Lets you change the delimiter that is used to identify field boundaries.

delimiter: str

A string containing characters to be used as delimiters.

set_generated_file(filename)

Set the name of the file that will be generated.

filename: str

Name of the input file to be generated.

set_template_file(filename)

Set the name of the template file to be used The template file is also read into memory when this method is called.

filename: str

Name of the template file to be used.

transfer_2Darray(value, row_start, row_end, field_start, field_end, sep=', ')

Changes the values of a 2D array in the template relative to the current anchor. This method is specialized for 2D arrays, where each row of the array is on its own line.

value: ndarray

Array of values to insert.

row_start: integer

Starting row for inserting the array. This is relative to the anchor, and can be negative.

row_end: integer

Final row for the array, relative to the anchor.

field_start: integer

starting field in the given row_start as denoted by delimiter(s).

field_end: integer

The final field the array uses in row_end. We need this to figure out if the template is too small or large.

sep: str (optional) (currently unsupported)

Separator to append between values if we go beyond the template.

transfer_array(value, row_start, field_start, field_end, row_end=None, sep=', ')

Changes the values of an array in the template relative to the current anchor. This should generally be used for one-dimensional or free form arrays.

value: float, integer, bool, str

Array of values to insert.

row_start: integer

Starting row for inserting the array. This is relative to the anchor, and can be negative.

field_start: integer

Starting field in the given row_start as denoted by delimiter(s).

field_end: integer

The final field the array uses in row_end. We need this to figure out if the template is too small or large

row_end: integer (optional)

Use if the array wraps to cover additional lines.

sep: integer (optional)

Separator to use if we go beyond the template.

transfer_var(value, row, field)

Changes a single variable in the template relative to the current anchor.

row - number of lines offset from anchor line (0 is anchor line). This can be negative.

field - which word in line to replace, as denoted by delimiter(s)

class openmdao.util.filewrap.ToFloat(expr, savelist=False)

Bases: pyparsing.TokenConverter

Converter for PyParsing that is used to turn a token into a float.

postParse(instring, loc, tokenlist)

Converter to make token into a float.

class openmdao.util.filewrap.ToInf(expr, savelist=False)

Bases: pyparsing.TokenConverter

Converter for PyParsing that is used to turn a token into Python inf.

postParse(instring, loc, tokenlist)

Converter to make token into Python inf.

class openmdao.util.filewrap.ToInteger(expr, savelist=False)

Bases: pyparsing.TokenConverter

Converter for PyParsing that is used to turn a token into an int.

postParse(instring, loc, tokenlist)

Converter to make token into an integer.

class openmdao.util.filewrap.ToNan(expr, savelist=False)

Bases: pyparsing.TokenConverter

Converter for PyParsing that is used to turn a token into Python nan.

postParse(instring, loc, tokenlist)

Converter to make token into Python nan.

filexfer.py

openmdao.util.filexfer.filexfer(src_server, src_path, dst_server, dst_path, mode='')

Transfer a file from one place to another.

If src_server or dst_server is None, then the os module is used for the source or destination respectively. Otherwise the respective object must support open(), stat(), and chmod().

After the copy has completed, permission bits from stat() are set via chmod().

src_server: Proxy

Host to get file from.

src_path: string

Path to file on src_server.

dst_server: Proxy

Host to put file to.

dst_path: string

Path to file on dst_server.

mode: string

Mode settings for open(), not including ‘r’ or ‘w’.

openmdao.util.filexfer.pack_zipfile(patterns, filename, logger=None)

Create ‘zip’ file filename of files in patterns. Returns (nfiles, nbytes).

patterns: list

List of fnmatch style patterns.

filename: string

Name of zip file to create.

logger: Logger

Used for recording progress.

Note

The code uses glob.glob() to process patterns. It does not check for the existence of any matches.

openmdao.util.filexfer.translate_newlines(filename)

Translate the newlines of filename to the local standard.

filename: string

Name of the file to be translated. The translated file will replace this file.

openmdao.util.filexfer.unpack_zipfile(filename, logger=None, textfiles=None)

Unpack ‘zip’ file filename. Returns (nfiles, nbytes).

filename: string

Name of zip file to unpack.

logger: Logger

Used for recording progress.

textfiles: list

List of fnmatch style patterns specifying which unpacked files are text files possibly needing newline translation. If not supplied, the first 4KB of each is scanned for a zero byte. If none is found, then the file is assumed to be a text file.

git.py

openmdao.util.git.download_github_tar(org_name, repo_name, version, dest='.')

Pull a tarfile of a GitHub repo and place it in the specified destination directory. ‘version’ can be a tag or a commit id.

grab_distrib.py

openmdao.util.grab_distrib.grab_distrib(req, index=None, dest='.', search_pypi=True)

Downloads a distribution from the given package index(s) based on the given requirement string(s). Downloaded distributions are placed in the specified destination or the current directory if no destination is specified. If a distribution cannot be found in the given index(s), the Python Package Index will be searched as a last resort unless search_pypi is False. This does NOT install the distribution.

Requirements may be supplied as strings or as Requirement objects.

graph.py

openmdao.util.graph.dump_valid(graph, filter=None, stream=None)

openmdao.util.graph.edges_matching_all(graph, **kwargs)

Return an iterator over edges matching all kwargs names and values. For example, edges_matching_all(G, foo=True, bar=True) would return a list of all edges that are marked with True values of both foo and bar.

openmdao.util.graph.edges_matching_some(graph, **kwargs)

Return an iterator over edges matching some kwargs names and values. For example, edges_matching_some(G, foo=True, bar=True) would return a list of all edges that are marked with True values of either foo or bar or both.

openmdao.util.graph.edges_to_dict(edges, dct=None)

Take an iterator of edges and return an ordered dict of sources mapped to lists of destinations.

openmdao.util.graph.flatten_list_of_iters(lst)

Returns a list of simple values, flattening any sub-lists or sub-tuples, or if the input is a string it just returns that string. NOTE: this only goes down one level.

openmdao.util.graph.get_valids(graph, val, prefix=None)

Returns all nodes with validity matching the given value.

openmdao.util.graph.nodes_matching_all(graph, **kwargs)

Return an iterator over nodes matching all kwargs names and values. For example, nodes_matching_all(G, valid=True, boundary=True) would return a list of all nodes that are marked as valid that are also boundary nodes.

openmdao.util.graph.nodes_matching_some(graph, **kwargs)

Return an iterator over nodes matching at least one of the kwargs names and values. For example, nodes_matching_some(G, valid=True, boundary=True) would return a list of all nodes that either are marked as valid or nodes that are boundary nodes, or nodes that are both.

graphplot.py

openmdao.util.graphplot.main()

openmdao.util.graphplot.plot_graph(graph, scope=None, parent=None, excludes=(), d3page='fixedforce.html')

Open up a display of the graph in a browser window.

openmdao.util.graphplot.plot_graphs(obj, recurse=False)

Return a list of tuples of the form (scope, parent, graph)

lib.py

openmdao.util.lib.add_to_pathvar(pathvarname, newpaths)

Reads the value of the pathvarname variable in the environment, add the specified paths to the end of it, removes duplicates, and returns the new value. The environment variable specified by pathvarname is assumed to be a ‘path’ type of variable, e.g. PATH, LD_LIBRARY_PATH, etc.

openmdao.util.lib.combine_paths()

Calls add_to_varpath with the first two command line args and prints the result.

openmdao.util.lib.get_env_libpath()

Find all of the shared libraries in the current virtual environment and return the string that must be added to LD_LIBRARY_PATH (or equivalent) in order to locate them.

openmdao.util.lib.get_full_libpath()

Find all of the shared libraries in the current virtual environment and return the required LD_LIBRARY_PATH string (or equivalent) necessary to find them.

openmdao.util.lib.update_libpath()

Updates LD_LIBRARY_PATH (or equivalent) in the activate script with new entries based on shared libraries found while searching the current virtual environment. Because the changes are applied to the activate (or activate.bat) script, the virtual environment must be re-activated in order for the environment to be updated.

log.py

This is just a wrapper for the logging module. Messages can be routed to the console via enable_console(). If the file logger.cfg exists, it can be used to configure logging. See the Python documentation for logging.config for details. The example below is equivalent to calling enable_console():

[loggers]
keys=root

[handlers]
keys=consoleHandler

[formatters]
keys=consoleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=consoleFormatter
args=(sys.stderr,)

[formatter_consoleFormatter]
format=%(levelname)s %(name)s: %(message)s

class openmdao.util.log.Logger(name, level=None)

Bases: object

Pickle-able logger. Mostly a pass-through to a real logger.

critical(msg, *args, **kwargs)

Log a critical message.

debug(msg, *args, **kwargs)

Log a debug message.

error(msg, *args, **kwargs)

Log an error message.

exception(msg, *args, **kwargs)

Log an exception.

info(msg, *args, **kwargs)

Log an information message.

log(level, msg, *args, **kwargs)

Log a message at a specified level.

rename(name)

Change name reported in log.

warning(msg, *args, **kwargs)

Log a warning message.

level

Logging message level.

class openmdao.util.log.NullLogger

Bases: object

Can be useful when no logger has been supplied to a routine. It produces no output.

critical(msg, *args, **kwargs)

Log a critical message.

debug(msg, *args, **kwargs)

Log a debug message.

error(msg, *args, **kwargs)

Log an error message.

exception(msg, *args, **kwargs)

Log an exception.

info(msg, *args, **kwargs)

Log an information message.

log(level, msg, *args, **kwargs)

Log a message at a specified level.

warning(msg, *args, **kwargs)

Log a warning message.

openmdao.util.log.getLogger(name)

Return the named logger.

openmdao.util.log.enable_console(level=10)

Configure logging to receive log messages at the console.

openmdao.util.log.disable_console()

Stop receiving log messages at the console.

openmdao.util.log.enable_trace(stream=None)

Enable iteration tracing.

stream: file or string

File object or filename for trace output. Only used on first enable, default sys.stderr.

openmdao.util.log.disable_trace()

Disable iteration tracing.

mkpseudo.py

openmdao.util.mkpseudo.mkpseudo(argv=None)

A command line script (mkpseudo) points to this. It generates a source distribution package that’s empty aside from having a number of dependencies on other packages.

usage: make_pseudopkg <pkg_name> <version> [-d <dest_dir>] [-l <links_url>] [-r req1] ... [-r req_n]

If pkg_name contains dots, a namespace package will be built.

Required dependencies are specified using the same notation used by setuptools/easy_install/distribute/pip.

Note

If your required dependencies use the “<” or “>” characters, you must put the entire requirement in quotes to avoid misinterpretation by the shell.

namelist_util.py

Utilities for reading and writing Fortran namelists.

class openmdao.util.namelist_util.Card(name, value, is_comment=0)

Bases: object

Data object that stores the value of a single card for a namelist.

class openmdao.util.namelist_util.Namelist(comp)

Bases: object

Utility to ease the task of constructing a formatted output file.

add_comment(comment)

Add a comment in the namelist.

comment: string

Comment text to be added. Text should include comment character if one is desired. (Note that a comment character isn’t always needed in a Namelist. It seems to figure out whether something is a comment without it.)

add_container(varpath='', skip=None)

Add every variable in an OpenMDAO container to the namelist. This can be used it your component has containers of variables.

varpath: string

Dotted path of container in the data hierarchy.

skip: list of str

List of variables to skip printing to the file.

add_group(name)

Add a new group to the namelist. Any variables added after this are added to this new group.

name: string

Group name to be added.

add_newvar(name, value)

Add a new variable to the namelist.

name: string

Name of the variable to be added.

value: int, float, string, ndarray, list, bool

Value of the variable to be added.

add_var(varpath)

Add an openmdao variable to the namelist.

varpath: string varpath is the dotted path (e.g., comp1.container1.var1).

find_card(group, name)

Returns the value for a given namelist variable in a given group.

group: string

namelist group name.

name: string

namelist variable name.

generate()

Generates the input file. This should be called after all cards and groups are added to the namelist.

load_model(rules=None, ignore=None, single_group=-1)

Loads the current deck into an OpenMDAO component.

rules: dict of lists of strings (optional)

An optional dictionary of rules can be passed if the component has a hierarchy of containers for its input variables. If no rules dictionary is passed, load_model will attempt to find each namelist variable in the top level of the model hierarchy.

ignore: list of strings (optional)

List of variable names that can safely be ignored.

single_group: integer (optional)

Group id number to use for processing one single namelist group. Useful if extra processing is needed or if multiple groups have the same name.

Returns a tuple containing the following values: (empty_groups, unlisted_groups, unlinked_vars). These need to be examined after calling load_model to make sure you loaded every variable into your model.

empty_groups: ordereddict( integer : string )

Names and ID number of groups that don’t have cards. This includes strings found at the top level that aren’t comments; these need to be processed by your wrapper to determine how the information fits into your component’s variable hierarchy.

unlisted_groups: ordereddict( integer : string )

This dictionary includes the names and ID number of groups that have variables that couldn’t be loaded because the group wasn’t mentioned in the rules dictionary.

unlinked_vars: list containing all variable names that weren’t found in the component.

parse_file()

Parses an existing namelist file and creates a deck of cards to hold the data. After this is executed, you need to call the load_model() method to extract the variables from this data structure.

set_filename(filename)

Set the name of the file that will be generated or parsed.

filename: string

Name of the file to be written.

set_title(title)

Sets the title for the namelist Note that a title is not required.

title: string

The title card in the namelist - generally optional.

class openmdao.util.namelist_util.ToBool(expr, savelist=False)

Bases: pyparsing.TokenConverter

Converter for PyParsing that is used to turn a token into a Boolean.

postParse(instring, loc, tokenlist)

Converter to make token into a bool.

nameutil.py

openmdao.util.nameutil.isidentifier(candidate)

Is the candidate string an identifier in Python 2.x ref: http://stackoverflow.com/questions/2544972/

openmdao.util.nameutil.partition_names_by_comp(names, compmap=None)

Take an iterator of names and return a dict with component names keyed to lists of variable names. Simple names (having no ‘.’ in them) will have a key of None.

For example, the list [‘abc.def’, ‘abc.pdq’, ‘foo’, ‘bar’] would return the dict { ‘abc’: [‘def’,’pdq’], None: [‘foo’, ‘bar’] }

If a compmap dict is passed in, it will be populated with data from the iterator of names.

network.py

Routines to help obtain debugging information.

openmdao.util.network.get_unused_ip_port()

Find an unused IP port.

ref: http://code.activestate.com/recipes/531822-pick-unused-port/

Note: Use the port before it is taken by some other process!

objects.py

openmdao.util.objects.has_class_changed(klass)

Return True if the given class is different from the class of the same name in the module that the class came from. This happens if the module was reloaded after the given class object was created.

parse_phoenixwrapper.py

Parses the variable definition section of a Phoenix Integration ModelCenter component wrapper and generates an OpenMDAO component stub.

openmdao.util.parse_phoenixwrapper.parse_phoenixwrapper(infile, outfile, compname)

Generates a dummy component given a Phoenix Integration Modelcenter script wrapper. The first section of this wrapper is parsed, and the appropriate variables and containers are placed in the new OpenMDAO component.

infile - ModelCenter scriptwrapper.

outfile - File containing new OpenMDAO component skeleton.

compname - Name for new component.

publickey.py

Support for generation, use, and storage of public/private key pairs. The pk_encrypt(), pk_decrypt(), pk_sign(), and pk_verify() functions provide a thin interface over Crypto.PublicKey.RSA methods for easier use and to work around some issues found with some keys read from ssh id_rsa files.

openmdao.util.publickey.decode_public_key(text)

Return public key from text representation.

text: string

base64 encoded key data.

openmdao.util.publickey.encode_public_key(key)

Return base64 text representation of public key key.

key: public key

Public part of key pair.

openmdao.util.publickey.get_key_pair(user_host, logger=None, overwrite_cache=False, ignore_ssh=False)

Returns RSA key containing both public and private keys for the user identified in user_host. This can be an expensive operation, so we avoid generating a new key pair whenever possible. If ~/.ssh/id_rsa exists and is private, that key is returned.

user_host: string

Format user@host.

logger: logging.Logger

Used for debug messages.

overwrite_cache: bool

If True, a new key is generated and forced into the cache of existing known keys. Used for testing.

ignore_ssh: bool

If True, ignore any existing ssh id_rsa key file. Used for testing.

Note

To avoid unnecessary key generation, the public/private key pair for the current user is stored in the private file ~/.openmdao/keys. On Windows this requires the pywin32 extension. Also, the public key is stored in ssh form in ~/.openmdao/id_rsa.pub.

openmdao.util.publickey.is_private(path)

Return True if path is accessible only by ‘owner’.

path: string

Path to file or directory to check.

Note

On Windows this requires the pywin32 extension.

openmdao.util.publickey.make_private(path)

Make path accessible only by ‘owner’.

path: string

Path to file or directory to be made private.

Note

On Windows this requires the pywin32 extension.

openmdao.util.publickey.pk_decrypt(encrypted, private_key)

Return encrypted decrypted by private_key as a string.

encrypted: list

Chunks of encrypted data returned by pk_encrypt().

private_key: Crypto.PublicKey.RSA

Private portion of key pair.

openmdao.util.publickey.pk_encrypt(data, public_key)

Return list of chunks of data encrypted by public_key.

data: string

The message to be encrypted.

public_key: Crypto.PublicKey.RSA

Public portion of key pair.

openmdao.util.publickey.pk_sign(hashed, private_key)

Return signature for hashed using private_key.

hashed: string

A hash value of the data to be signed.

private_key: Crypto.PublicKey.RSA

Private portion of key pair.

openmdao.util.publickey.pk_verify(hashed, signature, public_key)

Verify hashed based on signature and public_key.

hashed: string

A hash for the data that is signed.

signature: tuple

Value returned by pk_sign().

public_key: Crypto.PublicKey.RSA

Public portion of key pair.

openmdao.util.publickey.read_authorized_keys(filename=None, logger=None)

Return dictionary of public keys, indexed by user, read from filename. The file must be in ssh format, and only RSA keys are processed. If the file is not private, then no keys are returned.

filename: string

File to read from. The default is ~/.ssh/authorized_keys.

logger: logging.Logger

Used for log messages.

openmdao.util.publickey.write_authorized_keys(allowed_users, filename, logger=None)

Write allowed_users to filename in ssh format. The file will be made private if supported on this platform.

allowed_users: dict

Dictionary of public keys indexed by user.

filename: string

File to write to.

logger: logging.Logger

Used for log messages.

shellproc.py

exception openmdao.util.shellproc.CalledProcessError(returncode, cmd, errormsg)

Bases: subprocess.CalledProcessError

subprocess.CalledProcessError plus errormsg attribute.

class openmdao.util.shellproc.ShellProc(args, stdin=None, stdout=None, stderr=None, env=None, universal_newlines=False)

Bases: subprocess.Popen

A slight modification to subprocess.Popen. If args is a string, then the shell argument is set True. Updates a copy of os.environ with env and opens files for any stream which is a basestring.

args: string or list

If a string, then this is the command line to execute and the subprocess.Popen shell argument is set True. Otherwise, this is a list of arguments; the first is the command to execute.

stdin, stdout, stderr: string, file, or int

Specify handling of corresponding stream. If a string, a file of that name is opened. Otherwise, see the subprocess documentation.

env: dict

Environment variables for the command.

close_files()

Closes files that were implicitly opened.

error_message(return_code)

Return error message for return_code. The error messages are derived from the operating system definitions. Some programs don’t necessarily return exit codes conforming to these definitions.

return_code: int

Return code from poll().

terminate(timeout=None)

Stop child process. If timeout is specified, then wait() will be called to wait for the process to terminate.

timeout: float (seconds)

Maximum time to wait for the process to stop. A value of zero implies an infinite maximum wait.

wait(poll_delay=0.0, timeout=0.0)

Polls for command completion or timeout. Closes any files implicitly opened. Returns (return_code, error_msg).

poll_delay: float (seconds)

Time to delay between polling for command completion. A value of zero uses an internal default.

timeout: float (seconds)

Maximum time to wait for command completion. A value of zero implies an infinite maximum wait.

openmdao.util.shellproc.call(args, stdin=None, stdout=None, stderr=None, env=None, poll_delay=0.0, timeout=0.0)

Run command with arguments. Returns (return_code, error_msg).

args: string or list

If a string, then this is the command line to execute and the subprocess.Popen shell argument is set True. Otherwise, this is a list of arguments; the first is the command to execute.

stdin, stdout, stderr: string, file, or int

Specify handling of corresponding stream. If a string, a file of that name is opened. Otherwise, see the subprocess documentation.

env: dict

Environment variables for the command.

poll_delay: float (seconds)

Time to delay between polling for command completion. A value of zero uses an internal default.

timeout: float (seconds)

Maximum time to wait for command completion. A value of zero implies an infinite maximum wait.

openmdao.util.shellproc.check_call(args, stdin=None, stdout=None, stderr=None, env=None, poll_delay=0.0, timeout=0.0)

Run command with arguments. If non-zero, return_code raises CalledProcessError.

args: string or list

If a string, then this is the command line to execute, and the subprocess.Popen shell argument is set True. Otherwise, this is a list of arguments; the first is the command to execute.

stdin, stdout, stderr: string, file, or int

Specify handling of corresponding stream. If a string, a file of that name is opened. Otherwise, see the subprocess documentation.

env: dict

Environment variables for the command.

poll_delay: float (seconds)

Time to delay between polling for command completion. A value of zero uses an internal default.

timeout: float (seconds)

Maximum time to wait for command completion. A value of zero implies an infinite maximum wait.

stream.py

class openmdao.util.stream.Stream(file_obj, binary=False, big_endian=False, single_precision=False, integer_8=False, unformatted=False, recordmark_8=False)

Bases: object

Wrapper of standard Python file object. Supports reading/writing int and float arrays in various formats.

file_obj: file

File object opened for reading or writing.

binary: bool

If True, the data is in binary, not text, form.

big_endian: bool

If True, the data bytes are in ‘big-endian’ order. Only meaningful if binary.

single_precision: bool

If True, floating-point data is 32 bits, not 64. Only meaningful if binary.

integer_8: bool

If True, integer data is 64 bits, not 32. Only meaningful if binary.

unformatted: bool

If True, the data is surrounded by Fortran record length markers. Only meaningful if binary.

recordmark_8: bool

If True, the record length markers are 64 bits, not 32. Only meaningful if unformatted.

close()

Close underlying file.

read_float(full_record=False)

Returns next float.

full_record: bool

If True, then read surrounding recordmarks. Only meaningful if unformatted.

read_floats(shape, order='C', full_record=False)

Returns floats as a numpy array of shape.

shape: tuple(int)

Dimensions of returned array.

order: string

If ‘C’, the data is in row-major order. If ‘Fortran’, the data is in column-major order.

full_record: bool

If True, then read surrounding recordmarks. Only meaningful if unformatted.

read_int(full_record=False)

Returns next integer.

full_record: bool

If True, then read surrounding recordmarks. Only meaningful if unformatted.

read_ints(shape, order='C', full_record=False)

Returns integers as a numpy array of shape.

shape: tuple(int)

Dimensions of returned array.

order: string

If ‘C’, the data is in row-major order. If ‘Fortran’, the data is in column-major order.

full_record: bool

If True, then read surrounding recordmarks. Only meaningful if unformatted.

read_recordmark()

Returns value of next recordmark.

reclen_floats(count)

Returns record length for count floats.

count: int

Number of floats in record.

reclen_ints(count)

Returns record length for count ints.

count: int

Number of ints in record.

write_array(data, order='C', fmt='%s', sep=' ', linecount=0)

Writes array as text.

data: numpy.ndarray

Data array.

order: string

If ‘C’, the data is written in row-major order. If ‘Fortran’, the data is written in column-major order.

fmt: string

Format specifier for each item.

sep: string

Separator between items.

linecount: int

If > zero, then at most linecount values are written per line.

write_float(value, fmt='%.16g', sep='', full_record=False)

Writes a float.

value: float

Value to be written.

fmt: string

Format to use when writing as text.

sep: string

Appended to stream after writing value.

full_record: bool

If True, then write surrounding recordmarks. Only meaningful if unformatted.

write_floats(data, order='C', fmt='%.16g', sep=' ', linecount=0, full_record=False)

Writes a float array.

data: numpy.ndarray

Float data array.

order: string

If ‘C’, the data is written in row-major order. If ‘Fortran’, the data is written in column-major order.

fmt: string

Format specifier for each item.

sep: string

Separator between items.

linecount: int

If > zero, then at most linecount values are written per line.

full_record: bool

If True, then write surrounding recordmarks. Only meaningful if unformatted.

write_int(value, fmt='%d', sep='', full_record=False)

Writes an integer.

value: int

Value to be written.

fmt: string

Format to use when writing as text.

sep: string

Appended to stream after writing value.

full_record: bool

If True, then write surrounding recordmarks. Only meaningful if unformatted.

write_ints(data, order='C', fmt='%d', sep=' ', linecount=0, full_record=False)

Writes an integer array.

data: numpy.ndarray

Integer data array.

order: string

If ‘C’, the data is written in row-major order. If ‘Fortran’, the data is written in column-major order.

fmt: string

Format specifier for each item.

sep: string

Separator between items.

linecount: int

If > zero, then at most linecount values are written per line.

full_record: bool

If True, then write surrounding recordmarks. Only meaningful if unformatted.

write_recordmark(length)

Writes recordmark.

length: int

Length of record (bytes).

testutil.py

Utilities for the OpenMDAO test process.

openmdao.util.testutil.assertRaisesError(test_case_instance, code, err_type, err_msg)

Determine that code raises err_type with err_msg.

openmdao.util.testutil.assert_raises(test_case, code, globals, locals, exception, msg, use_exec=False)

Determine that code raises exception with msg.

test_case: unittest.TestCase

TestCase instance used for assertions.

code: string

Statement to be executed.

globals, locals: dict

Arguments for eval().

exception: Exception

Exception that should be raised.

msg: string

Expected message from exception.

use_exec: bool

If True, then evaluate code with exec() rather than eval(). This is necessary for testing statements that are not expressions.

openmdao.util.testutil.assert_rel_error(test_case, actual, desired, tolerance)

Determine that the relative error between actual and desired is within tolerance. If desired is zero, then use absolute error.

test_case: unittest.TestCase

TestCase instance used for assertions.

actual: float

The value from the test.

desired: float

The value expected.

tolerance: float

Maximum relative error (actual - desired) / desired.

openmdao.util.testutil.case_assert_rel_error(case1, case2, test_case, tolerance)

Perform assert_rel_error when comparing two Case objects.

openmdao.util.testutil.find_python()

Return path to the OpenMDAO Python command.

openmdao.util.testutil.make_protected_dir()

Returns the the absolute path of an inaccessible directory. Files cannot be created in it; it can’t be os.chdir() to, etc. Not supported on Windows.

typegroups.py

user.py

openmdao.util.user.get_username()

Return username for current user.

view_docs.py

openmdao.util.view_docs.view_docs(browser=None)

A script (openmdao docs) points to this. It just pops up a browser to view the openmdao Sphinx docs. If the docs are not already built, it builds them before viewing; but if the docs already exist, it’s not smart enough to rebuild them if they’ve changed since the last build.

If this is run from a non-developer install (i.e., there is no local copy of the docs), it just looks for the docs on the openmdao.org website.

wrkpool.py

class openmdao.util.wrkpool.WorkerPool

Bases: object

Pool of worker threads; grows as necessary.

static cleanup()

Cleanup resources (worker threads).

static get(one_shot=False)

Get a worker queue from the pool. Work requests should be of the form:

(callable, *args, **kwargs, reply_queue)

Work replies are of the form:

(queue, retval, exc, traceback)

one_shot: bool

If True, the worker will self-release after processing one request.

static get_instance()

Return singleton instance.

static release(queue)

Release a worker queue back to the pool.

queue: Queue

Worker queue previously obtained from get().