Warning

This document is for an old release of Galaxy. You can alternatively view this page in the latest release if it exists or view the top of the latest release's documentation.

galaxy.tools.parameters package

Classes encapsulating Galaxy tool parameters.

class galaxy.tools.parameters.DataCollectionToolParameter(tool, input_source, trans=None)[source]

Bases: galaxy.tools.parameters.basic.BaseDataToolParameter

__init__(tool, input_source, trans=None)[source]
collection_types
match_collections(trans, history, dataset_matcher)[source]
match_multirun_collections(trans, history, dataset_matcher)[source]
from_json(value, trans, other_values={})[source]
to_text(value)[source]
validate(value, trans=None)[source]
to_dict(trans, other_values=None)[source]
class galaxy.tools.parameters.DataToolParameter(tool, input_source, trans=None)[source]

Bases: galaxy.tools.parameters.basic.BaseDataToolParameter

Parameter that takes on one (or many) or a specific set of values.

TODO: There should be an alternate display that allows single selects to be
displayed as radio buttons and multiple selects as a set of checkboxes

TODO: The following must be fixed to test correctly for the new security_check tag in the DataToolParameter ( the last test below is broken ) Nate’s next pass at the dataset security stuff will dramatically alter this anyway.

__init__(tool, input_source, trans=None)[source]
match_collections(history, dataset_matcher, reduction=True)[source]
from_json(value, trans, other_values={})[source]
to_param_dict_string(value, other_values={})[source]
to_text(value)[source]
validate(value, trans=None)[source]
get_dependencies()[source]

Get the names of the other params this param depends on.

converter_safe(other_values, trans)[source]
get_options_filter_attribute(value)[source]
to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.SelectToolParameter(tool, input_source, context=None)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that takes on one (or many) or a specific set of values.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch() )
>>> p = SelectToolParameter( None, XML(
... '''
... <param name="_name" type="select">
...     <option value="x">x_label</option>
...     <option value="y" selected="true">y_label</option>
...     <option value="z">z_label</option>
... </param>
... ''' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('display', None), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'SelectToolParameter'), ('multiple', False), ('name', '_name'), ('optional', False), ('options', [('x_label', 'x', False), ('y_label', 'y', True), ('z_label', 'z', False)]), ('refresh_on_change', False), ('type', 'select'), ('value', 'y')]
>>> p = SelectToolParameter( None, XML(
... '''
... <param name="_name" type="select" multiple="true">
...     <option value="x">x_label</option>
...     <option value="y" selected="true">y_label</option>
...     <option value="z" selected="true">z_label</option>
... </param>
... ''' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('display', None), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'SelectToolParameter'), ('multiple', True), ('name', '_name'), ('optional', True), ('options', [('x_label', 'x', False), ('y_label', 'y', True), ('z_label', 'z', True)]), ('refresh_on_change', False), ('type', 'select'), ('value', ['y', 'z'])]
>>> print p.to_param_dict_string( ["y", "z"] )
y,z
__init__(tool, input_source, context=None)[source]
get_options(trans, other_values)[source]
from_json(value, trans, other_values={})[source]
to_param_dict_string(value, other_values={})[source]
to_json(value, app, use_security)[source]
get_initial_value(trans, other_values)[source]
to_text(value)[source]
get_dependencies()[source]

Get the names of the other params this param depends on.

to_dict(trans, other_values={})[source]

Submodules

galaxy.tools.parameters.basic module

Basic tool parameters.

galaxy.tools.parameters.basic.contains_workflow_parameter(value, search=False)[source]
galaxy.tools.parameters.basic.is_runtime_value(value)[source]
galaxy.tools.parameters.basic.parse_dynamic_options(param, input_source)[source]
class galaxy.tools.parameters.basic.ToolParameter(tool, input_source, context=None)[source]

Bases: object, galaxy.util.dictifiable.Dictifiable

Describes a parameter accepted by a tool. This is just a simple stub at the moment but in the future should encapsulate more complex parameters (lists of valid choices, validation logic, …)

dict_collection_visible_keys = ('name', 'argument', 'type', 'label', 'help', 'refresh_on_change')
__init__(tool, input_source, context=None)[source]
visible

Return true if the parameter should be rendered on the form

get_label()[source]

Return user friendly name for the parameter

from_json(value, trans=None, other_values={})[source]

Convert a value from an HTML POST into the parameters preferred value format.

get_initial_value(trans, other_values)[source]

Return the starting value of the parameter

get_required_enctype()[source]

If this parameter needs the form to have a specific encoding return it, otherwise return None (indicating compatibility with any encoding)

get_dependencies()[source]

Return the names of any other parameters this parameter depends on

to_json(value, app, use_security)[source]

Convert a value to a string representation suitable for persisting

to_python(value, app)[source]

Convert a value created with to_json back to an object representation

value_to_basic(value, app, use_security=False)[source]
value_from_basic(value, app, ignore_errors=False)[source]
value_to_display_text(value)[source]
to_text(value)[source]

Convert a value to a text representation suitable for displaying to the user >>> p = ToolParameter( None, XML( ‘<param name=”_name” />’ ) ) >>> print p.to_text( None ) Not available. >>> print p.to_text( ‘’ ) Empty. >>> print p.to_text( ‘text’ ) text >>> print p.to_text( True ) True >>> print p.to_text( False ) False >>> print p.to_text( 0 ) 0

to_param_dict_string(value, other_values={})[source]

Called via __str__ when used in the Cheetah template

validate(value, trans=None)[source]
to_dict(trans, other_values={})[source]

to_dict tool parameter. This can be overridden by subclasses.

classmethod build(tool, param)[source]

Factory method to create parameter of correct type

