Warning

This document is for an old release 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.webapps.galaxy.api package

This module does not contain API routes. It exclusively contains dependencies to be used in FastAPI routes

galaxy.webapps.galaxy.api.get_app() StructuredApp[source]
async galaxy.webapps.galaxy.api.get_app_with_request_session() AsyncGenerator[StructuredApp, None][source]
class galaxy.webapps.galaxy.api.GalaxyTypeDepends(callable, dep_type)[source]

Bases: Depends

Variant of fastapi Depends that can also work on WSGI Galaxy controllers.

__init__(callable, dep_type)[source]
galaxy.webapps.galaxy.api.depends(dep_type: ~typing.Type[~galaxy.webapps.galaxy.api.T], get_app=<function get_app>) T[source]
galaxy.webapps.galaxy.api.get_session_manager(app: StructuredApp = Depends(get_app_with_request_session)) GalaxySessionManager[source]
galaxy.webapps.galaxy.api.get_session(session_manager=Depends(get_session_manager), security: IdEncodingHelper = GalaxyTypeDepends(_do_resolve), galaxysession: str = Security(APIKeyCookie)) Optional[GalaxySession][source]
galaxy.webapps.galaxy.api.get_api_user(user_manager: UserManager = GalaxyTypeDepends(_do_resolve), key: str = Security(APIKeyQuery), x_api_key: str = Security(APIKeyHeader), run_as: Optional[DecodedDatabaseIdField] = Header(None)) Optional[User][source]
galaxy.webapps.galaxy.api.get_user(galaxy_session=Depends(get_session), api_user=Depends(get_api_user)) Optional[User][source]
class galaxy.webapps.galaxy.api.UrlBuilder(request: Request)[source]

Bases: object

__init__(request: Request)[source]
class galaxy.webapps.galaxy.api.GalaxyASGIRequest(request: Request)[source]

Bases: GalaxyAbstractRequest

Wrapper around Starlette/FastAPI Request object.

Implements the GalaxyAbstractRequest interface to provide access to some properties of the request commonly used.

__init__(request: Request)[source]
property base: str

Base URL of the request.

property url_path: str
property host: str

The host address.

property environ: MutableMapping[str, Any]

Fallback WSGI environ.

This is not a full environ, there is no body. This is only meant to make routes.url_for work.

property headers
property remote_host: str
property remote_addr: Optional[str]
property is_secure: bool

Was this a secure (https) request.

Return cookie.

class galaxy.webapps.galaxy.api.GalaxyASGIResponse(response: Response)[source]

Bases: GalaxyAbstractResponse

Wrapper around Starlette/FastAPI Response object.

Implements the GalaxyAbstractResponse interface to provide access to some properties of the response object commonly used.

__init__(response: Response)[source]
property headers

The response headers.

Set a cookie.

galaxy.webapps.galaxy.api.get_current_history_from_session(galaxy_session: Optional[GalaxySession]) Optional[History][source]
galaxy.webapps.galaxy.api.fix_url_for(mapper: Mapper, galaxy_request: GalaxyASGIRequest)[source]
galaxy.webapps.galaxy.api.get_trans(request: Request, response: Response, app: StructuredApp = Depends(get_app_with_request_session), user=Depends(get_user), galaxy_session=Depends(get_session)) SessionRequestContext[source]
galaxy.webapps.galaxy.api.get_admin_user(trans: SessionRequestContext = Depends(get_trans))[source]
class galaxy.webapps.galaxy.api.BaseGalaxyAPIController(app: StructuredApp)[source]

Bases: BaseAPIController

__init__(app: StructuredApp)[source]

Initialize an interface for application ‘app’

class galaxy.webapps.galaxy.api.RestVerb(value)[source]

Bases: str, Enum

An enumeration.

get = 'GET'
head = 'HEAD'
post = 'POST'
put = 'PUT'
patch = 'PATCH'
delete = 'DELETE'
options = 'OPTIONS'
class galaxy.webapps.galaxy.api.FrameworkRouter(*, prefix: str = '', tags: ~typing.Optional[~typing.List[~typing.Union[str, ~enum.Enum]]] = None, dependencies: ~typing.Optional[~typing.Sequence[~fastapi.params.Depends]] = None, default_response_class: ~typing.Type[~starlette.responses.Response] = <fastapi.datastructures.DefaultPlaceholder object>, responses: ~typing.Optional[~typing.Dict[~typing.Union[int, str], ~typing.Dict[str, ~typing.Any]]] = None, callbacks: ~typing.Optional[~typing.List[~starlette.routing.BaseRoute]] = None, routes: ~typing.Optional[~typing.List[~starlette.routing.BaseRoute]] = None, redirect_slashes: bool = True, default: ~typing.Optional[~typing.Callable[[~typing.MutableMapping[str, ~typing.Any], ~typing.Callable[[], ~typing.Awaitable[~typing.MutableMapping[str, ~typing.Any]]], ~typing.Callable[[~typing.MutableMapping[str, ~typing.Any]], ~typing.Awaitable[None]]], ~typing.Awaitable[None]]] = None, dependency_overrides_provider: ~typing.Optional[~typing.Any] = None, route_class: ~typing.Type[~fastapi.routing.APIRoute] = <class 'fastapi.routing.APIRoute'>, on_startup: ~typing.Optional[~typing.Sequence[~typing.Callable[[], ~typing.Any]]] = None, on_shutdown: ~typing.Optional[~typing.Sequence[~typing.Callable[[], ~typing.Any]]] = None, lifespan: ~typing.Optional[~typing.Union[~typing.Callable[[~typing.Any], ~typing.AbstractAsyncContextManager[None]], ~typing.Callable[[~typing.Any], ~typing.AbstractAsyncContextManager[~typing.Mapping[str, ~typing.Any]]]]] = None, deprecated: ~typing.Optional[bool] = None, include_in_schema: bool = True, generate_unique_id_function: ~typing.Callable[[~fastapi.routing.APIRoute], str] = <fastapi.datastructures.DefaultPlaceholder object>)[source]

Bases: InferringRouter

A FastAPI Inferring Router tailored to Galaxy.

admin_user_dependency: Any
wrap_with_alias(verb: RestVerb, *args, alias: Optional[str] = None, **kwd)[source]

Wraps FastAPI methods with additional alias keyword and require_admin handling.

@router.get(“/api/thing”, alias=”/api/deprecated_thing”) will then create routes for /api/thing and /api/deprecated_thing.

static construct_aliases(path: str, alias: Optional[str])[source]
get(*args, **kwd)[source]

Extend FastAPI.get to accept a require_admin Galaxy flag.

patch(*args, **kwd)[source]

Extend FastAPI.patch to accept a require_admin Galaxy flag.

put(*args, **kwd)[source]

Extend FastAPI.put to accept a require_admin Galaxy flag.

post(*args, **kwd)[source]

Extend FastAPI.post to accept a require_admin Galaxy flag.

delete(*args, **kwd)[source]

Extend FastAPI.delete to accept a require_admin Galaxy flag.

options(*args, **kwd)[source]
head(*args, **kwd)[source]
property cbv

Short-hand for frequently used Galaxy-pattern of FastAPI class based views.

Creates a class-based view for for this router, for more information see: https://fastapi-utils.davidmontague.xyz/user-guide/class-based-views/

class galaxy.webapps.galaxy.api.Router(*, prefix: str = '', tags: ~typing.Optional[~typing.List[~typing.Union[str, ~enum.Enum]]] = None, dependencies: ~typing.Optional[~typing.Sequence[~fastapi.params.Depends]] = None, default_response_class: ~typing.Type[~starlette.responses.Response] = <fastapi.datastructures.DefaultPlaceholder object>, responses: ~typing.Optional[~typing.Dict[~typing.Union[int, str], ~typing.Dict[str, ~typing.Any]]] = None, callbacks: ~typing.Optional[~typing.List[~starlette.routing.BaseRoute]] = None, routes: ~typing.Optional[~typing.List[~starlette.routing.BaseRoute]] = None, redirect_slashes: bool = True, default: ~typing.Optional[~typing.Callable[[~typing.MutableMapping[str, ~typing.Any], ~typing.Callable[[], ~typing.Awaitable[~typing.MutableMapping[str, ~typing.Any]]], ~typing.Callable[[~typing.MutableMapping[str, ~typing.Any]], ~typing.Awaitable[None]]], ~typing.Awaitable[None]]] = None, dependency_overrides_provider: ~typing.Optional[~typing.Any] = None, route_class: ~typing.Type[~fastapi.routing.APIRoute] = <class 'fastapi.routing.APIRoute'>, on_startup: ~typing.Optional[~typing.Sequence[~typing.Callable[[], ~typing.Any]]] = None, on_shutdown: ~typing.Optional[~typing.Sequence[~typing.Callable[[], ~typing.Any]]] = None, lifespan: ~typing.Optional[~typing.Union[~typing.Callable[[~typing.Any], ~typing.AbstractAsyncContextManager[None]], ~typing.Callable[[~typing.Any], ~typing.AbstractAsyncContextManager[~typing.Mapping[str, ~typing.Any]]]]] = None, deprecated: ~typing.Optional[bool] = None, include_in_schema: bool = True, generate_unique_id_function: ~typing.Callable[[~fastapi.routing.APIRoute], str] = <fastapi.datastructures.DefaultPlaceholder object>)[source]

Bases: FrameworkRouter

admin_user_dependency: Any = Depends(get_admin_user)
tags: List[Union[str, Enum]]
lifespan_context: Lifespan
class galaxy.webapps.galaxy.api.APIContentTypeRoute(path: str, endpoint: ~typing.Callable[[...], ~typing.Any], *, response_model: ~typing.Any = <fastapi.datastructures.DefaultPlaceholder object>, status_code: ~typing.Optional[int] = None, tags: ~typing.Optional[~typing.List[~typing.Union[str, ~enum.Enum]]] = None, dependencies: ~typing.Optional[~typing.Sequence[~fastapi.params.Depends]] = None, summary: ~typing.Optional[str] = None, description: ~typing.Optional[str] = None, response_description: str = 'Successful Response', responses: ~typing.Optional[~typing.Dict[~typing.Union[int, str], ~typing.Dict[str, ~typing.Any]]] = None, deprecated: ~typing.Optional[bool] = None, name: ~typing.Optional[str] = None, methods: ~typing.Optional[~typing.Union[~typing.Set[str], ~typing.List[str]]] = None, operation_id: ~typing.Optional[str] = None, response_model_include: ~typing.Optional[~typing.Union[~typing.Set[~typing.Union[int, str]], ~typing.Dict[~typing.Union[int, str], ~typing.Any]]] = None, response_model_exclude: ~typing.Optional[~typing.Union[~typing.Set[~typing.Union[int, str]], ~typing.Dict[~typing.Union[int, str], ~typing.Any]]] = None, response_model_by_alias: bool = True, response_model_exclude_unset: bool = False, response_model_exclude_defaults: bool = False, response_model_exclude_none: bool = False, include_in_schema: bool = True, response_class: ~typing.Union[~typing.Type[~starlette.responses.Response], ~fastapi.datastructures.DefaultPlaceholder] = <fastapi.datastructures.DefaultPlaceholder object>, dependency_overrides_provider: ~typing.Optional[~typing.Any] = None, callbacks: ~typing.Optional[~typing.List[~starlette.routing.BaseRoute]] = None, openapi_extra: ~typing.Optional[~typing.Dict[str, ~typing.Any]] = None, generate_unique_id_function: ~typing.Union[~typing.Callable[[~fastapi.routing.APIRoute], str], ~fastapi.datastructures.DefaultPlaceholder] = <fastapi.datastructures.DefaultPlaceholder object>)[source]

