managers Package

managers Package

Classes that manage resources (models, tools, etc.) by using the current Transaction.

Encapsulates the intersection of trans (or trans.sa_session), models, and Controllers.

Responsibilities:

model operations that involve the trans/sa_session (CRUD) security:

ownership, accessibility

common aspect-oriented operations via new mixins:

sharable, annotatable, tagable, ratable

Not responsible for:

encoding/decoding ids any http gobblygook formatting of returned data (always python structures) formatting of raised errors

The goal is to have Controllers only handle:

query-string/payload parsing and encoding/decoding ids http return formatting

and:

control, improve namespacing in Controllers DRY for Controller ops (define here - use in both UI/API Controllers)

In other words, ‘Business logic’ independent of web transactions/user context (trans) should be pushed into models - but logic that requires the context trans should be placed under this module.

api_keys Module

class galaxy.managers.api_keys.ApiKeyManager(app)

Bases: object

create_api_key(user)

get_or_create_api_key(user)

base Module

Keeps the older BaseController security and fetching methods and also defines a base ModelManager, ModelSerializer, and ModelDeserializer.

ModelManagers are used for operations on models that occur outside the scope of a single model object, such as:

• object creation
• object lookup
• interactions between 2+ objects of different model classes

(Since these were to replace model Mixins from web/framework/base/controller.py the rule of thumb used there also generally has been applied here: if it uses the trans or sa_session, put it in a manager and not the model.)

ModelSerializers allow flexible conversion of model objects to dictionaries. They control what keys are sent, how values are simplified, can remap keys, and allow both predefined and user controlled key sets.

ModelDeserializers control how a model validates and process an incoming attribute change to a model object.

class galaxy.managers.base.ModelDeserializer(app)

Bases: object

An object that converts an incoming serialized dict into values that can be directly assigned to an item’s attributes and assigns them.

add_deserializers()

Register a map of attribute keys -> functions that will deserialize data into attributes to be assigned to the item.

default_deserializer(item, key, val, **context)

If the incoming val is different than the item value change it and, in either case, return the value.

deserialize(item, data, flush=True, **context)

Convert an incoming serialized dict into values that can be directly assigned to an item’s attributes and assign them

deserialize_basestring(item, key, val, convert_none_to_empty=False, **context)

deserialize_bool(item, key, val, **context)

deserialize_genome_build(item, key, val, **context)

Make sure val is a valid dbkey and assign it.

deserialize_int(item, key, val, min=None, max=None, **context)

model_manager_class = None

the class used to create this deserializer’s generically accessible model_manager

exception galaxy.managers.base.ModelDeserializingError(err_msg=None, type='info', **extra_error_info)

Bases: galaxy.exceptions.ObjectAttributeInvalidException

Thrown when an incoming value isn’t usable by the model (bad type, out of range, etc.)

class galaxy.managers.base.ModelFilterParser(app)

Bases: object

Converts string tuples (partially converted query string params) of attr, op, val into either:

• ORM based filters (filters that can be applied by the ORM at the SQL

level) or - functional filters (filters that use derived values or values not within the SQL tables)

These filters can then be applied to queries.

This abstraction allows ‘smarter’ application of limit and offset at either the SQL level or the generator/list level based on the presence of functional filters. In other words, if no functional filters are present, limit and offset may be applied at the SQL level. If functional filters are present, limit and offset need to applied at the list level.

These might be safely be replaced in the future by creating SQLAlchemy hybrid properties or more thoroughly mapping derived values.

UNDERSCORED_OPS = ('lt', 'le', 'eq', 'ne', 'ge', 'gt')

these are the easier/shorter string equivalents to the python operator fn names that need ‘__’ around them

fn_filter_parsers = None

dictionary containing parsing data for functional filters - applied after a query is made

model_class = None

model class

orm_filter_parsers = None

dictionary containing parsing data for ORM/SQLAlchemy-based filters

over potentially expensive queries

parse_bool(bool_string)

Parse a boolean from a string.

parse_filter(attr, op, val)