classmethod parse_name(input_source)[source]
class galaxy.tools.parameters.basic.TextToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that can take on any text value.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None )
>>> p = TextToolParameter( None, XML( '<param name="_name" type="text" value="default" />' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('area', False), ('argument', None), ('datalist', []), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'TextToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('type', 'text'), ('value', 'default')]
__init__(tool, input_source)[source]
to_json(value, app, use_security)[source]

Convert a value to a string representation suitable for persisting

validate(value, trans=None)[source]
get_initial_value(trans, other_values)[source]
to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.basic.IntegerToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.TextToolParameter

Parameter that takes an integer value.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch(), workflow_building_mode=True )
>>> p = IntegerToolParameter( None, XML( '<param name="_name" type="integer" value="10" />' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('area', False), ('argument', None), ('datalist', []), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('max', None), ('min', None), ('model_class', 'IntegerToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('type', 'integer'), ('value', '10')]
>>> type( p.from_json( "10", trans ) )
<type 'int'>
>>> type( p.from_json( "_string", trans ) )
Traceback (most recent call last):
    ...
ValueError: An integer or workflow parameter e.g. ${name} is required
dict_collection_visible_keys = ('name', 'argument', 'type', 'label', 'help', 'refresh_on_change', 'min', 'max')
__init__(tool, input_source)[source]
from_json(value, trans, other_values={})[source]
to_python(value, app)[source]
get_initial_value(trans, other_values)[source]
class galaxy.tools.parameters.basic.FloatToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.TextToolParameter

Parameter that takes a real number value.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch(), workflow_building_mode=True )
>>> p = FloatToolParameter( None, XML( '<param name="_name" type="float" value="3.141592" />' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('area', False), ('argument', None), ('datalist', []), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('max', None), ('min', None), ('model_class', 'FloatToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('type', 'float'), ('value', '3.141592')]
>>> type( p.from_json( "36.1", trans ) )
<type 'float'>
>>> type( p.from_json( "_string", trans ) )
Traceback (most recent call last):
    ...
ValueError: A real number or workflow parameter e.g. ${name} is required
dict_collection_visible_keys = ('name', 'argument', 'type', 'label', 'help', 'refresh_on_change', 'min', 'max')
__init__(tool, input_source)[source]
from_json(value, trans, other_values={})[source]
to_python(value, app)[source]
get_initial_value(trans, other_values)[source]
class galaxy.tools.parameters.basic.BooleanToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that takes one of two values.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch() )
>>> p = BooleanToolParameter( None, XML( '<param name="_name" type="boolean" checked="yes" truevalue="_truevalue" falsevalue="_falsevalue" />' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('falsevalue', '_falsevalue'), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'BooleanToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('truevalue', '_truevalue'), ('type', 'boolean'), ('value', 'true')]
>>> print p.from_json( 'true' )
True
>>> print p.to_param_dict_string( True )
_truevalue
>>> print p.from_json( 'false' )
False
>>> print p.to_param_dict_string( False )
_falsevalue
__init__(tool, input_source)[source]
from_json(value, trans=None, other_values={})[source]
to_python(value, app=None)[source]
to_json(value, app, use_security)[source]
get_initial_value(trans, other_values)[source]
to_param_dict_string(value, other_values={})[source]
to_dict(trans, other_values={})[source]
legal_values
class galaxy.tools.parameters.basic.FileToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that takes an uploaded file as a value.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch() )
>>> p = FileToolParameter( None, XML( '<param name="_name" type="file"/>' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'FileToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('type', 'file'), ('value', None)]
__init__(tool, input_source)[source]
from_json(value, trans=None, other_values={})[source]
get_required_enctype()[source]

File upload elements require the multipart/form-data encoding

to_json(value, app, use_security)[source]
to_python(value, app)[source]
class galaxy.tools.parameters.basic.FTPFileToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that takes a file uploaded via FTP as a value.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch(), user=None )
>>> p = FTPFileToolParameter( None, XML( '<param name="_name" type="ftpfile"/>' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'FTPFileToolParameter'), ('multiple', True), ('name', '_name'), ('optional', True), ('refresh_on_change', False), ('type', 'ftpfile'), ('value', None)]
__init__(tool, input_source)[source]
get_initial_value(trans, other_values)[source]
visible
to_param_dict_string(value, other_values={})[source]
from_json(value, trans=None, other_values={})[source]
to_json(value, app, use_security)[source]
to_python(value, app, validate=False)[source]
to_dict(trans, other_values=None)[source]
class galaxy.tools.parameters.basic.HiddenToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that takes one of two values.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch() )
>>> p = HiddenToolParameter( None, XML( '<param name="_name" type="hidden" value="_value"/>' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('help', ''), ('hidden', True), ('is_dynamic', False), ('label', ''), ('model_class', 'HiddenToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('type', 'hidden'), ('value', u'_value')]
__init__(tool, input_source)[source]
get_initial_value(trans, other_values)[source]
get_label()[source]
class galaxy.tools.parameters.basic.ColorToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that stores a color.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch() )
>>> p = ColorToolParameter( None, XML( '<param name="_name" type="color" value="#ffffff"/>' ) )
>>> print p.name
_name
>>> print p.to_param_dict_string( "#fdeada" )
#fdeada
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'ColorToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('type', 'color'), ('value', u'#ffffff')]
>>> p = ColorToolParameter( None, XML( '<param name="_name" type="color" value="#ffffff" rgb="True"/>' ) )
>>> print p.to_param_dict_string( "#fdeada" )
(253, 234, 218)
>>> print p.to_param_dict_string( None )
Traceback (most recent call last):
    ...
ValueError: Failed to convert 'None' to RGB.
__init__(tool, input_source)[source]
get_initial_value(trans, other_values)[source]
to_param_dict_string(value, other_values={})[source]
class galaxy.tools.parameters.basic.BaseURLToolParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.HiddenToolParameter

Returns a parameter that contains its value prepended by the current server base url. Used in all redirects.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch() )
>>> p = BaseURLToolParameter( None, XML( '<param name="_name" type="base_url" value="_value"/>' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('help', ''), ('hidden', True), ('is_dynamic', False), ('label', ''), ('model_class', 'BaseURLToolParameter'), ('name', '_name'), ('optional', False), ('refresh_on_change', False), ('type', 'base_url'), ('value', u'_value')]
__init__(tool, input_source)[source]
get_initial_value(trans, other_values)[source]
from_json(value=None, trans=None, other_values={})[source]
to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.basic.SelectToolParameter(tool, input_source, context=None)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that takes on one (or many) or a specific set of values.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch() )
>>> p = SelectToolParameter( None, XML(
... '''
... <param name="_name" type="select">
...     <option value="x">x_label</option>
...     <option value="y" selected="true">y_label</option>
...     <option value="z">z_label</option>
... </param>
... ''' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('display', None), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'SelectToolParameter'), ('multiple', False), ('name', '_name'), ('optional', False), ('options', [('x_label', 'x', False), ('y_label', 'y', True), ('z_label', 'z', False)]), ('refresh_on_change', False), ('type', 'select'), ('value', 'y')]
>>> p = SelectToolParameter( None, XML(
... '''
... <param name="_name" type="select" multiple="true">
...     <option value="x">x_label</option>
...     <option value="y" selected="true">y_label</option>
...     <option value="z" selected="true">z_label</option>
... </param>
... ''' ) )
>>> print p.name
_name
>>> sorted( p.to_dict( trans ).items() )
[('argument', None), ('display', None), ('help', ''), ('hidden', False), ('is_dynamic', False), ('label', ''), ('model_class', 'SelectToolParameter'), ('multiple', True), ('name', '_name'), ('optional', True), ('options', [('x_label', 'x', False), ('y_label', 'y', True), ('z_label', 'z', True)]), ('refresh_on_change', False), ('type', 'select'), ('value', ['y', 'z'])]
>>> print p.to_param_dict_string( ["y", "z"] )
y,z
__init__(tool, input_source, context=None)[source]
get_options(trans, other_values)[source]
from_json(value, trans, other_values={})[source]
to_param_dict_string(value, other_values={})[source]
to_json(value, app, use_security)[source]
get_initial_value(trans, other_values)[source]
to_text(value)[source]
get_dependencies()[source]

Get the names of the other params this param depends on.

to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.basic.GenomeBuildParameter(*args, **kwds)[source]

Bases: galaxy.tools.parameters.basic.SelectToolParameter

Select list that sets the last used genome build for the current history as “selected”.

>>> # Create a mock transaction with 'hg17' as the current build
>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch( genome_build='hg17' ), db_builds=util.read_dbnames( None ) )
>>> p = GenomeBuildParameter( None, XML( '<param name="_name" type="genomebuild" value="hg17" />' ) )
>>> print p.name
_name
>>> d = p.to_dict( trans )
>>> o = d[ 'options' ]
>>> [ i for i in o if i[ 2 ] == True ]
[('Human May 2004 (NCBI35/hg17) (hg17)', 'hg17', True)]
>>> [ i for i in o if i[ 1 ] == 'hg18' ]
[('Human Mar. 2006 (NCBI36/hg18) (hg18)', 'hg18', False)]
__init__(*args, **kwds)[source]
get_options(trans, other_values)[source]
to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.basic.ColumnListParameter(tool, input_source)[source]

Bases: galaxy.tools.parameters.basic.SelectToolParameter

Select list that consists of either the total number of columns or only those columns that contain numerical values in the associated DataToolParameter.

# TODO: we need better testing here, but not sure how to associate a DatatoolParameter with a ColumnListParameter # from a twill perspective…

>>> # Mock up a history (not connected to database)
>>> from galaxy.model import History, HistoryDatasetAssociation
>>> from galaxy.util.bunch import Bunch
>>> from galaxy.model.mapping import init
>>> sa_session = init( "/tmp", "sqlite:///:memory:", create_tables=True ).session
>>> hist = History()
>>> sa_session.add( hist )
>>> sa_session.flush()
>>> hda = hist.add_dataset( HistoryDatasetAssociation( id=1, extension='interval', create_dataset=True, sa_session=sa_session ) )
>>> dtp =  DataToolParameter( None, XML( '<param name="blah" type="data" format="interval"/>' ) )
>>> print dtp.name
blah
>>> clp = ColumnListParameter ( None, XML( '<param name="numerical_column" type="data_column" data_ref="blah" numerical="true"/>' ) )
>>> print clp.name
numerical_column
__init__(tool, input_source)[source]
from_json(value, trans, other_values={})[source]

Label convention prepends column number with a ‘c’, but tool uses the integer. This removes the ‘c’ when entered into a workflow.

get_column_list(trans, other_values)[source]

Generate a select list containing the columns of the associated dataset (if found).

get_options(trans, other_values)[source]

Show column labels rather than c1..cn if use_header_names=True

get_initial_value(trans, other_values)[source]
get_dependencies()[source]
to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.basic.DrillDownSelectToolParameter(tool, input_source, context=None)[source]

Bases: galaxy.tools.parameters.basic.SelectToolParameter

Parameter that takes on one (or many) of a specific set of values. Creating a hierarchical select menu, which allows users to ‘drill down’ a tree-like set of options.

>>> from galaxy.util.bunch import Bunch
>>> trans = Bunch( app=None, history=Bunch( genome_build='hg17' ), db_builds=util.read_dbnames( None ) )
>>> p = DrillDownSelectToolParameter( None, XML(
... '''
... <param name="_name" type="drill_down" display="checkbox" hierarchy="recurse" multiple="true">
...   <options>
...    <option name="Heading 1" value="heading1">
...        <option name="Option 1" value="option1"/>
...        <option name="Option 2" value="option2"/>
...        <option name="Heading 2" value="heading2">
...          <option name="Option 3" value="option3"/>
...          <option name="Option 4" value="option4"/>
...        </option>
...    </option>
...    <option name="Option 5" value="option5"/>
...   </options>
... </param>
... ''' ) )
>>> print p.name
_name
>>> d = p.to_dict( trans )
>>> assert d[ 'multiple' ] == True
>>> assert d[ 'display' ] == 'checkbox'
>>> assert d[ 'options' ][ 0 ][ 'name' ] == 'Heading 1'
>>> assert d[ 'options' ][ 0 ][ 'value' ] == 'heading1'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 0 ][ 'name' ] == 'Option 1'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 0 ][ 'value' ] == 'option1'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 1 ][ 'name' ] == 'Option 2'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 1 ][ 'value' ] == 'option2'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 2 ][ 'name' ] == 'Heading 2'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 2 ][ 'value' ] == 'heading2'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 2 ][ 'options' ][ 0 ][ 'name' ] == 'Option 3'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 2 ][ 'options' ][ 0 ][ 'value' ] == 'option3'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 2 ][ 'options' ][ 1 ][ 'name' ] == 'Option 4'
>>> assert d[ 'options' ][ 0 ][ 'options' ][ 2 ][ 'options' ][ 1 ][ 'value' ] == 'option4'
>>> assert d[ 'options' ][ 1 ][ 'name' ] == 'Option 5'
>>> assert d[ 'options' ][ 1 ][ 'value' ] == 'option5'
__init__(tool, input_source, context=None)[source]
get_options(trans=None, value=None, other_values={})[source]
from_json(value, trans, other_values={})[source]
to_param_dict_string(value, other_values={})[source]
get_initial_value(trans, other_values)[source]
to_text(value)[source]
get_dependencies()[source]

