Warning

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

galaxy.tool_util.deps package

Dependency management for tools.

class galaxy.tool_util.deps.CachedDependencyManager(default_base_path, **kwd)[source]

Bases: galaxy.tool_util.deps.DependencyManager

__init__(default_base_path, **kwd)[source]
build_cache(requirements, **kwds)[source]
cached = True
dependency_shell_commands(requirements, **kwds)[source]

Runs a set of requirements through the dependency resolvers and returns a list of commands required to activate the dependencies. If dependencies are cacheable and the cache does not exist, will try to create it. If cached environment exists or is successfully created, will generate commands to activate it.

get_hashed_dependencies_path(resolved_dependencies)[source]

Returns the path to the hashed dependencies directory (but does not evaluate whether the path exists).

Parameters:resolved_dependencies (list) – list of resolved dependencies
Returns:path
Return type:str
hash_dependencies(resolved_dependencies)[source]

Return hash for dependencies

class galaxy.tool_util.deps.DependencyManager(default_base_path, conf_file=None, app_config=None)[source]

Bases: object

A DependencyManager attempts to resolve named and versioned dependencies by searching for them under a list of directories. Directories should be of the form:

$BASE/name/version/…

and should each contain a file ‘env.sh’ which can be sourced to make the dependency available in the current shell environment.

__init__(default_base_path, conf_file=None, app_config=None)[source]

Create a new dependency manager looking for packages under the paths listed in base_paths. The default base path is app.config.tool_dependency_dir.

cached = False
dependency_shell_commands(requirements, **kwds)[source]
enabled_container_types

Returns the union of enabled container types.

find_dep(name, version=None, type='package', **kwds)[source]
get_app_option(key, default=None)[source]
get_destination_info_for_container_type(container_type, destination_id=None)[source]
get_resolver_option(resolver, key, explicit_resolver_options=None)[source]

Look in resolver-specific settings for option and then fallback to global settings.

precache
requirements_to_dependencies(requirements, **kwds)[source]

Takes a list of requirements and returns a dictionary with requirements as key and dependencies as value caching these on the tool instance if supplied.

set_enabled_container_types(container_types_to_destinations)[source]

Set the union of all enabled container types.

to_dict()[source]
uses_tool_shed_dependencies()[source]
class galaxy.tool_util.deps.NullDependencyManager(default_base_path=None, conf_file=None, app_config=None)[source]

Bases: galaxy.tool_util.deps.DependencyManager

__init__(default_base_path=None, conf_file=None, app_config=None)[source]
cached = False
dependency_shell_commands(requirements, **kwds)[source]
find_dep(name, version=None, type='package', **kwds)[source]
to_dict()[source]
uses_tool_shed_dependencies()[source]
galaxy.tool_util.deps.build_dependency_manager(app_config_dict=None, resolution_config_dict=None, conf_file=None, default_tool_dependency_dir=None)[source]

Build a DependencyManager object from app and/or resolution config.

If app_config_dict is specified, it should be application configuration information and configuration options are generally named to identify the context of dependency management (e.g. conda_prefix not prefix or use_cached_dependency_manager not cache). resolution_config_dict if specified is assumed to be the to_dict() version of a DependencyManager and should only contain dependency configuration options.

Submodules

galaxy.tool_util.deps.brew_exts module

class galaxy.tool_util.deps.brew_exts.BrewContext(args=None)[source]

Bases: object

__init__(args=None)[source]
exception galaxy.tool_util.deps.brew_exts.CommandLineException(command, stdout, stderr)[source]

Bases: Exception

__init__(command, stdout, stderr)[source]
class galaxy.tool_util.deps.brew_exts.EnvAction(keg_root, action_description)[source]

Bases: object

__init__(keg_root, action_description)[source]
static build_env(env_actions)[source]
modify_environ(environ)[source]
to_statements()[source]
class galaxy.tool_util.deps.brew_exts.RecipeContext(recipe, version, brew_context=None)[source]

Bases: object