Attempt to parse filter as a custom/fn filter, then an orm filter, and if neither work - raise an error.

Raises exceptions.RequestParameterInvalidException:  if no functional or orm filter can be parsed.

parse_filters(filter_tuple_list)

Parse string 3-tuples (attr, op, val) into orm or functional filters.

parse_id_list(id_list_string, sep=', ')

Split id_list_string at sep.

string_standard_ops(key)

class galaxy.managers.base.ModelManager(app)

Bases: object

Base class for all model/resource managers.

Provides common queries and CRUD operations as a (hopefully) light layer over the ORM.

associate(associate_with, item, foreign_key_name=None)

Generically associate item with associate_with based on foreign_key_name.

by_id(id, **kwargs)

Gets a model by primary id.

by_ids(ids, filters=None, **kwargs)

Returns an in-order list of models with the matching ids in ids.

copy(item, **kwargs)

Clone or copy an item.

create(flush=True, *args, **kwargs)

Generically create a new model.

foreign_key_name = None

list(filters=None, order_by=None, limit=None, offset=None, **kwargs)

Returns all objects matching the given filters

model_class

alias of object

one(**kwargs)

Sends kwargs to build the query and returns one and only one model.

query(eagerloads=True, filters=None, order_by=None, limit=None, offset=None, **kwargs)

Return a basic query from model_class, filters, order_by, and limit and offset.

Set eagerloads to False to disable them for this query.

query_associated(associated_model_class, item, foreign_key_name=None)

Generically query other items that have been associated with this item.

session()

update(item, new_values, flush=True, **kwargs)

Given a dictionary of new values, update item and return it.

..note: NO validation or deserialization occurs here.

class galaxy.managers.base.ModelSerializer(app)

Bases: object

Turns models into JSONable dicts.

Maintains a map of requestable keys and the Callable() serializer functions that should be called for those keys. E.g. { ‘x’ : lambda item, key: item.x, ... }

Note: if a key to serialize is not listed in the Serializer.serializable_keyset or serializers, it will not be returned.

To serialize call:

my_serializer = MySerializer( app ) ... keys_to_serialize = [ ‘id’, ‘name’, ‘attr1’, ‘attr2’, ... ] item_dict = MySerializer.serialize( my_item, keys_to_serialize )

add_serializers()

Register a map of attribute keys -> serializing functions that will serialize the attribute.

add_view(view_name, key_list, include_keys_from=None)

Add the list of serializable attributes key_list to the serializer’s view dictionary under the key view_name.

If include_keys_from is a proper view name, extend key_list by the list in that view.

default_serializer(item, key, **context)

Serialize the item‘s attribute named key.

serialize(item, keys, **context)

Serialize the model item to a dictionary.

Given model item and the list keys, create and return a dictionary built from each key in keys that also exists in serializers and values of calling the keyed/named serializers on item.

serialize_date(item, key, **context)

Serialize a date attribute of item.

serialize_id(item, key, **context)

Serialize an id attribute of item.

serialize_to_view(item, view=None, keys=None, default_view=None, **context)

Use a predefined list of keys (the string view) and any additional keys listed in keys.

The combinations can be:

view only: return those keys listed in the named view keys only: return those keys listed no view or keys: use the default_view if any view and keys: combine both into one list of keys

skip(msg='skipped')

To be called from inside a serializer to skip it.

Handy for config checks, information hiding, etc.

static url_for(*args, **kargs)

‘service’ to use for getting urls - use class var to allow overriding when testing

exception galaxy.managers.base.ModelSerializingError(err_msg=None, type='info', **extra_error_info)

Bases: galaxy.exceptions.InternalServerError

Thrown when request model values can’t be serialized

class galaxy.managers.base.ModelValidator(app, *args, **kwargs)

Bases: object

An object that inspects a dictionary (generally meant to be a set of new/updated values for the model) and raises an error if a value is not acceptable.

basestring(key, val)

basestring_list(key, val)

Must be a list of basestrings.

bool(key, val)

genome_build(key, val)

Must be a valid base_string.

Note: no checking against installation’s ref list is done as many data sources consider this an open field.

