galaxy.util package

Utility functions used systemwide.

class galaxy.util.ExecutionTimer[source]

Bases: object

__init__()[source]
class galaxy.util.Params(params, sanitize=True)[source]

Bases: object

Stores and ‘sanitizes’ parameters. Alphanumeric characters and the non-alphanumeric ones that are deemed safe are let to pass through (see L{valid_chars}). Some non-safe characters are escaped to safe forms for example C{>} becomes C{__lt__} (see L{mapped_chars}). All other characters are replaced with C{X}.

Operates on string or list values only (HTTP parameters).

>>> values = { 'status':'on', 'symbols':[  'alpha', '<>', '$rm&#!' ]  }
>>> par = Params(values)
>>> par.status
'on'
>>> par.value == None      # missing attributes return None
True
>>> par.get('price', 0)
0
>>> par.symbols            # replaces unknown symbols with X
['alpha', '__lt____gt__', 'XrmX__pd__!']
>>> sorted(par.flatten())  # flattening to a list
[('status', 'on'), ('symbols', 'XrmX__pd__!'), ('symbols', '__lt____gt__'), ('symbols', 'alpha')]
NEVER_SANITIZE = ['file_data', 'url_paste', 'URL', 'filesystem_paths']
__init__(params, sanitize=True)[source]
flatten()[source]

Creates a tuple list from a dict with a tuple/value pair for every value that is a list

get(key, default)[source]
update(values)[source]
class galaxy.util.ParamsWithSpecs(specs=None, params=None)[source]

Bases: collections.defaultdict

__init__(specs=None, params=None)[source]
galaxy.util.asbool(obj)[source]
galaxy.util.build_url(base_url, port=80, scheme='http', pathspec=None, params=None, doseq=False)[source]
galaxy.util.commaify(amount)[source]
galaxy.util.compare_urls(url1, url2, compare_scheme=True, compare_hostname=True, compare_path=True)[source]
galaxy.util.config_directories_from_setting(directories_setting, galaxy_root='/var/jenkins/workspace/Sphinx-Docs/lib/galaxy/util/../../..')[source]

Parse the directories_setting into a list of relative or absolute filesystem paths that will be searched to discover plugins.

Parameters:
  • galaxy_root (string) – the root path of this galaxy installation
  • directories_setting (string (default: None)) – the filesystem path (or paths) to search for plugins. Can be CSV string of paths. Will be treated as absolute if a path starts with ‘/’, relative otherwise.
Return type:

list of strings

Returns:

list of filesystem paths

galaxy.util.directory_hash_id(id)[source]
>>> directory_hash_id( 100 )
['000']
>>> directory_hash_id( "90000" )
['090']
>>> directory_hash_id("777777777")
['000', '777', '777']
>>> directory_hash_id("135ee48a-4f51-470c-ae2f-ce8bd78799e6")
['1', '3', '5']
galaxy.util.docstring_trim(docstring)[source]

Trimming python doc strings. Taken from: http://www.python.org/dev/peps/pep-0257/

galaxy.util.download_to_file(url, dest_file_path, timeout=30, chunk_size=1048576)[source]

Download a URL to a file in chunks.

galaxy.util.file_iter(fname, sep=None)[source]