__init__(recipe, version, brew_context=None)[source]
cellar_path
static from_args(args, brew_context=None)[source]
tap_path
galaxy.tool_util.deps.brew_exts.brew_deps(package)[source]
galaxy.tool_util.deps.brew_exts.brew_execute(args, env=None)[source]
galaxy.tool_util.deps.brew_exts.brew_head_at_commit(commit, tap_path)[source]
galaxy.tool_util.deps.brew_exts.brew_head_at_version(recipe_context, package, version)[source]
galaxy.tool_util.deps.brew_exts.brew_info(recipe)[source]
galaxy.tool_util.deps.brew_exts.brew_versions_info(package, tap_path)[source]
galaxy.tool_util.deps.brew_exts.build_env_actions(deps, cellar_root, cellar_path, relaxed=None, custom_only=False)[source]
galaxy.tool_util.deps.brew_exts.build_env_statements(cellar_root, cellar_path, relaxed=None, custom_only=False)[source]
galaxy.tool_util.deps.brew_exts.build_env_statements_from_recipe_context(recipe_context, **kwds)[source]
galaxy.tool_util.deps.brew_exts.commit_for_version(recipe_context, package, version)[source]
galaxy.tool_util.deps.brew_exts.ensure_brew_on_path(args)[source]
galaxy.tool_util.deps.brew_exts.execute(cmds, env=None)[source]
galaxy.tool_util.deps.brew_exts.extended_brew_info(recipe)[source]
galaxy.tool_util.deps.brew_exts.git_execute(args)[source]
galaxy.tool_util.deps.brew_exts.load_versioned_deps(cellar_path, relaxed=None)[source]
galaxy.tool_util.deps.brew_exts.main()[source]
galaxy.tool_util.deps.brew_exts.print_versioned_deps(recipe_context, recipe, version)[source]
galaxy.tool_util.deps.brew_exts.recipe_cellar_path(cellar_path, recipe, version)[source]
galaxy.tool_util.deps.brew_exts.unversioned_install(package)[source]
galaxy.tool_util.deps.brew_exts.versioned_install(recipe_context, package=None, version=None, installed_deps=None)[source]
galaxy.tool_util.deps.brew_exts.which(file)[source]

galaxy.tool_util.deps.brew_util module

brew_exts defines generic extensions to Homebrew this file builds on those abstraction and provides Galaxy specific functionality not useful to the brew external commands.

class galaxy.tool_util.deps.brew_util.HomebrewRecipe(recipe, version, tap)[source]

Bases: object

__init__(recipe, version, tap)[source]
galaxy.tool_util.deps.brew_util.requirements_to_recipes(requirements)[source]
galaxy.tool_util.deps.brew_util.requirement_to_recipe(requirement)[source]
galaxy.tool_util.deps.brew_util.requirements_to_recipe_contexts(requirements, brew_context)[source]

galaxy.tool_util.deps.commands module

galaxy.tool_util.deps.conda_compat module

Compat. layer with conda_build/verify if Galaxy/galaxy-lib not installed through conda.

In general there are utilities available for Conda building and parsing that are high-quality and should be utilized when available but that are only available in conda channels and not in PyPI. This module serves as a PyPI capable interface to these utilities.

galaxy.tool_util.deps.conda_compat.raw_metadata(recipe_dir)[source]

Evaluate Conda template if needed and return raw metadata for supplied recipe directory.

galaxy.tool_util.deps.conda_compat.MetaData

alias of galaxy.tool_util.deps.conda_compat._MetaData

galaxy.tool_util.deps.conda_util module

class galaxy.tool_util.deps.conda_util.CondaContext(conda_prefix=None, conda_exec=None, shell_exec=None, debug=False, ensure_channels='', condarc_override=None, use_path_exec=False, copy_dependencies=False, use_local=False)[source]

Bases: galaxy.tool_util.deps.installable.InstallableContext

__init__(conda_prefix=None, conda_exec=None, shell_exec=None, debug=False, ensure_channels='', condarc_override=None, use_path_exec=False, copy_dependencies=False, use_local=False)[source]
activate
can_install()[source]
can_install_conda()[source]

If conda_exec is set to a path outside of conda_prefix, there is no use installing conda into conda_prefix, since it can’t be used by galaxy. If conda_exec equals conda_prefix/bin/conda, we can install conda if either conda_prefix does not exist or is empty.

conda_build_available
conda_info()[source]
conda_version
deactivate
ensure_conda_build_installed_if_needed()[source]
env_path(env_name)[source]
envs_path
exec_clean(args=None, quiet=False)[source]

Clean up after conda installation.

Return the process exit code (i.e. 0 in case of success).

exec_command(operation, args, stdout_path=None)[source]