int(key, val)

int_range(key, val, min=None, max=None)

Must be a int between min and max.

nullable_basestring(key, val)

Must be a basestring or None.

type(key, val, types)

Check val against the type (or tuple of types) in types.

Raises exceptions.RequestParameterInvalidException:  if not an instance.

exception galaxy.managers.base.SkipAttribute

Bases: exceptions.Exception

Raise this inside a serializer to prevent the returned dictionary from having a the associated key or value for this attribute.

galaxy.managers.base.get_class(class_name)

Returns the class object that a string denotes. Without this method, we’d have to do eval(<class_name>).

galaxy.managers.base.get_object(trans, id, class_name, check_ownership=False, check_accessible=False, deleted=None)

Convenience method to get a model object with the specified checks. This is a generic method for dealing with objects uniformly from the older controller mixin code - however whenever possible the managers for a particular model should be used to load objects.

galaxy.managers.base.security_check(trans, item, check_ownership=False, check_accessible=False)

Security checks for an item: checks if (a) user owns item or (b) item is accessible to user. This is a generic method for dealing with objects uniformly from the older controller mixin code - however whenever possible the managers for a particular model should be used to perform security checks.

citations Module

class galaxy.managers.citations.BaseCitation

Bases: object

equals(other_citation)

has_doi()

to_dict(citation_format)

class galaxy.managers.citations.BibtexCitation(elem, directory, citation_manager)

Bases: galaxy.managers.citations.BaseCitation

to_bibtex()

class galaxy.managers.citations.CitationCollection

Bases: object

add(new_citation)

class galaxy.managers.citations.CitationsManager(app)

Bases: object

citations_for_tool(tool)

citations_for_tool_ids(tool_ids)

parse_citation(citation_elem, tool_directory)

class galaxy.managers.citations.DoiCache(config)

Bases: object

get_bibtex(doi)

class galaxy.managers.citations.DoiCitation(elem, directory, citation_manager)

Bases: galaxy.managers.citations.BaseCitation

BIBTEX_UNSET = <object object>

doi()

has_doi()

to_bibtex()

galaxy.managers.citations.parse_citation(elem, directory, citation_manager)

Parse an abstract citation entry from the specified XML element. The directory parameter should be used to find external files for this citation.

collections Module

class galaxy.managers.collections.DatasetCollectionManager(app)

Bases: object

Abstraction for interfacing with dataset collections instance - ideally abstarcts out model and plugin details.

ELEMENTS_UNINITIALIZED = <object object>

copy(trans, parent, source, encoded_source_id)

create(trans, parent, name, collection_type, element_identifiers=None, elements=None, implicit_collection_info=None)

create_dataset_collection(trans, collection_type, elements=None)

delete(trans, instance_type, id)

get_dataset_collection(trans, encoded_id)

get_dataset_collection_instance(trans, instance_type, id, **kwds)

history_dataset_collections(history, query)

match_collections(collections_to_match)

May seem odd to place it here, but planning to grow sophistication and get plugin types involved so it will likely make sense in the future.

set_collection_elements(dataset_collection, dataset_instances)

update(trans, instance_type, id, payload)

collections_util Module

galaxy.managers.collections_util.api_payload_to_create_params(payload)

Cleanup API payload to pass into dataset_collections.

galaxy.managers.collections_util.dictify_dataset_collection_instance(dataset_collection_instance, parent, security, view='element')

galaxy.managers.collections_util.dictify_element(element)

galaxy.managers.collections_util.validate_input_element_identifiers(element_identifiers)

Scan through the list of element identifiers supplied by the API consumer and verify the structure is valid.

context Module

Mixins for transaction-like objects.

class galaxy.managers.context.ProvidesAppContext

Bases: object

For transaction-like objects to provide Galaxy convience layer for database and event handling.

Mixed in class must provide app property.

expunge_all()

get_toolbox()

Returns the application toolbox

install_model

log_action(user=None, action=None, context=None, params=None)

Application-level logging of user actions.

log_event(message, tool_id=None, **kwargs)