Bases: APIRoute

Determines endpoint to match using content-type.

match_content_type: str
accept_matches(scope: MutableMapping[str, Any]) Tuple[Match, MutableMapping[str, Any]][source]
matches(scope: MutableMapping[str, Any]) Tuple[Match, MutableMapping[str, Any]][source]
galaxy.webapps.galaxy.api.as_form(cls: Type[BaseModel])[source]

Adds an as_form class method to decorated models. The as_form class method can be used with FastAPI endpoints.

See https://github.com/tiangolo/fastapi/issues/2387#issuecomment-731662551

async galaxy.webapps.galaxy.api.try_get_request_body_as_json(request: Request) Optional[Any][source]

Returns the request body as a JSON object if the content type is JSON.

class galaxy.webapps.galaxy.api.IndexQueryTag(tag, description, alias, admin_only)[source]

Bases: tuple

property tag

Alias for field number 0

property description

Alias for field number 1

property alias

Alias for field number 2

property admin_only

Alias for field number 3

as_markdown()[source]
galaxy.webapps.galaxy.api.search_query_param(model_name: str, tags: list, free_text_fields: list) Optional[str][source]

Submodules

galaxy.webapps.galaxy.api.annotations module

API operations on annotations.

class galaxy.webapps.galaxy.api.annotations.BaseAnnotationsController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController, UsesStoredWorkflowMixin, UsesAnnotations

tagged_item_id: str
index(trans: ProvidesHistoryContext, **kwd)[source]
create(trans: ProvidesHistoryContext, payload: dict, **kwd)[source]
delete(trans: ProvidesHistoryContext, **kwd)[source]
undelete(trans: ProvidesHistoryContext, **kwd)[source]
class galaxy.webapps.galaxy.api.annotations.HistoryAnnotationsController(app: StructuredApp)[source]

Bases: BaseAnnotationsController

controller_name = 'history_annotations'
tagged_item_id: str = 'history_id'
history_manager: HistoryManager = GalaxyTypeDepends(_do_resolve)
class galaxy.webapps.galaxy.api.annotations.HistoryContentAnnotationsController(app: StructuredApp)[source]

Bases: BaseAnnotationsController

controller_name = 'history_content_annotations'
tagged_item_id: str = 'history_content_id'
hda_manager: HDAManager = GalaxyTypeDepends(_do_resolve)
class galaxy.webapps.galaxy.api.annotations.WorkflowAnnotationsController(app: StructuredApp)[source]

Bases: BaseAnnotationsController

controller_name = 'workflow_annotations'
tagged_item_id: str = '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: StructuredApp)[source]

Bases: BaseGalaxyAPIController

authentication_service = GalaxyTypeDepends(_do_resolve)
options(trans: GalaxyWebTransaction, **kwd)[source]