Execute the requested command.

Return the process exit code (i.e. 0 in case of success).

exec_create(args, allow_local=True, stdout_path=None)[source]

Return the process exit code (i.e. 0 in case of success).

exec_install(args, allow_local=True, stdout_path=None)[source]

Return the process exit code (i.e. 0 in case of success).

exec_remove(args)[source]

Remove a conda environment using conda env remove -y –name args.

Return the process exit code (i.e. 0 in case of success).

export_list(name, path)[source]

Return the process exit code (i.e. 0 in case of success).

has_env(env_name)[source]
installable_description = 'Conda'
is_conda_installed()[source]

Check if conda_exec exists

is_installed()[source]
parent_path
class galaxy.tool_util.deps.conda_util.CondaTarget(package, version=None, channel=None)[source]

Bases: object

__init__(package, version=None, channel=None)[source]
install_environment

The dependency resolution and installation frameworks will expect each target to be installed it its own environment with a fixed and predictable name given package and version.

package_specifier

Return a package specifier as consumed by conda install/create.

galaxy.tool_util.deps.conda_util.install_conda(conda_context, force_conda_build=False)[source]
galaxy.tool_util.deps.conda_util.install_conda_target(conda_target, conda_context, skip_environment=False)[source]

Install specified target into a its own environment.

Return the process exit code (i.e. 0 in case of success).

galaxy.tool_util.deps.conda_util.requirements_to_conda_targets(requirements)[source]

galaxy.tool_util.deps.container_classes module

class galaxy.tool_util.deps.container_classes.Container(container_id, app_info, tool_info, destination_info, job_info, container_description, container_name=None)[source]

Bases: object

__init__(container_id, app_info, tool_info, destination_info, job_info, container_description, container_name=None)[source]
containerize_command(command)[source]

Use destination supplied container configuration parameters, container_id, and command to build a new command that runs input command in container.

prop(name, default)[source]
resolve_dependencies
shell
source_environment
class galaxy.tool_util.deps.container_classes.DockerContainer(container_id, app_info, tool_info, destination_info, job_info, container_description, container_name=None)[source]

Bases: galaxy.tool_util.deps.container_classes.Container, galaxy.tool_util.deps.container_classes.HasDockerLikeVolumes

build_pull_command()[source]
connection_configuration
container_type = 'docker'
containerize_command(command)[source]
docker_host_props
class galaxy.tool_util.deps.container_classes.HasDockerLikeVolumes[source]

Bases: object

Mixin to share functionality related to Docker volume handling.

Singularity seems to have a fairly compatible syntax for volume handling.

class galaxy.tool_util.deps.container_classes.NullContainer[source]

Bases: object

__init__()[source]
class galaxy.tool_util.deps.container_classes.SingularityContainer(container_id, app_info, tool_info, destination_info, job_info, container_description, container_name=None)[source]

Bases: galaxy.tool_util.deps.container_classes.Container, galaxy.tool_util.deps.container_classes.HasDockerLikeVolumes

build_mulled_singularity_pull_command(cache_directory, namespace='biocontainers')[source]
build_singularity_pull_command(cache_path)[source]
connection_configuration
container_type = 'singularity'
containerize_command(command)[source]
get_singularity_target_kwds()[source]
galaxy.tool_util.deps.container_classes.docker_cache_path(cache_directory, container_id)[source]
galaxy.tool_util.deps.container_classes.preprocess_volumes(volumes_raw_str, container_type)[source]

Process Galaxy volume specification string to either Docker or Singularity specification.

Galaxy allows the mount try “default_ro” which translates to ro for Docker and ro for Singularity iff no subdirectories are rw (Singularity does not allow ro parent directories with rw subdirectories).

>>> preprocess_volumes(None, DOCKER_CONTAINER_TYPE)
[]
>>> preprocess_volumes("", DOCKER_CONTAINER_TYPE)
[]
>>> preprocess_volumes("/a/b", DOCKER_CONTAINER_TYPE)
['/a/b:rw']
>>> preprocess_volumes("/a/b:ro,/a/b/c:rw", DOCKER_CONTAINER_TYPE)
['/a/b:ro', '/a/b/c:rw']
>>> preprocess_volumes("/a/b:/a:ro,/a/b/c:/a/b:rw", DOCKER_CONTAINER_TYPE)
['/a/b:/a:ro', '/a/b/c:/a/b:rw']
>>> preprocess_volumes("/a/b:default_ro,/a/b/c:rw", DOCKER_CONTAINER_TYPE)
['/a/b:ro', '/a/b/c:rw']
>>> preprocess_volumes("/a/b:default_ro,/a/b/c:ro", SINGULARITY_CONTAINER_TYPE)
['/a/b:ro', '/a/b/c:ro']
>>> preprocess_volumes("/a/b:default_ro,/a/b/c:rw", SINGULARITY_CONTAINER_TYPE)
['/a/b', '/a/b/c']