Application level logging. Still needs fleshing out (log levels and such) Logging events is a config setting - if False, do not log.

model

request_types()

sa_session

Returns a SQLAlchemy session – currently just gets the current session from the threadlocal session context, but this is provided to allow migration toward a more SQLAlchemy 0.4 style of use.

class galaxy.managers.context.ProvidesHistoryContext

Bases: object

For transaction-like objects to provide Galaxy convience layer for reasoning about histories.

Mixed in class must provide user, history, and app properties.

db_builds

Returns the builds defined by galaxy and the builds defined by the user (chromInfo in history).

db_dataset_for(dbkey)

Returns the db_file dataset associated/needed by dataset, or None.

class galaxy.managers.context.ProvidesUserContext

Bases: object

For transaction-like objects to provide Galaxy convience layer for reasoning about users.

Mixed in class must provide user, api_inherit_admin, and app properties.

anonymous

get_current_user_roles()

user_can_do_run_as()

user_ftp_dir

user_is_admin()

folders Module

Manager and Serializer for Library Folders.

class galaxy.managers.folders.FolderManager

Bases: object

Interface/service object for interacting with folders.

can_add_item(trans, folder)

Return true if the user has permissions to add item to the given folder.

check_accessible(trans, folder)

Check whether the folder is accessible to current user. By default every folder is accessible (contents have their own permissions).

check_manageable(trans, folder)

Check whether the user can manage the folder.

Returns:the original folder Return type:LibraryFolder Raises:AuthenticationRequired, InsufficientPermissionsException

create(trans, parent_folder_id, new_folder_name, new_folder_description='')

Create a new folder under the given folder.

Parameters:

• parent_folder_id (int) – decoded id
• new_folder_name (str) – name of the new folder
• new_folder_description (str) – description of the folder (optional, defaults to empty string)

Returns:

the new folder

Return type:

LibraryFolder

Raises:

InsufficientPermissionsException

cut_and_decode(trans, encoded_folder_id)

Cuts the folder prefix (the prepended ‘F’) and returns the decoded id.

Parameters:encoded_folder_id (string) – encoded id of the Folder object Returns:decoded Folder id Return type:int

cut_the_prefix(encoded_folder_id)

Remove the prefix from the encoded folder id.

Parameters:encoded_folder_id (string) – encoded id of the Folder object with ‘F’ prepended Returns:encoded Folder id without the ‘F’ prefix Return type:string Raises:MalformedId

decode_folder_id(trans, encoded_folder_id)

Decode the folder id given that it has already lost the prefixed ‘F’.

Parameters:encoded_folder_id (string) – encoded id of the Folder object Returns:decoded Folder id Return type:int Raises:MalformedId

delete(trans, folder, undelete=False)

Mark given folder deleted/undeleted based on the flag.

Parameters:

• folder (LibraryFolder) – the model object
• undelete (Bool) – flag whether to delete (when False) or undelete

Returns:

the folder

Return type:

LibraryFolder

Raises:

ItemAccessibilityException

get(trans, decoded_folder_id, check_manageable=False, check_accessible=True)

Get the folder from the DB.

Parameters:

• decoded_folder_id (int) – decoded folder id
• check_manageable (bool) – flag whether the check that user can manage item
• check_accessible (bool) – flag whether to check that user can access item

Returns:

the requested folder

Return type:

LibraryFolder

Raises:

InconsistentDatabase, RequestParameterInvalidException, InternalServerError

get_current_roles(trans, folder)

Find all roles currently connected to relevant permissions on the folder.

Parameters:folder (LibraryFolder) – the model object Returns:dict of current roles for all available permission types Return type:dictionary

get_folder_dict(trans, folder)

Return folder data in the form of a dictionary.

Parameters:folder (LibraryFolder) – folder item Returns:dict with data about the folder Return type:dictionary

secure(trans, folder, check_manageable=True, check_accessible=True)

Check if (a) user can manage folder or (b) folder is accessible to user.

Parameters:

