galaxy package

Abstractions used by Galaxy should come through this interface so we can swap out the backend as needed. For instance https://punq.readthedocs.io/en/latest/ containers look very nice and would allow us to also inject by name (e.g. for config variables for instance).

resolve_or_none(dep_type: Type[T]) → T | None[source]

Resolve the dependent type or just return None.

If resolution is impossible assume caller has a backup plan for constructing the desired object. Used to construct controllers that may or may not be resolvable (some have upgraded but legacy framework still works).

galaxy.main module

Entry point for starting Galaxy without starting as part of a web server.

Example Usage: Start a job/workflow handler without a web server and with a given name using.

galaxy-main –server-name handler0

Start as a daemon with (requires daemonized - install with ‘pip install daemonize’):

galaxy-main -d –daemon-log-file=handler0-daemon.log –pid-file handler0.pid –server-name handler0

In daemon mode logging of Galaxy (as opposed to this script) is configured via a loggers section in Galaxy’s ini file - this can be overridden with sensible defaults logging to a single file with the following:

galaxy-main -d –server-name handler0 –daemon-log-file=handler0-daemon.log –pid-file handler0.pid –log-file handler0.log

galaxy.main.load_galaxy_app(config_builder, config_env=False, log=None, attach_to_pools=None, **kwds)[source]

galaxy.main.handle_signal(signum, frame)[source]

galaxy.main.register_signals()[source]

galaxy.main.app_loop(args, log)[source]

class galaxy.main.GalaxyConfigBuilder(args=None, **kwds)[source]

Bases: object

Generate paste-like configuration from supplied command-line arguments.

__init__(args=None, **kwds)[source]

classmethod populate_options(arg_parser)[source]

property config_is_ini

app_kwds()[source]

global_conf()[source]

setup_logging()[source]

galaxy.main.main(func=<function app_loop>)[source]

galaxy.main_config module

Utilities for finding Galaxy’s configuration file.

This is for use by web framework code and scripts (e.g. scripts/galaxy_main.py).

galaxy.main_config.default_relative_config_paths_for(app_name: str) → List[str][source]

galaxy.main_config.absolute_config_path(path, galaxy_root: str | None) → str | None[source]

galaxy.main_config.config_is_ini(config_file: str | None) → bool[source]

galaxy.main_config.find_config(supplied_config: str | None, galaxy_root: str | None, app_name: str = 'galaxy') → str | None[source]

class galaxy.main_config.WebappSetupProps(app_name: str, default_section_name: str, env_config_file: str, env_config_section: str | None = None, check_galaxy_root: bool = False)[source]

Bases: tuple

Basic properties to provide information about the App and the environment variables used to resolve the App configuration.

app_name: str: Alias for field number 0

default_section_name: str: Alias for field number 1

env_config_file: str: Alias for field number 2

env_config_section: str | None: Alias for field number 3

check_galaxy_root: bool: Alias for field number 4

class galaxy.main_config.WebappConfig(global_conf: dict, load_app_kwds: dict, wsgi_preflight: bool = False)[source]

Bases: tuple

The resolved configuration values for a Webapp.

global_conf: dict: Alias for field number 0

load_app_kwds: dict: Alias for field number 1

wsgi_preflight: bool: Alias for field number 2

class galaxy.main_config.WebappConfigResolver(props: WebappSetupProps)[source]

Bases: object

__init__(props: WebappSetupProps) → None[source]

resolve_config() → WebappConfig[source]

galaxy.queue_worker module

Galaxy control queue and worker. This is used to handle ‘app’ control like reloading the toolbox, etc., across multiple processes.

galaxy.queue_worker.send_local_control_task(app, task, get_response=False, kwargs=None)[source]: This sends a message to the process-local control worker, which is useful for one-time asynchronous tasks like recalculating user disk usage.

galaxy.queue_worker.send_control_task(app, task, noop_self=False, get_response=False, routing_key='control.*', kwargs=None)[source]: This sends a control task out to all processes, useful for things like reloading a data table, which needs to happen individually in all processes. Set noop_self to True to not run task for current process. Set get_response to True to wait for and return the task results as a list.

class galaxy.queue_worker.ControlTask(queue_worker)[source]

Bases: object

__init__(queue_worker)[source]

property connection

property control_queues

property exchange

property declare_queues

on_response(message)[source]

send_task(payload, routing_key, local=False, get_response=False, timeout=10)[source]

galaxy.queue_worker.reconfigure_watcher(app, **kwargs)[source]

galaxy.queue_worker.create_panel_section(app, **kwargs)[source]: Updates in memory toolbox dictionary.

galaxy.queue_worker.reload_tool(app, **kwargs)[source]