This generator iterates over a file and yields its lines splitted via the C{sep} parameter. Skips empty lines and lines starting with the C{#} character.

>>> lines = [ line for line in file_iter(__file__) ]
>>> len(lines) !=  0
True
galaxy.util.file_reader(fp, chunk_size=65536)[source]

This generator yields the open fileobject in chunks (default 64k). Closes the file at the end

galaxy.util.galaxy_directory()[source]
galaxy.util.get_charset_from_http_headers(headers, default=None)[source]
galaxy.util.get_file_size(value, default=None)[source]
galaxy.util.in_directory(file, directory, local_path_module=<module 'posixpath' from '/var/jenkins/shiningpanda/jobs/1f5cc05e/virtualenvs/d41d8cd9/lib/python2.7/posixpath.pyc'>)[source]

Return true, if the common prefix of both is equal to directory e.g. /a/b/c/d.rst and directory is /a/b, the common prefix is /a/b

galaxy.util.is_binary(value, binary_chars=None)[source]

File is binary if it contains a null-byte by default (e.g. behavior of grep, etc.). This may fail for utf-16 files, but so would ASCII encoding. >>> is_binary( string.printable ) False >>> is_binary( ‘xcex94’ ) False >>> is_binary( ‘000’ ) True

galaxy.util.is_uuid(value)[source]

This method returns True if value is a UUID, otherwise False. >>> is_uuid( “123e4567-e89b-12d3-a456-426655440000” ) True >>> is_uuid( “0x3242340298902834” ) False

galaxy.util.listify(item, do_strip=False)[source]

Make a single item a single item list, or return a list if passed a list. Passing a None returns an empty list.

galaxy.util.mask_password_from_url(url)[source]

Masks out passwords from connection urls like the database connection in galaxy.ini

>>> mask_password_from_url( 'sqlite+postgresql://user:password@localhost/' )
'sqlite+postgresql://user:********@localhost/'
>>> mask_password_from_url( 'amqp://user:amqp@localhost' )
'amqp://user:********@localhost'
>>> mask_password_from_url( 'amqp://localhost')
'amqp://localhost'
galaxy.util.merge_sorted_iterables(operator, *iterables)[source]
>>> operator = lambda x: x
>>> list( merge_sorted_iterables( operator, [1,2,3], [4,5] ) )
[1, 2, 3, 4, 5]
>>> list( merge_sorted_iterables( operator, [4, 5], [1,2,3] ) )
[1, 2, 3, 4, 5]
>>> list( merge_sorted_iterables( operator, [1, 4, 5], [2], [3] ) )
[1, 2, 3, 4, 5]
galaxy.util.mkstemp_ln(src, prefix='mkstemp_ln_')[source]

From tempfile._mkstemp_inner, generate a hard link in the same dir with a random name. Created so we can persist the underlying file of a NamedTemporaryFile upon its closure.

galaxy.util.move_merge(source, target)[source]
galaxy.util.nice_size(size)[source]

Returns a readably formatted string with the size

>>> nice_size(100)
'100 bytes'
>>> nice_size(10000)
'9.8 KB'
>>> nice_size(1000000)
'976.6 KB'
>>> nice_size(100000000)
'95.4 MB'
galaxy.util.object_to_string(obj)[source]
galaxy.util.parse_int(value, min_val=None, max_val=None, default=None, allow_none=False)[source]
galaxy.util.parse_non_hex_float(s)[source]

Parse string s into a float but throw a ValueError if the string is in the otherwise acceptable format d+ed+ (e.g. 40000000000000e5.)

This can be passed into json.loads to prevent a hex string in the above format from being incorrectly parsed as a float in scientific notation.

>>> parse_non_hex_float( '123.4' )
123.4
>>> parse_non_hex_float( '2.45e+3' )
2450.0
>>> parse_non_hex_float( '2.45e-3' )
0.00245
>>> parse_non_hex_float( '40000000000000e5' )
Traceback (most recent call last):
    ...
ValueError: could not convert string to float: 40000000000000e5
galaxy.util.parse_xml(fname)[source]

Returns a parsed xml tree

galaxy.util.parse_xml_string(xml_string)[source]
galaxy.util.pretty_print_json(json_data, is_json_string=False)[source]
galaxy.util.pretty_print_time_interval(time=False, precise=False)[source]

Get a datetime object or a int() Epoch timestamp and return a pretty string like ‘an hour ago’, ‘Yesterday’, ‘3 months ago’, ‘just now’, etc credit: http://stackoverflow.com/questions/1551382/user-friendly-time-format-in-python

galaxy.util.pretty_print_xml(elem, level=0)[source]
galaxy.util.read_build_sites(filename, check_builds=True)[source]

read db names to ucsc mappings from file, this file should probably be merged with the one above

galaxy.util.read_dbnames(filename)[source]

Read build names from file

galaxy.util.ready_name_for_url(raw_name)[source]

General method to convert a string (i.e. object name) to a URL-ready slug.

>>> ready_name_for_url( "My Cool Object" )
'My-Cool-Object'
>>> ready_name_for_url( "!My Cool Object!" )
'My-Cool-Object'
>>> ready_name_for_url( "Hello₩◎ґʟⅾ" )
'Hello'
galaxy.util.recursively_stringify_dictionary_keys(d)[source]
galaxy.util.remove_protocol_from_url(url)[source]

Supplied URL may be null, if not ensure http:// or https:// etc... is stripped off.

galaxy.util.restore_text(text, character_map={'@': '__at__', '\t': '__tc__', '\n': '__cn__', '\r': '__cr__', '[': '__ob__', ']': '__cb__', '#': '__pd__', '"': '__dq__', "'": '__sq__', '{': '__oc__', '}': '__cc__', '<': '__lt__', '>': '__gt__'})[source]

Restores sanitized text

galaxy.util.roundify(amount, sfs=2)[source]

Take a number in string form and truncate to ‘sfs’ significant figures.

galaxy.util.rst_to_html(s)[source]

Convert a blob of reStructuredText to HTML

galaxy.util.safe_makedirs(path)[source]

Safely make a directory, do not fail if it already exist or is created during execution.

galaxy.util.safe_relpath(path)[source]

Given what we expect to be a relative path, determine whether the path would exist inside the current directory.

Parameters:path (string) – a path to check
Return type:bool
Returns:True if path is relative and does not reference a path in a parent directory, False otherwise.
galaxy.util.safe_str_cmp(a, b)[source]

safely compare two strings in a timing-attack-resistant manner

galaxy.util.sanitize_for_filename(text, default=None)[source]

Restricts the characters that are allowed in a filename portion; Returns default value or a unique id string if result is not a valid name. Method is overly aggressive to minimize possible complications, but a maximum length is not considered.

galaxy.util.sanitize_lists_to_string(values, valid_characters=set(['!', ' ', ')', '(', '+', '*', '-', ', ', '/', '.', '1', '0', '3', '2', '5', '4', '7', '6', '9', '8', ':', '=', '?', 'A', 'C', 'B', 'E', 'D', 'G', 'F', 'I', 'H', 'K', 'J', 'M', 'L', 'O', 'N', 'Q', 'P', 'S', 'R', 'U', 'T', 'W', 'V', 'Y', 'X', 'Z', '_', '^', 'a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k', 'j', 'm', 'l', 'o', 'n', 'q', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y', 'x', 'z']), character_map={'@': '__at__', '\t': '__tc__', '\n': '__cn__', '\r': '__cr__', '[': '__ob__', ']': '__cb__', '#': '__pd__', '"': '__dq__', "'": '__sq__', '{': '__oc__', '}': '__cc__', '<': '__lt__', '>': '__gt__'}, invalid_character='X')[source]
galaxy.util.sanitize_param(value, valid_characters=set(['!', ' ', ')', '(', '+', '*', '-', ', ', '/', '.', '1', '0', '3', '2', '5', '4', '7', '6', '9', '8', ':', '=', '?', 'A', 'C', 'B', 'E', 'D', 'G', 'F', 'I', 'H', 'K', 'J', 'M', 'L', 'O', 'N', 'Q', 'P', 'S', 'R', 'U', 'T', 'W', 'V', 'Y', 'X', 'Z', '_', '^', 'a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k', 'j', 'm', 'l', 'o', 'n', 'q', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y', 'x', 'z']), character_map={'@': '__at__', '\t': '__tc__', '\n': '__cn__', '\r': '__cr__', '[': '__ob__', ']': '__cb__', '#': '__pd__', '"': '__dq__', "'": '__sq__', '{': '__oc__', '}': '__cc__', '<': '__lt__', '>': '__gt__'}, invalid_character='X')[source]

Clean incoming parameters (strings or lists)

galaxy.util.sanitize_text(text, valid_characters=set(['!', ' ', ')', '(', '+', '*', '-', ', ', '/', '.', '1', '0', '3', '2', '5', '4', '7', '6', '9', '8', ':', '=', '?', 'A', 'C', 'B', 'E', 'D', 'G', 'F', 'I', 'H', 'K', 'J', 'M', 'L', 'O', 'N', 'Q', 'P', 'S', 'R', 'U', 'T', 'W', 'V', 'Y', 'X', 'Z', '_', '^', 'a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k', 'j', 'm', 'l', 'o', 'n', 'q', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y', 'x', 'z']), character_map={'@': '__at__', '\t': '__tc__', '\n': '__cn__', '\r': '__cr__', '[': '__ob__', ']': '__cb__', '#': '__pd__', '"': '__dq__', "'": '__sq__', '{': '__oc__', '}': '__cc__', '<': '__lt__', '>': '__gt__'}, invalid_character='X')[source]

Restricts the characters that are allowed in text; accepts both strings and lists of strings; non-string entities will be cast to strings.

galaxy.util.send_mail(frm, to, subject, body, config, html=None)[source]

Sends an email.

Parameters:
  • frm (str) – from address
  • to (str) – to address
  • subject (str) – Subject line
  • body (str) – Body text (should be plain text)
  • config (object) – Galaxy configuration object
  • html (str) – Alternative HTML representation of the body content. If provided will convert the message to a MIMEMultipart. (Default ‘None’)
galaxy.util.shrink_stream_by_size(value, size, join_by='..', left_larger=True, beginning_on_size_error=False, end_on_size_error=False)[source]
galaxy.util.shrink_string_by_size(value, size, join_by='..', left_larger=True, beginning_on_size_error=False, end_on_size_error=False)[source]
galaxy.util.size_to_bytes(size)[source]

Returns a number of bytes if given a reasonably formatted string with the size

galaxy.util.smart_str(s, encoding='utf-8', strings_only=False, errors='strict')[source]

Returns a bytestring version of ‘s’, encoded as specified in ‘encoding’.

If strings_only is True, don’t convert (some) non-string-like objects.

Adapted from an older, simpler version of django.utils.encoding.smart_str.

>>> assert smart_str(None) == b'None'
>>> assert smart_str(None, strings_only=True) is None
>>> assert smart_str(3) == b'3'
>>> assert smart_str(3, strings_only=True) == 3
>>> assert smart_str(b'a bytes string') == b'a bytes string'
>>> assert smart_str(u'a simple unicode string') == b'a simple unicode string'
>>> assert smart_str(u'à strange ünicode ڃtring') == b'\xc3\xa0 strange \xc3\xbcnicode \xda\x83tring'
>>> assert smart_str(b'\xc3\xa0n \xc3\xabncoded utf-8 string', encoding='latin-1') == b'\xe0n \xebncoded utf-8 string'
galaxy.util.string_as_bool(string)[source]
galaxy.util.string_as_bool_or_none(string)[source]
Returns True, None or False based on the argument:
True if passed True, ‘True’, ‘Yes’, or ‘On’ None if passed None or ‘None’ False otherwise

Note: string comparison is case-insensitive so lowecase versions of those function equivalently.

galaxy.util.string_to_object(s)[source]
galaxy.util.stringify_dictionary_keys(in_dict)[source]
galaxy.util.synchronized(func)[source]

This wrapper will serialize access to ‘func’ to a single thread. Use it as a decorator.

galaxy.util.umask_fix_perms(path, umask, unmasked_perms, gid=None)[source]

umask-friendly permissions fixing

galaxy.util.unicodify(value, encoding='utf-8', error='replace', default=None)[source]

Returns a unicode string or None.

galaxy.util.unique_id(KEY_SIZE=128)[source]

Generates an unique id

>>> ids = [ unique_id() for i in range(1000) ]
>>> len(set(ids))
1000
galaxy.util.url_get(base_url, password_mgr=None, pathspec=None, params=None)[source]

Make contact with the uri provided and return any contents.

galaxy.util.which(file)[source]
galaxy.util.xml_element_compare(elem1, elem2)[source]
galaxy.util.xml_element_list_compare(elem_list1, elem_list2)[source]
galaxy.util.xml_element_to_dict(elem)[source]
galaxy.util.xml_text(root, name=None)[source]

Returns the text inside an element

galaxy.util.xml_to_string(elem, pretty=False)[source]

Returns a string from an xml tree

Submodules

galaxy.util.aliaspickler module

class galaxy.util.aliaspickler.AliasPickleModule(aliases)[source]

Bases: object

__init__(aliases)[source]
dump(obj, fileobj, protocol=0)[source]
dumps(obj, protocol=0)[source]
load(fileobj)[source]
loads(string)[source]
class galaxy.util.aliaspickler.AliasUnpickler(aliases, *args, **kw)[source]

Bases: pickle.Unpickler

__init__(aliases, *args, **kw)[source]
find_class(module, name)[source]

galaxy.util.biostar module

Support for integration with the Biostar application

class galaxy.util.biostar.BiostarErrorReporter(hda, app)[source]

Bases: galaxy.tools.errors.ErrorReporter

galaxy.util.biostar.biostar_enabled(app)[source]
galaxy.util.biostar.biostar_logged_in(trans)[source]
galaxy.util.biostar.biostar_logout(trans)[source]
galaxy.util.biostar.get_biostar_url(app, payload=None, biostar_action=None)[source]
galaxy.util.biostar.populate_tag_payload(payload=None, tool=None)[source]
galaxy.util.biostar.populate_tool_payload(payload=None, tool=None)[source]
galaxy.util.biostar.slugify(text, delim=u'-')[source]

Generates an slightly worse ASCII-only slug.

galaxy.util.biostar.tag_for_tool(tool)[source]

Generate a reasonable biostar tag for a tool.

galaxy.util.bunch module

class galaxy.util.bunch.Bunch(**kwds)[source]

Bases: object

http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/52308

Often we want to just collect a bunch of stuff together, naming each item of the bunch; a dictionary’s OK for that, but a small do-nothing class is even handier, and prettier to use.

__init__(**kwds)[source]
dict()[source]
get(key, default=None)[source]
items()[source]
keys()[source]
values()[source]

galaxy.util.checkers module

galaxy.util.checkers.check_binary(name, file_path=True)[source]
galaxy.util.checkers.check_bz2(file_path)[source]
galaxy.util.checkers.check_gzip(file_path)[source]
galaxy.util.checkers.check_html(file_path, chunk=None)[source]
galaxy.util.checkers.check_image(file_path)[source]

Simple wrapper around image_type to yield a True/False verdict

galaxy.util.checkers.check_zip(file_path)[source]
galaxy.util.checkers.is_gzip(file_path)[source]
galaxy.util.checkers.is_bz2(file_path)[source]

galaxy.util.dbkeys module

Functionality for dealing with dbkeys.

class galaxy.util.dbkeys.GenomeBuilds(app, data_table_name='__dbkeys__', load_old_style=True)[source]

Bases: object

__init__(app, data_table_name='__dbkeys__', load_old_style=True)[source]
default_name = 'unspecified (?)'
default_value = '?'
get_chrom_info(dbkey, trans=None, custom_build_hack_get_len_from_fasta_conversion=True)[source]
get_genome_build_names(trans=None)[source]

galaxy.util.dictifiable module

class galaxy.util.dictifiable.Dictifiable[source]

Mixin that enables objects to be converted to dictionaries. This is useful when for sharing objects across boundaries, such as the API, tool scripts, and JavaScript code.

to_dict(view='collection', value_mapper=None)[source]

Return item dictionary.

galaxy.util.expressions module

Expression evaluation support.

For the moment this depends on python’s eval. In the future it should be replaced with a “safe” parser.

class galaxy.util.expressions.ExpressionContext(dict, parent=None)[source]

Bases: _abcoll.MutableMapping

__init__(dict, parent=None)[source]

Create a new expression context that looks for values in the container object ‘dict’, and falls back to ‘parent’

galaxy.util.filelock module

Code obtained from https://github.com/dmfrey/FileLock.

See full license at:

https://github.com/dmfrey/FileLock/blob/master/LICENSE.txt

class galaxy.util.filelock.FileLock(file_name, timeout=10, delay=0.05)[source]

Bases: object

A file locking mechanism that has context-manager support so you can use it in a with statement. This should be relatively cross compatible as it doesn’t rely on msvcrt or fcntl for the locking.

__init__(file_name, timeout=10, delay=0.05)[source]

Prepare the file locker. Specify the file to lock and optionally the maximum timeout and the delay between each attempt to lock.

acquire()[source]

Acquire the lock, if possible. If the lock is in use, it check again every wait seconds. It does this until it either gets the lock or exceeds timeout number of seconds, in which case it throws an exception.

release()[source]

Get rid of the lock by deleting the lockfile. When working in a with statement, this gets automatically called at the end.

exception galaxy.util.filelock.FileLockException[source]

Bases: exceptions.Exception

galaxy.util.hash_util module

Utility functions for bi-directional Python version compatibility. Python 2.5 introduced hashlib which replaced sha in Python 2.4 and previous versions.

galaxy.util.hash_util.md5()

Returns a md5 hash object; optionally initialized with a string

galaxy.util.hash_util.sha1()

Returns a sha1 hash object; optionally initialized with a string

galaxy.util.hash_util.sha()

Returns a sha1 hash object; optionally initialized with a string

galaxy.util.hash_util.new_secure_hash(text_type=None)[source]

Returns either a sha1 hash object (if called with no arguments), or a hexdigest of the sha1 hash of the argument text_type.

galaxy.util.hash_util.hmac_new(key, value)[source]
galaxy.util.hash_util.is_hashable(value)[source]

galaxy.util.heartbeat module

class galaxy.util.heartbeat.Heartbeat(config, name='Heartbeat Thread', period=20, fname='heartbeat.log')[source]

Bases: threading.Thread

Thread that periodically dumps the state of all threads to a file

__init__(config, name='Heartbeat Thread', period=20, fname='heartbeat.log')[source]
close_logs()[source]
dump()[source]
dump_signal_handler(signum, frame)[source]
get_interesting_stack_frame(stack_frames)[source]

Scans a given backtrace stack frames, returns a single quadraple of [filename, line, function-name, text] of the single, deepest, most interesting frame.

Interesting being:

inside the galaxy source code ("/lib/galaxy"),
prefreably not an egg.
open_logs()[source]
print_nonsleeping(threads_object_dict)[source]
run()[source]
shutdown()[source]
thread_is_sleeping(last_stack_frame)[source]

Returns True if the given stack-frame represents a known sleeper function (at least in python 2.5)

galaxy.util.heartbeat.get_current_thread_object_dict()[source]

Get a dictionary of all ‘Thread’ objects created via the threading module keyed by thread_id. Note that not all interpreter threads have a thread objects, only the main thread and any created via the ‘threading’ module. Threads created via the low level ‘thread’ module will not be in the returned dictionary.

HACK: This mucks with the internals of the threading module since that
module does not expose any way to match ‘Thread’ objects with intepreter thread identifiers (though it should).

galaxy.util.image_util module

Provides utilities for working with image files.

galaxy.util.image_util.check_image_type(filename, types)[source]
galaxy.util.image_util.get_image_ext(file_path)[source]
galaxy.util.image_util.image_type(filename)[source]

galaxy.util.inflection module

class galaxy.util.inflection.Base[source]

Locale inflectors must inherit from this base class inorder to provide the basic Inflector functionality

camelize(word)[source]

Returns given word as CamelCased Converts a word like “send_email” to “SendEmail”. It will remove non alphanumeric character from the word, so “who’s online” will be converted to “WhoSOnline”

classify(table_name)[source]

Converts a table name to its class name according to rails naming conventions. Example: Converts “people” to “Person”

cond_plural(number_of_records, word)[source]

Returns the plural form of a word if first parameter is greater than 1

demodulize(module_name)[source]
foreignKey(class_name, separate_class_name_and_id_with_underscore=1)[source]

Returns class_name in underscored form, with “_id” tacked on at the end. This is for use in dealing with the database.

humanize(word, uppercase='')[source]

Returns a human-readable string from word Returns a human-readable string from word, by replacing underscores with a space, and by upper-casing the initial character by default. If you need to uppercase all the words you just have to pass ‘all’ as a second parameter.

modulize(module_description)[source]
ordinalize(number)[source]

Converts number to its ordinal English form. This method converts 13 to 13th, 2 to 2nd ...

string_replace(word, find, replace)[source]

This function returns a copy of word, translating all occurrences of each character in find to the corresponding character in replace

tableize(class_name)[source]

Converts a class name to its table name according to rails naming conventions. Example. Converts “Person” to “people”

titleize(word, uppercase='')[source]

Converts an underscored or CamelCase word into a English sentence. The titleize function converts text like “WelcomePage”, “welcome_page” or “welcome page” to this “Welcome Page”. If second parameter is set to ‘first’ it will only capitalize the first character of the title.

unaccent(text)[source]

Transforms a string to its unaccented version. This might be useful for generating “friendly” URLs

underscore(word)[source]

Converts a word “into_it_s_underscored_version” Convert any “CamelCased” or “ordinary Word” into an “underscored_word”. This can be really useful for creating friendly URLs.

urlize(text)[source]

Transform a string its unaccented and underscored version ready to be inserted in friendly URLs

variablize(word)[source]

Same as camelize but first char is lowercased Converts a word like “send_email” to “sendEmail”. It will remove non alphanumeric character from the word, so “who’s online” will be converted to “whoSOnline”

class galaxy.util.inflection.English[source]

Bases: galaxy.util.inflection.Base

Inflector for pluralize and singularize English nouns.

This is the default Inflector for the Inflector obj

pluralize(word)[source]

Pluralizes English nouns.

singularize(word)[source]

Singularizes English nouns.

class galaxy.util.inflection.Inflector(Inflector=<class galaxy.util.inflection.English>)[source]

Inflector for pluralizing and singularizing nouns.

It provides methods for helping on creating programs based on naming conventions like on Ruby on Rails.

__init__(Inflector=<class galaxy.util.inflection.English>)[source]
camelize(word)[source]

Returns given word as CamelCased Converts a word like “send_email” to “SendEmail”. It will remove non alphanumeric character from the word, so “who’s online” will be converted to “WhoSOnline”

classify(table_name)[source]

Converts a table name to its class name according to rails naming conventions. Example: Converts “people” to “Person”

cond_plural(number_of_records, word)[source]

Returns the plural form of a word if first parameter is greater than 1

demodulize(module_name)[source]
foreignKey(class_name, separate_class_name_and_id_with_underscore=1)[source]

Returns class_name in underscored form, with “_id” tacked on at the end. This is for use in dealing with the database.

humanize(word, uppercase='')[source]

Returns a human-readable string from word Returns a human-readable string from word, by replacing underscores with a space, and by upper-casing the initial character by default. If you need to uppercase all the words you just have to pass ‘all’ as a second parameter.

modulize(module_description)[source]
ordinalize(number)[source]

Converts number to its ordinal form. This method converts 13 to 13th, 2 to 2nd ...

pluralize(word)[source]

Pluralizes nouns.

singularize(word)[source]

Singularizes nouns.

tableize(class_name)[source]

Converts a class name to its table name according to rails naming conventions. Example. Converts “Person” to “people”

titleize(word, uppercase='')[source]

Converts an underscored or CamelCase word into a sentence. The titleize function converts text like “WelcomePage”, “welcome_page” or “welcome page” to this “Welcome Page”. If the “uppercase” parameter is set to ‘first’ it will only capitalize the first character of the title.

unaccent(text)[source]

Transforms a string to its unaccented version. This might be useful for generating “friendly” URLs

underscore(word)[source]

Converts a word “into_it_s_underscored_version” Convert any “CamelCased” or “ordinary Word” into an “underscored_word”. This can be really useful for creating friendly URLs.

urlize(text)[source]

Transform a string to its unaccented and underscored version ready to be inserted in friendly URLs

variablize(word)[source]

Same as camelize but first char is lowercased Converts a word like “send_email” to “sendEmail”. It will remove non alphanumeric character from the word, so “who’s online” will be converted to “whoSOnline”

galaxy.util.json module

galaxy.util.json.safe_dumps(*args, **kwargs)[source]

This is a wrapper around dumps that encodes Infinity and NaN values. It’s a fairly rare case (which will be low in request volume). Basically, we tell json.dumps to blow up if it encounters Infinity/NaN, and we ‘fix’ it before re-encoding.

galaxy.util.json.json_fix(val)[source]
galaxy.util.json.validate_jsonrpc_request(request, regular_methods, notification_methods)[source]
galaxy.util.json.validate_jsonrpc_response(response, id=None)[source]
galaxy.util.json.jsonrpc_request(method, params=None, id=None, jsonrpc='2.0')[source]
galaxy.util.json.jsonrpc_response(request=None, id=None, result=None, error=None, jsonrpc='2.0')[source]

galaxy.util.jstree module

class galaxy.util.jstree.JSTree(paths, **kwargs)[source]

Bases: dictobj.DictionaryObject

An immutable dictionary-like object that converts a list of “paths” into a tree structure suitable for jQuery’s jsTree.

__init__(paths, **kwargs)[source]

Take a list of paths and put them into a tree. Paths with the same prefix should be at the same level in the tree.

kwargs may be standard jsTree options used at all levels in the tree. These will be outputted in the JSON.

jsonData()[source]

Returns a copy of the internal tree in a JSON-friendly format, ready for consumption by jsTree. The data is represented as a list of dictionaries, each of which are our internal nodes.

pretty(root=None, depth=0, spacing=2)[source]

Create a “pretty print” represenation of the tree with customized indentation at each level of the tree.

class galaxy.util.jstree.Node(path, oid, **kwargs)[source]

Bases: dictobj.DictionaryObject

Copyright 2012 “Grim Apps”

Licensed under the Apache License, Version 2.0 (the “License”); you may not use this file except in compliance with the License. You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Helper class written by William Grim - grimwm Original repo: https://github.com/grimwm/py-jstree Code adjusted according to the idea of Frank Blechschmidt - FraBle Thank you! ******************** This class exists as a helper to the JSTree. Its “jsonData” method can generate sub-tree JSON without putting the logic directly into the JSTree.

This data structure is only semi-immutable. The JSTree uses a directly iterative (i.e. no stack is managed) builder pattern to construct a tree out of paths. Therefore, the children are not known in advance, and we have to keep the children attribute mutable.

__init__(path, oid, **kwargs)[source]

kwargs allows users to pass arbitrary information into a Node that will later be output in jsonData(). It allows for more advanced configuration than the default path handling that JSTree currently allows. For example, users may want to pass “attr” or some other valid jsTree options.

Example:
>>> import jstree
>>> node = jstree.Node('a', None)
>>> print node
Node({'text': 'a', 'children': MutableDictionaryObject({})})
>>> print node.jsonData()
{'text': 'a'}
>>> import jstree
>>> node = jstree.Node('a', 1)
>>> print node
Node({'text': 'a', 'children': MutableDictionaryObject({}), 'li_attr': DictionaryObject({'id': 1}), 'id': 1})
>>> print node.jsonData()
{'text': 'a', 'id': 1, 'li_attr': {'id': 1}}
>>> import jstree
>>> node = jstree.Node('a', 5, icon="folder", state = {'opened': True})
>>> print node
Node({'text': 'a', 'id': 5, 'state': DictionaryObject({'opened': True}), 'children': MutableDictionaryObject({}), 'li_attr': DictionaryObject({'id': 5}), 'icon': 'folder'})
>>> print node.jsonData()
{'text': 'a', 'state': {'opened': True}, 'id': 5, 'li_attr': {'id': 5}, 'icon': 'folder'}
jsonData()[source]
class galaxy.util.jstree.Path(path, id, options)

Bases: tuple

id

Alias for field number 1

options

Alias for field number 2

path

Alias for field number 0

galaxy.util.lazy_process module

class galaxy.util.lazy_process.LazyProcess(command_and_args)[source]

Bases: object

Abstraction describing a command line launching a service - probably as needed as functionality is accessed in Galaxy.

__init__(command_and_args)[source]
running
shutdown()[source]
start_process()[source]
class galaxy.util.lazy_process.NoOpLazyProcess[source]

Bases: object

LazyProcess abstraction meant to describe potentially optional services, in those cases where one is not configured or valid, this class can be used in place of LazyProcess.

running
shutdown()[source]
start_process()[source]

galaxy.util.multi_byte module

galaxy.util.multi_byte.is_multi_byte(chars)[source]

galaxy.util.none_like module

Objects with No values

class galaxy.util.none_like.NoneDataset(datatypes_registry=None, ext='data', dbkey='?')[source]

Bases: galaxy.util.none_like.RecursiveNone

__init__(datatypes_registry=None, ext='data', dbkey='?')[source]
missing_meta()[source]
class galaxy.util.none_like.RecursiveNone[source]

galaxy.util.object_wrapper module

Classes for wrapping Objects and Sanitizing string output.

class galaxy.util.object_wrapper.CallableSafeStringWrapper(value, safe_string_wrapper_function=<function wrap_with_safe_string>)[source]

Bases: galaxy.util.object_wrapper.SafeStringWrapper

class galaxy.util.object_wrapper.SafeStringWrapper(value, safe_string_wrapper_function=<function wrap_with_safe_string>)[source]

Bases: object

Class that wraps and sanitizes any provided value’s attributes that will attempt to be cast into a string.

Attempts to mimic behavior of original class, including operands.

To ensure proper handling of e.g. subclass checks, the wrap_with_safe_string() method should be used.

This wrapping occurs in a recursive/parasitic fashion, as all called attributes of the originally wrapped object will also be wrapped and sanitized, unless the attribute is of a type found in __DONT_SANITIZE_TYPES__ + __DONT_WRAP_TYPES__, where e.g. ~(strings will still be sanitized, but not wrapped), and e.g. integers will have neither.

__init__(value, safe_string_wrapper_function=<function wrap_with_safe_string>)[source]
galaxy.util.object_wrapper.cmp(x, y)[source]
galaxy.util.object_wrapper.pickle_SafeStringWrapper(safe_object)[source]
galaxy.util.object_wrapper.sanitize_lists_to_string(values, valid_characters=set(['!', ' ', ')', '(', '+', '*', '-', ', ', '/', '.', '1', '0', '3', '2', '5', '4', '7', '6', '9', '8', ':', '=', '?', 'A', '@', 'C', 'B', 'E', 'D', 'G', 'F', 'I', 'H', 'K', 'J', 'M', 'L', 'O', 'N', 'Q', 'P', 'S', 'R', 'U', 'T', 'W', 'V', 'Y', 'X', 'Z', '_', '^', 'a', 'c', 'b', 'e', 'd', 'g', 'f', 'i', 'h', 'k', 'j', 'm', 'l', 'o', 'n', 'q', 'p', 's', 'r', 'u', 't', 'w', 'v', 'y', 'x', 'z']), character_map={'\t': '__tc__', '\n': '__cn__', '\r': '__cr__', '[': '__ob__', ']': '__cb__', '#': '__pd__', '"': '__dq__', "'": '__sq__', '{': '__oc__', '}': '__cc__', '<': '__lt__', '>': '__gt__'}, invalid_character='X')[source]
galaxy.util.object_wrapper.wrap_with_safe_string(value, no_wrap_classes=None)[source]

Recursively wrap values that should be wrapped.

galaxy.util.odict module

Ordered dictionary implementation.

class galaxy.util.odict.odict(dict=None)[source]

Bases: UserDict.UserDict

http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/107747

This dictionary class extends UserDict to record the order in which items are added. Calling keys(), values(), items(), etc. will return results in this order.

__init__(dict=None)[source]
clear()[source]
copy()[source]
insert(index, key, item)[source]
items()[source]
iteritems()[source]
iterkeys()[source]
itervalues()[source]
keys()[source]
popitem()[source]
reverse()[source]
setdefault(key, failobj=None)[source]
update(dict)[source]
values()[source]

galaxy.util.permutations module

There is some shared logic between matching/multiplying inputs in workflows and tools. This module is meant to capture some general permutation logic that can be applicable for both cases but will only be used in the newer tools case first.

Maybe this doesn’t make sense and maybe much of this stuff could be replaced with itertools product and permutations. These are open questions.

exception galaxy.util.permutations.InputMatchedException(err_msg=None, type='info', **extra_error_info)[source]

Bases: galaxy.exceptions.MessageException

Indicates problem matching inputs while building up inputs permutations.

galaxy.util.permutations.expand_multi_inputs(inputs, classifier, key_filter=None)[source]

galaxy.util.plugin_config module

galaxy.util.plugin_config.load_plugins(plugins_dict, plugin_source, extra_kwds={})[source]
galaxy.util.plugin_config.plugin_source_from_path(path)[source]
galaxy.util.plugin_config.plugins_dict(module, plugin_type_identifier)[source]

Walk through all classes in submodules of module and find ones labelled with specified plugin_type_identifier and throw in a dictionary to allow constructions from plugins by these types later on.

galaxy.util.postfork module

Handle postfork functions under uWSGI

galaxy.util.postfork.do_postfork()[source]
galaxy.util.postfork.pf_dec(func)[source]
galaxy.util.postfork.postfork(func)
galaxy.util.postfork.register_postfork_function(f, *args, **kwargs)[source]

galaxy.util.properties module

Module used to blend ini, environment, and explicit dictionary properties to determine application configuration. Some hard coded defaults for Galaxy but this should be reusable by tool shed and pulsar as well.

galaxy.util.properties.find_config_file(default, old_default, explicit, cwd=None)[source]
galaxy.util.properties.load_app_properties(kwds={}, ini_file=None, ini_section='app:main', config_prefix='GALAXY_CONFIG_')[source]
class galaxy.util.properties.NicerConfigParser(filename, *args, **kw)[source]

Bases: ConfigParser.ConfigParser

class InterpolateWrapper(original)[source]

Bases: object

__init__(original)[source]
before_get(parser, section, option, value, defaults)[source]
NicerConfigParser.__init__(filename, *args, **kw)[source]
NicerConfigParser.defaults()[source]

Return the defaults, with their values interpolated (with the defaults dict itself)

Mainly to support defaults using values such as %(here)s

NicerConfigParser.read_file(fp, filename=None)

Like read() but the argument must be a file-like object.

The `fp’ argument must have a `readline’ method. Optional second argument is the `filename’, which if not given, is taken from fp.name. If fp has no `name’ attribute, `<???>’ is used.

galaxy.util.sanitize_html module

HTML Sanitizer (ripped from feedparser)

galaxy.util.sanitize_html.sanitize_html(htmlSource, encoding='utf-8', type='text/html')[source]

galaxy.util.simplegraph module

Fencepost-simple graph structure implementation.

class galaxy.util.simplegraph.SimpleGraph(nodes=None, edges=None)[source]

Bases: object

Each node is unique (by id) and stores its own index in the node list/odict. Each edge is represented as two indeces into the node list/odict. Both nodes and edges allow storing extra information if needed.

Allows:
multiple edges between two nodes self referential edges (an edge from a node to itself)

These graphs are not specifically directed but since source and targets on the edges are listed - it could easily be used that way.

__init__(nodes=None, edges=None)[source]
add_edge(source_id, target_id, **data)[source]

Adds a new node only if it doesn’t already exist. :param source_id: the id of the source node :type source_id: (hashable) :param target_id: the id of the target node :type target_id: (hashable) :param data: any extra data that needs to be saved for the edge :type data: (variadic dictionary) :returns: the new node

..note: that, although this will create new nodes if necessary, there’s no way to pass data to them - so if you need to assoc. more data with the nodes, use add_node first.

add_node(node_id, **data)[source]

Adds a new node only if it doesn’t already exist. :param node_id: some unique identifier :type node_id: (hashable) :param data: any extra data that needs to be saved :type data: (variadic dictionary) :returns: the new node

as_dict()[source]

Returns a dictionary of the form:

{ 'nodes': <a list of node dictionaries>, 'edges': <a list of node dictionaries> }
gen_edge_dicts()[source]

Returns a generator that yields node dictionaries in the form:

{
    'source': <the index of the source node in the graph's node list>,
    'target': <the index of the target node in the graph's node list>,
    'data'  : <any additional edge data>
}
gen_node_dicts()[source]
Returns a generator that yields node dictionaries in the form:
{ ‘id’: <the nodes unique id>, ‘data’: <any additional node data> }
class galaxy.util.simplegraph.SimpleGraphEdge(source_index, target_index, **data)[source]

Bases: object

Edge representation.

__init__(source_index, target_index, **data)[source]
Parameters:
  • source_index (int) – index of the edge’s source node in some parent list
  • target_index (int) – index of the edge’s target node in some parent list
  • data ((variadic dictionary)) – any extra data that needs to be saved
class galaxy.util.simplegraph.SimpleGraphNode(index, **data)[source]

Bases: object

Node representation.

__init__(index, **data)[source]
Parameters:
  • index (int) – index of this node in some parent list
  • data ((variadic dictionary)) – any extra data that needs to be saved

galaxy.util.sleeper module

class galaxy.util.sleeper.Sleeper[source]

Bases: object

Provides a ‘sleep’ method that sleeps for a number of seconds unless the notify method is called (from a different thread).

__init__()[source]
sleep(seconds)[source]
wake()[source]

galaxy.util.sockets module

galaxy.util.sockets.unused_port(range=None)[source]

galaxy.util.specs module

galaxy.util.specs.is_in(*args)[source]
galaxy.util.specs.to_bool(value)[source]
galaxy.util.specs.to_bool_or_none(value)[source]
galaxy.util.specs.to_float_or_none(value)[source]
galaxy.util.specs.to_str_or_none(value)[source]

galaxy.util.sqlite module

galaxy.util.sqlite.connect(path)[source]
galaxy.util.sqlite.is_read_only_query(query)[source]

galaxy.util.streamball module

A simple wrapper for writing tarballs as a stream.

class galaxy.util.streamball.StreamBall(mode, members=None)[source]

Bases: object

__init__(mode, members=None)[source]
add(file, relpath, check_file=False)[source]
stream(environ, start_response)[source]
class galaxy.util.streamball.ZipBall(tmpf, tmpd)[source]

Bases: object

__init__(tmpf, tmpd)[source]
stream(environ, start_response)[source]

galaxy.util.submodules module

galaxy.util.submodules.submodules(module)[source]

galaxy.util.template module

Entry point for the usage of Cheetah templating within Galaxy.

galaxy.util.template.fill_template(template_text, context=None, **kwargs)[source]

Fill a cheetah template out for specified context.

If template_text is None, an exception will be thrown, if context is None (the default) - keyword arguments to this function will be used as the context.

galaxy.util.topsort module

Topological sort.

From Tim Peters, see:
http://mail.python.org/pipermail/python-list/1999-July/006660.html

topsort takes a list of pairs, where each pair (x, y) is taken to mean that x <= y wrt some abstract partial ordering. The return value is a list, representing a total ordering that respects all the input constraints. E.g.,

topsort( [(1,2), (3,3)] )

Valid topological sorts would be any of (but nothing other than)

[3, 1, 2] [1, 3, 2] [1, 2, 3]

... however this variant ensures that ‘key’ order (first element of tuple) is preserved so the following will be result returned:

[1, 3, 2]

because those are the permutations of the input elements that respect the “1 precedes 2” and “3 precedes 3” input constraints. Note that a constraint of the form (x, x) is really just a trick to make sure x appears somewhere in the output list.

If there’s a cycle in the constraints, say

topsort( [(1,2), (2,1)] )

then CycleError is raised, and the exception object supports many methods to help analyze and break the cycles. This requires a good deal more code than topsort itself!

exception galaxy.util.topsort.CycleError(sofar, numpreds, succs)[source]

Bases: exceptions.Exception

__init__(sofar, numpreds, succs)[source]
get_elements()[source]
get_pairlist()[source]
get_partial()[source]
get_pred_counts()[source]
get_preds()[source]
get_succs()[source]
pick_a_cycle()[source]
galaxy.util.topsort.topsort(pairlist)[source]
galaxy.util.topsort.topsort_levels(pairlist)[source]

galaxy.util.ucsc module

Utilities for dealing with UCSC data.

exception galaxy.util.ucsc.UCSCLimitException[source]

Bases: exceptions.Exception

class galaxy.util.ucsc.UCSCOutWrapper(other)[source]

Bases: object

File-like object that throws an exception if it encounters the UCSC limit error lines

__init__(other)[source]
next()[source]
readline()[source]

galaxy.util.validation module

Module for validation of incoming inputs.

TODO: Refactor BaseController references to similar methods to use this module.

galaxy.util.validation.validate_and_sanitize_basestring(key, val)[source]
galaxy.util.validation.validate_and_sanitize_basestring_list(key, val)[source]
galaxy.util.validation.validate_boolean(key, val)[source]

galaxy.util.xml_macros module

class galaxy.util.xml_macros.XmlMacroDef(el)[source]

Bases: object

__init__(el)[source]
macro_tokens(expand_el)[source]
galaxy.util.xml_macros.imported_macro_paths(root)[source]
galaxy.util.xml_macros.load(path)[source]

Loads tool from file system and preprocesses tool macros.

galaxy.util.xml_macros.raw_tool_xml_tree(path)[source]

Load raw (no macro expansion) tree representation of tool represented at the specified path.

galaxy.util.xml_macros.template_macro_params(root)[source]

Look for template macros and populate param_dict (for cheetah) with these.