A no-op endpoint to return generic OPTIONS for the API. Any OPTIONS request to /api/* maps here. Right now this is solely to inform preflight CORS checks, which are API wide. Might be better placed elsewhere, but for now this is the initial entrypoint for relevant consumers.

class galaxy.webapps.galaxy.api.authenticate.FastAPIAuthenticate(*, authentication_service: AuthenticationService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

authentication_service: AuthenticationService = GalaxyTypeDepends(_do_resolve)
get_api_key(*, request: Request) APIKeyResponse[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.cloud module

API operations on Cloud-based storages, such as Amazon Simple Storage Service (S3).

class galaxy.webapps.galaxy.api.cloud.FastAPICloudController(*, cloud_manager: CloudManager = GalaxyTypeDepends(_do_resolve), datasets_serializer: DatasetSerializer = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

cloud_manager: CloudManager = GalaxyTypeDepends(_do_resolve)
datasets_serializer: DatasetSerializer = GalaxyTypeDepends(_do_resolve)
index(*, response: Response)[source]
get(*, payload: CloudObjects = Body(Ellipsis), trans: ProvidesHistoryContext = Depends(get_trans)) DatasetSummaryList[source]
send(*, payload: CloudDatasets = Body(Ellipsis), trans: ProvidesHistoryContext = Depends(get_trans)) CloudDatasetsResponse[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.cloudauthz module

API operations on defining cloud authorizations.

Through means of cloud authorization a user is able to grant a Galaxy server a secure access to his/her cloud-based resources without sharing his/her long-lasting credentials.

User provides a provider-specific configuration, which Galaxy users to request temporary credentials from the provider to access the user’s resources.

class galaxy.webapps.galaxy.api.cloudauthz.CloudAuthzController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController

RESTfull controller for defining cloud authorizations.

__init__(app: StructuredApp)[source]

Initialize an interface for application ‘app’

index(trans, **kwargs)[source]

GET /api/cloud/authz

Lists all the cloud authorizations user has defined.

Parameters:
Return type:

list of dict

Returns:

a list of cloud authorizations (each represented in key-value pair format) defined for the user.

create(trans, payload, **kwargs)[source]
  • POST /api/cloud/authz

    Request to store the payload as a cloudauthz (cloud authorization) configuration for a user.

Parameters:
  • trans (galaxy.webapps.base.webapp.GalaxyWebTransaction) – Galaxy web transaction

  • payload (dict) –

    A dictionary structure containing the following keys: * provider: the cloud-based resource provider to which this configuration belongs to.

    • config: a dictionary containing all the configuration required to request temporary credentials

      from the provider. See the following page for details: https://galaxyproject.org/authnz/

    • authn_id: the (encoded) ID of a third-party authentication of a user. To have this ID, user must

      have logged-in to this Galaxy server using third-party identity (e.g., Google), or has associated his/her Galaxy account with a third-party OIDC-based identity. See this page: https://galaxyproject.org/authnz/config/

    • description: [Optional] a brief description for this configuration.

  • kwargs – empty dict

Return type:

dict

Returns:

a dictionary with the following kvp: * status: HTTP response code * message: A message complementary to the response code.

delete(trans, encoded_authz_id, **kwargs)[source]
  • DELETE /api/cloud/authz/{encoded_authz_id}

    Deletes the CloudAuthz record with the given encoded_authz_id from database.

Parameters:

:rtype JSON :return The cloudauthz record marked as deleted, serialized as a JSON object.

update(trans, encoded_authz_id, payload, **kwargs)[source]

PUT /api/cloud/authz/{encoded_authz_id}

Updates the values for the cloudauthz configuration with the given encoded_authz_id.

With this API only the following attributes of a cloudauthz configuration can be updated: authn_id, provider, config, deleted.

Parameters:
  • trans (galaxy.webapps.base.webapp.GalaxyWebTransaction) – Galaxy web transaction

  • encoded_authz_id (string) – The encoded ID of the CloudAuthz record to be updated.

  • payload (dict) –

    A dictionary structure containing the attributes to modified with their new values. It can contain any number of the following attributes:

    • provider: the cloud-based resource provider

      to which this configuration belongs to.

    • authn_id: the (encoded) ID of a third-party authentication of a user.

      To have this ID, user must have logged-in to this Galaxy server using third-party identity (e.g., Google), or has associated their Galaxy account with a third-party OIDC-based identity. See this page: https://galaxyproject.org/authnz/config/

      Note: A user can associate a cloudauthz record with their own authentications only. If the given authentication with authn_id belongs to a different user, Galaxy will throw the ItemAccessibilityException exception.

    • config: a dictionary containing all the configuration required to

      request temporary credentials from the provider. See the following page for details: https://galaxyproject.org/authnz/

    • deleted: a boolean type marking the specified cloudauthz as (un)deleted.

galaxy.webapps.galaxy.api.common module

This module contains utility functions shared across the api package.

galaxy.webapps.galaxy.api.common.parse_serialization_params(view: Optional[str] = None, keys: Optional[str] = None, default_view: Optional[str] = None, **_) SerializationParams[source]
galaxy.webapps.galaxy.api.common.query_serialization_params(view: Optional[str] = Query(None), keys: Optional[str] = Query(None)) SerializationParams[source]
galaxy.webapps.galaxy.api.common.get_value_filter_query_params(q: Optional[List[str]] = Query(None), qv: Optional[List[str]] = Query(None)) ValueFilterQueryParams[source]

This function is meant to be used as a Dependency. See https://fastapi.tiangolo.com/tutorial/dependencies/#first-steps

galaxy.webapps.galaxy.api.common.get_filter_query_params(q: Optional[List[str]] = Query(None), qv: Optional[List[str]] = Query(None), offset: Optional[int] = Query(0), limit: Optional[int] = Query(None), order: Optional[str] = Query(None)) FilterQueryParams[source]

This function is meant to be used as a Dependency. See https://fastapi.tiangolo.com/tutorial/dependencies/#first-steps

galaxy.webapps.galaxy.api.common.get_update_permission_payload(payload: Dict[str, Any]) UpdateDatasetPermissionsPayload[source]

Converts the generic payload dictionary into a UpdateDatasetPermissionsPayload model with custom parsing. This is an attempt on supporting multiple aliases for the permissions params.

galaxy.webapps.galaxy.api.common.get_query_parameters_from_request_excluding(request: Request, exclude: Set[str]) dict[source]

Gets all the request query parameters excluding the given parameters names in exclude set.

This is useful when an endpoint uses arbitrary or dynamic query parameters that cannot be anticipated or documented beforehand. The exclude set can be used to avoid including those parameters that are already handled by the endpoint.

galaxy.webapps.galaxy.api.common.query_parameter_as_list(query)[source]

Used as FastAPI dependable for query parameters that need to behave as a list of values separated by comma or as multiple instances of the same parameter.

Important

the query annotation provided must define the alias exactly as the name of the actual parameter name.

Usage example:

ValueQueryParam = Query(
    default=None,
    alias="value", # Important! this is the parameter name that will be displayed in the API docs
    title="My Value",
    description="A single value, a comma-separated list of values or a list of values.",
)

@router.get("/api/my_route")
def index(
    self,
    values: Optional[List[str]] = Depends(query_parameter_as_list(ValueQueryParam)),
):
    ...

This will render in the API docs as a single string query parameter but will make the following requests equivalent:

  • api/my_route?value=val1,val2,val3

  • api/my_route?value=val1&value=val2&value=val3

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.FastAPIConfiguration(*, configuration_manager: ConfigurationManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

configuration_manager: ConfigurationManager = GalaxyTypeDepends(_do_resolve)
whoami(*, trans: ProvidesUserContext = Depends(get_trans)) Optional[UserModel][source]

Return information about the current authenticated user.

index(*, trans: ProvidesUserContext = Depends(get_trans), view: Optional[str] = Query(None), keys: Optional[str] = Query(None)) Dict[str, Any][source]

Return an object containing exposable configuration settings.

A more complete list is returned if the user is an admin. Pass in view and a comma-seperated list of keys to control which configuration settings are returned.

version() Dict[str, Any][source]

Return Galaxy version information: major/minor version, optional extra info.

dynamic_tool_confs() List[Dict[str, str]][source]

Return dynamic tool configuration files.

decode_id(*, encoded_id: str = Path(Ellipsis)) Dict[str, int][source]

Decode a given id.

tool_lineages() List[Dict[str, Dict]][source]

Return tool lineages for tools that have them.

reload_toolbox()[source]

Reload the Galaxy toolbox (but not individual tools).

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.container_resolution module

API operations allowing clients to manage container resolution.

class galaxy.webapps.galaxy.api.container_resolution.ContainerResolutionAPIController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController

__init__(app: StructuredApp)[source]

Initialize an interface for application ‘app’

index(trans, **kwd)[source]

GET /api/container_resolvers

show(trans, index)[source]

GET /api/container_resolvers/<id>

resolve(trans, index=None, **kwds)[source]

GET /api/container_resolvers/resolve GET /api/container_resolvers/{index}/resolve

Resolve described requirement against specified container resolvers.

Parameters:
  • tool_id (str) – tool_id to resolve against containers

  • requirements_only (boolean) – ignore tool containers, properties - just search based on tool requirements set to True to mimic default behavior of tool dependency API.

  • index (int) – index of the container resolver, if unset resolvers searched in order

  • container_type (str) – restrict resolution to specified container type (e.g. ‘docker’, ‘singularity’)

  • resolver_type (str) – restrict resolution to specified resolver type (e.g. ‘build_mulled’, ‘explicit’)

  • install (boolean) – allow installation of new containers (for build_mulled* containers) the way job resolution will operate, defaults to False

Return type:

dict

Returns:

a dictified description of the container dependency, with attribute dependency_type: None if no match was found.

resolve_toolbox(trans, **kwds)[source]

GET /api/container_resolvers/toolbox GET /api/container_resolvers/{index}/toolbox

Apply resolve() to each tool in the toolbox and return the results as a list. See documentation for resolve() for a description of parameters that can be consumed and a description of the resulting items.

Parameters:

tool_ids (str) – tool_ids to filter toolbox on

Return type:

list

Returns:

list of items returned from resolve()

resolve_toolbox_with_install(trans, payload, **kwds)[source]

POST /api/container_resolvers/toolbox/install POST /api/container_resolvers/{index}/toolbox/install

Do the resolution of dependencies like resolve_toolbox(), but allow building and installing new containers. payload of POST body maybe contain same parameters as resolve_toolbox query parameters.

Return type:

list

Returns:

list of items returned from resolve()

resolve_with_install(trans, payload, **kwds)[source]

POST /api/container_resolvers/resolve/install POST /api/container_resolvers/{index}/resolve/install

Do the resolution of dependencies like resolve(), but allow building and installing new containers during installation. payload of POST body maybe contain same parameters as resolve query parameters.

Return type:

dict

Returns:

a dictified description of the container dependency, with attribute dependency_type: None if no match was found.

galaxy.webapps.galaxy.api.dataset_collections module

class galaxy.webapps.galaxy.api.dataset_collections.FastAPIDatasetCollections(*, service: DatasetCollectionsService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: DatasetCollectionsService = GalaxyTypeDepends(_do_resolve)
create(*, trans: ProvidesHistoryContext = Depends(get_trans), payload: CreateNewCollectionPayload = Body(Ellipsis)) HDCADetailed[source]
copy(*, trans: ProvidesHistoryContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), payload: UpdateCollectionAttributePayload = Body(Ellipsis))[source]
attributes(*, trans: ProvidesHistoryContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), instance_type: typing_extensions.Literal[history, library] = Query(history)) DatasetCollectionAttributesResult[source]
suitable_converters(*, trans: ProvidesHistoryContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), instance_type: typing_extensions.Literal[history, library] = Query(history)) SuitableConverters[source]
show(*, trans: ProvidesHistoryContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), instance_type: typing_extensions.Literal[history, library] = Query(history)) HDCADetailed[source]
contents(*, trans: ProvidesHistoryContext = Depends(get_trans), hdca_id: DecodedDatabaseIdField = Path(Ellipsis), parent_id: DecodedDatabaseIdField = Path(Ellipsis), instance_type: typing_extensions.Literal[history, library] = Query(history), limit: Optional[int] = Query(None), offset: Optional[int] = Query(None)) DatasetCollectionContentElements[source]
content(*, trans: ProvidesHistoryContext = Depends(get_trans), dce_id: DecodedDatabaseIdField = Path(Ellipsis)) DCESummary[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.datasets module

API operations on the contents of a history dataset.

class galaxy.webapps.galaxy.api.datasets.FastAPIDatasets(*, service: DatasetsService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: DatasetsService = GalaxyTypeDepends(_do_resolve)
index(*, trans=Depends(get_trans), history_id: Optional[DecodedDatabaseIdField] = Query(None), serialization_params: SerializationParams = Depends(query_serialization_params), filter_query_params: FilterQueryParams = Depends(get_filter_query_params)) List[Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem]][source]
show_storage(*, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), hda_ldda: DatasetSourceType = Query(hda)) DatasetStorageDetails[source]
show_inheritance_chain(*, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), hda_ldda: DatasetSourceType = Query(hda)) DatasetInheritanceChain[source]
get_content_as_text(*, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis)) DatasetTextContentDetails[source]
converted_ext(*, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), ext: str = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[HDADetailed, HDASummary][source]

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

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

Note: view and keys are also available to control the serialization of the dataset.

converted(*, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis)) ConvertedDatasetsMap[source]

Return a map of <converted extension> : <converted id> containing all the existing converted datasets.

update_permissions(*, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), payload: Dict[str, Any] = Body(Ellipsis)) DatasetAssociationRoles[source]

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

extra_files(*, trans=Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), history_content_id: DecodedDatabaseIdField = Path(Ellipsis))[source]
display_history_content(*, request: Request, trans=Depends(get_trans), history_id: Optional[DecodedDatabaseIdField] = Path(Ellipsis), history_content_id: DecodedDatabaseIdField = Path(Ellipsis), preview: bool = Query(False), filename: Optional[str] = Query(None), to_ext: Optional[str] = Query(None), raw: bool = Query(False), offset: Optional[int] = Query(None), ck_size: Optional[int] = Query(None))[source]

Streams the dataset for download or the contents preview to be displayed in a browser.

display(*, request: Request, trans=Depends(get_trans), history_content_id: DecodedDatabaseIdField = Path(Ellipsis), preview: bool = Query(False), filename: Optional[str] = Query(None), to_ext: Optional[str] = Query(None), raw: bool = Query(False), offset: Optional[int] = Query(None), ck_size: Optional[int] = Query(None))[source]

Streams the dataset for download or the contents preview to be displayed in a browser.

get_metadata_file_history_content(*, trans=Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), history_content_id: DecodedDatabaseIdField = Path(Ellipsis), metadata_file: str = Query(Ellipsis))[source]
get_metadata_file_datasets(*, trans=Depends(get_trans), history_content_id: DecodedDatabaseIdField = Path(Ellipsis), metadata_file: str = Query(Ellipsis))[source]
show(*, request: Request, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), hda_ldda: DatasetSourceType = Query(hda), data_type: Optional[RequestDataType] = Query(None), serialization_params: SerializationParams = Depends(query_serialization_params))[source]

Note: Due to the multipurpose nature of this endpoint, which can receive a wild variety of parameters and return different kinds of responses, the documentation here will be limited. To get more information please check the source code.

get_structured_content(*, request: Request, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), content_type: DatasetContentType = DatasetContentType.data)[source]
delete_batch(*, trans=Depends(get_trans), payload: DeleteDatasetBatchPayload = Body(Ellipsis)) DeleteDatasetBatchResult[source]

Deletes or purges a batch of datasets. Warning: only the ownership of the datasets (and upload state for HDAs) is checked, no other checks or restrictions are made.

compute_hash(*, trans=Depends(get_trans), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), hda_ldda: DatasetSourceType = Query(hda), payload: ComputeDatasetHashPayload = Body(Ellipsis)) AsyncTaskResultSummary[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.datatypes module

API operations allowing clients to determine datatype supported by Galaxy.

class galaxy.webapps.galaxy.api.datatypes.FastAPIDatatypes(*, datatypes_registry: Registry = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

datatypes_registry: Registry = GalaxyTypeDepends(_do_resolve)
async index(*, extension_only: Optional[bool] = Query(True), upload_only: Optional[bool] = Query(True)) Union[List[DatatypeDetails], List[str]][source]

Gets the list of all available data types.

async mapping() DatatypesMap[source]

Gets mappings for data types.

async types_and_mapping(*, extension_only: Optional[bool] = Query(True), upload_only: Optional[bool] = Query(True)) DatatypesCombinedMap[source]

Combines the datatype information from (/api/datatypes) and the mapping information from (/api/datatypes/mapping) into a single response.

async sniffers() List[str][source]

Gets the list of all installed data type sniffers.

async converters() DatatypeConverterList[source]

Gets the list of all installed converters.

async edam_formats() Dict[str, str][source]

Gets a map of datatypes and their corresponding EDAM formats.

async edam_formats_detailed()[source]

Gets a map of datatypes and their corresponding EDAM formats. EDAM formats contain the EDAM iri, label, and definition.

async edam_data() Dict[str, str][source]

Gets a map of datatypes and their corresponding EDAM data.

async edam_data_detailed()[source]

Gets a map of datatypes and their corresponding EDAM data. EDAM data contains the EDAM iri, label, and definition.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.display_applications module

API operations on annotations.

class galaxy.webapps.galaxy.api.display_applications.FastAPIDisplay(*, manager: DisplayApplicationsManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: DisplayApplicationsManager = GalaxyTypeDepends(_do_resolve)
index() List[DisplayApplication][source]

Returns the list of display applications.

reload(*, payload: Optional[Dict[str, List[str]]] = Body(None)) ReloadFeedback[source]

Reloads the list of display applications.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.dynamic_tools module

class galaxy.webapps.galaxy.api.dynamic_tools.DynamicToolsController(app)[source]

Bases: BaseAPIController

RESTful controller for interactions with dynamic tools.

Dynamic tools are tools defined in the database. Use the tools controller to run these tools and view functional information.

index(trans, **kwds)[source]

GET /api/dynamic_tools

This returns meta-information about the dynamic tool, such as tool_uuid. To use the tool or view funtional information such as inputs and outputs, use the standard tools API indexed by the ID (and optionally version) returned from this endpoint.

show(trans, id, **kwd)[source]

GET /api/dynamic_tools/{encoded_dynamic_tool_id|tool_uuid}

create(trans, payload, **kwd)[source]

POST /api/dynamic_tools

The payload is expected to be a tool definition to dynamically load into Galaxy’s toolbox.

Parameters:
  • representation (dict) – a JSON-ified tool description to load

  • uuid (str) – the uuid to associate with the tool being created

delete(trans, id, **kwd)[source]

DELETE /api/dynamic_tools/{encoded_dynamic_tool_id|tool_uuid}

Deactivate the specified dynamic tool. Deactivated tools will not be loaded into the toolbox.

galaxy.webapps.galaxy.api.extended_metadata module

API operations on annotations.

class galaxy.webapps.galaxy.api.extended_metadata.BaseExtendedMetadataController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController, UsesExtendedMetadataMixin, UsesLibraryMixinItems, UsesStoredWorkflowMixin, Generic[T]

exmeta_item_id: str
index(trans, **kwd)[source]
create(trans, payload, **kwd)[source]
class galaxy.webapps.galaxy.api.extended_metadata.LibraryDatasetExtendMetadataController(app: StructuredApp)[source]

Bases: BaseExtendedMetadataController[LibraryDatasetDatasetAssociation]

controller_name = 'library_dataset_extended_metadata'
exmeta_item_id: str = 'library_content_id'
class galaxy.webapps.galaxy.api.extended_metadata.HistoryDatasetExtendMetadataController(app: StructuredApp)[source]

Bases: BaseExtendedMetadataController[HistoryDatasetAssociation]

controller_name = 'history_dataset_extended_metadata'
exmeta_item_id: str = 'history_content_id'
hda_manager: HDAManager = GalaxyTypeDepends(_do_resolve)

galaxy.webapps.galaxy.api.folder_contents module

API operations on the contents of a library folder.

class galaxy.webapps.galaxy.api.folder_contents.FastAPILibraryFoldersContents(*, service: LibraryFolderContentsService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: LibraryFolderContentsService = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesUserContext = Depends(get_trans), folder_id: LibraryFolderDatabaseIdField = Path(Ellipsis), limit: int = Query(10), offset: int = Query(0), search_text: Optional[str] = Query(None), include_deleted: Optional[bool] = Query(False), order_by: typing_extensions.Literal[name, description, type, size, update_time] = Query(name), sort_desc: Optional[bool] = Query(False))[source]

Returns a list of a folder’s contents (files and sub-folders).

Additional metadata for the folder is provided in the response as a separate object containing data for breadcrumb path building, permissions and other folder’s details.

Note: When sorting, folders always have priority (they show-up before any dataset regardless of the sorting).

Security note: - Accessing a library folder or sub-folder requires only access to the parent library. - Deleted folders can only be accessed by admins or users with MODIFY permission. - Datasets may be public, private or restricted (to a group of users). Listing deleted datasets has the same requirements as folders.

create(*, trans: ProvidesUserContext = Depends(get_trans), folder_id: LibraryFolderDatabaseIdField = Path(Ellipsis), payload: CreateLibraryFilePayload = Body(Ellipsis))[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.folders module

API operations on library folders.

class galaxy.webapps.galaxy.api.folders.FastAPILibraryFolders(*, service: LibraryFoldersService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: LibraryFoldersService = GalaxyTypeDepends(_do_resolve)
show(*, trans: ProvidesUserContext = Depends(get_trans), id: LibraryFolderDatabaseIdField = Path(Ellipsis)) LibraryFolderDetails[source]

Returns detailed information about the library folder with the given ID.

create(*, trans: ProvidesUserContext = Depends(get_trans), id: LibraryFolderDatabaseIdField = Path(Ellipsis), payload: CreateLibraryFolderPayload = Body(Ellipsis)) LibraryFolderDetails[source]

Returns detailed information about the newly created library folder.

update(*, trans: ProvidesUserContext = Depends(get_trans), id: LibraryFolderDatabaseIdField = Path(Ellipsis), payload: UpdateLibraryFolderPayload = Body(Ellipsis)) LibraryFolderDetails[source]

Updates the information of an existing library folder.

delete(*, trans: ProvidesUserContext = Depends(get_trans), id: LibraryFolderDatabaseIdField = Path(Ellipsis), undelete: Optional[bool] = Query(None)) LibraryFolderDetails[source]

Marks the specified library folder as deleted (or undeleted).

get_permissions(*, trans: ProvidesUserContext = Depends(get_trans), id: LibraryFolderDatabaseIdField = Path(Ellipsis), scope: Optional[LibraryPermissionScope] = Query(None), page: int = Query(1), page_limit: int = Query(10), q: Optional[str] = Query(None)) Union[LibraryFolderCurrentPermissions, LibraryAvailablePermissions][source]

Gets the current or available permissions of a particular library. The results can be paginated and additionally filtered by a query.

set_permissions(*, trans: ProvidesUserContext = Depends(get_trans), id: LibraryFolderDatabaseIdField = Path(Ellipsis), action: Optional[LibraryFolderPermissionAction] = Query(None), payload: LibraryFolderPermissionsPayload = Body(Ellipsis)) LibraryFolderCurrentPermissions[source]

Sets the permissions to manage a library folder.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.forms module

API operations on FormDefinition objects.

class galaxy.webapps.galaxy.api.forms.FormDefinitionAPIController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController

index(trans, **kwd)[source]

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

show(trans, id, **kwd)[source]

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

create(trans, payload, **kwd)[source]

POST /api/forms Creates a new form.

galaxy.webapps.galaxy.api.genomes module

galaxy.webapps.galaxy.api.genomes.get_id(base, format)[source]
class galaxy.webapps.galaxy.api.genomes.FastAPIGenomes(*, manager: GenomesManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: GenomesManager = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesUserContext = Depends(get_trans), chrom_info: bool = Query(None)) List[List[str]][source]
show(*, trans: ProvidesUserContext = Depends(get_trans), id: str = Path(Ellipsis), reference: bool = Query(None), num: int = Query(None), chrom: str = Query(None), low: int = Query(None), high: int = Query(None), format: str = Query(None)) Any[source]
indexes(*, id: str = Path(Ellipsis), type: str = Query(fasta_indexes), format: str = Query(None)) Any[source]
sequences(*, trans: ProvidesUserContext = Depends(get_trans), id: str = Path(Ellipsis), reference: bool = Query(None), chrom: str = Query(None), low: int = Query(None), high: int = Query(None), format: str = Query(None)) Any[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.group_roles module

API operations on Group objects.

galaxy.webapps.galaxy.api.group_roles.group_role_to_model(trans, group_id: int, role) GroupRoleResponse[source]
class galaxy.webapps.galaxy.api.group_roles.FastAPIGroupRoles(*, manager: GroupRolesManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: GroupRolesManager = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupRoleListResponse[source]
show(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis), role_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupRoleResponse[source]
update(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis), role_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupRoleResponse[source]
delete(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis), role_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupRoleResponse[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.group_users module

API operations on Group objects.

galaxy.webapps.galaxy.api.group_users.group_user_to_model(trans, group_id, user) GroupUserResponse[source]
class galaxy.webapps.galaxy.api.group_users.FastAPIGroupUsers(*, manager: GroupUsersManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: GroupUsersManager = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupUserListResponse[source]

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

show(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis), user_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupUserResponse[source]

Displays information about a group user.

update(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis), user_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupUserResponse[source]

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

delete(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis), user_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupUserResponse[source]

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

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.groups module

API operations on Group objects.

class galaxy.webapps.galaxy.api.groups.FastAPIGroups(*, manager: GroupsManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: GroupsManager = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesAppContext = Depends(get_trans)) GroupListResponse[source]
create(*, trans: ProvidesAppContext = Depends(get_trans), payload: GroupCreatePayload = Body(Ellipsis)) GroupListResponse[source]
show(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis)) GroupResponse[source]
update(*, trans: ProvidesAppContext = Depends(get_trans), group_id: DecodedDatabaseIdField = Path(Ellipsis), payload: GroupCreatePayload = Body(Ellipsis)) GroupResponse[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.histories module

API operations on a history.

class galaxy.webapps.galaxy.api.histories.DeleteHistoryPayload(*, purge: bool = False)[source]

Bases: BaseModel

purge: bool
class galaxy.webapps.galaxy.api.histories.CreateHistoryFormData(*, name: Optional[str] = None, history_id: Optional[DecodedDatabaseIdField] = None, all_datasets: Optional[bool] = True, archive_source: Optional[str] = None, archive_type: Optional[HistoryImportArchiveSourceType] = HistoryImportArchiveSourceType.url, archive_file: Optional[Any] = None)[source]

Bases: CreateHistoryPayload

Uses Form data instead of JSON

async as_form(history_id=Form(None), all_datasets=Form(True), archive_source=Form(None), archive_type=Form(url), archive_file=Form(None), /)
name: Optional[str]
history_id: Optional[DecodedDatabaseIdField]
all_datasets: Optional[bool]
archive_source: Optional[str]
archive_type: Optional[HistoryImportArchiveSourceType]
archive_file: Optional[Any]
class galaxy.webapps.galaxy.api.histories.FastAPIHistories(*, service: HistoriesService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: HistoriesService = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesHistoryContext = Depends(get_trans), filter_query_params: FilterQueryParams = Depends(get_filter_query_params), serialization_params: SerializationParams = Depends(query_serialization_params), all: Optional[bool] = Query(False), deleted: Optional[bool] = Query(False)) List[Union[HistorySummary, HistoryDetailed, Any]][source]
count(*, trans: ProvidesHistoryContext = Depends(get_trans)) int[source]
index_deleted(*, trans: ProvidesHistoryContext = Depends(get_trans), filter_query_params: FilterQueryParams = Depends(get_filter_query_params), serialization_params: SerializationParams = Depends(query_serialization_params), all: Optional[bool] = Query(False)) List[Union[HistorySummary, HistoryDetailed, Any]][source]
published(*, trans: ProvidesHistoryContext = Depends(get_trans), filter_query_params: FilterQueryParams = Depends(get_filter_query_params), serialization_params: SerializationParams = Depends(query_serialization_params)) List[Union[HistorySummary, HistoryDetailed, Any]][source]
shared_with_me(*, trans: ProvidesHistoryContext = Depends(get_trans), filter_query_params: FilterQueryParams = Depends(get_filter_query_params), serialization_params: SerializationParams = Depends(query_serialization_params)) List[Union[HistorySummary, HistoryDetailed, Any]][source]
get_archived_histories(*, response: Response, trans: ProvidesHistoryContext = Depends(get_trans), serialization_params: SerializationParams = Depends(query_serialization_params), filter_query_params: FilterQueryParams = Depends(get_filter_query_params)) List[Union[ArchivedHistorySummary, ArchivedHistoryDetailed, Any]][source]

Get a list of all archived histories for the current user.

Archived histories are histories are not part of the active histories of the user but they can be accessed using this endpoint.

show_recent(*, trans: ProvidesHistoryContext = Depends(get_trans), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[HistorySummary, HistoryDetailed, Any][source]
show(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[HistorySummary, HistoryDetailed, Any][source]
prepare_store_download(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), payload: StoreExportPayload = Body(Ellipsis)) AsyncFile[source]
write_store(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), payload: WriteStoreToPayload = Body(Ellipsis)) AsyncTaskResultSummary[source]
citations(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis)) List[Any][source]
create(*, trans: ProvidesHistoryContext = Depends(get_trans), payload: CreateHistoryPayload = Depends(_as_form), payload_as_json: Optional[Any] = Depends(try_get_request_body_as_json), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[JobImportHistoryResponse, HistorySummary, HistoryDetailed, Any][source]

The new history can also be copied form a existing history or imported from an archive or URL.

delete(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params), purge: bool = Query(False), payload: Optional[DeleteHistoryPayload] = Body(None)) Union[HistorySummary, HistoryDetailed, Any][source]
undelete(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[HistorySummary, HistoryDetailed, Any][source]
update(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), payload: Any = Body(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[HistorySummary, HistoryDetailed, Any][source]
create_from_store(*, trans: ProvidesHistoryContext = Depends(get_trans), serialization_params: SerializationParams = Depends(query_serialization_params), payload: CreateHistoryFromStore = Body(Ellipsis)) Union[HistorySummary, HistoryDetailed, Any][source]
create_from_store_async(*, trans: ProvidesHistoryContext = Depends(get_trans), payload: CreateHistoryFromStore = Body(Ellipsis)) AsyncTaskResultSummary[source]
index_exports(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), limit: Optional[int] = Query(None), offset: Optional[int] = Query(0), accept: str = Header(application / json)) Union[JobExportHistoryArchiveListResponse, ExportTaskListResponse][source]

By default the legacy job-based history exports (jeha) are returned.

Change the accept content type header to return the new task-based history exports.

archive_export(*, response: Response, trans=Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), payload: Optional[ExportHistoryArchivePayload] = Body(None)) Union[JobExportHistoryArchiveModel, JobIdResponse][source]

This will start a job to create a history export archive.

Calling this endpoint multiple times will return the 202 status code until the archive has been completely generated and is ready to download. When ready, it will return the 200 status code along with the download link information.

If the history will be exported to a directory_uri, instead of returning the download link information, the Job ID will be returned so it can be queried to determine when the file has been written.

Deprecation notice: Please use /api/histories/{id}/prepare_store_download or /api/histories/{id}/write_store instead.

archive_download(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), jeha_id: Union[DecodedDatabaseIdField, typing_extensions.Literal[latest]] = Path(Ellipsis))[source]

See PUT /api/histories/{id}/exports to initiate the creation of the history export - when ready, that route will return 200 status code (instead of 202) and this route can be used to download the archive.

Deprecation notice: Please use /api/histories/{id}/prepare_store_download or /api/histories/{id}/write_store instead.

get_custom_builds_metadata(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis)) CustomBuildsMetadataResponse[source]
archive_history(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), payload: Optional[ArchiveHistoryRequestPayload] = Body(None)) Union[ArchivedHistorySummary, ArchivedHistoryDetailed, Any][source]

Marks the given history as ‘archived’ and returns the history.

Archiving a history will remove it from the list of active histories of the user but it will still be accessible via the /api/histories/{id} or the /api/histories/archived endpoints.

Associating an export record:

  • Optionally, an export record (containing information about a recent snapshot of the history) can be associated with the

archived history by providing an archive_export_id in the payload. The export record must belong to the history and must be in the ready state. - When associating an export record, the history can be purged after it has been archived using the purge_history flag.

If the history is already archived, this endpoint will return a 409 Conflict error, indicating that the history is already archived. If the history was not purged after it was archived, you can restore it using the /api/histories/{id}/archive/restore endpoint.

restore_archived_history(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), force: Optional[bool] = Query(None)) Union[HistorySummary, HistoryDetailed, Any][source]

Restores an archived history and returns it.

Restoring an archived history will add it back to the list of active histories of the user (unless it was purged).

Warning: Please note that histories that are associated with an archive export might be purged after export, so un-archiving them will not restore the datasets that were in the history before it was archived. You will need to import back the archive export record to restore the history and its datasets as a new copy. See /api/histories/from_store_async for more information.

sharing(*, trans: ProvidesUserContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis)) SharingStatus[source]

Return the sharing status of the item.

Makes this item accessible by a URL link and return the current sharing status.

Makes this item inaccessible by a URL link and return the current sharing status.

publish(*, trans: ProvidesUserContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis)) SharingStatus[source]

Makes this item publicly available by a URL link and return the current sharing status.

unpublish(*, trans: ProvidesUserContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis)) SharingStatus[source]

Removes this item from the published list and return the current sharing status.

share_with_users(*, trans: ProvidesUserContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), payload: ShareWithPayload = Body(Ellipsis)) ShareWithStatus[source]

Shares this item with specific users and return the current sharing status.

set_slug(*, trans: ProvidesUserContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), payload: SetSlugPayload = Body(Ellipsis))[source]

Sets a new slug to access this item by URL. The new slug must be unique.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.history_contents module

API operations on the contents of a history.

galaxy.webapps.galaxy.api.history_contents.ContentTypeQueryParam(default: Optional[HistoryContentType])[source]
galaxy.webapps.galaxy.api.history_contents.get_index_query_params(v: Optional[str] = Query(None), dataset_details: Optional[str] = Query(None)) HistoryContentsIndexParams[source]

This function is meant to be used as a dependency to render the OpenAPI documentation correctly

galaxy.webapps.galaxy.api.history_contents.parse_index_query_params(v: Optional[str] = None, dataset_details: Optional[str] = None, **_) HistoryContentsIndexParams[source]

Parses query parameters for the history contents index operation and returns a model containing the values in the correct type.

galaxy.webapps.galaxy.api.history_contents.get_legacy_index_query_params(ids: Optional[str] = Query(None), types: Optional[List[str]] = Query(None), details: Optional[str] = Query(None), deleted: Optional[bool] = Query(None), visible: Optional[bool] = Query(None), shareable: Optional[bool] = Query(None)) LegacyHistoryContentsIndexParams[source]

This function is meant to be used as a dependency to render the OpenAPI documentation correctly

galaxy.webapps.galaxy.api.history_contents.parse_legacy_index_query_params(ids: Optional[str] = None, types: Optional[Union[List[str], str]] = None, details: Optional[str] = None, deleted: Optional[bool] = None, visible: Optional[bool] = None, shareable: Optional[bool] = None, **_) LegacyHistoryContentsIndexParams[source]

Parses (legacy) query parameters for the history contents index operation and returns a model containing the values in the correct type.

galaxy.webapps.galaxy.api.history_contents.parse_content_types(types: Union[List[str], str]) List[HistoryContentType][source]
galaxy.webapps.galaxy.api.history_contents.parse_dataset_details(details: Optional[str])[source]

Parses the different values that the dataset_details parameter can have from a string.

galaxy.webapps.galaxy.api.history_contents.get_index_jobs_summary_params(ids: Optional[str] = Query(None), types: Optional[str] = Query(None)) HistoryContentsIndexJobsSummaryParams[source]

This function is meant to be used as a dependency to render the OpenAPI documentation correctly

galaxy.webapps.galaxy.api.history_contents.parse_index_jobs_summary_params(ids: Optional[str] = None, types: Optional[str] = None, **_) HistoryContentsIndexJobsSummaryParams[source]

Parses query parameters for the history contents index_jobs_summary operation and returns a model containing the values in the correct type.

class galaxy.webapps.galaxy.api.history_contents.FastAPIHistoryContents(*, service: HistoriesContentsService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: HistoriesContentsService = GalaxyTypeDepends(_do_resolve)
index_typed(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), index_params: HistoryContentsIndexParams = Depends(get_index_query_params), type: HistoryContentType = Path(Ellipsis), legacy_params: LegacyHistoryContentsIndexParams = Depends(get_legacy_index_query_params), serialization_params: SerializationParams = Depends(query_serialization_params), filter_query_params: FilterQueryParams = Depends(get_filter_query_params), accept: str = Header(application / json)) Union[HistoryContentsResult, HistoryContentsWithStatsResult][source]

Return a list of either HDA/HDCA data for the history with the given ID.

  • The contents can be filtered and queried using the appropriate parameters.

  • The amount of information returned for each item can be customized.

Note: Anonymous users are allowed to get their current history contents.

index(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), index_params: HistoryContentsIndexParams = Depends(get_index_query_params), type: Optional[str] = Query(None), legacy_params: LegacyHistoryContentsIndexParams = Depends(get_legacy_index_query_params), serialization_params: SerializationParams = Depends(query_serialization_params), filter_query_params: FilterQueryParams = Depends(get_filter_query_params), accept: str = Header(application / json)) Union[HistoryContentsResult, HistoryContentsWithStatsResult][source]

Return a list of HDA/HDCA data for the history with the given ID.

  • The contents can be filtered and queried using the appropriate parameters.

  • The amount of information returned for each item can be customized.

Note: Anonymous users are allowed to get their current history contents.

show_jobs_summary(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Path(Ellipsis)) Union[galaxy.schema.schema.JobStateSummary, galaxy.schema.schema.ImplicitCollectionJobsStateSummary, galaxy.schema.schema.WorkflowInvocationStateSummary][Union[JobStateSummary, ImplicitCollectionJobsStateSummary, WorkflowInvocationStateSummary]][source]

Return detailed information about an HDA or HDCAs jobs.

Warning: We allow anyone to fetch job state information about any object they can guess an encoded ID for - it isn’t considered protected data. This keeps polling IDs as part of state calculation for large histories and collections as efficient as possible.

show(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Path(Ellipsis), fuzzy_count: Optional[int] = Query(None), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem][source]

Return detailed information about an HDA or HDCA within a history.

Note: Anonymous users are allowed to get their current history contents.

show_legacy(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Query(dataset), id: DecodedDatabaseIdField = Path(Ellipsis), fuzzy_count: Optional[int] = Query(None), serialization_params: SerializationParams = Depends(query_serialization_params)) Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem][source]

Return detailed information about an HDA or HDCA within a history.

Note: Anonymous users are allowed to get their current history contents.

prepare_store_download(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Path(Ellipsis), payload: StoreExportPayload = Body(Ellipsis)) AsyncFile[source]
write_store(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Path(Ellipsis), payload: WriteStoreToPayload = Body(Ellipsis)) AsyncTaskResultSummary[source]
index_jobs_summary(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), params: HistoryContentsIndexJobsSummaryParams = Depends(get_index_jobs_summary_params)) List[Union[galaxy.schema.schema.JobStateSummary, galaxy.schema.schema.ImplicitCollectionJobsStateSummary, galaxy.schema.schema.WorkflowInvocationStateSummary][Union[JobStateSummary, ImplicitCollectionJobsStateSummary, WorkflowInvocationStateSummary]]][source]

Return job state summary info for jobs, implicit groups jobs for collections or workflow invocations.

Warning: We allow anyone to fetch job state information about any object they can guess an encoded ID for - it isn’t considered protected data. This keeps polling IDs as part of state calculation for large histories and collections as efficient as possible.

download_dataset_collection_history_content(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: Optional[DecodedDatabaseIdField] = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis))[source]

Download the content of a history dataset collection as a zip archive while maintaining approximate collection structure.

download_dataset_collection(*, trans: ProvidesHistoryContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis))[source]

Download the content of a history dataset collection as a zip archive while maintaining approximate collection structure.

prepare_collection_download(*, trans: ProvidesHistoryContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) AsyncFile[source]

The history dataset collection will be written as a zip archive to the returned short term storage object. Progress tracking this file’s creation can be tracked with the short_term_storage API.

create_typed(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params), payload: CreateHistoryContentPayload = Body(Ellipsis)) Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem, List[Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem]]][source]

Create a new HDA or HDCA in the given History.

create(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), type: Optional[HistoryContentType] = Query(None), serialization_params: SerializationParams = Depends(query_serialization_params), payload: CreateHistoryContentPayload = Body(Ellipsis)) Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem, List[Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem]]][source]

Create a new HDA or HDCA in the given History.

update_permissions(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), dataset_id: DecodedDatabaseIdField = Path(Ellipsis), payload: Dict[str, Any] = Body(Ellipsis)) DatasetAssociationRoles[source]

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

update_batch(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params), payload: UpdateHistoryContentsBatchPayload = Body(Ellipsis)) HistoryContentsResult[source]

Batch update specific properties of a set items contained in the given History.

If you provide an invalid/unknown property key the request will not fail, but no changes will be made to the items.

bulk_operation(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), filter_query_params: ValueFilterQueryParams = Depends(get_value_filter_query_params), payload: HistoryContentBulkOperationPayload = Body(Ellipsis)) HistoryContentBulkOperationResult[source]

Executes an operation on a set of items contained in the given History.

The items to be processed can be explicitly set or determined by a dynamic query.

validate(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis)) dict[source]

Validates the metadata associated with a dataset within a History.

update_typed(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params), payload: UpdateHistoryContentsPayload = Body(Ellipsis)) Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem][source]

Updates the values for the history content item with the given ID.

update_legacy(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Query(dataset), serialization_params: SerializationParams = Depends(query_serialization_params), payload: UpdateHistoryContentsPayload = Body(Ellipsis)) Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem][source]

Updates the values for the history content item with the given ID.

delete_typed(*, response: Response, trans: ProvidesHistoryContext = Depends(get_trans), history_id: str = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params), purge: Optional[bool] = Query(False), recursive: Optional[bool] = Query(False), stop_job: Optional[bool] = Query(False), payload: DeleteHistoryContentPayload = Body(None))[source]

Delete the history content with the given ID and path specified type.

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

delete_legacy(*, response: Response, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis), type: HistoryContentType = Query(dataset), serialization_params: SerializationParams = Depends(query_serialization_params), purge: Optional[bool] = Query(False), recursive: Optional[bool] = Query(False), stop_job: Optional[bool] = Query(False), payload: DeleteHistoryContentPayload = Body(None))[source]

Delete the history content with the given ID and query specified type (defaults to dataset).

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

archive_named(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), filename: str = Path(Ellipsis), format: str = Path(Ellipsis), dry_run: Optional[bool] = Query(True), filter_query_params: FilterQueryParams = Depends(get_filter_query_params))[source]

Build and return a compressed archive of the selected history contents.

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

archive(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), filename: Optional[str] = Query(None), dry_run: Optional[bool] = Query(True), filter_query_params: FilterQueryParams = Depends(get_filter_query_params))[source]

Build and return a compressed archive of the selected history contents.

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

create_from_store(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), serialization_params: SerializationParams = Depends(query_serialization_params), create_payload: CreateHistoryContentFromStore = Body(Ellipsis)) List[Union[HDADetailed, HDASummary, HDCADetailed, HDCASummary, CustomHistoryItem]][source]

Create history contents from model store. Input can be a tarfile created with build_objects script distributed with galaxy-data, from an exported history with files stripped out, or hand-crafted JSON dictionary.

materialize_dataset(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), id: DecodedDatabaseIdField = Path(Ellipsis)) AsyncTaskResultSummary[source]
materialize_to_history(*, trans: ProvidesHistoryContext = Depends(get_trans), history_id: DecodedDatabaseIdField = Path(Ellipsis), materialize_api_payload: MaterializeDatasetInstanceAPIRequest = Body(Ellipsis)) AsyncTaskResultSummary[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.item_tags module

API operations related to tagging items.

class galaxy.webapps.galaxy.api.item_tags.FastAPIItemTags(*, manager: ItemTagsManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: ItemTagsManager = GalaxyTypeDepends(_do_resolve)
classmethod create_class(prefix, tagged_item_class, tagged_item_id, api_docs_tag, extra_path_params)[source]
__init__(*args: Any, **kwargs: Any) None

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: StructuredApp)[source]

Bases: BaseGalaxyAPIController

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.

index(trans, job_id, **kwargs)[source]

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

create(self, trans, job_id, payload, **kwargs)[source]
  • 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

galaxy.webapps.galaxy.api.job_lock module

galaxy.webapps.galaxy.api.job_lock.job_lock_status(job_manager: JobManager = GalaxyTypeDepends(_do_resolve)) JobLock[source]

Get job lock status.

galaxy.webapps.galaxy.api.job_lock.update_job_lock(job_manager: JobManager = GalaxyTypeDepends(_do_resolve), job_lock: JobLock = Body(Ellipsis)) JobLock[source]

Set job lock status.

galaxy.webapps.galaxy.api.job_ports 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_ports.JobPortsAPIController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController

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

See the JobFiles API for information about per-job API keys.

__init__(app: StructuredApp)[source]

Initialize an interface for application ‘app’

create(self, trans, job_id, payload, **kwargs)[source]
  • POST /api/jobs/{job_id}/ports

    Populate port information for interactive tools.

Parameters:
  • job_id (str) – encoded id string of the job

  • payload (dict) – dictionary structure containing:: ‘job_key’ = Key authenticating ‘container_runtime’ = 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

galaxy.webapps.galaxy.api.jobs module

API operations on a jobs.

See also

galaxy.model.Jobs

class galaxy.webapps.galaxy.api.jobs.FastAPIJobs(*, service: JobsService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: JobsService = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesUserContext = Depends(get_trans), states: Optional[List[str]] = Depends(parse_elements), user_details: bool = Query(False), user_id: Optional[DecodedDatabaseIdField] = Query(None), view: JobIndexViewEnum = Query(collection), tool_ids: Optional[List[str]] = Depends(parse_elements), tool_ids_like: Optional[List[str]] = Depends(parse_elements), date_range_min: Optional[Union[datetime, date]] = Query(None), date_range_max: Optional[Union[datetime, date]] = Query(None), history_id: Optional[DecodedDatabaseIdField] = Query(None), workflow_id: Optional[DecodedDatabaseIdField] = Query(None), invocation_id: Optional[DecodedDatabaseIdField] = Query(None), order_by: JobIndexSortByEnum = Query(update_time), search: Optional[str] = Query(None), limit: int = Query(500), offset: int = Query(0)) List[Dict[str, Any]][source]
common_problems(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], trans: ProvidesUserContext = Depends(get_trans)) JobInputSummary[source]
resume(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], trans: ProvidesUserContext = Depends(get_trans)) List[JobOutputAssociation][source]
error(*, payload: ReportJobErrorPayload[ReportJobErrorPayload], job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], trans: ProvidesUserContext = Depends(get_trans)) JobErrorSummary[source]
inputs(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], trans: ProvidesUserContext = Depends(get_trans)) List[JobInputAssociation][source]
outputs(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], trans: ProvidesUserContext = Depends(get_trans)) List[JobOutputAssociation][source]
parameters_display_by_job(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], hda_ldda: Optional[galaxy.schema.schema.DatasetSourceType][Optional[DatasetSourceType]] = DatasetSourceType.hda, trans: ProvidesUserContext = Depends(get_trans)) JobDisplayParametersSummary[source]

Resolve parameters as a list for nested display. This API endpoint is unstable and tied heavily to Galaxy’s JS client code, this endpoint will change frequently.

parameters_display_by_dataset(*, dataset_id: DecodedDatabaseIdField[DecodedDatabaseIdField], hda_ldda: DatasetSourceType[DatasetSourceType] = DatasetSourceType.hda, trans: ProvidesUserContext = Depends(get_trans)) JobDisplayParametersSummary[source]

Resolve parameters as a list for nested display. This API endpoint is unstable and tied heavily to Galaxy’s JS client code, this endpoint will change frequently.

metrics_by_job(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], hda_ldda: Optional[galaxy.schema.schema.DatasetSourceType][Optional[DatasetSourceType]] = DatasetSourceType.hda, trans: ProvidesUserContext = Depends(get_trans)) List[Optional[JobMetric]][source]
metrics_by_dataset(*, dataset_id: DecodedDatabaseIdField[DecodedDatabaseIdField], hda_ldda: DatasetSourceType[DatasetSourceType] = DatasetSourceType.hda, trans: ProvidesUserContext = Depends(get_trans)) List[Optional[JobMetric]][source]
destination_params(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], trans: ProvidesUserContext = Depends(get_trans)) JobDestinationParams[source]
search(*, payload: SearchJobsPayload[SearchJobsPayload], trans: ProvidesHistoryContext = Depends(get_trans)) List[EncodedJobDetails][source]

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(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], full: Optional[bool][Optional[bool]] = False, trans: ProvidesUserContext = Depends(get_trans)) Dict[str, Any][source]
delete(*, job_id: DecodedDatabaseIdField[DecodedDatabaseIdField], trans: ProvidesUserContext = Depends(get_trans), payload: Optional[Optional[galaxy.schema.jobs.DeleteJobPayload][Optional[DeleteJobPayload]]] = None) bool[source]
__init__(*args: Any, **kwargs: Any) None
class galaxy.webapps.galaxy.api.jobs.JobController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController, UsesVisualizationMixin

job_manager = GalaxyTypeDepends(_do_resolve)
build_for_rerun(trans: ProvidesHistoryContext, id, **kwd)[source]
  • 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

galaxy.webapps.galaxy.api.libraries module

API operations on a data library.

class galaxy.webapps.galaxy.api.libraries.FastAPILibraries(*, service: LibrariesService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: LibrariesService = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesUserContext = Depends(get_trans), deleted: Optional[bool] = Query(None)) LibrarySummaryList[source]

Returns a list of summary data for all libraries.

index_deleted(*, trans: ProvidesUserContext = Depends(get_trans)) LibrarySummaryList[source]

Returns a list of summary data for all libraries marked as deleted.

show(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) LibrarySummary[source]

Returns summary information about a particular library.

create(*, trans: ProvidesUserContext = Depends(get_trans), payload: CreateLibraryPayload = Body(Ellipsis)) LibrarySummary[source]

Creates a new library and returns its summary information. Currently, only admin users can create libraries.

create_from_store(*, trans: ProvidesUserContext = Depends(get_trans), payload: CreateLibrariesFromStore = Body(Ellipsis)) List[LibrarySummary][source]
update(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), payload: UpdateLibraryPayload = Body(Ellipsis)) LibrarySummary[source]

Updates the information of an existing library.

delete(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), undelete: Optional[bool] = Query(None), payload: Optional[DeleteLibraryPayload] = Body(None)) LibrarySummary[source]

Marks the specified library as deleted (or undeleted). Currently, only admin users can delete or restore libraries.

get_permissions(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), scope: Optional[LibraryPermissionScope] = Query(None), is_library_access: Optional[bool] = Query(None), page: int = Query(1), page_limit: int = Query(10), q: Optional[str] = Query(None)) Union[LibraryCurrentPermissions, LibraryAvailablePermissions][source]

Gets the current or available permissions of a particular library. The results can be paginated and additionally filtered by a query.

set_permissions(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), action: Optional[LibraryPermissionAction] = Query(None), payload: Union[LibraryPermissionsPayload, LegacyLibraryPermissionsPayload] = Body(Ellipsis)) Union[LibraryLegacySummary, LibraryCurrentPermissions][source]

Sets the permissions to access and manipulate a library.

__init__(*args: Any, **kwargs: Any) None

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: StructuredApp, hda_manager: HDAManager)[source]

Bases: BaseGalaxyAPIController, UsesLibraryMixinItems, UsesFormDefinitionsMixin, LibraryActions

__init__(app: StructuredApp, hda_manager: HDAManager)[source]

Initialize an interface for application ‘app’

index(trans, library_id, **kwd)[source]

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

Return a list of library files and folders.

Note

This endpoint is slow for large libraries. Returns all content traversing recursively through all folders.

See also

galaxy.webapps.galaxy.api.FolderContentsController.index for a faster 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(trans, id, library_id, **kwd)[source]

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

create(trans, library_id, payload, **kwd)[source]

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).

To copy an HDCA into a library send create_type of ‘file’ and the HDCA’s encoded id in from_hdca_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) sub-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 (if admin) or user_library_import_dir (if non-admin) 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

    • tag_using_filenames: (optional)

      create tags on datasets using the file’s original name

    • tags: (optional)

      create the given list of tags on datasets

Returns:

a dictionary describing the new item unless from_hdca_id is supplied, in that case a list of such dictionaries is returned.

Return type:

object

update(trans, id, library_id, payload, **kwd)[source]

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

Create an 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

delete(trans, library_id, id, **kwd)[source]

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

galaxy.webapps.galaxy.api.library_datasets module

API operations on the library datasets.

class galaxy.webapps.galaxy.api.library_datasets.LibraryDatasetsController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController, UsesVisualizationMixin, LibraryActions

__init__(app: StructuredApp)[source]

Initialize an interface for application ‘app’

show(trans, id, **kwd)[source]

GET /api/libraries/datasets/{encoded_dataset_id}

Show the details of a library dataset.

Parameters:

id (an encoded id string) – the encoded id of the library dataset to query

Returns:

detailed library dataset information

Return type:

dictionary

show_version(trans, encoded_dataset_id, encoded_ldda_id, **kwd)[source]

GET /api/libraries/datasets/{encoded_dataset_id}/versions/{encoded_ldda_id}

Display a specific version of a library dataset (i.e. ldda).

Parameters:
  • encoded_dataset_id (an encoded id string) – the encoded id of the related library dataset

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

Returns:

dict of ldda’s details

Return type:

dictionary

Raises:

ObjectNotFound

show_roles(trans, encoded_dataset_id, **kwd)[source]

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

Display 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’

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)

Return type:

dictionary

Raises:

InsufficientPermissionsException

update(trans, encoded_dataset_id, payload=None, **kwd)[source]

PATCH /api/libraries/datasets/{encoded_dataset_id}

Update the given library dataset (the latest linked ldda).

Parameters:
  • encoded_dataset_id (an encoded id string) – the encoded id of the library dataset to update

  • payload (dict) – dictionary structure containing:: :param name: new ld’s name, must be longer than 0 :type name: str :param misc_info: new ld’s misc info :type misc_info: str :param file_ext: new ld’s extension, must exist in the Galaxy registry :type file_ext: str :param genome_build: new ld’s genome build :type genome_build: str :param tags: list of dataset tags :type tags: list

Returns:

detailed library dataset information

Return type:

dictionary

update_permissions(trans, encoded_dataset_id, payload=None, **kwd)[source]

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

Set permissions of the given library 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

delete(trans, encoded_dataset_id, **kwd)[source]

DELETE /api/libraries/datasets/{encoded_dataset_id}

Mark the dataset deleted or undeleted.

Parameters:
  • encoded_dataset_id (an encoded id string) – the encoded id of the dataset to change

  • undelete (bool) – flag whether to undeleted instead of deleting

Returns:

dict containing information about the dataset

Return type:

dictionary

load(trans, payload=None, **kwd)[source]

POST /api/libraries/datasets

Load dataset(s) from the given source into the library.

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. 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

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

param tag_using_filenames:

flag whether to generate dataset tags from filenames

type tag_using_filenames:

bool

:type dictionary

Returns:

dict containing information about the created upload job

Return type:

dictionary

Raises:

RequestParameterMissingException, AdminRequiredException, ConfigDoesNotAllowException, RequestParameterInvalidException InsufficientPermissionsException, ObjectNotFound

download(trans, archive_format, **kwd)[source]

GET /api/libraries/datasets/download/{archive_format} POST /api/libraries/datasets/download/{archive_format}

Download requested datasets (identified by encoded IDs) in requested archive_format.

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

Note

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

Parameters:
  • archive_format (string) – string representing requested archive archive_format

  • ld_ids[] (an array) – an array of encoded dataset ids

  • folder_ids[] (an array) – an array of encoded folder ids

Returns:

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

Return type:

file

Raises:

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

galaxy.webapps.galaxy.api.licenses module

class galaxy.webapps.galaxy.api.licenses.FastAPILicenses(*, licenses_manager: LicensesManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

licenses_manager: LicensesManager = GalaxyTypeDepends(_do_resolve)
async index() List[LicenseMetadataModel][source]

Returns an index with all the available [SPDX licenses](https://spdx.org/licenses/).

async get(*, id=Path(Ellipsis)) LicenseMetadataModel[source]

Returns the license metadata associated with the given [SPDX license short ID](https://spdx.github.io/spdx-spec/appendix-I-SPDX-license-list/).

__init__(*args: Any, **kwargs: Any) 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.FastAPIMetrics(*, manager: MetricsManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: MetricsManager = GalaxyTypeDepends(_do_resolve)
create(*, trans: ProvidesUserContext = Depends(get_trans), payload: CreateMetricsPayload = Body(Ellipsis)) Any[source]

Record any metrics sent and return some status object.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.page_revisions module

API for updating Galaxy Pages

class galaxy.webapps.galaxy.api.page_revisions.PageRevisionsController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController

manager: PageManager = GalaxyTypeDepends(_do_resolve)
index(self, trans, page_id, **kwd)[source]
  • 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

create(self, trans, page_id, payload **kwd)[source]
  • 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:: ‘content’ = New content of new page revision

Return type:

dictionary

Returns:

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

galaxy.webapps.galaxy.api.pages module

API for updating Galaxy Pages

class galaxy.webapps.galaxy.api.pages.FastAPIPages(*, service: PagesService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: PagesService = GalaxyTypeDepends(_do_resolve)
async index(*, response: Response, trans: ProvidesUserContext = Depends(get_trans), deleted: bool = Query(False), user_id: Optional[DecodedDatabaseIdField] = Query(None), show_published: bool = Query(True), show_shared: bool = Query(False), sort_by: typing_extensions.Literal[update_time, title, username] = Query(update_time), sort_desc: bool = Query(False), limit: int = Query(100), offset: int = Query(0), search: Optional[str] = Query(None)) PageSummaryList[source]

Get a list with summary information of all Pages available to the user.

create(*, trans: ProvidesUserContext = Depends(get_trans), payload: CreatePagePayload = Body(Ellipsis)) PageSummary[source]

Get a list with details of all Pages available to the user.

async delete(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis))[source]

Marks the Page with the given ID as deleted.

async show_pdf(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis))[source]

Return a PDF document of the last revision of the Page.

This feature may not be available in this Galaxy.

async prepare_pdf(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) AsyncFile[source]

Return a STS download link for this page to be downloaded as a PDF.

This feature may not be available in this Galaxy.

async show(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) PageDetails[source]

Return summary information about a specific Page and the content of the last revision.

sharing(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) SharingStatus[source]

Return the sharing status of the item.

Makes this item accessible by a URL link and return the current sharing status.

Makes this item inaccessible by a URL link and return the current sharing status.

publish(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) SharingStatus[source]

Makes this item publicly available by a URL link and return the current sharing status.

unpublish(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) SharingStatus[source]

Removes this item from the published list and return the current sharing status.

share_with_users(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), payload: ShareWithPayload = Body(Ellipsis)) ShareWithStatus[source]

Shares this item with specific users and return the current sharing status.

set_slug(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis), payload: SetSlugPayload = Body(Ellipsis))[source]

Sets a new slug to access this item by URL. The new slug must be unique.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.plugins module

Plugins resource control over the API.

class galaxy.webapps.galaxy.api.plugins.PluginsController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController

RESTful controller for interactions with plugins.

hda_manager: HDAManager = GalaxyTypeDepends(_do_resolve)
history_manager: HistoryManager = GalaxyTypeDepends(_do_resolve)
index(trans, **kwargs)[source]

GET /api/plugins:

show(trans, id, **kwargs)[source]

GET /api/plugins/{id}:

galaxy.webapps.galaxy.api.provenance module

API operations provenance

class galaxy.webapps.galaxy.api.provenance.BaseProvenanceController(app: StructuredApp)[source]

Bases: BaseGalaxyAPIController

index(trans, **kwd)[source]
show(trans, elem_name, **kwd)[source]
create(trans, tag_name, payload=None, **kwd)[source]
delete(trans, tag_name, **kwd)[source]
class galaxy.webapps.galaxy.api.provenance.HDAProvenanceController(app: StructuredApp)[source]

Bases: BaseProvenanceController

controller_name = 'history_content_provenance'
provenance_item_class = 'HistoryDatasetAssociation'
provenance_item_id = 'history_content_id'
hda_manager: HDAManager = GalaxyTypeDepends(_do_resolve)
class galaxy.webapps.galaxy.api.provenance.LDDAProvenanceController(app: StructuredApp)[source]

Bases: BaseProvenanceController

controller_name = 'ldda_provenance'
provenance_item_class = 'LibraryDatasetDatasetAssociation'
provenance_item_id = 'library_content_id'
hda_manager: HDAManager = GalaxyTypeDepends(_do_resolve)

galaxy.webapps.galaxy.api.quotas module

API operations on Quota objects.

class galaxy.webapps.galaxy.api.quotas.FastAPIQuota(*, service: QuotasService = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

service: QuotasService = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesUserContext = Depends(get_trans)) QuotaSummaryList[source]

Displays a list with information of quotas that are currently active.

index_deleted(*, trans: ProvidesUserContext = Depends(get_trans)) QuotaSummaryList[source]

Displays a list with information of quotas that have been deleted.

show(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) QuotaDetails[source]

Displays details on a particular active quota.

show_deleted(*, trans: ProvidesUserContext = Depends(get_trans), id: DecodedDatabaseIdField = Path(Ellipsis)) QuotaDetails[source]

Displays details on a particular quota that has been deleted.

create(*, payload: CreateQuotaParams, trans: ProvidesUserContext = Depends(get_trans)) CreateQuotaResult[source]

Creates a new quota.

update(*, payload: UpdateQuotaParams, id: DecodedDatabaseIdField = Path(Ellipsis), trans: ProvidesUserContext = Depends(get_trans)) str[source]

Updates an existing quota.

delete(*, id: DecodedDatabaseIdField = Path(Ellipsis), trans: ProvidesUserContext = Depends(get_trans), payload: DeleteQuotaPayload = Body(None)) str[source]

Deletes an existing quota.

undelete(*, id: DecodedDatabaseIdField = Path(Ellipsis), trans: ProvidesUserContext = Depends(get_trans)) str[source]

Restores a previously deleted quota.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.remote_files module

API operations on remote files.

class galaxy.webapps.galaxy.api.remote_files.FastAPIRemoteFiles(*, manager: RemoteFilesManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: RemoteFilesManager = GalaxyTypeDepends(_do_resolve)
async index(*, user_ctx: ProvidesUserContext = Depends(get_trans), target: str = Query(ftpdir), format: Optional[RemoteFilesFormat] = Query(uri), recursive: Optional[bool] = Query(None), disable: Optional[RemoteFilesDisableMode] = Query(None), writeable: Optional[bool] = Query(None)) Union[ListUriResponse, ListJstreeResponse][source]

Lists all remote files available to the user from different sources.

async plugins(*, user_ctx: ProvidesUserContext = Depends(get_trans), browsable_only: Optional[bool] = Query(True), include_kind: Optional[Optional[List[galaxy.files.sources.PluginKind]][Optional[List[PluginKind]]]] = None, exclude_kind: Optional[Optional[List[galaxy.files.sources.PluginKind]][Optional[List[PluginKind]]]] = None) FilesSourcePluginList[source]

Display plugin information for each of the gxfiles:// URI targets available.

async create_entry(*, user_ctx: ProvidesUserContext = Depends(get_trans), payload: CreateEntryPayload = Body(Ellipsis)) CreatedEntryResponse[source]

Creates a new entry on the remote files source.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.roles module

API operations on Role objects.

galaxy.webapps.galaxy.api.roles.role_to_model(role)[source]
class galaxy.webapps.galaxy.api.roles.FastAPIRoles(*, role_manager: RoleManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

role_manager: RoleManager = GalaxyTypeDepends(_do_resolve)
index(*, trans: ProvidesUserContext = Depends(get_trans)) RoleListResponse[source]
show(*, id: DecodedDatabaseIdField, trans: ProvidesUserContext = Depends(get_trans)) RoleModelResponse[source]
create(*, trans: ProvidesUserContext = Depends(get_trans), role_definition_model: RoleDefinitionModel = Body(Ellipsis)) RoleModelResponse[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.sanitize_allow module

API operations allowing clients to retrieve and modify the HTML sanitization allow list.

class galaxy.webapps.galaxy.api.sanitize_allow.SanitizeAllowController(app)[source]

Bases: BaseAPIController

index(trans, **kwd)[source]

GET /api/sanitize_allow Return an object showing the current state of the toolbox and allow list.

create(trans, tool_id, **kwd)[source]

PUT /api/sanitize_allow Add a new tool_id to the allowlist.

delete(trans, tool_id, **kwd)[source]

DELETE /api/sanitize_allow Remove tool_id from allowlist.

galaxy.webapps.galaxy.api.search module

galaxy.webapps.galaxy.api.short_term_storage module

API operations around galaxy.web.short_term_storage infrastructure.

class galaxy.webapps.galaxy.api.short_term_storage.FastAPIShortTermStorage(*, short_term_storage_monitor: ShortTermStorageMonitor = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

short_term_storage_monitor: ShortTermStorageMonitor = GalaxyTypeDepends(_do_resolve)
is_ready(*, storage_request_id: UUID) bool[source]
serve(*, storage_request_id: UUID)[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.tags module

API Controller providing Galaxy Tags

class galaxy.webapps.galaxy.api.tags.FastAPITags(*, manager: TagsManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: TagsManager = GalaxyTypeDepends(_do_resolve)
update(*, trans: ProvidesUserContext = Depends(get_trans), payload: ItemTagsPayload = Body(Ellipsis))[source]

Replaces the tags associated with an item with the new ones specified in the payload.

  • The previous tags will be __deleted__.

  • If no tags are provided in the request body, the currently associated tags will also be __deleted__.

__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.tasks module

API Controller providing experimental access to Celery Task State.

class galaxy.webapps.galaxy.api.tasks.FastAPITasks(*, manager: AsyncTasksManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

manager: AsyncTasksManager = GalaxyTypeDepends(_do_resolve)
state(*, task_id: UUID) TaskState[source]
__init__(*args: Any, **kwargs: Any) None

galaxy.webapps.galaxy.api.tool_data module

class galaxy.webapps.galaxy.api.tool_data.ImportToolDataBundle(*, source: Union[ImportToolDataBundleDatasetSource, ImportToolDataBundleUriSource])[source]

Bases: BaseModel

source: Union[ImportToolDataBundleDatasetSource, ImportToolDataBundleUriSource]
class galaxy.webapps.galaxy.api.tool_data.FastAPIToolData(*, tool_data_manager: ToolDataManager = GalaxyTypeDepends(_do_resolve))[source]

Bases: object

tool_data_manager: ToolDataManager = GalaxyTypeDepends(_do_resolve)
async index() ToolDataEntryList[source]

Get the list of all available data tables.

async create(*, tool_data_file_path=None, import_bundle_model: ImportToolDataBundle = Body(Ellipsis)) AsyncTaskResultSummary[source]
async show(*, table_name: str = Path(Ellipsis)) ToolDataDetails[source]

Get details of a given tool data table.

async reload(*, table_name: str = Path(Ellipsis)) ToolDataDetails[source]

Reloads a data table and return its details.

async show_field(*, table_name: str = Path(Ellipsis), field_name: str = Path(Ellipsis)) ToolDataField[source]

Reloads a data table and return its details.

async download_field_file(*, table_name: str = Path(Ellipsis), field_name: str = Path(Ellipsis), file_name: str = Path(Ellipsis))[source]

Download a file associated with the data table field.

async delete(*, payload: ToolDataItem, table_name: str = Path(Ellipsis)) ToolDataDetails[source]

Removes an item from a data table and reloads it to return its updated details.

__init__(*args: Any, **kwargs: Any)