galaxy.queue_worker.reload_toolbox(app, save_integrated_tool_panel=True, **kwargs)[source]

galaxy.queue_worker.reload_data_managers(app, **kwargs)[source]

galaxy.queue_worker.reload_display_application(app, **kwargs)[source]

galaxy.queue_worker.reload_sanitize_allowlist(app)[source]

galaxy.queue_worker.recalculate_user_disk_usage(app, **kwargs)[source]

galaxy.queue_worker.reload_tool_data_tables(app, **kwargs)[source]

galaxy.queue_worker.rebuild_toolbox_search_index(app, **kwargs)[source]

galaxy.queue_worker.reload_job_rules(app, **kwargs)[source]

galaxy.queue_worker.reload_core_config(app, **kwargs)[source]

galaxy.queue_worker.reload_tour(app, **kwargs)[source]

galaxy.queue_worker.job_rule_modules(app)[source]

galaxy.queue_worker.admin_job_lock(app, **kwargs)[source]

class galaxy.queue_worker.GalaxyQueueWorker(app, task_mapping=None)[source]

Bases: ConsumerProducerMixin, Thread

This is a flexible worker for galaxy’s queues. Each process, web or handler, will have one of these used for dispatching so called ‘control’ tasks.

__init__(app, task_mapping=None)[source]

send_control_task(task, noop_self=False, get_response=False, routing_key='control.*', kwargs=None)[source]

send_local_control_task(task, get_response=False, kwargs=None)[source]

property declare_queues

bind_and_start()[source]

get_consumers(Consumer, channel)[source]

process_task(body, message)[source]

shutdown()[source]

galaxy.queues module

All message queues used by Galaxy

galaxy.queues.all_control_queues_for_declare(application_stack)[source]: For in-memory routing (used by sqlalchemy-based transports), we need to be able to build the entire routing table in producers.

galaxy.queues.control_queues_from_config(config)[source]: Returns a Queue instance with the correct name and routing key for this galaxy process’s config

galaxy.queues.connection_from_config(config) → Connection | None[source]

galaxy.structured_app module

Typed description of Galaxy’s app object.

class galaxy.structured_app.BasicSharedApp[source]

Bases: Container

Stripped down version of the app shared between Galaxy and ToolShed.

Code that is shared between Galaxy and the Tool Shed should be annotated as using BasicSharedApp instead of StructuredApp below.

name: str

config: Any

datatypes_registry: Registry

application_stack: ApplicationStack

model: SharedModelMapping

security: IdEncodingHelper

auth_manager: AuthManager

security_agent: Any

quota_agent: QuotaAgent

property toolbox: ToolBox

class galaxy.structured_app.MinimalToolApp(*args, **kwargs)[source]

Bases: Protocol

is_webapp: bool

name: str

config: Any

datatypes_registry: Registry

object_store: BaseObjectStore

tool_data_tables: ToolDataTableManager

file_sources: ConfiguredFileSources

security: IdEncodingHelper

__init__(*args, **kwargs)

class galaxy.structured_app.MinimalApp[source]

Bases: BasicSharedApp

is_webapp: bool

tag_handler: GalaxyTagHandler

model: GalaxyModelMapping

install_model: ModelMapping

security_agent: GalaxyRBACAgent

host_security_agent: HostAgent

server_starttime: int

class galaxy.structured_app.MinimalManagerApp[source]

Bases: MinimalApp

carbon_intensity: float

file_sources: ConfiguredFileSources

genome_builds: GenomeBuilds

geographical_server_location_name: str

dataset_collection_manager: DatasetCollectionManager

tool_data_tables: ToolDataTableManager

history_manager: HistoryManager

hda_manager: HDAManager

workflow_manager: WorkflowsManager

workflow_contents_manager: Any

library_folder_manager: Any

library_manager: Any

role_manager: Any

installed_repository_manager: InstalledRepositoryManager

user_manager: Any

job_config: JobConfiguration

job_manager: Any

job_metrics: JobMetrics

dynamic_tool_manager: Any

genomes: Genomes

error_reports: ErrorReports

notification_manager: Any

object_store: BaseObjectStore

tool_shed_registry: Registry

abstract property is_job_handler: bool

wait_for_toolbox_reload(old_toolbox: ToolBox) → None[source]

class galaxy.structured_app.StructuredApp[source]

Bases: MinimalManagerApp

Interface defining typed description of the Galaxy UniverseApplication.

Ideally nothing that depends on StructuredApp should require StructuredApp so we can have a clean import dag. This will require setting up a lot more distinction between interfaces and implementations in Galaxy though. In the meantime, for imports that would bring in StructuredApp if properly type (cyclical imports), we’re just setting the class attributes to Any.