galaxy.webapps.galaxy.api package

Submodules

galaxy.webapps.galaxy.api.annotations module

API operations on annotations.

class galaxy.webapps.galaxy.api.annotations.BaseAnnotationsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesStoredWorkflowMixin, galaxy.model.item_attrs.UsesAnnotations

create(trans, *args, **kwargs)

delete(trans, *args, **kwargs)

index(trans, *args, **kwargs)

undelete(trans, *args, **kwargs)

class galaxy.webapps.galaxy.api.annotations.HistoryAnnotationsController(app)

Bases: galaxy.webapps.galaxy.api.annotations.BaseAnnotationsController

__init__(app)

controller_name = 'history_annotations'

tagged_item_id = 'history_id'

class galaxy.webapps.galaxy.api.annotations.HistoryContentAnnotationsController(app)

Bases: galaxy.webapps.galaxy.api.annotations.BaseAnnotationsController

__init__(app)

controller_name = 'history_content_annotations'

tagged_item_id = 'history_content_id'

class galaxy.webapps.galaxy.api.annotations.WorkflowAnnotationsController(app)

Bases: galaxy.webapps.galaxy.api.annotations.BaseAnnotationsController

controller_name = 'workflow_annotations'

tagged_item_id = 'workflow_id'

galaxy.webapps.galaxy.api.authenticate module

API key retrieval through BaseAuth Sample usage:

curl –user zipzap@foo.com:password http://localhost:8080/api/authenticate/baseauth

Returns:

{

“api_key”: “baa4d6e3a156d3033f05736255f195f9”

}

class galaxy.webapps.galaxy.api.authenticate.AuthenticationController(app)

Bases: galaxy.web.base.controller.BaseAPIController

__init__(app)

get_api_key(trans, *args, **kwargs)

def get_api_key( self, trans, **kwd ) * GET /api/authenticate/baseauth

returns an API key for authenticated user based on BaseAuth headers

Returns:api_key in json format Return type:dict Raises:ObjectNotFound, HTTPBadRequest

galaxy.webapps.galaxy.api.configuration module

API operations allowing clients to determine Galaxy instance’s capabilities and configuration settings.

class galaxy.webapps.galaxy.api.configuration.ConfigurationController(app)

Bases: galaxy.web.base.controller.BaseAPIController

__init__(app)

dynamic_tool_confs(trans, *args, **kwargs)

get_config_dict(trans, return_admin=False, view=None, keys=None, default_view='all')

Return a dictionary with (a subset of) current Galaxy settings.

If return_admin also include a subset of more sensitive keys. Pass in view (String) and comma seperated list of keys to control which configuration settings are returned.

index(trans, *args, **kwargs)

GET /api/configuration Return an object containing exposable configuration settings.

Note: a more complete list is returned if the user is an admin.

reload_toolbox(trans, *args, **kwargs)

PUT /api/configuration/toolbox Reload the Galaxy toolbox (but not individual tools).

tool_lineages(trans, *args, **kwargs)

version(trans, *args, **kwargs)

GET /api/version Return a description of the major version of Galaxy (e.g. 15.03).

Return type:dict Returns:dictionary with major version keyed on ‘version_major’

whoami(trans, *args, **kwargs)

GET /api/whoami Return information about the current authenticated user.

Returns:dictionary with user information Return type:dict

galaxy.webapps.galaxy.api.dataset_collections module

class galaxy.webapps.galaxy.api.dataset_collections.DatasetCollectionsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesLibraryMixinItems

__init__(app)

create(trans, *args, **kwargs)

• POST /api/dataset_collections:

  create a new dataset collection instance.

Parameters:payload (dict) – (optional) dictionary structure containing: * collection_type: dataset colltion type to create. * instance_type: Instance type - ‘history’ or ‘library’. * name: the new dataset collections’s name * datasets: object describing datasets for collection Return type:dict Returns:element view of new dataset collection

index(trans, *args, **kwargs)

show(trans, *args, **kwargs)

galaxy.webapps.galaxy.api.datasets module

API operations on the contents of a history dataset.

class galaxy.webapps.galaxy.api.datasets.DatasetsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesVisualizationMixin

__init__(app)

converted(self, trans, dataset_id, ext, **kwargs)

• GET /api/datasets/{dataset_id}/converted/{ext}

  return information about datasets made by converting this dataset to a new format

Parameters:

• dataset_id (str) – the encoded id of the original HDA to check
• ext (str) – file extension of the target format or None.

If there is no existing converted dataset for the format in ext, one will be created.

If ext is None, a dictionary will be returned of the form { <converted extension> : <converted id>, ... } containing all the existing converted datasets.

..note: view and keys are also available to control the serialization

of individual datasets. They have no effect when ext is None.

Return type:dict Returns:dictionary containing detailed HDA information or (if ext is None) an extension->dataset_id map

display(trans, *args, **kwargs)

GET /api/histories/{encoded_history_id}/contents/{encoded_content_id}/display Displays history content (dataset).