Get the names of the other params this param depends on.

to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.basic.BaseDataToolParameter(tool, input_source, trans)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

__init__(tool, input_source, trans)[source]
get_initial_value(trans, other_values)[source]
to_json(value, app, use_security)[source]
to_python(value, app)[source]
class galaxy.tools.parameters.basic.DataToolParameter(tool, input_source, trans=None)[source]

Bases: galaxy.tools.parameters.basic.BaseDataToolParameter

Parameter that takes on one (or many) or a specific set of values.

TODO: There should be an alternate display that allows single selects to be
displayed as radio buttons and multiple selects as a set of checkboxes

TODO: The following must be fixed to test correctly for the new security_check tag in the DataToolParameter ( the last test below is broken ) Nate’s next pass at the dataset security stuff will dramatically alter this anyway.

__init__(tool, input_source, trans=None)[source]
match_collections(history, dataset_matcher, reduction=True)[source]
from_json(value, trans, other_values={})[source]
to_param_dict_string(value, other_values={})[source]
to_text(value)[source]
validate(value, trans=None)[source]
get_dependencies()[source]

Get the names of the other params this param depends on.

converter_safe(other_values, trans)[source]
get_options_filter_attribute(value)[source]
to_dict(trans, other_values={})[source]
class galaxy.tools.parameters.basic.DataCollectionToolParameter(tool, input_source, trans=None)[source]

