galaxy.tool_shed.galaxy_install package

Subpackages

Submodules

galaxy.tool_shed.galaxy_install.install_manager module

galaxy.tool_shed.galaxy_install.install_manager.get_install_info_from_tool_shed(tool_shed_url: str, tool_shed_registry: Registry, name: str, owner: str, changeset_revision: str) → tuple[RepositoryMetadataInstallInfoDict, dict[str, list]][source]

class galaxy.tool_shed.galaxy_install.install_manager.InstallRepositoryManager(app: InstallationTarget, tpm: ToolPanelManager | None = None)[source]

Bases: object

__init__(app: InstallationTarget, tpm: ToolPanelManager | None = None)[source]

app: InstallationTarget

tpm: ToolPanelManager

handle_tool_shed_repositories(installation_dict)[source]

initiate_repository_installation(installation_dict)[source]

install(tool_shed_url: str, name: str, owner: str, changeset_revision: str, install_options: dict[str, Any])[source]

install_repositories(tsr_ids, decoded_kwd, reinstalling, install_options=None)[source]

install_tool_shed_repository(tool_shed_repository, repo_info_dict, tool_panel_section_key, shed_tool_conf, tool_path, install_resolver_dependencies, install_tool_dependencies, reinstalling=False, tool_panel_section_mapping=None, install_options=None)[source]

update_tool_shed_repository(repository, tool_shed_url, latest_ctx_rev, latest_changeset_revision, install_new_dependencies=True, install_options=None)[source]

order_components_for_installation(tsr_ids: list[str], repo_info_dicts, tool_panel_section_keys)[source]: Some repositories may have repository dependencies that are required to be installed before the dependent repository. This method will inspect the list of repositories about to be installed and make sure to order them appropriately. For each repository about to be installed, if required repositories are not contained in the list of repositories about to be installed, then they are not considered. Repository dependency definitions that contain circular dependencies should not result in an infinite loop, but obviously prior installation will not be handled for one or more of the repositories that require prior installation.

update_tool_shed_repository_status(tool_shed_repository, status, error_message=None)[source]: Update the status of a tool shed repository in the process of being installed into Galaxy.

exception galaxy.tool_shed.galaxy_install.install_manager.RepositoriesInstalledException[source]

Bases: RequestParameterInvalidException

__init__()[source]

galaxy.tool_shed.galaxy_install.installed_repository_manager module

Class encapsulating the management of repositories installed into Galaxy from the Tool Shed.

class galaxy.tool_shed.galaxy_install.installed_repository_manager.InstalledRepositoryManager(app: InstallationTarget)[source]

Bases: object

__init__(app: InstallationTarget)[source]: Among other things, keep in in-memory sets of tuples defining installed repositories and tool dependencies along with the relationships between each of them. This will allow for quick discovery of those repositories or components that can be uninstalled. The feature allowing a Galaxy administrator to uninstall a repository should not be available to repositories or tool dependency packages that are required by other repositories or their contents (packages). The uninstall feature should be available only at the repository hierarchy level where every dependency will be uninstalled. The exception for this is if an item (repository or tool dependency package) is not in an INSTALLED state - in these cases, the specific item can be uninstalled in order to attempt re-installation.

app: InstallationTarget

installed_repository_dicts: list[dict[str, Any]]

repository_dependencies_of_installed_repositories: dict[tuple[str, str, str, str], list[tuple[str, str, str, str]]]

installed_repository_dependencies_of_installed_repositories: dict[tuple[str, str, str, str], list[tuple[str, str, str, str]]]

installed_dependent_repositories_of_installed_repositories: dict[tuple[str, str, str, str], list[tuple[str, str, str, str]]]

activate_repository(repository: ToolShedRepository) → None[source]: Activate an installed tool shed repository that has been marked as deactivated.

get_installed_and_missing_repository_dependencies(repository: ToolShedRepository) → tuple[dict[str, Any], dict[str, Any]][source]: Return the installed and missing repository dependencies for a tool shed repository that has a record in the Galaxy database, but may or may not be installed. In this case, the repository dependencies are associated with the repository in the database. Do not include a repository dependency if it is required only to compile a tool dependency defined for the dependent repository since these special kinds of repository dependencies are really a dependency of the dependent repository’s contained tool dependency, and only if that tool dependency requires compilation.

handle_existing_tool_dependencies_that_changed_in_update(repository: ToolShedRepository, original_dependency_dict, new_dependency_dict) → tuple[list[str], list[str]][source]: This method is called when a Galaxy admin is getting updates for an installed tool shed repository in order to cover the case where an existing tool dependency was changed (e.g., the version of the dependency was changed) but the tool version for which it is a dependency was not changed. In this case, we only want to determine if any of the dependency information defined in original_dependency_dict was changed in new_dependency_dict. We don’t care if new dependencies were added in new_dependency_dict since they will just be treated as missing dependencies for the tool.

uninstall_repository(repository: ToolShedRepository, remove_from_disk=True) → str[source]

repository_dependency_needed_only_for_compiling_tool_dependency(repository: ToolShedRepository, repository_dependency) → bool[source]

set_only_if_compiling_contained_td(repository, required_repository)[source]: Return True if the received required_repository is only needed to compile a tool dependency defined for the received repository.

set_prior_installation_required(repository, required_repository) → str[source]: Return True if the received required_repository must be installed before the received repository.

galaxy.tool_shed.galaxy_install.update_repository_manager module

Determine if installed tool shed repositories have updates available in their respective tool sheds.

class galaxy.tool_shed.galaxy_install.update_repository_manager.UpdateToChangeset(changeset_revision, ctx_rev)[source]

Bases: NamedTuple

changeset_revision: str: Alias for field number 0

ctx_rev: str: Alias for field number 1

class galaxy.tool_shed.galaxy_install.update_repository_manager.UpdateRepositoryManager(app)[source]

Bases: object

__init__(app)[source]

get_update_to_changeset_revision_and_ctx_rev(repository: ToolShedRepository) → UpdateToChangeset[source]: Return the changeset revision hash to which the repository can be updated.

shutdown() → None[source]

update_repository_record(repository: ToolShedRepository, updated_metadata_dict, updated_changeset_revision, updated_ctx_rev) → ToolShedRepository[source]: Update a tool_shed_repository database record with new information retrieved from the Tool Shed. This happens when updating an installed repository to a new changeset revision.