The query parameter ‘raw’ should be considered experimental and may be dropped at some point in the future without warning. Generally, data should be processed by its datatype prior to display (the defult if raw is unspecified or explicitly false.

get_metadata_file(trans, *args, **kwargs)

index(trans, *args, **kwargs)

GET /api/datasets Lists datasets.

show(trans, *args, **kwargs)

GET /api/datasets/{encoded_dataset_id} Displays information about and/or content of a dataset.

galaxy.webapps.galaxy.api.datatypes module

API operations allowing clients to determine datatype supported by Galaxy.

class galaxy.webapps.galaxy.api.datatypes.DatatypesController(app)

Bases: galaxy.web.base.controller.BaseAPIController

converters(trans, *args, **kwargs)

edam_data(trans, *args, **kwargs)

edam_formats(trans, *args, **kwargs)

index(trans, *args, **kwargs)

GET /api/datatypes Return an object containing upload datatypes.

mapping(trans, *args, **kwargs)

GET /api/datatypes/mapping Return a dictionary of class to class mappings.

sniffers(trans, *args, **kwargs)

GET /api/datatypes/sniffers Return a list of sniffers.

galaxy.webapps.galaxy.api.extended_metadata module

API operations on annotations.

class galaxy.webapps.galaxy.api.extended_metadata.BaseExtendedMetadataController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesExtendedMetadataMixin, galaxy.web.base.controller.UsesLibraryMixinItems, galaxy.web.base.controller.UsesStoredWorkflowMixin

create(trans, *args, **kwargs)

delete(trans, *args, **kwargs)

index(trans, *args, **kwargs)

undelete(trans, *args, **kwargs)

class galaxy.webapps.galaxy.api.extended_metadata.HistoryDatasetExtendMetadataController(app)

Bases: galaxy.webapps.galaxy.api.extended_metadata.BaseExtendedMetadataController

__init__(app)

controller_name = 'history_dataset_extended_metadata'

exmeta_item_id = 'history_content_id'

class galaxy.webapps.galaxy.api.extended_metadata.LibraryDatasetExtendMetadataController(app)

Bases: galaxy.webapps.galaxy.api.extended_metadata.BaseExtendedMetadataController

controller_name = 'library_dataset_extended_metadata'

exmeta_item_id = 'library_content_id'

galaxy.webapps.galaxy.api.folder_contents module

API operations on the contents of a library folder.

class galaxy.webapps.galaxy.api.folder_contents.FolderContentsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesLibraryMixin, galaxy.web.base.controller.UsesLibraryMixinItems

Class controls retrieval, creation and updating of folder contents.

__init__(app)

build_path(trans, folder)

Search the path upwards recursively and load the whole route of names and ids for breadcrumb building purposes.

Parameters:

• folder – current folder for navigating up
• type – Galaxy LibraryFolder

Returns:

list consisting of full path to the library

Type:

list

create(trans, *args, **kwargs)

• POST /api/folders/{encoded_id}/contents

  create a new library file from an HDA

Parameters:

• encoded_folder_id (an encoded id string) – the encoded id of the folder to import dataset(s) to
• payload (dict) – dictionary structure containing: :param from_hda_id: (optional) the id of an accessible HDA to copy into the library :type from_hda_id: encoded id :param ldda_message: (optional) the new message attribute of the LDDA created :type ldda_message: str :param extended_metadata: (optional) dub-dictionary containing any extended metadata to associate with the item :type extended_metadata: dict

Returns:

a dictionary containing the id, name, and ‘show’ url of the new item

Return type:

dict

Raises:

ObjectAttributeInvalidException, InsufficientPermissionsException, ItemAccessibilityException, InternalServerError

index(trans, *args, **kwargs)

GET /api/folders/{encoded_folder_id}/contents

Displays a collection (list) of a folder’s contents (files and folders). Encoded folder ID is prepended with ‘F’ if it is a folder as opposed to a data set which does not have it. Full path is provided in response as a separate object providing data for breadcrumb path building.

Parameters:

• folder_id (encoded string) – encoded ID of the folder which contents should be library_dataset_dict
• kwd (dict) – keyword dictionary with other params

Returns:

dictionary containing all items and metadata

Type:

dict

Raises:

MalformedId, InconsistentDatabase, ObjectNotFound, InternalServerError

show(trans, *args, **kwargs)

GET /api/folders/{encoded_folder_id}/

update(trans, *args, **kwargs)

PUT /api/folders/{encoded_folder_id}/contents

galaxy.webapps.galaxy.api.folders module

API operations on library folders.

class galaxy.webapps.galaxy.api.folders.FoldersController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesLibraryMixin, galaxy.web.base.controller.UsesLibraryMixinItems

__init__(app)

create(trans, *args, **kwargs)

*POST /api/folders/{encoded_parent_folder_id}

Create a new folder object underneath the one specified in the parameters.

Parameters:

• encoded_parent_folder_id (an encoded id string (should be prefixed by 'F')) – (required) the parent folder’s id
• payload – dictionary structure containing: :param name: (required) the name of the new folder :type name: str :param description: the description of the new folder :type description: str

:type dictionary :returns: information about newly created folder, notably including ID :rtype: dictionary :raises: RequestParameterMissingException

delete(self, trans, encoded_folder_id, **kwd)

• DELETE /api/folders/{encoded_folder_id}

  marks the folder with the given encoded_folder_id as deleted (or removes the deleted mark if the undelete param is true)

Note

Currently, only admin users can un/delete folders.

Parameters:

• encoded_folder_id (an encoded id string) – the encoded id of the folder to un/delete
• undelete (bool) – (optional) flag specifying whether the item should be deleted or undeleted, defaults to false:

Returns:

detailed folder information

Return type:

dictionary

get_permissions(trans, *args, **kwargs)

• GET /api/folders/{id}/permissions

Load all permissions for the given folder id and return it.

Parameters:

• encoded_folder_id (an encoded id string) – the encoded id of the folder
• scope (string) – either ‘current’ or ‘available’

Returns:

dictionary with all applicable permissions’ values

Return type:

dictionary

Raises:

InsufficientPermissionsException

index(trans, *args, **kwargs)

*GET /api/folders/ This would normally display a list of folders. However, that would be across multiple libraries, so it’s not implemented.

set_permissions(trans, *args, **kwargs)

*POST /api/folders/{encoded_folder_id}/permissions

Set permissions of the given folder to the given role ids.

Parameters:

• encoded_folder_id (an encoded id string) – the encoded id of the folder to set the permissions of
• payload – dictionary structure containing: :param action: (required) describes what action should be performed :type action: string :param add_ids[]: list of Role.id defining roles that should have add item permission on the folder :type add_ids[]: string or list :param manage_ids[]: list of Role.id defining roles that should have manage permission on the folder :type manage_ids[]: string or list :param modify_ids[]: list of Role.id defining roles that should have modify permission on the folder :type modify_ids[]: string or list

:type dictionary :returns: dict of current roles for all available permission types. :rtype: dictionary :raises: RequestParameterInvalidException, InsufficientPermissionsException, RequestParameterMissingException

show(self, trans, id, **kwd)

*GET /api/folders/{encoded_folder_id}

Displays information about a folder.

Parameters:id (an encoded id string (has to be prefixed by 'F')) – the folder’s encoded id (required) Returns:dictionary including details of the folder Return type:dict

update(trans, *args, **kwargs)

• PATCH /api/folders/{encoded_folder_id}

  Update the folder defined by an encoded_folder_id with the data in the payload.

Note

Currently, only admin users can update library folders. Also the folder must not be deleted.

param id:the encoded id of the folder type id:an encoded id string param payload:(required) dictionary structure containing:: ‘name’: new folder’s name, cannot be empty ‘description’: new folder’s description type payload:dict returns:detailed folder information rtype:dict raises:RequestParameterMissingException

galaxy.webapps.galaxy.api.forms module

API operations on FormDefinition objects.

class galaxy.webapps.galaxy.api.forms.FormDefinitionAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

create(trans, *args, **kwargs)

POST /api/forms Creates a new form.

index(trans, *args, **kwargs)

GET /api/forms Displays a collection (list) of forms.

show(trans, *args, **kwargs)

GET /api/forms/{encoded_form_id} Displays information about a form.

galaxy.webapps.galaxy.api.genomes module

class galaxy.webapps.galaxy.api.genomes.GenomesController(app)

Bases: galaxy.web.base.controller.BaseAPIController

RESTful controller for interactions with genome data.

index(trans, *args, **kwargs)

GET /api/genomes: returns a list of installed genomes

indexes(trans, *args, **kwargs)

GET /api/genomes/{id}/indexes?type={table name}

Returns all available indexes for a genome id for type={table name} For instance, /api/genomes/hg19/indexes?type=fasta_indexes

sequences(trans, *args, **kwargs)

GET /api/genomes/{id}/sequences

This is a wrapper for accepting sequence requests that want a raw return, not json

show(trans, *args, **kwargs)

GET /api/genomes/{id}

Returns information about build <id>

galaxy.webapps.galaxy.api.genomes.get_id(base, format)

galaxy.webapps.galaxy.api.group_roles module

API operations on Group objects.

class galaxy.webapps.galaxy.api.group_roles.GroupRolesAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

delete(trans, *args, **kwargs)

DELETE /api/groups/{encoded_group_id}/roles/{encoded_role_id} Removes a role from a group

index(trans, *args, **kwargs)

GET /api/groups/{encoded_group_id}/roles Displays a collection (list) of groups.

show(trans, *args, **kwargs)

GET /api/groups/{encoded_group_id}/roles/{encoded_role_id} Displays information about a group role.

update(trans, *args, **kwargs)

PUT /api/groups/{encoded_group_id}/roles/{encoded_role_id} Adds a role to a group

galaxy.webapps.galaxy.api.group_users module

API operations on Group objects.

class galaxy.webapps.galaxy.api.group_users.GroupUsersAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

delete(trans, *args, **kwargs)

DELETE /api/groups/{encoded_group_id}/users/{encoded_user_id} Removes a user from a group

index(trans, *args, **kwargs)

GET /api/groups/{encoded_group_id}/users Displays a collection (list) of groups.

show(trans, *args, **kwargs)

GET /api/groups/{encoded_group_id}/users/{encoded_user_id} Displays information about a group user.

update(trans, *args, **kwargs)

PUT /api/groups/{encoded_group_id}/users/{encoded_user_id} Adds a user to a group

galaxy.webapps.galaxy.api.groups module

API operations on Group objects.

class galaxy.webapps.galaxy.api.groups.GroupAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

create(trans, *args, **kwargs)

POST /api/groups Creates a new group.

index(trans, *args, **kwargs)

GET /api/groups Displays a collection (list) of groups.

show(trans, *args, **kwargs)

GET /api/groups/{encoded_group_id} Displays information about a group.

update(trans, *args, **kwargs)

PUT /api/groups/{encoded_group_id} Modifies a group.

galaxy.webapps.galaxy.api.histories module

API operations on a history.

See also

galaxy.model.History

class galaxy.webapps.galaxy.api.histories.HistoriesController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.ExportsHistoryMixin, galaxy.web.base.controller.ImportsHistoryMixin

__init__(app)

archive_download(trans, *args, **kwargs)

export_download( self, trans, id, jeha_id ) * GET /api/histories/{id}/exports/{jeha_id}:

If ready and available, return raw contents of exported history. Use/poll “PUT /api/histories/{id}/exports” to initiate the creation of such an export - when ready that route will return 200 status code (instead of 202) with a JSON dictionary containing a download_url.

archive_export(trans, *args, **kwargs)

export_archive( self, trans, id, payload ) * PUT /api/histories/{id}/exports:

start job (if needed) to create history export for corresponding history.

Parameters:id (str) – the encoded id of the history to export Return type:dict Returns:object containing url to fetch export from.

citations(trans, *args, **kwargs)

create(trans, payload)

• POST /api/histories:

  create a new history

Parameters:

• payload (dict) – (optional) dictionary structure containing: * name: the new history’s name * history_id: the id of the history to copy * all_datasets: copy deleted hdas/hdcas? ‘True’ or ‘False’, defaults to True * archive_source: the url that will generate the archive to import * archive_type: ‘url’ (default)
• keys – same as the use of keys in the index function above
• view – same as the use of view in the index function above

Return type:

dict

Returns:

element view of new history

delete(self, trans, id, **kwd)

• DELETE /api/histories/{id}

  delete the history with the given id

Note

Stops all active jobs in the history if purge is set.

Parameters:

• id (str) – the encoded id of the history to delete
• kwd (dict) – (optional) dictionary structure containing extra parameters

You can purge a history, removing all it’s datasets from disk (if unshared), by passing in purge=True in the url.

Parameters:

• keys – same as the use of keys in the index function above
• view – same as the use of view in the index function above

Return type:

dict

Returns:

the deleted or purged history

index(trans, deleted='False')

• GET /api/histories:

  return undeleted histories for the current user

• GET /api/histories/deleted:

  return deleted histories for the current user

Note

Anonymous users are allowed to get their current history

Parameters:deleted (boolean) – if True, show only deleted histories, if False, non-deleted Return type:list Returns:list of dictionaries containing summary history information

The following are optional parameters:

view: string, one of (‘summary’,’detailed’), defaults to ‘summary’

controls which set of properties to return

keys: comma separated strings, unused by default

keys/names of individual properties to return

If neither keys or views are sent, the default view (set of keys) is returned. If both a view and keys are sent, the key list and the view’s keys are combined. If keys are send and no view, only those properties in keys are returned.

For which properties are available see:

galaxy/managers/histories/HistorySerializer

The list returned can be filtered by using two optional parameters:

q: string, generally a property name to filter by followed

by an (often optional) hyphen and operator string.

qv: string, the value to filter by

..example:

To filter the list to only those created after 2015-01-29, the query string would look like:

‘?q=create_time-gt&qv=2015-01-29’

Multiple filters can be sent in using multiple q/qv pairs:

‘?q=create_time-gt&qv=2015-01-29&q=tag-has&qv=experiment-1’

The list returned can be paginated using two optional parameters:

limit: integer, defaults to no value and no limit (return all)

how many items to return

offset: integer, defaults to 0 and starts at the beginning

skip the first ( offset - 1 ) items and begin returning at the Nth item

..example:

limit and offset can be combined. Skip the first two and return five:

‘?limit=5&offset=3’

The list returned can be ordered using the optional parameter:

order: string containing one of the valid ordering attributes followed

(optionally) by ‘-asc’ or ‘-dsc’ for ascending and descending order respectively. Orders can be stacked as a comma- separated list of values.

..example:

To sort by name descending then create time descending:

‘?order=name-dsc,create_time’

The ordering attributes and their default orders are:

create_time defaults to ‘create_time-dsc’ update_time defaults to ‘update_time-dsc’ name defaults to ‘name-asc’

‘order’ defaults to ‘create_time-dsc’

published(trans, *args, **kwargs)

published( self, trans, **kwd ): * GET /api/histories/published:

return all histories that are published

Return type:list Returns:list of dictionaries containing summary history information

Follows the same filtering logic as the index() method above.

shared_with_me(self, trans, **kwd)

• GET /api/histories/shared_with_me:

  return all histories that are shared with the current user

Return type:list Returns:list of dictionaries containing summary history information

Follows the same filtering logic as the index() method above.

show(trans, id, deleted='False')

• GET /api/histories/{id}:

  return the history with id

• GET /api/histories/deleted/{id}:

  return the deleted history with id

• GET /api/histories/most_recently_used:

  return the most recently used history

Parameters:

• id (an encoded id string) – the encoded id of the history to query or the string ‘most_recently_used’
• deleted (boolean) – if True, allow information on a deleted history to be shown.
• keys – same as the use of keys in the index function above
• view – same as the use of view in the index function above

Return type:

dictionary

Returns:

detailed history information

undelete(self, trans, id, **kwd)

• POST /api/histories/deleted/{id}/undelete:

  undelete history (that hasn’t been purged) with the given id

Parameters:

• id (str) – the encoded id of the history to undelete
• keys – same as the use of keys in the index function above
• view – same as the use of view in the index function above

Return type:

str

Returns:

‘OK’ if the history was undeleted

update(self, trans, id, payload, **kwd)

• PUT /api/histories/{id}

  updates the values for the history with the given id

Parameters:

• id (str) – the encoded id of the history to update
• payload (dict) –

  a dictionary containing any or all the fields in galaxy.model.History.to_dict() and/or the following:

  • annotation: an annotation for the history
• keys – same as the use of keys in the index function above
• view – same as the use of view in the index function above

Return type:

dict

Returns:

an error object if an error occurred or a dictionary containing any values that were different from the original and, therefore, updated

galaxy.webapps.galaxy.api.history_contents module

API operations on the contents of a history.

class galaxy.webapps.galaxy.api.history_contents.HistoryContentsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesLibraryMixin, galaxy.web.base.controller.UsesLibraryMixinItems, galaxy.web.base.controller.UsesTagsMixin

__init__(app)

archive(self, trans, history_id, filename='', format='tgz', dry_run=True, **kwd)

• GET /api/histories/{history_id}/contents/archive/{id}

• GET /api/histories/{history_id}/contents/archive/{filename}.{format}

  build and return a compressed archive of the selected history contents

Parameters:

• filename (string) – (optional) archive name (defaults to history name)
• dry_run (boolean) – (optional) if True, return the archive and file paths only as json and not an archive file

Returns:

archive file for download

Note

this is a volatile endpoint and settings and behavior may change.

create(self, trans, history_id, payload, **kwd)

• POST /api/histories/{history_id}/contents/{type}

  create a new HDA by copying an accessible LibraryDataset

Parameters:

• history_id (str) – encoded id string of the new HDA’s History
• type (str) – Type of history content - ‘dataset’ (default) or ‘dataset_collection’.
• payload (dict) –

  dictionary structure containing:: copy from library (for type ‘dataset’): ‘source’ = ‘library’ ‘content’ = [the encoded id from the library dataset]

  copy from library folder ‘source’ = ‘library_folder’ ‘content’ = [the encoded id from the library folder]

  copy from history dataset (for type ‘dataset’): ‘source’ = ‘hda’ ‘content’ = [the encoded id from the HDA]

  copy from history dataset collection (for type ‘dataset_collection’) ‘source’ = ‘hdca’ ‘content’ = [the encoded id from the HDCA]

  create new history dataset collection (for type ‘dataset_collection’) ‘source’ = ‘new_collection’ (default ‘source’ if type is

  ‘dataset_collection’ - no need to specify this)

  ‘collection_type’ = For example, “list”, “paired”, “list:paired”. ‘name’ = Name of new dataset collection. ‘element_identifiers’ = Recursive list structure defining collection.

  Each element must have ‘src’ which can be ‘hda’, ‘ldda’, ‘hdca’, or ‘new_collection’, as well as a ‘name’ which is the name of element (e.g. “forward” or “reverse” for paired datasets, or arbitrary sample names for instance for lists). For all src’s except ‘new_collection’ - a encoded ‘id’ attribute must be included wiht element as well. ‘new_collection’ sources must defined a ‘collection_type’ and their own list of (potentially) nested ‘element_identifiers’.

..note:

Currently, a user can only copy an HDA from a history that the user owns.

Return type:dict Returns:dictionary containing detailed information for the new HDA

delete(self, trans, history_id, id, **kwd)

• DELETE /api/histories/{history_id}/contents/{id}

  delete the HDA with the given id

Note

Currently does not stop any active jobs for which this dataset is an output.

Parameters:

• id (str) – the encoded id of the history to delete
• purge (bool) – if True, purge the HDA
• kwd (dict) –

  (optional) dictionary structure containing:

  • payload: a dictionary itself containing:

    • purge: if True, purge the HDA

Note

that payload optionally can be placed in the query string of the request. This allows clients that strip the request body to still purge the dataset.

Return type:dict Returns:an error object if an error occurred or a dictionary containing: * id: the encoded id of the history, * deleted: if the history was marked as deleted, * purged: if the history was purged

encode_type_id(type_id)

index(self, trans, history_id, ids=None, **kwd)

• GET /api/histories/{history_id}/contents

  return a list of HDA data for the history with the given id

Note

Anonymous users are allowed to get their current history contents

If Ids is not given, index returns a list of summary objects for every HDA associated with the given history_id.

If ids is given, index returns a more complete json object for each HDA in the ids list.

Parameters:

• history_id (str) – encoded id string of the HDA’s History
• ids (str) – (optional) a comma separated list of encoded HDA ids
• types (str) – (optional) kinds of contents to index (currently just dataset, but dataset_collection will be added shortly).

Return type:

list

Returns:

dictionaries containing summary or detailed HDA information

show(self, trans, id, history_id, **kwd)

• GET /api/histories/{history_id}/contents/{id}

  return detailed information about an HDA within a history

Note

Anonymous users are allowed to get their current history contents

Parameters:

• ids – the encoded id of the HDA to return
• history_id (str) – encoded id string of the HDA’s History

Return type:

dict

Returns:

dictionary containing detailed HDA information

update(self, trans, history_id, id, payload, **kwd)

• PUT /api/histories/{history_id}/contents/{id}

  updates the values for the HDA with the given id

Parameters:

• history_id (str) – encoded id string of the HDA’s History
• id (str) – the encoded id of the history to update
• payload (dict) –

  a dictionary containing any or all the fields in galaxy.model.HistoryDatasetAssociation.to_dict() and/or the following:

  • annotation: an annotation for the HDA

Return type:

dict

Returns:

an error object if an error occurred or a dictionary containing any values that were different from the original and, therefore, updated

galaxy.webapps.galaxy.api.item_tags module

API operations related to tagging items.

class galaxy.webapps.galaxy.api.item_tags.BaseItemTagsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesTagsMixin

create(trans, *args, **kwargs)

delete(trans, *args, **kwargs)

index(trans, *args, **kwargs)

show(trans, *args, **kwargs)

update(trans, *args, **kwargs)

class galaxy.webapps.galaxy.api.item_tags.HistoryContentTagsController(app)

Bases: galaxy.webapps.galaxy.api.item_tags.BaseItemTagsController

controller_name = 'history_content_tags'

tagged_item_class = 'HistoryDatasetAssociation'

tagged_item_id = 'history_content_id'

class galaxy.webapps.galaxy.api.item_tags.HistoryTagsController(app)

Bases: galaxy.webapps.galaxy.api.item_tags.BaseItemTagsController

controller_name = 'history_tags'

tagged_item_class = 'History'

tagged_item_id = 'history_id'

class galaxy.webapps.galaxy.api.item_tags.WorkflowTagsController(app)

Bases: galaxy.webapps.galaxy.api.item_tags.BaseItemTagsController

controller_name = 'workflow_tags'

tagged_item_class = 'StoredWorkflow'

tagged_item_id = 'workflow_id'

galaxy.webapps.galaxy.api.job_files module

API for asynchronous job running mechanisms can use to fetch or put files related to running and queued jobs.

class galaxy.webapps.galaxy.api.job_files.JobFilesAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

This job files controller allows remote job running mechanisms to read and modify the current state of files for queued and running jobs. It is certainly not meant to represent part of Galaxy’s stable, user facing API.

Furthermore, even if a user key corresponds to the user running the job, it should not be accepted for authorization - this API allows access to low-level unfiltered files and such authorization would break Galaxy’s security model for tool execution.

create(self, trans, job_id, payload, **kwargs)

• POST /api/jobs/{job_id}/files

  Populate an output file (formal dataset, task split part, working directory file (such as those related to metadata)). This should be a multipart post with a ‘file’ parameter containing the contents of the actual file to create.

Parameters:

• job_id (str) – encoded id string of the job
• payload (dict) – dictionary structure containing:: ‘job_key’ = Key authenticating ‘path’ = Path to file to create.

..note:

This API method is intended only for consumption by job runners, not end users.

Return type:dict Returns:an okay message

index(self, trans, job_id, **kwargs)

• GET /api/jobs/{job_id}/files

  Get a file required to staging a job (proper datasets, extra inputs, task-split inputs, working directory files).

Parameters:

• job_id (str) – encoded id string of the job
• path (str) – Path to file.
• job_key (str) – A key used to authenticate this request as acting on behalf or a job runner for the specified job.

..note:

This API method is intended only for consumption by job runners, not end users.

Return type:binary Returns:contents of file

galaxy.webapps.galaxy.api.jobs module

API operations on a jobs.

See also

galaxy.model.Jobs

class galaxy.webapps.galaxy.api.jobs.JobController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesLibraryMixinItems

__init__(app)

build_for_rerun(trans, *args, **kwargs)

• GET /api/jobs/{id}/build_for_rerun

  returns a tool input/param template prepopulated with this job’s information, suitable for rerunning or rendering parameters of the job.

Parameters:id (string) – Encoded job id Return type:dictionary Returns:dictionary containing output dataset associations

create(trans, *args, **kwargs)

See the create method in tools.py in order to submit a job.

index(trans, state=None, tool_id=None, history_id=None, date_range_min=None, date_range_max=None, user_details=False)

• GET /api/jobs:

  return jobs for current user

  !! if user is admin and user_details is True, then

  return jobs for all galaxy users based on filtering - this is an extended service

Parameters:state (string or list) – limit listing of jobs to those that match one of the included states. If none, all are returned.

Valid Galaxy job states include:

‘new’, ‘upload’, ‘waiting’, ‘queued’, ‘running’, ‘ok’, ‘error’, ‘paused’, ‘deleted’, ‘deleted_new’

Parameters:

• tool_id (string or list) – limit listing of jobs to those that match one of the included tool_ids. If none, all are returned.
• user_details (boolean) – if true, and requestor is an admin, will return external job id and user email.
• date_range_min (string '2014-01-01') – limit the listing of jobs to those updated on or after requested date
• date_range_max (string '2014-12-31') – limit the listing of jobs to those updated on or before requested date
• history_id (string) – limit listing of jobs to those that match the history_id. If none, all are returned.

Return type:

list

Returns:

list of dictionaries containing summary job information

inputs(trans, *args, **kwargs)

show( trans, id ) * GET /api/jobs/{id}/inputs

returns input datasets created by job

Parameters:id (string) – Encoded job id Return type:dictionary Returns:dictionary containing input dataset associations

outputs(trans, *args, **kwargs)

show( trans, id ) * GET /api/jobs/{id}/outputs

returns output datasets created by job

Parameters:id (string) – Encoded job id Return type:dictionary Returns:dictionary containing output dataset associations

search(trans, payload)

• POST /api/jobs/search:

  return jobs for current user

Parameters:payload (dict) – Dictionary containing description of requested job. This is in the same format as a request to POST /apt/tools would take to initiate a job Return type:list Returns:list of dictionaries containing summary job information of the jobs that match the requested job run

This method is designed to scan the list of previously run jobs and find records of jobs that had the exact some input parameters and datasets. This can be used to minimize the amount of repeated work, and simply recycle the old results.

show(trans, id)

• GET /api/jobs/{id}:

  return jobs for current user

Parameters:

• id (string) – Specific job id
• full (boolean) – whether to return extra information

Return type:

dictionary

Returns:

dictionary containing full description of job data

galaxy.webapps.galaxy.api.lda_datasets module

API operations on the library datasets.

class galaxy.webapps.galaxy.api.lda_datasets.LibraryDatasetsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesVisualizationMixin

__init__(app)

delete(trans, *args, **kwargs)

delete( self, trans, encoded_dataset_id, **kwd ): * DELETE /api/libraries/datasets/{encoded_dataset_id}

Marks the dataset deleted or undeleted based on the value of the undelete flag. If the flag is not present it is considered False and the item is marked deleted.

Parameters:encoded_dataset_id (an encoded id string) – the encoded id of the dataset to change Returns:dict containing information about the dataset Return type:dictionary

download(self, trans, format, **kwd)

• GET /api/libraries/datasets/download/{format}

• POST /api/libraries/datasets/download/{format}

  Downloads requested datasets (identified by encoded IDs) in requested format.

example: GET localhost:8080/api/libraries/datasets/download/tbz?ld_ids%255B%255D=a0d84b45643a2678&ld_ids%255B%255D=fe38c84dcd46c828

Note

supported format values are: ‘zip’, ‘tgz’, ‘tbz’, ‘uncompressed’

Parameters:

• format (string) – string representing requested archive format
• ld_ids[] (an array) – an array of encoded dataset ids
• folder_ids[] (an array) – an array of encoded folder ids

Return type:

file

Returns:

either archive with the requested datasets packed inside or a single uncompressed dataset

Raises:

MessageException, ItemDeletionException, ItemAccessibilityException, HTTPBadRequest, OSError, IOError, ObjectNotFound

load(trans, *args, **kwargs)

• POST /api/libraries/datasets

Load dataset from the given source into the library. Source can be:

user directory - root folder specified in galaxy.ini as “$user_library_import_dir”

example path: path/to/galaxy/$user_library_import_dir/user@example.com/{user can browse everything here} the folder with the user login has to be created beforehand

(admin)import directory - root folder specified in galaxy ini as “$library_import_dir”

example path: path/to/galaxy/$library_import_dir/{admin can browse everything here}

(admin)any absolute or relative path - option allowed with “allow_library_path_paste” in galaxy.ini

Parameters:payload –

dictionary structure containing: :param encoded_folder_id: the encoded id of the folder to import dataset(s) to :type encoded_folder_id: an encoded id string :param source: source the datasets should be loaded from :type source: str :param link_data: flag whether to link the dataset to data or copy it to Galaxy, defaults to copy

while linking is set to True all symlinks will be resolved _once_

type link_data:  bool param preserve_dirs:  flag whether to preserve the directory structure when importing dir if False only datasets will be imported type preserve_dirs:  bool param file_type:  file type of the loaded datasets, defaults to ‘auto’ (autodetect) type file_type:  str param dbkey:dbkey of the loaded genome, defaults to ‘?’ (unknown) type dbkey:str

:type dictionary :returns: dict containing information about the created upload job :rtype: dictionary :raises: RequestParameterMissingException, AdminRequiredException, ConfigDoesNotAllowException, RequestParameterInvalidException

InsufficientPermissionsException, ObjectNotFound

show(self, trans, id, **kwd)

• GET /api/libraries/datasets/{encoded_dataset_id}

  Displays information about the dataset identified by the encoded ID.

Parameters:id (an encoded id string) – the encoded id of the dataset to query Returns:detailed dataset information from base controller Return type:dictionary

See also

galaxy.web.base.controller.UsesLibraryMixinItems.get_library_dataset

show_roles(trans, *args, **kwargs)

show_roles( self, trans, id, **kwd ): * GET /api/libraries/datasets/{encoded_dataset_id}/permissions

Displays information about current or available roles for a given dataset permission.

Parameters:

• encoded_dataset_id (an encoded id string) – the encoded id of the dataset to query
• scope (string) – either ‘current’ or ‘available’

Return type:

dictionary

Returns:

either dict of current roles for all permission types or dict of available roles to choose from (is the same for any permission type)

show_version(trans, *args, **kwargs)

show_version( self, trans, encoded_dataset_id, encoded_ldda_id, **kwd ): * GET /api/libraries/datasets/{encoded_dataset_id}/versions/{encoded_ldda_id}

Displays information about specific version of the library_dataset (i.e. ldda).

Parameters:

• encoded_dataset_id (an encoded id string) – the encoded id of the dataset to query
• encoded_ldda_id (an encoded id string) – the encoded id of the ldda to query

Return type:

dictionary

Returns:

dict of ldda’s details

update_permissions(trans, *args, **kwargs)

*POST /api/libraries/datasets/{encoded_dataset_id}/permissions

Set permissions of the given dataset to the given role ids.

Parameters:

• encoded_dataset_id (an encoded id string) – the encoded id of the dataset to update permissions of
• payload –

  dictionary structure containing: :param action: (required) describes what action should be performed

  available actions: make_private, remove_restrictions, set_permissions

  type action:string param access_ids[]:  list of Role.id defining roles that should have access permission on the dataset type access_ids[]:  string or list param manage_ids[]:  list of Role.id defining roles that should have manage permission on the dataset type manage_ids[]:  string or list param modify_ids[]:  list of Role.id defining roles that should have modify permission on the library dataset item type modify_ids[]:  string or list

Type:

dictionary

Returns:

dict of current roles for all available permission types

Return type:

dictionary

Raises:

RequestParameterInvalidException, ObjectNotFound, InsufficientPermissionsException, InternalServerError RequestParameterMissingException

galaxy.webapps.galaxy.api.libraries module

API operations on a data library.

class galaxy.webapps.galaxy.api.libraries.LibrariesController(app)

Bases: galaxy.web.base.controller.BaseAPIController

__init__(app)

create(trans, *args, **kwargs)

• POST /api/libraries:

  Creates a new library.

Note

Currently, only admin users can create libraries.

Parameters:payload (dict) – dictionary structure containing:: :param name: (required) the new library’s name :type name: str :param description: the new library’s description :type description: str :param synopsis: the new library’s synopsis :type synopsis: str Returns:detailed library information Return type:dict Raises:RequestParameterMissingException

delete(trans, *args, **kwargs)

• DELETE /api/libraries/{id}

  marks the library with the given id as deleted (or removes the deleted mark if the undelete param is true)

Note

Currently, only admin users can un/delete libraries.

Parameters:

• id (an encoded id string) – the encoded id of the library to un/delete
• payload – dictionary structure containing: :param undelete: (optional) flag specifying whether the item should be deleted or undeleted, defaults to false: :type undelete: bool

Type:

dictionary

Returns:

detailed library information

Return type:

dictionary

See also

galaxy.model.Library.dict_element_visible_keys

get_permissions(trans, *args, **kwargs)

• GET /api/libraries/{id}/permissions

Load all permissions for the given library id and return it.

Parameters:

• encoded_library_id (an encoded id string) – the encoded id of the library
• scope (string) – either ‘current’ or ‘available’
• is_library_access (bool) – indicates whether the roles available for the library access are requested

Returns:

dictionary with all applicable permissions’ values

Return type:

dictionary

Raises:

InsufficientPermissionsException

index(self, trans, **kwd)

• GET /api/libraries:

  Returns a list of summary data for all libraries.

Parameters:deleted (boolean (optional)) – if True, show only deleted libraries, if False show only non-deleted Returns:list of dictionaries containing library information Return type:list

See also

galaxy.model.Library.dict_collection_visible_keys

set_permissions(trans, *args, **kwargs)

*POST /api/libraries/{encoded_library_id}/permissions

Set permissions of the given library to the given role ids.

Parameters:

• encoded_library_id (an encoded id string) – the encoded id of the library to set the permissions of
• payload –

  dictionary structure containing: :param action: (required) describes what action should be performed

  available actions: remove_restrictions, set_permissions

  type action:str param access_ids[]:  list of Role.id defining roles that should have access permission on the library type access_ids[]:  string or list param add_ids[]:  list of Role.id defining roles that should have add item permission on the library type add_ids[]:  string or list param manage_ids[]:  list of Role.id defining roles that should have manage permission on the library type manage_ids[]:  string or list param modify_ids[]:  list of Role.id defining roles that should have modify permission on the library type modify_ids[]:  string or list

Type:

dictionary

Returns:

dict of current roles for all available permission types

Return type:

dictionary

Raises:

RequestParameterInvalidException, InsufficientPermissionsException, InternalServerError RequestParameterMissingException

set_permissions_old(trans, library, payload, **kwd)

* old implementation for backward compatibility *

POST /api/libraries/{encoded_library_id}/permissions Updates the library permissions.

show(self, trans, id, deleted='False', **kwd)

• GET /api/libraries/{encoded_id}:

  returns detailed information about a library

• GET /api/libraries/deleted/{encoded_id}:

  returns detailed information about a deleted library

Parameters:

• id (an encoded id string) – the encoded id of the library
• deleted (boolean) – if True, allow information on a deleted library

Returns:

detailed library information

Return type:

dictionary

See also

galaxy.model.Library.dict_element_visible_keys

Raises:MalformedId, ObjectNotFound

update(trans, *args, **kwargs)

• PATCH /api/libraries/{encoded_id}

  Updates the library defined by an encoded_id with the data in the payload.

Note

Currently, only admin users can update libraries. Also the library must not be deleted.

param id:the encoded id of the library type id:an encoded id string param payload:dictionary structure containing:: :param name: new library’s name, cannot be empty :type name: str :param description: new library’s description :type description: str :param synopsis: new library’s synopsis :type synopsis: str type payload:dict returns:detailed library information rtype:dict raises:RequestParameterMissingException

galaxy.webapps.galaxy.api.library_contents module

API operations on the contents of a data library.

class galaxy.webapps.galaxy.api.library_contents.LibraryContentsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesLibraryMixin, galaxy.web.base.controller.UsesLibraryMixinItems

__init__(app)

create(self, trans, library_id, payload, **kwd)

• POST /api/libraries/{library_id}/contents:

  create a new library file or folder

To copy an HDA into a library send create_type of ‘file’ and the HDA’s encoded id in from_hda_id (and optionally ldda_message).

Parameters:

• library_id (str) – the encoded id of the library where to create the new item
• payload (dict) –

  dictionary structure containing:

  • folder_id: the encoded id of the parent folder of the new item
  • create_type: the type of item to create (‘file’, ‘folder’ or ‘collection’)

  • from_hda_id: (optional, only if create_type is ‘file’) the

    encoded id of an accessible HDA to copy into the library

  • ldda_message: (optional) the new message attribute of the LDDA created

  • extended_metadata: (optional) dub-dictionary containing any extended

    metadata to associate with the item

  • upload_option: (optional) one of ‘upload_file’ (default), ‘upload_directory’ or ‘upload_paths’

  • server_dir: (optional, only if upload_option is

    ‘upload_directory’) relative path of the subdirectory of Galaxy library_import_dir to upload. All and only the files (i.e. no subdirectories) contained in the specified directory will be uploaded.

  • filesystem_paths: (optional, only if upload_option is

    ‘upload_paths’ and the user is an admin) file paths on the Galaxy server to upload to the library, one file per line

  • link_data_only: (optional, only when upload_option is

    ‘upload_directory’ or ‘upload_paths’) either ‘copy_files’ (default) or ‘link_to_files’. Setting to ‘link_to_files’ symlinks instead of copying the files

  • name: (optional, only if create_type is ‘folder’) name of the

    folder to create

  • description: (optional, only if create_type is ‘folder’)

    description of the folder to create

Return type:

dict

Returns:

a dictionary containing the id, name, and ‘show’ url of the new item

delete(self, trans, library_id, id, **kwd)

• DELETE /api/libraries/{library_id}/contents/{id}

  delete the LibraryDataset with the given id

Parameters:

• id (str) – the encoded id of the library dataset to delete
• kwd (dict) –

  (optional) dictionary structure containing:

  • payload: a dictionary itself containing:

    • purge: if True, purge the LD

Return type:

dict

Returns:

an error object if an error occurred or a dictionary containing: * id: the encoded id of the library dataset, * deleted: if the library dataset was marked as deleted, * purged: if the library dataset was purged

index(self, trans, library_id, **kwd)

• GET /api/libraries/{library_id}/contents:

  Returns a list of library files and folders.

Note

May be slow! Returns all content traversing recursively through all folders.

See also

galaxy.webapps.galaxy.api.FolderContentsController.index for a non-recursive solution

Parameters:library_id (str) – the encoded id of the library Returns:list of dictionaries of the form: * id: the encoded id of the library item * name: the ‘library path’

or relationship of the library item to the root

• type: ‘file’ or ‘folder’
• url: the url to get detailed information on the library item

Return type:list Raises:MalformedId, InconsistentDatabase, RequestParameterInvalidException, InternalServerError

show(self, trans, id, library_id, **kwd)

• GET /api/libraries/{library_id}/contents/{id}

  Returns information about library file or folder.

Parameters:

• id (str) – the encoded id of the library item to return
• library_id (str) – the encoded id of the library that contains this item

Returns:

detailed library item information

Return type:

dict

See also

galaxy.model.LibraryDataset.to_dict() and galaxy.model.LibraryFolder.dict_element_visible_keys

update(self, trans, id, library_id, payload, **kwd)

• PUT /api/libraries/{library_id}/contents/{id}

  create a ImplicitlyConvertedDatasetAssociation

See also

galaxy.model.ImplicitlyConvertedDatasetAssociation

Parameters:

• id (str) – the encoded id of the library item to return
• library_id (str) – the encoded id of the library that contains this item
• payload (dict) – dictionary structure containing:: ‘converted_dataset_id’:

Return type:

None

Returns:

None

galaxy.webapps.galaxy.api.metrics module

API operations for for querying and recording user metrics from some client (typically a user’s browser).

class galaxy.webapps.galaxy.api.metrics.MetricsController(app)

Bases: galaxy.web.base.controller.BaseAPIController

__init__(app)

create(trans, payload)

• POST /api/metrics:

  record any metrics sent and return some status object

Note

Anonymous users can post metrics

Parameters:payload (dict) –

(optional) dictionary structure containing: * metrics: a list containing dictionaries of the form:

** namespace: label indicating the source of the metric ** time: isoformat datetime when the metric was recorded ** level: an integer representing the metric’s log level ** args: a json string containing an array of extra data

Return type:dict Returns:status object

debugging = None

set to true to send additional debugging info to the log

galaxy.webapps.galaxy.api.page_revisions module

API for updating Galaxy Pages

class galaxy.webapps.galaxy.api.page_revisions.PageRevisionsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.SharableItemSecurityMixin, galaxy.model.item_attrs.UsesAnnotations, galaxy.web.base.controller.SharableMixin

create(self, trans, page_id, payload **kwd)

• POST /api/pages/{page_id}/revisions

  Create a new revision for a page

Parameters:

• page_id – Add revision to Page with ID=page_id
• payload – A dictionary containing:: ‘title’ = New title of the page ‘content’ = New content of the page

Return type:

dictionary

Returns:

Dictionary with ‘success’ or ‘error’ element to indicate the result of the request

index(self, trans, page_id, **kwd)

• GET /api/pages/{page_id}/revisions

  return a list of Page revisions

Parameters:page_id – Display the revisions of Page with ID=page_id Return type:list Returns:dictionaries containing different revisions of the page

galaxy.webapps.galaxy.api.pages module

API for updating Galaxy Pages

class galaxy.webapps.galaxy.api.pages.PagesController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.SharableItemSecurityMixin, galaxy.model.item_attrs.UsesAnnotations, galaxy.web.base.controller.SharableMixin

create(self, trans, payload, **kwd)

• POST /api/pages

  Create a page and return dictionary containing Page summary

Parameters:payload – dictionary structure containing:: ‘slug’ = The title slug for the page URL, must be unique ‘title’ = Title of the page ‘content’ = HTML contents of the page ‘annotation’ = Annotation that will be attached to the page Return type:dict Returns:Dictionary return of the Page.to_dict call

delete(self, trans, id, **kwd)

• DELETE /api/pages/{id}

  Create a page and return dictionary containing Page summary

Parameters:id – ID of page to be deleted Return type:dict Returns:Dictionary with ‘success’ or ‘error’ element to indicate the result of the request

index(self, trans, deleted=False, **kwd)

• GET /api/pages

  return a list of Pages viewable by the user

Parameters:deleted – Display deleted pages Return type:list Returns:dictionaries containing summary or detailed Page information

show(self, trans, id, **kwd)

• GET /api/pages/{id}

  View a page summary and the content of the latest revision

Parameters:id – ID of page to be displayed Return type:dict Returns:Dictionary return of the Page.to_dict call with the ‘content’ field populated by the most recent revision

galaxy.webapps.galaxy.api.provenance module

API operations provenance

class galaxy.webapps.galaxy.api.provenance.BaseProvenanceController(app)

Bases: galaxy.web.base.controller.BaseAPIController

__init__(app)

create(trans, *args, **kwargs)

delete(trans, *args, **kwargs)

index(trans, *args, **kwargs)

show(trans, *args, **kwargs)

class galaxy.webapps.galaxy.api.provenance.HDAProvenanceController(app)

Bases: galaxy.webapps.galaxy.api.provenance.BaseProvenanceController

controller_name = 'history_content_provenance'

provenance_item_class = 'HistoryDatasetAssociation'

provenance_item_id = 'history_content_id'

class galaxy.webapps.galaxy.api.provenance.LDDAProvenanceController(app)

Bases: galaxy.webapps.galaxy.api.provenance.BaseProvenanceController

controller_name = 'ldda_provenance'

provenance_item_class = 'LibraryDatasetDatasetAssociation'

provenance_item_id = 'library_content_id'

galaxy.webapps.galaxy.api.quotas module

API operations on Quota objects.

class galaxy.webapps.galaxy.api.quotas.QuotaAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controllers.admin.Admin, galaxy.actions.admin.AdminActions, galaxy.web.base.controller.UsesQuotaMixin, galaxy.web.params.QuotaParamParser

create(trans, *args, **kwargs)

POST /api/quotas Creates a new quota.

delete(trans, *args, **kwargs)

DELETE /api/quotas/{encoded_quota_id} Deletes a quota

index(trans, *args, **kwargs)

GET /api/quotas GET /api/quotas/deleted Displays a collection (list) of quotas.

show(trans, *args, **kwargs)

GET /api/quotas/{encoded_quota_id} GET /api/quotas/deleted/{encoded_quota_id} Displays information about a quota.

undelete(trans, *args, **kwargs)

POST /api/quotas/deleted/{encoded_quota_id}/undelete Undeletes a quota

update(trans, *args, **kwargs)

PUT /api/quotas/{encoded_quota_id} Modifies a quota.

galaxy.webapps.galaxy.api.remote_files module

API operations on remote files.

class galaxy.webapps.galaxy.api.remote_files.RemoteFilesAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

index(trans, *args, **kwargs)

GET /api/remote_files/

Displays remote files.

Parameters:

• target (str) – target to load available datasets from, defaults to ftp possible values: ftp, userdir, importdir
• format – requested format of data, defaults to flat possible values: flat, jstree, ajax

Returns:

list of available files

Return type:

list

galaxy.webapps.galaxy.api.request_types module

API operations on RequestType objects.

class galaxy.webapps.galaxy.api.request_types.RequestTypeAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

create(trans, *args, **kwargs)

POST /api/request_types Creates a new request type (external_service configuration).

index(trans, *args, **kwargs)

GET /api/request_types Displays a collection (list) of request_types.

show(trans, *args, **kwargs)

GET /api/request_types/{encoded_request_type_id} Displays information about a request_type.

galaxy.webapps.galaxy.api.requests module

API operations on a sample tracking system.

class galaxy.webapps.galaxy.api.requests.RequestsAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

index(trans, *args, **kwargs)

GET /api/requests Displays a collection (list) of sequencing requests.

show(trans, *args, **kwargs)

GET /api/requests/{encoded_request_id} Displays details of a sequencing request.

update(trans, *args, **kwargs)

PUT /api/requests/{encoded_request_id} Updates a request state, sample state or sample dataset transfer status depending on the update_type

v = ('REQUEST', 'request_state')

galaxy.webapps.galaxy.api.roles module

API operations on Role objects.

class galaxy.webapps.galaxy.api.roles.RoleAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

create(trans, *args, **kwargs)

POST /api/roles Creates a new role.

index(trans, *args, **kwargs)

GET /api/roles Displays a collection (list) of roles.

show(trans, *args, **kwargs)

GET /api/roles/{encoded_role_id} Displays information about a role.

galaxy.webapps.galaxy.api.samples module

API operations for samples in the Galaxy sample tracking system.

class galaxy.webapps.galaxy.api.samples.SamplesAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController

index(trans, *args, **kwargs)

GET /api/requests/{encoded_request_id}/samples Displays a collection (list) of sample of a sequencing request.

k = 'SAMPLE_DATASET'

update(trans, *args, **kwargs)

PUT /api/samples/{encoded_sample_id} Updates a sample or objects related ( mapped ) to a sample.

update_type_values = ['sample_state', 'run_details', 'sample_dataset_transfer_status']

update_types = <galaxy.util.bunch.Bunch object>

v = ['sample_dataset_transfer_status']

galaxy.webapps.galaxy.api.search module

API for searching Galaxy Datasets

class galaxy.webapps.galaxy.api.search.SearchController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.SharableItemSecurityMixin

create(trans, *args, **kwargs)

POST /api/search Do a search of the various elements of Galaxy.

galaxy.webapps.galaxy.api.tool_data module

class galaxy.webapps.galaxy.api.tool_data.ToolData(app)

Bases: galaxy.web.base.controller.BaseAPIController

RESTful controller for interactions with tool data

delete(trans, *args, **kwargs)

DELETE /api/tool_data/{id} Removes an item from a data table

Parameters:

• id (str) – the id of the data table containing the item to delete
• kwd (dict) –

  (required) dictionary structure containing:

  • payload: a dictionary itself containing:

    • values: <TAB> separated list of column contents, there must be a value for all the columns of the data table

download_field_file(trans, *args, **kwargs)

index(trans, *args, **kwargs)

GET /api/tool_data: returns a list tool_data tables:

reload(trans, *args, **kwargs)

GET /api/tool_data/{id}/reload

Reloads a tool_data table.

show(trans, *args, **kwargs)

show_field(trans, *args, **kwargs)

GET /api/tool_data/<id>/fields/<value>

Get information about a partiular field in a tool_data table

galaxy.webapps.galaxy.api.tool_shed_repositories module

class galaxy.webapps.galaxy.api.tool_shed_repositories.ToolShedRepositoriesController(app)

Bases: galaxy.web.base.controller.BaseAPIController

RESTful controller for interactions with tool shed repositories.

check_for_updates(trans, *args, **kwargs)

GET /api/tool_shed_repositories/check_for_updates Check for updates to the specified repository, or all installed repositories.

Parameters:

• key – the current Galaxy admin user’s API key
• id – the galaxy-side encoded repository ID

exported_workflows(trans, *args, **kwargs)

GET /api/tool_shed_repositories/{encoded_tool_shed_repository_id}/exported_workflows

Display a list of dictionaries containing information about this tool shed repository’s exported workflows.

Parameters:id – the encoded id of the ToolShedRepository object

get_latest_installable_revision(trans, *args, **kwargs)

POST /api/tool_shed_repositories/get_latest_installable_revision Get the latest installable revision of a specified repository from a specified Tool Shed.

Parameters:key – the current Galaxy admin user’s API key

The following parameters are included in the payload. :param tool_shed_url (required): the base URL of the Tool Shed from which to retrieve the Repository revision. :param name (required): the name of the Repository :param owner (required): the owner of the Repository

import_workflow(trans, *args, **kwargs)

POST /api/tool_shed_repositories/import_workflow

Import the specified exported workflow contained in the specified installed tool shed repository into Galaxy.

Parameters:

• key – the API key of the Galaxy user with which the imported workflow will be associated.
• id – the encoded id of the ToolShedRepository object

The following parameters are included in the payload. :param index: the index location of the workflow tuple in the list of exported workflows stored in the metadata for the specified repository

import_workflows(trans, *args, **kwargs)

POST /api/tool_shed_repositories/import_workflows

Import all of the exported workflows contained in the specified installed tool shed repository into Galaxy.

Parameters:

• key – the API key of the Galaxy user with which the imported workflows will be associated.
• id – the encoded id of the ToolShedRepository object

index(trans, *args, **kwargs)

GET /api/tool_shed_repositories Display a list of dictionaries containing information about installed tool shed repositories.

install(trans, *args, **kwargs)

POST /api/tool_shed_repositories/install Initiate the installation of a repository.

Parameters:

• install_resolver_dependencies – True to install resolvable dependencies.
• install_tool_dependencies – True to install tool dependencies.
• install_repository_dependencies – True to install repository dependencies.
• tool_panel_section_id – The unique identifier for an existing tool panel section
• new_tool_panel_section_label – Create a new tool panel section with this label
• shed_tool_conf – The shed tool config file to use for this installation
• tool_shed_url – The URL for the toolshed whence this repository is being installed
• changeset – The changeset to update to after cloning the repository

install_repository_revision(trans, *args, **kwargs)

POST /api/tool_shed_repositories/install_repository_revision Install a specified repository revision from a specified tool shed into Galaxy.

Parameters:key – the current Galaxy admin user’s API key

The following parameters are included in the payload. :param tool_shed_url (required): the base URL of the Tool Shed from which to install the Repository :param name (required): the name of the Repository :param owner (required): the owner of the Repository :param changeset_revision (required): the changeset_revision of the RepositoryMetadata object associated with the Repository :param new_tool_panel_section_label (optional): label of a new section to be added to the Galaxy tool panel in which to load

tools contained in the Repository. Either this parameter must be an empty string or the tool_panel_section_id parameter must be an empty string or both must be an empty string (both cannot be used simultaneously).

Parameters:

• (optional) (shed_tool_conf) – id of the Galaxy tool panel section in which to load tools contained in the Repository. If this parameter is an empty string and the above new_tool_panel_section_label parameter is an empty string, tools will be loaded outside of any sections in the tool panel. Either this parameter must be an empty string or the tool_panel_section_id parameter must be an empty string of both must be an empty string (both cannot be used simultaneously).
• (optional) – Set to True if you want to install repository dependencies defined for the specified repository being installed. The default setting is False.
• (optional) – Set to True if you want to install tool dependencies defined for the specified repository being installed. The default setting is False.
• (optional) – The shed-related tool panel configuration file configured in the “tool_config_file” setting in the Galaxy config file (e.g., galaxy.ini). At least one shed-related tool panel config file is required to be configured. Setting this parameter to a specific file enables you to choose where the specified repository will be installed because the tool_path attribute of the <toolbox> from the specified file is used as the installation location (e.g., <toolbox tool_path=”../shed_tools”>). If this parameter is not set, a shed-related tool panel configuration file will be selected automatically.

install_repository_revisions(trans, *args, **kwargs)

POST /api/tool_shed_repositories/install_repository_revisions Install one or more specified repository revisions from one or more specified tool sheds into Galaxy. The received parameters must be ordered lists so that positional values in tool_shed_urls, names, owners and changeset_revisions are associated.

It’s questionable whether this method is needed as the above method for installing a single repository can probably cover all desired scenarios. We’ll keep this one around just in case...

Parameters:key – the current Galaxy admin user’s API key

The following parameters are included in the payload. :param tool_shed_urls: the base URLs of the Tool Sheds from which to install a specified Repository :param names: the names of the Repositories to be installed :param owners: the owners of the Repositories to be installed :param changeset_revisions: the changeset_revisions of each RepositoryMetadata object associated with each Repository to be installed :param new_tool_panel_section_label: optional label of a new section to be added to the Galaxy tool panel in which to load

tools contained in the Repository. Either this parameter must be an empty string or the tool_panel_section_id parameter must be an empty string, as both cannot be used.

Parameters:

• tool_panel_section_id – optional id of the Galaxy tool panel section in which to load tools contained in the Repository. If not set, tools will be loaded outside of any sections in the tool panel. Either this parameter must be an empty string or the tool_panel_section_id parameter must be an empty string, as both cannot be used.
• (optional) (shed_tool_conf) – Set to True if you want to install repository dependencies defined for the specified repository being installed. The default setting is False.
• (optional) – Set to True if you want to install tool dependencies defined for the specified repository being installed. The default setting is False.
• (optional) – The shed-related tool panel configuration file configured in the “tool_config_file” setting in the Galaxy config file (e.g., galaxy.ini). At least one shed-related tool panel config file is required to be configured. Setting this parameter to a specific file enables you to choose where the specified repository will be installed because the tool_path attribute of the <toolbox> from the specified file is used as the installation location (e.g., <toolbox tool_path=”../shed_tools”>). If this parameter is not set, a shed-related tool panel configuration file will be selected automatically.

repair_repository_revision(trans, *args, **kwargs)

POST /api/tool_shed_repositories/repair_repository_revision Repair a specified repository revision previously installed into Galaxy.

Parameters:key – the current Galaxy admin user’s API key

The following parameters are included in the payload. :param tool_shed_url (required): the base URL of the Tool Shed from which the Repository was installed :param name (required): the name of the Repository :param owner (required): the owner of the Repository :param changeset_revision (required): the changeset_revision of the RepositoryMetadata object associated with the Repository

reset_metadata_on_installed_repositories(trans, *args, **kwargs)

PUT /api/tool_shed_repositories/reset_metadata_on_installed_repositories

Resets all metadata on all repositories installed into Galaxy in an “orderly fashion”.

Parameters:key – the API key of the Galaxy admin user.

shed_categories(trans, *args, **kwargs)

GET /api/tool_shed_repositories/shed_categories

Display a list of categories in the selected toolshed.

Parameters:tool_shed_url – the url of the toolshed to get categories from

shed_category(trans, *args, **kwargs)

GET /api/tool_shed_repositories/shed_category

Display a list of repositories in the selected category.

Parameters:

• tool_shed_url – the url of the toolshed to get repositories from
• category_id – the category to get repositories from

shed_repository(trans, *args, **kwargs)

GET /api/tool_shed_repositories/shed_repository

Get details about the specified repository from its shed.

Parameters:tsr_id – the tool_shed_repository_id

show(trans, *args, **kwargs)

GET /api/tool_shed_repositories/{encoded_tool_shed_repsository_id} Display a dictionary containing information about a specified tool_shed_repository.

Parameters:id – the encoded id of the ToolShedRepository object

status(trans, *args, **kwargs)

GET /api/tool_shed_repositories/{id}/status Display a dictionary containing information about a specified repository’s installation status and a list of its dependencies and the status of each.

Parameters:id – the repository’s encoded id

galaxy.webapps.galaxy.api.tool_shed_repositories.get_message_for_no_shed_tool_config()

galaxy.webapps.galaxy.api.tools module

class galaxy.webapps.galaxy.api.tools.ToolsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesVisualizationMixin

RESTful controller for interactions with tools.

__init__(app)

all_requirements(trans, *args, **kwargs)

GET /api/tools/all_requirements Return list of unique requirements for all tools.

build(trans, *args, **kwargs)

GET /api/tools/{tool_id}/build Returns a tool model including dynamic parameters and updated values, repeats block etc.

build_dependency_cache(trans, *args, **kwargs)

POST /api/tools/{tool_id}/build_dependency_cache Attempts to cache installed dependencies.

parameters:

force_rebuild: If true and chache dir exists, attempts to delete cache dir

citations(trans, *args, **kwargs)

create(trans, *args, **kwargs)

POST /api/tools Executes tool using specified inputs and returns tool’s outputs.

diagnostics(trans, *args, **kwargs)

GET /api/tools/{tool_id}/diagnostics Return diagnostic information to help debug panel and dependency related problems.

download(trans, *args, **kwargs)

index(trans, *args, **kwargs)

GET /api/tools: returns a list of tools defined by parameters:

parameters:

    in_panel  - if true, tools are returned in panel structure,
                including sections and labels
    trackster - if true, only tools that are compatible with
                Trackster are returned
    q         - if present search on the given query will be performed
    tool_id   - if present the given tool_id will be searched for
                all installed versions

install_dependencies(trans, *args, **kwargs)

POST /api/tools/{tool_id}/install_dependencies Attempts to install requirements via the dependency resolver

parameters:

build_dependency_cache: If true, attempts to cache dependencies for this tool force_rebuild: If true and chache dir exists, attempts to delete cache dir

reload(trans, *args, **kwargs)

GET /api/tools/{tool_id}/reload Reload specified tool.

requirements(trans, *args, **kwargs)

GET /api/tools/{tool_id}/requirements Return the resolver status for a specific tool id. [{“status”: “installed”, “name”: “hisat2”, “versionless”: false, “resolver_type”: “conda”, “version”: “2.0.3”, “type”: “package”}]

show(trans, *args, **kwargs)

GET /api/tools/{tool_id} Returns tool information, including parameters and inputs.

galaxy.webapps.galaxy.api.users module

API operations on User objects.

class galaxy.webapps.galaxy.api.users.UserAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesTagsMixin, galaxy.web.base.controller.CreatesUsersMixin, galaxy.web.base.controller.CreatesApiKeysMixin, galaxy.web.base.controller.BaseUIController, galaxy.web.base.controller.UsesFormDefinitionsMixin

__init__(app)

anon_user_api_value(trans)

Return data for an anonymous user, truncated to only usage and quota_percent

api_key(trans, *args, **kwargs)

Create API key.

create(trans, *args, **kwargs)

POST /api/users Creates a new Galaxy user.

delete(trans, *args, **kwargs)

DELETE /api/users/{id} delete the user with the given id

Parameters:

• id (str) – the encoded id of the user to delete
• purge (bool) – (optional) if True, purge the user

get_activation_token(trans, email)

Check for the activation token. Create new activation token and store it in the database if no token found.

get_api_key(trans, *args, **kwargs)

Get API key inputs.

get_communication(trans, *args, **kwargs)

Build communication server inputs.

get_information(trans, *args, **kwargs)

Return user details such as username, email, addresses etc.

get_password(trans, *args, **kwargs)

Return available password inputs.

get_permissions(trans, *args, **kwargs)

Get the user’s default permissions for the new histories

get_toolbox_filters(trans, *args, **kwargs)

API call for fetching toolbox filters data. Toolbox filters are specified in galaxy.ini. The user can activate them and the choice is stored in user_preferences.

index(trans, *args, **kwargs)

GET /api/users GET /api/users/deleted Displays a collection (list) of users.

Parameters:

• deleted (bool) – (optional) If true, show deleted users
• f_email (str) – (optional) An email address to filter on. (Non-admin users can only use this if expose_user_email is True in galaxy.ini)
• f_name (str) – (optional) A username to filter on. (Non-admin users can only use this if expose_user_name is True in galaxy.ini)
• f_any (str) – (optional) Filter on username OR email. (Non-admin users can use this, the email filter and username filter will only be active if their corresponding expose_user_* is True in galaxy.ini)

prepare_activation_link(trans, email)

Prepare the account activation link for the user.

send_verification_email(trans, email, username)

Send the verification email containing the activation link to the user’s email.

set_api_key(trans, *args, **kwargs)

Get API key inputs with new API key.

set_communication(trans, *args, **kwargs)

Allows the user to activate/deactivate the communication server.

set_information(trans, *args, **kwargs)

Save a user’s email, username, addresses etc.

set_password(trans, *args, **kwargs)

Allows to change a user password.

set_permissions(trans, *args, **kwargs)

Set the user’s default permissions for the new histories

set_toolbox_filters(trans, *args, **kwargs)

API call to update toolbox filters data.

show(trans, *args, **kwargs)

GET /api/users/{encoded_id} GET /api/users/deleted/{encoded_id} GET /api/users/current Displays information about a user.

undelete(trans, *args, **kwargs)

update(self, trans, id, payload, **kwd)

• PUT /api/users/{id}

  updates the values for the item with the given id

Parameters:

• id (str) – the encoded id of the item to update
• payload (dict) – a dictionary of new attribute values

Return type:

dict

Returns:

an error object if an error occurred or a dictionary containing the serialized item after any changes

galaxy.webapps.galaxy.api.visualizations module

Visualizations resource control over the API.

NOTE!: this is a work in progress and functionality and data structures may change often.

class galaxy.webapps.galaxy.api.visualizations.VisualizationsController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesVisualizationMixin, galaxy.web.base.controller.SharableMixin, galaxy.model.item_attrs.UsesAnnotations

RESTful controller for interactions with visualizations.

create(trans, *args, **kwargs)

POST /api/visualizations creates a new visualization using the given payload

POST /api/visualizations?import_id={encoded_visualization_id} imports a copy of an existing visualization into the user’s workspace

index(trans, *args, **kwargs)

GET /api/visualizations:

show(trans, *args, **kwargs)

GET /api/visualizations/{viz_id}

update(trans, *args, **kwargs)

PUT /api/visualizations/{encoded_visualization_id}

galaxy.webapps.galaxy.api.workflows module

API operations for Workflows

class galaxy.webapps.galaxy.api.workflows.WorkflowsAPIController(app)

Bases: galaxy.web.base.controller.BaseAPIController, galaxy.web.base.controller.UsesStoredWorkflowMixin, galaxy.model.item_attrs.UsesAnnotations, galaxy.web.base.controller.SharableMixin

__init__(app)

build_module(trans, *args, **kwargs)

POST /api/workflows/build_module Builds module details including a tool model for the workflow editor.

cancel_invocation(trans, *args, **kwargs)

DELETE /api/workflows/{workflow_id}/invocations/{invocation_id} Cancel the specified workflow invocation.

Parameters:

• workflow_id (str) – the workflow id (required)
• invocation_id (str) – the usage id (required)

Raises:

exceptions.MessageException, exceptions.ObjectNotFound

create(trans, *args, **kwargs)

POST /api/workflows

Run or create workflows from the api.

If installed_repository_file or from_history_id is specified a new workflow will be created for this user. Otherwise, workflow_id must be specified and this API method will cause a workflow to execute.

:param installed_repository_file The path of a workflow to import. Either workflow_id, installed_repository_file or from_history_id must be specified :type installed_repository_file str

Parameters:

• workflow_id (str) – An existing workflow id. Either workflow_id, installed_repository_file or from_history_id must be specified
• parameters (dict) – If workflow_id is set - see _update_step_parameters()
• ds_map (dict) – If workflow_id is set - a dictionary mapping each input step id to a dictionary with 2 keys: ‘src’ (which can be ‘ldda’, ‘ld’ or ‘hda’) and ‘id’ (which should be the id of a LibraryDatasetDatasetAssociation, LibraryDataset or HistoryDatasetAssociation respectively)
• no_add_to_history (str) – If workflow_id is set - if present in the payload with any value, the input datasets will not be added to the selected history
• history (str) – If workflow_id is set - optional history where to run the workflow, either the name of a new history or “hist_id=HIST_ID” where HIST_ID is the id of an existing history. If not specified, the workflow will be run a new unnamed history
• replacement_params (dict) – If workflow_id is set - an optional dictionary used when renaming datasets
• from_history_id (str) – Id of history to extract a workflow from. Either workflow_id, installed_repository_file or from_history_id must be specified
• job_ids (str) – If from_history_id is set - optional list of jobs to include when extracting a workflow from history
• dataset_ids (str) – If from_history_id is set - optional list of HDA `hid`s corresponding to workflow inputs when extracting a workflow from history
• dataset_collection_ids (str) – If from_history_id is set - optional list of HDCA `hid`s corresponding to workflow inputs when extracting a workflow from history
• workflow_name (str) – If from_history_id is set - name of the workflow to create when extracting a workflow from history
• allow_tool_state_corrections (bool) – If set to True, any Tool parameter changes will not prevent running workflow, defaults to False

delete(trans, *args, **kwargs)

DELETE /api/workflows/{encoded_workflow_id} Deletes a specified workflow Author: rpark

copied from galaxy.web.controllers.workflows.py (delete)

import_new_workflow_deprecated(trans, *args, **kwargs)

POST /api/workflows/upload Importing dynamic workflows from the api. Return newly generated workflow id. Author: rpark

# currently assumes payload[‘workflow’] is a json representation of a workflow to be inserted into the database

Deprecated in favor to POST /api/workflows with encoded ‘workflow’ in payload the same way.

import_shared_workflow_deprecated(trans, *args, **kwargs)

POST /api/workflows/import Import a workflow shared by other users.

Parameters:workflow_id (str) – the workflow id (required) Raises:exceptions.MessageException, exceptions.ObjectNotFound

index(trans, *args, **kwargs)

GET /api/workflows

Displays a collection of workflows.

Parameters:show_published (boolean) – if True, show also published workflows

index_invocations(trans, *args, **kwargs)

GET /api/workflows/{workflow_id}/invocations

Get the list of the workflow invocations

Parameters:workflow_id (str) – the workflow id (required) Raises:exceptions.MessageException, exceptions.ObjectNotFound

invocation_step(trans, *args, **kwargs)

GET /api/workflows/{workflow_id}/invocations/{invocation_id}/steps/{step_id}

Parameters:

• workflow_id (str) – the workflow id (required)
• invocation_id (str) – the invocation id (required)
• step_id (str) – encoded id of the WorkflowInvocationStep (required)
• payload – payload containing update action information for running workflow.

Raises:

exceptions.MessageException, exceptions.ObjectNotFound

invoke(trans, *args, **kwargs)

POST /api/workflows/{encoded_workflow_id}/invocations

Schedule the workflow specified by workflow_id to run.

show(trans, *args, **kwargs)

GET /api/workflows/{encoded_workflow_id}

Displays information needed to run a workflow from the command line.

show_invocation(trans, *args, **kwargs)

GET /api/workflows/{workflow_id}/invocations/{invocation_id} Get detailed description of workflow invocation

Parameters:

• workflow_id (str) – the workflow id (required)
• invocation_id (str) – the invocation id (required)

Raises:

exceptions.MessageException, exceptions.ObjectNotFound

update(trans, *args, **kwargs)

• PUT /api/workflows/{id}

  updates the workflow stored with id

Parameters:

• id (str) – the encoded id of the workflow to update
• payload (dict) –

  a dictionary containing any or all the * workflow the json description of the workflow as would be

  produced by GET workflows/<id>/download or given to POST workflows

  The workflow contents will be updated to target this.

  • name optional string name for the workflow, if not present in payload,

    name defaults to existing name

  • annotation optional string annotation for the workflow, if not present in payload,

    annotation defaults to existing annotation

  • menu_entry optional boolean marking if the workflow should appear in the user’s menu,

    if not present, workflow menu entries are not modified

Return type:

dict

Returns:

serialized version of the workflow

update_invocation_step(trans, *args, **kwargs)

PUT /api/workflows/{workflow_id}/invocations/{invocation_id}/steps/{step_id} Update state of running workflow step invocation - still very nebulous but this would be for stuff like confirming paused steps can proceed etc....

Parameters:

• workflow_id (str) – the workflow id (required)
• invocation_id (str) – the usage id (required)
• step_id (str) – encoded id of the WorkflowInvocationStep (required)

Raises:

exceptions.MessageException, exceptions.ObjectNotFound

workflow_dict(trans, *args, **kwargs)

GET /api/workflows/{encoded_workflow_id}/download Returns a selected workflow as a json dictionary.