Bases: galaxy.tools.parameters.basic.BaseDataToolParameter

__init__(tool, input_source, trans=None)[source]
collection_types
match_collections(trans, history, dataset_matcher)[source]
match_multirun_collections(trans, history, dataset_matcher)[source]
from_json(value, trans, other_values={})[source]
to_text(value)[source]
validate(value, trans=None)[source]
to_dict(trans, other_values=None)[source]
class galaxy.tools.parameters.basic.HiddenDataToolParameter(tool, elem)[source]

Bases: galaxy.tools.parameters.basic.HiddenToolParameter, galaxy.tools.parameters.basic.DataToolParameter

Hidden parameter that behaves as a DataToolParameter. As with all hidden parameters, this is a HACK.

__init__(tool, elem)[source]
class galaxy.tools.parameters.basic.LibraryDatasetToolParameter(tool, input_source, context=None)[source]

Bases: galaxy.tools.parameters.basic.ToolParameter

Parameter that lets users select a LDDA from a modal window, then use it within the wrapper.

__init__(tool, input_source, context=None)[source]
from_json(value, trans, other_values={})[source]
to_param_dict_string(value, other_values={})[source]
to_json(value, app, use_security)[source]
to_python(value, app, other_values={}, validate=False)[source]
to_dict(trans, other_values=None)[source]
class galaxy.tools.parameters.basic.RuntimeValue[source]

Bases: object

Wrapper to note a value that is not yet set, but will be required at runtime.

galaxy.tools.parameters.dataset_matcher module

class galaxy.tools.parameters.dataset_matcher.DatasetMatcher(trans, param, value, other_values)[source]

Bases: object

Utility class to aid DataToolParameter and similar classes in reasoning about what HDAs could match or are selected for a parameter and value.

Goal here is to both encapsulate and reuse logic related to filtering, datatype matching, hiding errored dataset, finding implicit conversions, and permission handling.

__init__(trans, param, value, other_values)[source]
hda_accessible(hda, check_security=True)[source]

Does HDA correspond to dataset that is an a valid state and is accessible to user.

valid_hda_match(hda, check_implicit_conversions=True, check_security=False)[source]

Return False of this parameter can not be matched to the supplied HDA, otherwise return a description of the match (either a HdaDirectMatch describing a direct match or a HdaImplicitMatch describing an implicit conversion.)

hda_match(hda, check_implicit_conversions=True, check_security=True, ensure_visible=True)[source]

If HDA is accessible, return information about whether it could match this parameter and if so how. See valid_hda_match for more information.

selected(hda)[source]

Given value for DataToolParameter, is this HDA “selected”.

filter(hda)[source]

Filter out this value based on other values for job (if applicable).

class galaxy.tools.parameters.dataset_matcher.DatasetCollectionMatcher(dataset_matcher)[source]

Bases: object

__init__(dataset_matcher)[source]
hdca_match(history_dataset_collection_association, reduction=False)[source]
dataset_collection_match(dataset_collection)[source]

galaxy.tools.parameters.dynamic_options module

Support for generating the options for a SelectToolParameter dynamically (based on the values of other parameters or other aspects of the current state)