galaxy.tool_util.deps.containers module

class galaxy.tool_util.deps.containers.ContainerFinder(app_info, mulled_resolution_cache=None)[source]

Bases: object

__init__(app_info, mulled_resolution_cache=None)[source]
find_best_container_description(enabled_container_types, tool_info, **kwds)[source]

Regardless of destination properties - find best container for tool.

Given container types and container.ToolInfo description of the tool.

find_container(tool_info, destination_info, job_info)[source]
resolution_cache()[source]
resolve(enabled_container_types, tool_info, **kwds)[source]

Regardless of destination properties - find ResolvedContainerDescription for tool.

class galaxy.tool_util.deps.containers.ContainerRegistry(app_info, destination_info=None, mulled_resolution_cache=None)[source]

Bases: object

Loop through enabled ContainerResolver plugins and find first match.

__init__(app_info, destination_info=None, mulled_resolution_cache=None)[source]
find_best_container_description(enabled_container_types, tool_info, **kwds)[source]

Yield best container description of supplied types matching tool info.

get_resolution_cache()[source]
resolve(enabled_container_types, tool_info, index=None, resolver_type=None, install=True, resolution_cache=None, session=None)[source]
class galaxy.tool_util.deps.containers.NullContainerFinder[source]

Bases: object

find_container(tool_info, destination_info, job_info)[source]
class galaxy.tool_util.deps.containers.ResolvedContainerDescription(container_resolver, container_description)

Bases: tuple

container_description

Alias for field number 1

container_resolver

Alias for field number 0

galaxy.tool_util.deps.dependencies module

class galaxy.tool_util.deps.dependencies.AppInfo(galaxy_root_dir=None, default_file_path=None, tool_data_path=None, shed_tool_data_path=None, outputs_to_working_directory=False, container_image_cache_path=None, library_import_dir=None, enable_mulled_containers=False, container_resolvers_config_file=None, container_resolvers_config_dict=None, involucro_path=None, involucro_auto_init=True, mulled_channels=['conda-forge', 'bioconda'])[source]

Bases: object

__init__(galaxy_root_dir=None, default_file_path=None, tool_data_path=None, shed_tool_data_path=None, outputs_to_working_directory=False, container_image_cache_path=None, library_import_dir=None, enable_mulled_containers=False, container_resolvers_config_file=None, container_resolvers_config_dict=None, involucro_path=None, involucro_auto_init=True, mulled_channels=['conda-forge', 'bioconda'])[source]
class galaxy.tool_util.deps.dependencies.ToolInfo(container_descriptions=None, requirements=None, requires_galaxy_python_environment=False, env_pass_through=None, guest_ports=None, tool_id=None, tool_version=None, profile=-1)[source]

Bases: object

__init__(container_descriptions=None, requirements=None, requires_galaxy_python_environment=False, env_pass_through=None, guest_ports=None, tool_id=None, tool_version=None, profile=-1)[source]
class galaxy.tool_util.deps.dependencies.JobInfo(working_directory, tool_directory, job_directory, tmp_directory, home_directory, job_directory_type)[source]

Bases: object

__init__(working_directory, tool_directory, job_directory, tmp_directory, home_directory, job_directory_type)[source]
class galaxy.tool_util.deps.dependencies.DependenciesDescription(requirements=None, installed_tool_dependencies=None)[source]

Bases: object

Capture (in a readily serializable way) context related a tool dependencies - both the tool’s listed requirements and the tool shed related context required to resolve dependencies via the ToolShedPackageDependencyResolver.

This is meant to enable remote resolution of dependencies, by the Pulsar or other potential remote execution mechanisms.

__init__(requirements=None, installed_tool_dependencies=None)[source]
to_dict()[source]
static from_dict(as_dict)[source]