• folder (LibraryFolder) – folder item
• check_manageable (bool) – flag whether to check that user can manage item
• check_accessible (bool) – flag whether to check that user can access item

Returns:

the original folder

Return type:

LibraryFolder

hdas Module

Manager and Serializer for HDAs.

HistoryDatasetAssociations (HDAs) are datasets contained or created in a history.

class galaxy.managers.hdas.HDADeserializer(app)

Bases: galaxy.managers.datasets.DatasetAssociationDeserializer, galaxy.managers.taggable.TaggableDeserializerMixin, galaxy.managers.annotatable.AnnotatableDeserializerMixin

Interface/service object for validating and deserializing dictionaries into histories.

add_deserializers()

model_manager_class

alias of HDAManager

class galaxy.managers.hdas.HDAFilterParser(app)

Bases: galaxy.managers.datasets.DatasetAssociationFilterParser, galaxy.managers.taggable.TaggableFilterMixin, galaxy.managers.annotatable.AnnotatableFilterMixin

model_class

alias of HistoryDatasetAssociation

class galaxy.managers.hdas.HDAManager(app)

Bases: galaxy.managers.datasets.DatasetAssociationManager, galaxy.managers.secured.OwnableManagerMixin, galaxy.managers.taggable.TaggableManagerMixin, galaxy.managers.annotatable.AnnotatableManagerMixin

Interface/service object for interacting with HDAs.

annotation_assoc

alias of HistoryDatasetAssociationAnnotationAssociation

copy(hda, history=None, **kwargs)

Copy and return the given HDA.

copy_ldda(history, ldda, **kwargs)

Copy this HDA as a LDDA and return.

create(history=None, dataset=None, flush=True, **kwargs)

Create a new hda optionally passing in it’s history and dataset.

..note: to explicitly set hid to None you must pass in hid=None, otherwise it will be automatically set.

data_conversion_status(hda)

Returns a message if an hda is not ready to be used in visualization.

error_if_uploading(hda)

Raise error if HDA is still uploading.

foreign_key_name = 'history_dataset_association'

has_been_resubmitted(hda)

Return True if the hda’s job was resubmitted at any point.

is_accessible(hda, user, **kwargs)

Override to allow owners (those that own the associated history).

is_owner(hda, user, current_history=None, **kwargs)

Use history to see if current user owns HDA.

model_class

alias of HistoryDatasetAssociation

purge(hda, current_user=None, flush=True)

Purge this HDA and the dataset underlying it.

tag_assoc

alias of HistoryDatasetAssociationTagAssociation

text_data(hda, preview=True)

Get data from text file, truncating if necessary.

class galaxy.managers.hdas.HDASerializer(app)

Bases: galaxy.managers.datasets.DatasetAssociationSerializer, galaxy.managers.taggable.TaggableSerializerMixin, galaxy.managers.annotatable.AnnotatableSerializerMixin

add_serializers()

serialize_display_apps(hda, key, trans=None, **context)

Return dictionary containing new-style display app urls.

serialize_old_display_applications(hda, key, trans=None, **context)

Return dictionary containing old-style display app urls.

serialize_type_id(hda, key, **context)

serialize_urls(hda, key, **context)

Return web controller urls useful for this HDA.

serialize_visualization_links(hda, key, trans=None, **context)

Return a list of dictionaries with links to visualization pages for those visualizations that apply to this hda.

histories Module

Manager and Serializer for histories.

Histories are containers for datasets or dataset collections created (or copied) by users over the course of an analysis.

class galaxy.managers.histories.HistoryDeserializer(app)

Bases: galaxy.managers.sharable.SharableModelDeserializer, galaxy.managers.deletable.PurgableDeserializerMixin

Interface/service object for validating and deserializing dictionaries into histories.

add_deserializers()

model_manager_class

alias of HistoryManager

class galaxy.managers.histories.HistoryFilters(app)

Bases: galaxy.managers.sharable.SharableModelFilters, galaxy.managers.deletable.PurgableFiltersMixin

model_class

alias of History

class galaxy.managers.histories.HistoryManager(app, *args, **kwargs)