class galaxy.tools.parameters.dynamic_options.Filter(d_option, elem)[source]

Bases: object

A filter takes the current options list and modifies it.

classmethod from_element(d_option, elem)[source]

Loads the proper filter by the type attribute of elem

__init__(d_option, elem)[source]
get_dependency_name()[source]

Returns the name of any depedencies, otherwise None

filter_options(options, trans, other_values)[source]

Returns a list of options after the filter is applied

class galaxy.tools.parameters.dynamic_options.StaticValueFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Filters a list of options on a column by a static value.

Type: static_value

Required Attributes:
value: static value to compare to column: column in options to compare with
Optional Attributes:
keep: Keep columns matching value (True)
Discard columns matching value (False)
__init__(d_option, elem)[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.DataMetaFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Filters a list of options on a column by a dataset metadata value.

Type: data_meta

When no ‘from’ source has been specified in the <options> tag, this will populate the options list with (meta_value, meta_value, False). Otherwise, options which do not match the metadata value in the column are discarded.

Required Attributes:

  • ref: Name of input dataset
  • key: Metadata key to use for comparison
  • column: column in options to compare with (not required when not associated with input options)

Optional Attributes:

  • multiple: Option values are multiple, split column by separator (True)
  • separator: When multiple split by this (,)
__init__(d_option, elem)[source]
get_dependency_name()[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.ParamValueFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Filters a list of options on a column by the value of another input.

Type: param_value

Required Attributes:

  • ref: Name of input value
  • column: column in options to compare with

Optional Attributes:

  • keep: Keep columns matching value (True)

    Discard columns matching value (False)

  • ref_attribute: Period (.) separated attribute chain of input (ref) to use as value for filter

__init__(d_option, elem)[source]
get_dependency_name()[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.UniqueValueFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Filters a list of options to be unique by a column value.

Type: unique_value

Required Attributes:
column: column in options to compare with
__init__(d_option, elem)[source]
get_dependency_name()[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.MultipleSplitterFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Turns a single line of options into multiple lines, by splitting a column and creating a line for each item.

Type: multiple_splitter

Required Attributes:
column: column in options to compare with
Optional Attributes:
separator: Split column by this (,)
__init__(d_option, elem)[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.AttributeValueSplitterFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Filters a list of attribute-value pairs to be unique attribute names.

Type: attribute_value_splitter

Required Attributes:
column: column in options to compare with
Optional Attributes:
pair_separator: Split column by this (,) name_val_separator: Split name-value pair by this ( whitespace )
__init__(d_option, elem)[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.AdditionalValueFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Adds a single static value to an options list.

Type: add_value

Required Attributes:
value: value to appear in select list
Optional Attributes:
name: Display name to appear in select list (value) index: Index of option list to add value (APPEND)
__init__(d_option, elem)[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.RemoveValueFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Removes a value from an options list.

Type: remove_value

Required Attributes:

value: value to remove from select list
    or
ref: param to refer to
    or
meta_ref: dataset to refer to
key: metadata key to compare to
__init__(d_option, elem)[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.SortByColumnFilter(d_option, elem)[source]

Bases: galaxy.tools.parameters.dynamic_options.Filter

Sorts an options list by a column

Type: sort_by

Required Attributes:
column: column to sort by
__init__(d_option, elem)[source]
filter_options(options, trans, other_values)[source]
class galaxy.tools.parameters.dynamic_options.DynamicOptions(elem, tool_param)[source]

Bases: object

Handles dynamically generated SelectToolParameter options

__init__(elem, tool_param)[source]
parse_column_definitions(elem)[source]
parse_file_fields(reader)[source]
get_dependency_names()[source]

Return the names of parameters these options depend on – both data and other param types.

get_fields(trans, other_values)[source]
get_fields_by_value(value, trans, other_values)[source]

Return a list of fields with column ‘value’ matching provided value.

get_field_by_name_for_value(field_name, value, trans, other_values)[source]

Get contents of field by name for specified value.

get_options(trans, other_values)[source]
column_spec_to_index(column_spec)[source]

Convert a column specification (as read from the config file), to an index. A column specification can just be a number, a column name, or a column alias.

galaxy.tools.parameters.grouping module

Constructs for grouping tool parameters

class galaxy.tools.parameters.grouping.Group[source]

Bases: object, galaxy.util.dictifiable.Dictifiable

dict_collection_visible_keys = ('name', 'type')
__init__()[source]
visible
value_to_basic(value, app)[source]

Convert value to a (possibly nested) representation using only basic types (dict, list, tuple, string_types, int, long, float, bool, None)

value_from_basic(value, app, ignore_errors=False)[source]

Convert a basic representation as produced by value_to_basic back into the preferred value form.

get_initial_value(trans, context)[source]

Return the initial state/value for this group

to_dict(trans)[source]
class galaxy.tools.parameters.grouping.Repeat[source]

Bases: galaxy.tools.parameters.grouping.Group

dict_collection_visible_keys = ('name', 'type', 'title', 'help', 'default', 'min', 'max')
type = 'repeat'
__init__()[source]
title_plural
label()[source]
value_to_basic(value, app)[source]
value_from_basic(value, app, ignore_errors=False)[source]
get_initial_value(trans, context)[source]
to_dict(trans)[source]
class galaxy.tools.parameters.grouping.Section[source]

Bases: galaxy.tools.parameters.grouping.Group

dict_collection_visible_keys = ('name', 'type', 'title', 'help', 'expanded')
type = 'section'
__init__()[source]
title_plural
label()[source]
value_to_basic(value, app)[source]
value_from_basic(value, app, ignore_errors=False)[source]
get_initial_value(trans, context)[source]
to_dict(trans)[source]
class galaxy.tools.parameters.grouping.UploadDataset[source]

Bases: galaxy.tools.parameters.grouping.Group

type = 'upload_dataset'
__init__()[source]
get_composite_dataset_name(context)[source]
get_file_base_name(context)[source]
get_file_type(context)[source]
get_datatype_ext(trans, context)[source]
get_datatype(trans, context)[source]
title_plural
group_title(context)[source]
title_by_index(trans, index, context)[source]
value_to_basic(value, app)[source]
value_from_basic(value, app, ignore_errors=False)[source]
get_initial_value(trans, context)[source]
get_uploaded_datasets(trans, context, override_name=None, override_info=None)[source]
class galaxy.tools.parameters.grouping.Conditional[source]

Bases: galaxy.tools.parameters.grouping.Group

type = 'conditional'
__init__()[source]
label
get_current_case(value)[source]
value_to_basic(value, app)[source]
value_from_basic(value, app, ignore_errors=False)[source]
get_initial_value(trans, context)[source]
to_dict(trans)[source]
class galaxy.tools.parameters.grouping.ConditionalWhen[source]

Bases: object, galaxy.util.dictifiable.Dictifiable

dict_collection_visible_keys = ('value',)
__init__()[source]
to_dict(trans)[source]

galaxy.tools.parameters.history_query module

class galaxy.tools.parameters.history_query.HistoryQuery(**kwargs)[source]

Bases: object

An object for describing the collections to pull out of a history, used by DataCollectionToolParameter.

__init__(**kwargs)[source]
static from_parameter(param, collection_type_descriptions)[source]

Take in a tool parameter element.

direct_match(hdca)[source]
can_map_over(hdca)[source]

galaxy.tools.parameters.input_translation module

Tool Input Translation.

class galaxy.tools.parameters.input_translation.ToolInputTranslator[source]

Bases: object

Handles Tool input translation. This is used for data source tools

>>> from galaxy.util import Params
>>> from xml.etree.ElementTree import XML
>>> translator = ToolInputTranslator.from_element( XML(
... '''
... <request_param_translation>
...  <request_param galaxy_name="URL_method" remote_name="URL_method" missing="post" />
...  <request_param galaxy_name="URL" remote_name="URL" missing="" >
...     <append_param separator="&amp;" first_separator="?" join="=">
...         <value name="_export" missing="1" />
...         <value name="GALAXY_URL" missing="0" />
...     </append_param>
...  </request_param>
...  <request_param galaxy_name="dbkey" remote_name="db" missing="?" />
...  <request_param galaxy_name="organism" remote_name="org" missing="unknown species" />
...  <request_param galaxy_name="table" remote_name="hgta_table" missing="unknown table" />
...  <request_param galaxy_name="description" remote_name="hgta_regionType" missing="no description" />
...  <request_param galaxy_name="data_type" remote_name="hgta_outputType" missing="tabular" >
...   <value_translation>
...    <value galaxy_value="tabular" remote_value="primaryTable" />
...    <value galaxy_value="tabular" remote_value="selectedFields" />
...    <value galaxy_value="wig" remote_value="wigData" />
...    <value galaxy_value="interval" remote_value="tab" />
...    <value galaxy_value="html" remote_value="hyperlinks" />
...    <value galaxy_value="fasta" remote_value="sequence" />
...   </value_translation>
...  </request_param>
... </request_param_translation>
... ''' ) )
>>> params = Params( { 'db':'hg17', 'URL':'URL_value', 'org':'Human', 'hgta_outputType':'primaryTable'  } )
>>> translator.translate( params )
>>> print sorted(list(params.__dict__.keys()))
['URL', 'URL_method', 'data_type', 'db', 'dbkey', 'description', 'hgta_outputType', 'org', 'organism', 'table']
>>> params.get('URL', None) in ['URL_value?GALAXY_URL=0&_export=1', 'URL_value?_export=1&GALAXY_URL=0']
True
classmethod from_element(elem)[source]

Loads the proper filter by the type attribute of elem

__init__()[source]
translate(params)[source]

update params in-place

galaxy.tools.parameters.meta module

galaxy.tools.parameters.meta.expand_workflow_inputs(inputs)[source]

Expands incoming encoded multiple payloads, into the set of all individual payload combinations >>> params, param_keys = expand_workflow_inputs( {‘1’: {‘input’: {‘batch’: True, ‘product’: True, ‘values’: [{‘hid’: ‘1’}, {‘hid’: ‘2’}] }}} ) >>> print [ “%s” % ( p[ ‘1’ ][ ‘input’ ][ ‘hid’ ] ) for p in params ] [‘1’, ‘2’] >>> params, param_keys = expand_workflow_inputs( {‘1’: {‘input’: {‘batch’: True, ‘values’: [{‘hid’: ‘1’}, {‘hid’: ‘2’}] }}} ) >>> print [ “%s” % ( p[ ‘1’ ][ ‘input’ ][ ‘hid’ ] ) for p in params ] [‘1’, ‘2’] >>> params, param_keys = expand_workflow_inputs( {‘1’: {‘input’: {‘batch’: True, ‘values’: [{‘hid’: ‘1’}, {‘hid’: ‘2’}] }}, ‘2’: {‘input’: {‘batch’: True, ‘values’: [{‘hid’: ‘3’}, {‘hid’: ‘4’}] }}} ) >>> print [ “%s%s” % ( p[ ‘1’ ][ ‘input’ ][ ‘hid’ ], p[ ‘2’ ][ ‘input’ ][ ‘hid’ ] ) for p in params ] [‘13’, ‘24’] >>> params, param_keys = expand_workflow_inputs( {‘1’: {‘input’: {‘batch’: True, ‘product’: True, ‘values’: [{‘hid’: ‘1’}, {‘hid’: ‘2’}] }}, ‘2’: {‘input’: {‘batch’: True, ‘values’: [{‘hid’: ‘3’}, {‘hid’: ‘4’}, {‘hid’: ‘5’}] }}} ) >>> print [ “%s%s” % ( p[ ‘1’ ][ ‘input’ ][ ‘hid’ ], p[ ‘2’ ][ ‘input’ ][ ‘hid’ ] ) for p in params ] [‘13’, ‘23’, ‘14’, ‘24’, ‘15’, ‘25’] >>> params, param_keys = expand_workflow_inputs( {‘1’: {‘input’: {‘batch’: True, ‘product’: True, ‘values’: [{‘hid’: ‘1’}, {‘hid’: ‘2’}] }}, ‘2’: {‘input’: {‘batch’: True, ‘product’: True, ‘values’: [{‘hid’: ‘3’}, {‘hid’: ‘4’}, {‘hid’: ‘5’}] }}, ‘3’: {‘input’: {‘batch’: True, ‘product’: True, ‘values’: [{‘hid’: ‘6’}, {‘hid’: ‘7’}, {‘hid’: ‘8’}] }}} ) >>> print [ “%s%s%s” % ( p[ ‘1’ ][ ‘input’ ][ ‘hid’ ], p[ ‘2’ ][ ‘input’ ][ ‘hid’ ], p[ ‘3’ ][ ‘input’ ][ ‘hid’ ] ) for p in params ] [‘136’, ‘137’, ‘138’, ‘146’, ‘147’, ‘148’, ‘156’, ‘157’, ‘158’, ‘236’, ‘237’, ‘238’, ‘246’, ‘247’, ‘248’, ‘256’, ‘257’, ‘258’]

galaxy.tools.parameters.meta.expand_meta_parameters(trans, tool, incoming)[source]

Take in a dictionary of raw incoming parameters and expand to a list of expanded incoming parameters (one set of parameters per tool execution).

galaxy.tools.parameters.output_collect module

Code allowing tools to define extra files associated with an output datset.

galaxy.tools.parameters.output_collect.collect_dynamic_collections(tool, output_collections, job_working_directory, inp_data={}, job=None, input_dbkey='?')[source]
class galaxy.tools.parameters.output_collect.JobContext(tool, job, job_working_directory, inp_data, input_dbkey)[source]

Bases: object

__init__(tool, job, job_working_directory, inp_data, input_dbkey)[source]
permissions
find_files(collection, dataset_collectors)[source]
populate_collection_elements(collection, root_collection_builder, output_collection_def)[source]
create_dataset(ext, designation, visible, dbkey, name, filename, metadata_source_name)[source]
galaxy.tools.parameters.output_collect.collect_primary_datasets(tool, output, job_working_directory, input_ext, input_dbkey='?')[source]
galaxy.tools.parameters.output_collect.walk_over_extra_files(extra_file_collectors, job_working_directory, matchable)[source]
galaxy.tools.parameters.output_collect.dataset_collector(dataset_collection_description)[source]
class galaxy.tools.parameters.output_collect.DatasetCollector(dataset_collection_description)[source]

Bases: object

__init__(dataset_collection_description)[source]
pattern_for_dataset(dataset_instance=None)[source]
match(dataset_instance, filename, path=None)[source]
sort(matches)[source]
class galaxy.tools.parameters.output_collect.CollectedDatasetMatch(re_match, collector, filename, path=None)[source]

Bases: object

__init__(re_match, collector, filename, path=None)[source]
designation
element_identifiers
raw_element_identifiers
name

Return name or None if not defined by the discovery pattern.

dbkey
ext
visible

galaxy.tools.parameters.sanitize module

Tool Parameter specific sanitizing.

class galaxy.tools.parameters.sanitize.ToolParameterSanitizer[source]

Bases: object

Handles tool parameter specific sanitizing.

>>> from xml.etree.ElementTree import XML
>>> sanitizer = ToolParameterSanitizer.from_element( XML(
... '''
... <sanitizer invalid_char="">
...   <valid initial="string.letters"/>
... </sanitizer>
... ''' ) )
>>> sanitizer.sanitize_param( ''.join( sorted( [ c for c in string.printable ] ) ) ) == ''.join( sorted( [ c for c in string.letters ] ) )
True
>>> slash = chr( 92 )
>>> sanitizer = ToolParameterSanitizer.from_element( XML(
... '''
... <sanitizer>
...   <valid initial="none">
...    <add preset="string.printable"/>
...    <remove value="&quot;"/>
...    <remove value="%s"/>
...   </valid>
...   <mapping initial="none">
...     <add source="&quot;" target="%s&quot;"/>
...     <add source="%s" target="%s%s"/>
...   </mapping>
... </sanitizer>
... ''' % ( slash, slash, slash, slash, slash ) ) )
>>> text = '%s"$rm&#!' % slash
>>> [ c for c in sanitizer.sanitize_param( text ) ] == [ slash, slash, slash, '"', '$', 'r', 'm', '&', '#', '!' ]
True
VALID_PRESET = {'default': 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789 -=_.()/+*^,:?!', 'none': ''}
MAPPING_PRESET = {'default': {'@': '__at__', '\t': '__tc__', '\n': '__cn__', '\r': '__cr__', '[': '__ob__', ']': '__cb__', '#': '__pd__', '"': '__dq__', "'": '__sq__', '{': '__oc__', '}': '__cc__', '<': '__lt__', '>': '__gt__'}, 'none': {}}
DEFAULT_INVALID_CHAR = 'X'
classmethod from_element(elem)[source]

Loads the proper filter by the type attribute of elem

classmethod get_valid_by_name(name)[source]
classmethod get_mapping_by_name(name)[source]
__init__()[source]
restore_text(text)[source]

Restores sanitized text

sanitize_text(text)[source]

Restricts the characters that are allowed in a text

sanitize_param(value)[source]

Clean incoming parameters (strings or lists)

galaxy.tools.parameters.validation module

Classes related to parameter validation.

class galaxy.tools.parameters.validation.Validator[source]

Bases: object

A validator checks that a value meets some conditions OR raises ValueError

requires_dataset_metadata = False
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.RegexValidator(message, expression)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that evaluates a regular expression

>>> from xml.etree.ElementTree import XML
>>> from galaxy.tools.parameters.basic import ToolParameter
>>> p = ToolParameter.build( None, XML( '''
... <param name="blah" type="text" size="10" value="10">
...     <validator type="regex" message="Not gonna happen">[Ff]oo</validator>
... </param>
... ''' ) )
>>> t = p.validate( "Foo" )
>>> t = p.validate( "foo" )
>>> t = p.validate( "Fop" )
Traceback (most recent call last):
    ...
ValueError: Not gonna happen
classmethod from_element(param, elem)[source]
__init__(message, expression)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.ExpressionValidator(message, expression, substitute_value_in_message)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that evaluates a python expression using the value

>>> from xml.etree.ElementTree import XML
>>> from galaxy.tools.parameters.basic import ToolParameter
>>> p = ToolParameter.build( None, XML( '''
... <param name="blah" type="text" size="10" value="10">
...     <validator type="expression" message="Not gonna happen">value.lower() == "foo"</validator>
... </param>
... ''' ) )
>>> t = p.validate( "Foo" )
>>> t = p.validate( "foo" )
>>> t = p.validate( "Fop" )
Traceback (most recent call last):
    ...
ValueError: Not gonna happen
classmethod from_element(param, elem)[source]
__init__(message, expression, substitute_value_in_message)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.InRangeValidator(message, range_min, range_max, exclude_min=False, exclude_max=False)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that ensures a number is in a specific range

>>> from xml.etree.ElementTree import XML
>>> from galaxy.tools.parameters.basic import ToolParameter
>>> p = ToolParameter.build( None, XML( '''
... <param name="blah" type="integer" size="10" value="10">
...     <validator type="in_range" message="Not gonna happen" min="10" exclude_min="true" max="20"/>
... </param>
... ''' ) )
>>> t = p.validate( 10 )
Traceback (most recent call last):
    ...
ValueError: Not gonna happen
>>> t = p.validate( 15 )
>>> t = p.validate( 20 )
>>> t = p.validate( 21 )
Traceback (most recent call last):
    ...
ValueError: Not gonna happen
classmethod from_element(param, elem)[source]
__init__(message, range_min, range_max, exclude_min=False, exclude_max=False)[source]

When the optional exclude_min and exclude_max attributes are set to true, the range excludes the end points (i.e., min < value < max), while if set to False ( the default), then range includes the end points (1.e., min <= value <= max). Combinations of exclude_min and exclude_max values are allowed.

validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.LengthValidator(message, length_min, length_max)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that ensures the length of the provided string (value) is in a specific range

>>> from xml.etree.ElementTree import XML
>>> from galaxy.tools.parameters.basic import ToolParameter
>>> p = ToolParameter.build( None, XML( '''
... <param name="blah" type="text" size="10" value="foobar">
...     <validator type="length" min="2" max="8"/>
... </param>
... ''' ) )
>>> t = p.validate( "foo" )
>>> t = p.validate( "bar" )
>>> t = p.validate( "f" )
Traceback (most recent call last):
    ...
ValueError: Must have length of at least 2
>>> t = p.validate( "foobarbaz" )
Traceback (most recent call last):
    ...
ValueError: Must have length no more than 8
classmethod from_element(param, elem)[source]
__init__(message, length_min, length_max)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.DatasetOkValidator(message=None)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks if a dataset is in an ‘ok’ state

__init__(message=None)[source]
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.DatasetEmptyValidator(message=None)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks if a dataset has a positive file size.

__init__(message=None)[source]
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.DatasetExtraFilesPathEmptyValidator(message=None)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks if a dataset’s extra_files_path exists and is not empty.

__init__(message=None)[source]
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.MetadataValidator(message=None, check='', skip='')[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks for missing metadata

requires_dataset_metadata = True
__init__(message=None, check='', skip='')[source]
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.UnspecifiedBuildValidator(message=None)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks for dbkey not equal to ‘?’

requires_dataset_metadata = True
__init__(message=None)[source]
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.NoOptionsValidator(message=None)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks for empty select list

__init__(message=None)[source]
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.EmptyTextfieldValidator(message=None)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks for empty text field

__init__(message=None)[source]
classmethod from_element(param, elem)[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.MetadataInFileColumnValidator(filename, metadata_name, metadata_column, message='Value for metadata not found.', line_startswith=None, split='t')[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks if the value for a dataset’s metadata item exists in a file.

requires_dataset_metadata = True
classmethod from_element(param, elem)[source]
__init__(filename, metadata_name, metadata_column, message='Value for metadata not found.', line_startswith=None, split='\t')[source]
validate(value, trans=None)[source]
class galaxy.tools.parameters.validation.MetadataInDataTableColumnValidator(tool_data_table, metadata_name, metadata_column, message='Value for metadata not found.', line_startswith=None)[source]

Bases: galaxy.tools.parameters.validation.Validator

Validator that checks if the value for a dataset’s metadata item exists in a file.

requires_dataset_metadata = True
classmethod from_element(param, elem)[source]
__init__(tool_data_table, metadata_name, metadata_column, message='Value for metadata not found.', line_startswith=None)[source]
validate(value, trans=None)[source]
galaxy.tools.parameters.validation.get_suite()[source]

Get unittest suite for this module

galaxy.tools.parameters.wrapped module

class galaxy.tools.parameters.wrapped.WrappedParameters(trans, tool, incoming)[source]

Bases: object

__init__(trans, tool, incoming)[source]
params
wrap_values(inputs, input_values, skip_missing_values=False)[source]
galaxy.tools.parameters.wrapped.make_dict_copy(from_dict)[source]

Makes a copy of input dictionary from_dict such that all values that are dictionaries result in creation of a new dictionary ( a sort of deepcopy ). We may need to handle other complex types ( e.g., lists, etc ), but not sure… Yes, we need to handle lists (and now are)…

galaxy.tools.parameters.wrapped_json module

galaxy.tools.parameters.wrapped_json.json_wrap(inputs, input_values, as_dict=None, handle_files='SKIP')[source]