galaxy.tool_util.deps.docker_util module

Utilities for building up Docker commands…

…using common defaults and configuration mechanisms.

galaxy.tool_util.deps.docker_util.build_command(image, docker_build_path, **kwds)[source]
galaxy.tool_util.deps.docker_util.build_docker_cache_command(image, **kwds)[source]
galaxy.tool_util.deps.docker_util.build_docker_images_command(truncate=True, **kwds)[source]
galaxy.tool_util.deps.docker_util.build_docker_load_command(**kwds)[source]
galaxy.tool_util.deps.docker_util.build_docker_run_command(container_command, image, interactive=False, terminal=False, tag=None, volumes=None, volumes_from=None, memory=None, env_directives=None, working_directory=None, name=None, net=None, run_extra_arguments=None, docker_cmd='docker', sudo=False, sudo_cmd='sudo', auto_rm=True, set_user='$UID', host=None, guest_ports=False, container_name=None)[source]
galaxy.tool_util.deps.docker_util.build_docker_simple_command(command, docker_cmd='docker', sudo=False, sudo_cmd='sudo', container_name=None, **kwd)[source]
galaxy.tool_util.deps.docker_util.build_pull_command(tag, **kwds)[source]
galaxy.tool_util.deps.docker_util.build_save_image_command(image, destination, **kwds)[source]
galaxy.tool_util.deps.docker_util.command_list(command, command_args=None, **kwds)[source]

Return Docker command as an argv list.

galaxy.tool_util.deps.docker_util.command_shell(command, command_args=None, **kwds)[source]

Return Docker command as a string for a shell or command-list.

galaxy.tool_util.deps.docker_util.kill_command(container, signal=None, **kwds)[source]
galaxy.tool_util.deps.docker_util.logs_command(container, **kwds)[source]
galaxy.tool_util.deps.docker_util.parse_port_text(port_text)[source]
>>> slurm_ports = parse_port_text("8888/tcp -> 0.0.0.0:32769")
>>> slurm_ports[8888]['host']
'0.0.0.0'
>>> ports = parse_port_text("5432/tcp -> :::5432")

galaxy.tool_util.deps.dockerfiles module

galaxy.tool_util.deps.dockerfiles.docker_host_args(**kwds)[source]
galaxy.tool_util.deps.dockerfiles.dockerfile_build(path, dockerfile=None, error=<bound method Logger.error of <CBLogger galaxy.tool_util.deps.dockerfiles (WARNING)>>, **kwds)[source]

galaxy.tool_util.deps.installable module

Abstractions for installing local software managed and required by Galaxy/galaxy-lib.

class galaxy.tool_util.deps.installable.InstallableContext[source]

Bases: object

Represent a directory/configuration of something that can be installed.

can_install()[source]

Check preconditions for installation.

installable_description

Short description of thing being installed for log statements.

is_installed()[source]

Return bool indicating if the configured software is installed.

parent_path

Return parent path of the location the installable will be created within.

galaxy.tool_util.deps.installable.ensure_installed(installable_context, install_func, auto_init)[source]

Make sure target is installed - handle multiple processes potentially attempting installation.

galaxy.tool_util.deps.requirements module

class galaxy.tool_util.deps.requirements.ContainerDescription(identifier=None, type='docker', resolve_dependencies=False, shell='/bin/sh')[source]

Bases: object

__init__(identifier=None, type='docker', resolve_dependencies=False, shell='/bin/sh')[source]
static from_dict(dict)[source]
to_dict(*args, **kwds)[source]
class galaxy.tool_util.deps.requirements.RequirementSpecification(uri, version=None)[source]

Bases: object

Refine a requirement using a URI.

__init__(uri, version=None)[source]
static from_dict(dict)[source]
short_name
specifies_version
to_dict()[source]
class galaxy.tool_util.deps.requirements.ToolRequirement(name=None, type=None, version=None, specs=None)[source]

Bases: object

Represents an external requirement that must be available for the tool to run (for example, a program, package, or library). Requirements can optionally assert a specific version.

__init__(name=None, type=None, version=None, specs=None)[source]
copy()[source]
static from_dict(d)[source]
to_dict()[source]
class galaxy.tool_util.deps.requirements.ToolRequirements(tool_requirements=None)[source]

Bases: object

Represents all requirements (packages, env vars) needed to run a tool.