Bases: galaxy.managers.sharable.SharableModelManager, galaxy.managers.deletable.PurgableManagerMixin

annotation_assoc

alias of HistoryAnnotationAssociation

by_user(user, current_history=None, **kwargs)

Get all the histories for a given user (allowing anon users’ theirs) ordered by update time.

copy(history, user, **kwargs)

Copy and return the given history.

foreign_key_name = 'history'

get_current(trans)

Return the current history.

is_owner(history, user, current_history=None, **kwargs)

True if the current user is the owner of the given history.

model_class

alias of History

most_recent(user, filters=None, current_history=None, **kwargs)

Return the most recently update history for the user.

If user is anonymous, return the current history. If the user is anonymous and the current history is deleted, return None.

purge(history, flush=True, **kwargs)

Purge this history and all HDAs, Collections, and Datasets inside this history.

rating_assoc

alias of HistoryRatingAssociation

set_current(trans, history)

Set the current history.

set_current_by_id(trans, history_id)

Set the current history by an id.

tag_assoc

alias of HistoryTagAssociation

user_share_model

alias of HistoryUserShareAssociation

class galaxy.managers.histories.HistorySerializer(app)

Bases: galaxy.managers.sharable.SharableModelSerializer, galaxy.managers.deletable.PurgableSerializerMixin

Interface/service object for serializing histories into dictionaries.

SINGLE_CHAR_ABBR = 'h'

add_serializers()

serialize_contents(history, *args, **context)

serialize_history_state(history, key, **context)

Returns the history state based on the states of the HDAs it contains.

serialize_state_counts(history, key, exclude_deleted=True, exclude_hidden=False, **context)

Return a dictionary keyed to possible dataset states and valued with the number of datasets in this history that have those states.

serialize_state_ids(history, key, **context)

Return a dictionary keyed to possible dataset states and valued with lists containing the ids of each HDA in that state.

lddas Module

class galaxy.managers.lddas.LDDAManager(app)

Bases: object

A fairly sparse manager for LDDAs.

get(trans, id, check_accessible=True)

libraries Module

Manager and Serializer for libraries.

class galaxy.managers.libraries.LibraryManager(*args, **kwargs)

Bases: object

Interface/service object for interacting with libraries.

check_accessible(trans, library)

Check whether the library is accessible to current user.

create(trans, name, description='', synopsis='')

Create a new library.

delete(trans, library, undelete=False)

Mark given library deleted/undeleted based on the flag.

get(trans, decoded_library_id, check_accessible=True)

Get the library from the DB.

Parameters:

• decoded_library_id (int) – decoded library id
• check_accessible (bool) – flag whether to check that user can access item

Returns:

the requested library

Return type:

Library

get_access_roles(trans, library)

Load access roles for all library permissions

get_add_roles(trans, library)

Load add roles for all library permissions

get_current_roles(trans, library)

Load all permissions currently related to the given library.

Parameters:library (Library) – the model object Return type:dictionary Returns:dict of current roles for all available permission types

get_library_dict(trans, library)

Return library data in the form of a dictionary.

Parameters:library (Library) – library Returns:dict with data about the library Return type:dictionary

get_manage_roles(trans, library)

Load manage roles for all library permissions

get_modify_roles(trans, library)

Load modify roles for all library permissions

is_public(trans, library)

Return true if lib is public.

list(trans, deleted=False)

Return a list of libraries from the DB.

Parameters:deleted (boolean (optional)) – if True, show only deleted libraries, if False show only non-deleted Returns:query that will emit all accessible libraries Return type:sqlalchemy query

make_public(trans, library)

Makes the given library public (removes all access roles)

secure(trans, library, check_accessible=True)

Check if library is accessible to user.

Parameters:

• folder (Library) – library
• check_accessible (bool) – flag whether to check that user can access library

Returns:

the original folder

Return type:

LibraryFolder

set_permission_roles(trans, library, access_roles, modify_roles, manage_roles, add_roles)

Set permissions on the given library.

update(trans, library, name=None, description=None, synopsis=None)

Update the given library

roles Module

Manager and Serializer for Roles.

class galaxy.managers.roles.RoleManager(app)

Bases: galaxy.managers.base.ModelManager

Business logic for roles.

foreign_key_name = 'role'

get(trans, decoded_role_id)

Method loads the role from the DB based on the given role id.

Parameters:decoded_role_id (int) – id of the role to load from the DB Returns:the loaded Role object Return type:Role Raises:InconsistentDatabase, RequestParameterInvalidException, InternalServerError

group_assoc

alias of GroupRoleAssociation

model_class

alias of Role

user_assoc

alias of UserRoleAssociation

tags Module

class galaxy.managers.tags.CommunityTagManager(app)

Bases: galaxy.managers.tags.TagManager

class galaxy.managers.tags.GalaxyTagManager(app)

Bases: galaxy.managers.tags.TagManager

class galaxy.managers.tags.ItemTagAssocInfo(item_class, tag_assoc_class, item_id_col)

Bases: object

class galaxy.managers.tags.TagManager(app)

Bases: object

Manages CRUD operations related to tagging objects.

apply_item_tag(user, item, name, value=None)

apply_item_tags(user, item, tags_str)

Apply tags to an item.

delete_item_tags(user, item)

Delete tags from an item.

get_community_tags(item=None, limit=None)

Returns community tags for an item.

get_id_col_in_item_tag_assoc_table(item_class)

Returns item id column in class’ item-tag association table.

get_tag_assoc_class(item_class)

Returns tag association class for item class.

get_tag_by_id(tag_id)

Get a Tag object from a tag id.

get_tag_by_name(tag_name)

Get a Tag object from a tag name (string).

get_tags_str(tags)

Build a string from an item’s tags.

get_tool_tags()

item_has_tag(user, item, tag)

Returns true if item is has a given tag.

parse_tags(tag_str)

Returns a list of raw (tag-name, value) pairs derived from a string; method scrubs tag names and values as well. Return value is a dictionary where tag-names are keys.

remove_item_tag(user, item, tag_name)

Remove a tag from an item.

set_tags_from_list(user, item, new_tags_list)

workflows Module

class galaxy.managers.workflows.CreatedWorkflow(stored_workflow, missing_tools)

Bases: tuple

missing_tools

Alias for field number 1

stored_workflow

Alias for field number 0

class galaxy.managers.workflows.MissingToolsException(workflow, errors)

Bases: object

class galaxy.managers.workflows.WorkflowContentsManager

Bases: galaxy.model.item_attrs.UsesAnnotations

build_workflow_from_dict(trans, data, source=None, add_to_menu=False, publish=False)

update_workflow_from_dict(trans, stored_workflow, workflow_data, from_editor=False)

workflow_to_dict(trans, stored, style='export')

Export the workflow contents to a dictionary ready for JSON-ification and to be sent out via API for instance. There are three styles of export allowed ‘export’, ‘instance’, and ‘editor’. The Galaxy team will do it best to preserve the backward compatibility of the ‘export’ stye - this is the export method meant to be portable across Galaxy instances and over time. The ‘editor’ style is subject to rapid and unannounced changes. The ‘instance’ export option describes the workflow in a context more tied to the current Galaxy instance and includes fields like ‘url’ and ‘url’ and actual unencoded step ids instead of ‘order_index’.

class galaxy.managers.workflows.WorkflowsManager(app)

Bases: object

Handle CRUD type operaitons related to workflows. More interesting stuff regarding workflow execution, step sorting, etc... can be found in the galaxy.workflow module.

build_invocations_query(trans, decoded_stored_workflow_id)

cancel_invocation(trans, decoded_invocation_id)

check_security(trans, has_workflow, check_ownership=True, check_accessible=True)

check accessibility or ownership of workflows, storedworkflows, and workflowinvocations. Throw an exception or returns True if user has needed level of access.

get_invocation(trans, decoded_invocation_id)

get_invocation_step(trans, decoded_workflow_invocation_step_id)

update_invocation_step(trans, decoded_workflow_invocation_step_id, action)