__init__(tool_requirements=None)[source]
append(requirement)[source]
static from_list(requirements)[source]
packages
resolvable
to_dict()[source]
to_list()[source]
exception galaxy.tool_util.deps.requirements.ToolRequirementsException[source]

Bases: Exception

galaxy.tool_util.deps.requirements.container_from_element(container_elem)[source]
galaxy.tool_util.deps.requirements.parse_requirements_from_dict(root_dict)[source]
galaxy.tool_util.deps.requirements.parse_requirements_from_xml(xml_root)[source]
>>> from galaxy.util import parse_xml_string
>>> def load_requirements(contents):
...     contents_document = '''<tool><requirements>%s</requirements></tool>'''
...     root = parse_xml_string(contents_document % contents)
...     return parse_requirements_from_xml(root)
>>> reqs, containers = load_requirements('''<requirement>bwa</requirement>''')
>>> reqs[0].name
'bwa'
>>> reqs[0].version is None
True
>>> reqs[0].type
'package'
>>> reqs, containers = load_requirements('''<requirement type="binary" version="1.3.3">cufflinks</requirement>''')
>>> reqs[0].name
'cufflinks'
>>> reqs[0].version
'1.3.3'
>>> reqs[0].type
'binary'

galaxy.tool_util.deps.singularity_util module

galaxy.tool_util.deps.singularity_util.build_singularity_run_command(container_command, image, volumes=None, env=None, working_directory=None, singularity_cmd='singularity', run_extra_arguments=None, sudo=False, sudo_cmd='sudo', guest_ports=False, container_name=None)[source]
galaxy.tool_util.deps.singularity_util.pull_mulled_singularity_command(docker_image_identifier, cache_directory, namespace=None, singularity_cmd='singularity', sudo=False, sudo_cmd='sudo')[source]
galaxy.tool_util.deps.singularity_util.pull_singularity_command(image_identifier: str, cache_path: str, singularity_cmd: str = 'singularity', sudo: bool = False, sudo_cmd: str = 'sudo')[source]

galaxy.tool_util.deps.views module

class galaxy.tool_util.deps.views.DependencyResolversView(app)[source]

Bases: object

Provide a RESTfulish/JSONy interface to a galaxy.tool_util.deps.DependencyResolver object. This can be adapted by the Galaxy web framework or other web apps.

__init__(app)[source]
index()[source]
show(index)[source]
reload()[source]
manager_requirements()[source]
resolver_requirements(index)[source]
manager_dependency(**kwds)[source]
resolver_dependency(index, **kwds)[source]
show_dependencies(tool_requirements_d, installed_tool_dependencies=None, **kwd)[source]

Resolves dependencies to build a requirements status in the admin panel/API

uninstall_dependencies(index=None, resolver_type=None, container_type=None, **payload)[source]

Attempt to uninstall requirements. Returns 0 if successfull, else None.

unused_dependency_paths

List dependencies that are not currently installed.

remove_unused_dependency_paths(envs)[source]

Remove dependencies that are not currently used.

Returns a list of all environments that have been successfully removed.

install_dependencies(requirements, **kwds)[source]
install_dependency(index=None, **payload)[source]

Installs dependency using highest priority resolver that supports dependency installation (Currently only the conda resolver supports this). If index is given, attempt installation directly using the corresponding resolver. Returns True on success, False on failure. payload is dictionary that must container name, version and type, e.g. {‘name’: ‘numpy’, version=’1.9.1’, type=’package’}

installable_resolvers

List index for all active resolvers that have the ‘install_dependency’ attribute.

uninstallable_resolvers

List index for all active resolvers that can uninstall dependencies that have been installed through this resolver.

tool_ids_by_requirements

Dictionary with requirements as keys, and tool_ids as values.

toolbox_requirements_status
summarize_requirements(**kwds)[source]
summarize_tools(**kwds)[source]
get_requirements_status(tool_requirements_d, installed_tool_dependencies=None, **kwd)[source]
clean(index=None, **kwds)[source]
class galaxy.tool_util.deps.views.ContainerResolutionView(app)[source]

Bases: object

__init__(app)[source]
index()[source]
show(index)[source]
resolve(**kwds)[source]
resolve_toolbox(**kwds)[source]
galaxy.tool_util.deps.views.pop_tool_ids(kwds)[source]