galaxy.schema package

class galaxy.schema.BootstrapAdminUser(*, id: int = 0, email: str | None = None, username: str | None = None, preferences: Dict[str, str] = {}, bootstrap_admin_user: bool = True)[source]

Bases: BaseModel

id: int
email: str | None
username: str | None
preferences: Dict[str, str]
bootstrap_admin_user: bool
all_roles() list[source]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'bootstrap_admin_user': FieldInfo(annotation=bool, required=False, default=True), 'email': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=int, required=False, default=0), 'preferences': FieldInfo(annotation=Dict[str, str], required=False, default={}), 'username': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.ValueFilterQueryParams(*, q: List[str] | str | None = None, qv: List[str] | str | None = None)[source]

Bases: BaseModel

Allows filtering/querying elements by value like q=<property>-<operator>&qv=<value>

Multiple q/qv queries can be concatenated.

q: List[str] | str | None
qv: List[str] | str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'q': FieldInfo(annotation=Union[List[str], str, NoneType], required=False, default=None, title='Filter Query', description='Generally a property name to filter by followed by an (often optional) hyphen and operator string.', examples=['create_time-gt']), 'qv': FieldInfo(annotation=Union[List[str], str, NoneType], required=False, default=None, title='Filter Value', description='The value to filter by.', examples=['2015-01-29'])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.PaginationQueryParams(*, offset: int | None[int | None] = 0, limit: int | None[int | None] = None)[source]

Bases: BaseModel

Used to paginate a the request results by limiting and offsetting.

offset: int | None
limit: int | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'limit': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, title='Limit', description='The maximum number of items to return.', metadata=[Ge(ge=1)]), 'offset': FieldInfo(annotation=Union[int, NoneType], required=False, default=0, title='Offset', description='Starts at the beginning skip the first ( offset - 1 ) items and begin returning at the Nth item', metadata=[Ge(ge=0)])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.FilterQueryParams(*, offset: int | None[int | None] = 0, limit: int | None[int | None] = None, q: List[str] | str | None = None, qv: List[str] | str | None = None, order: str | None = None)[source]

Bases: ValueFilterQueryParams, PaginationQueryParams

Contains full filtering options to query elements, paginate and order them.

order: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'limit': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, title='Limit', description='The maximum number of items to return.', metadata=[Ge(ge=1)]), 'offset': FieldInfo(annotation=Union[int, NoneType], required=False, default=0, title='Offset', description='Starts at the beginning skip the first ( offset - 1 ) items and begin returning at the Nth item', metadata=[Ge(ge=0)]), 'order': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Order', description="String containing one of the valid ordering attributes followed (optionally) by '-asc' or '-dsc' for ascending and descending order respectively. Orders can be stacked as a comma-separated list of values.", examples=['name-dsc,create_time']), 'q': FieldInfo(annotation=Union[List[str], str, NoneType], required=False, default=None, title='Filter Query', description='Generally a property name to filter by followed by an (often optional) hyphen and operator string.', examples=['create_time-gt']), 'qv': FieldInfo(annotation=Union[List[str], str, NoneType], required=False, default=None, title='Filter Value', description='The value to filter by.', examples=['2015-01-29'])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.SerializationParams(*, view: str | None = None, keys: List[str] | None = None, default_view: str | None = None)[source]

Bases: BaseModel

Contains common parameters for customizing model serialization.

view: str | None
keys: List[str] | None
default_view: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'default_view': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Default View', description='The item view that will be used in case none was specified.'), 'keys': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, title='Keys', description='List of keys (name of the attributes) that will be returned in addition to the ones included in the `view`.'), 'view': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='View', description='The name of the view used to serialize this item. This will return a predefined set of attributes of the item.', examples=['summary'])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.PdfDocumentType(value)[source]

Bases: str, Enum

An enumeration.

invocation_report = 'invocation_report'
page = 'page'
class galaxy.schema.APIKeyModel(*, key: str, create_time: datetime)[source]

Bases: BaseModel

key: str
create_time: datetime
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'create_time': FieldInfo(annotation=datetime, required=True, title='Create Time', description='The time and date this API key was created.'), 'key': FieldInfo(annotation=str, required=True, title='Key', description='API key to interact with the Galaxy API')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

galaxy.schema.partial_model(include: List[str] | None = None, exclude: List[str] | None = None) Callable[[Type[T]], Type[T]][source]

Decorator to make all model fields optional

Submodules

galaxy.schema.fetch_data module

class galaxy.schema.fetch_data.FetchBaseModel[source]

Bases: Model

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_fields: ClassVar[dict[str, FieldInfo]] = {}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.ElementsFromType(value)[source]

Bases: str, Enum

An enumeration.

archive = 'archive'
bagit = 'bagit'
bagit_archive = 'bagit_archive'
directory = 'directory'
class galaxy.schema.fetch_data.BaseFetchDataTarget(*, auto_decompress: bool = False)[source]

Bases: FetchBaseModel

auto_decompress: bool
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.ItemsFromSrc(value)[source]

Bases: str, Enum

An enumeration.

url = 'url'
files = 'files'
path = 'path'
ftp_import = 'ftp_import'
server_dir = 'server_dir'
class galaxy.schema.fetch_data.Src(value)[source]

Bases: str, Enum

An enumeration.

url = 'url'
pasted = 'pasted'
files = 'files'
path = 'path'
composite = 'composite'
ftp_import = 'ftp_import'
server_dir = 'server_dir'
class galaxy.schema.fetch_data.DestinationType(value)[source]

Bases: str, Enum

An enumeration.

library = 'library'
library_folder = 'library_folder'
hdcas = 'hdcas'
hdas = 'hdas'
class galaxy.schema.fetch_data.HdaDestination(*, type: typing_extensions.Literal[hdas])[source]

Bases: FetchBaseModel

type: typing_extensions.Literal[hdas]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'type': FieldInfo(annotation=Literal['hdas'], required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.HdcaDestination(*, type: typing_extensions.Literal[hdca])[source]

Bases: FetchBaseModel

type: typing_extensions.Literal[hdca]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'type': FieldInfo(annotation=Literal['hdca'], required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.LibraryFolderDestination(*, type: typing_extensions.Literal[library_folder], library_folder_id: int[int])[source]

Bases: FetchBaseModel

type: typing_extensions.Literal[library_folder]
library_folder_id: int[int]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'library_folder_id': FieldInfo(annotation=int, required=True, metadata=[BeforeValidator(func=<function <lambda>>), BeforeValidator(func=<function ensure_valid_id>), PlainSerializer(func=<function <lambda>>, return_type=<class 'str'>, when_used='json'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'type': FieldInfo(annotation=Literal['library_folder'], required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.BaseCollectionTarget(*, auto_decompress: bool = False, destination: HdcaDestination, collection_type: str | None = None, tags: List[str] | None = None, name: str | None = None)[source]

Bases: BaseFetchDataTarget

destination: HdcaDestination
collection_type: str | None
tags: List[str] | None
name: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'destination': FieldInfo(annotation=HdcaDestination, required=True), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.LibraryDestination(*, type: typing_extensions.Literal[library], name: str, description: str | None = None, synopsis: str | None = None)[source]

Bases: FetchBaseModel

type: typing_extensions.Literal[library]
name: str
description: str | None
synopsis: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description for library to create'), 'name': FieldInfo(annotation=str, required=True, description='Must specify a library name'), 'synopsis': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, description='Description for library to create'), 'type': FieldInfo(annotation=Literal['library'], required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.ExtraFiles(*, items_from: str | None = None, src: Src, fuzzy_root: bool | None = True)[source]

Bases: FetchBaseModel

items_from: str | None
src: Src
fuzzy_root: bool | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'fuzzy_root': FieldInfo(annotation=Union[bool, NoneType], required=False, default=True, description='Prevent Galaxy from checking for a single file in a directory and re-interpreting the archive'), 'items_from': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'src': FieldInfo(annotation=Src, required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.BaseDataElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None)[source]

Bases: FetchBaseModel

name: str | int | float | bool[str | int | float | bool] | None
dbkey: str
info: str | None
ext: str
space_to_tab: bool
to_posix_lines: bool
deferred: bool
tags: List[str] | None
created_from_basename: str | None
extra_files: ExtraFiles | None
auto_decompress: bool
items_from: ElementsFromType | None
collection_type: str | None
MD5: str | None
description: str | None
model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.FileDataElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, src: typing_extensions.Literal[files])[source]

Bases: BaseDataElement

src: typing_extensions.Literal[files]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'src': FieldInfo(annotation=Literal['files'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.PastedDataElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, src: typing_extensions.Literal[pasted], paste_content: str | int | float | bool[str | int | float | bool])[source]

Bases: BaseDataElement

src: typing_extensions.Literal[pasted]
paste_content: str | int | float | bool[str | int | float | bool]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'paste_content': FieldInfo(annotation=Union[str, int, float, bool], required=True, description='Content to upload', metadata=[AfterValidator(func=<function <lambda>>)]), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'src': FieldInfo(annotation=Literal['pasted'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.UrlDataElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, src: typing_extensions.Literal[url], url: str)[source]

Bases: BaseDataElement

src: typing_extensions.Literal[url]
url: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'src': FieldInfo(annotation=Literal['url'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False), 'url': FieldInfo(annotation=str, required=True, description='URL to upload')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.ServerDirElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, src: typing_extensions.Literal[server_dir], server_dir: str, link_data_only: bool | None = None)[source]

Bases: BaseDataElement

src: typing_extensions.Literal[server_dir]
server_dir: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'link_data_only': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'server_dir': FieldInfo(annotation=str, required=True), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'src': FieldInfo(annotation=Literal['server_dir'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.FtpImportElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, src: typing_extensions.Literal[ftp_import], ftp_path: str)[source]

Bases: BaseDataElement

src: typing_extensions.Literal[ftp_import]
ftp_path: str
collection_type: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'ftp_path': FieldInfo(annotation=str, required=True), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'src': FieldInfo(annotation=Literal['ftp_import'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.ItemsFromModel(*, src: ItemsFromSrc, path: str | None = None, ftp_path: str | None = None, server_dir: str | None = None, url: str | None = None)[source]

Bases: Model

src: ItemsFromSrc
path: str | None
ftp_path: str | None
server_dir: str | None
url: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'ftp_path': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'path': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'server_dir': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'src': FieldInfo(annotation=ItemsFromSrc, required=True), 'url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.FtpImportTarget(*, auto_decompress: bool = False, destination: HdcaDestination, collection_type: str | None = None, tags: List[str] | None = None, name: str | None = None, src: typing_extensions.Literal[ftp_import], ftp_path: str, elements_from: ElementsFromType | None = None)[source]

Bases: BaseCollectionTarget

src: typing_extensions.Literal[ftp_import]
ftp_path: str
items_from: ElementsFromType | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'destination': FieldInfo(annotation=HdcaDestination, required=True), 'ftp_path': FieldInfo(annotation=str, required=True), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'src': FieldInfo(annotation=Literal['ftp_import'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.PathDataElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, src: typing_extensions.Literal[path], path: str, link_data_only: bool | None = None)[source]

Bases: BaseDataElement

src: typing_extensions.Literal[path]
path: str
items_from: ElementsFromType | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'link_data_only': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'path': FieldInfo(annotation=str, required=True), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'src': FieldInfo(annotation=Literal['path'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.CompositeDataElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, src: typing_extensions.Literal[composite], composite: CompositeItems)[source]

Bases: BaseDataElement

src: typing_extensions.Literal[composite]
composite: CompositeItems
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'composite': FieldInfo(annotation=CompositeItems, required=True), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'src': FieldInfo(annotation=Literal['composite'], required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.CompositeItems(*, elements: List[FileDataElement | PastedDataElement | UrlDataElement | PathDataElement | ServerDirElement | FtpImportElement])[source]

Bases: FetchBaseModel

items: List[FileDataElement | PastedDataElement | UrlDataElement | PathDataElement | ServerDirElement | FtpImportElement]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'items': FieldInfo(annotation=List[Union[galaxy.schema.fetch_data.FileDataElement, galaxy.schema.fetch_data.PastedDataElement, galaxy.schema.fetch_data.UrlDataElement, galaxy.schema.fetch_data.PathDataElement, galaxy.schema.fetch_data.ServerDirElement, galaxy.schema.fetch_data.FtpImportElement]], required=True, alias='elements', alias_priority=2)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.NestedElement(*, name: str | int | float | bool[str | int | float | bool] | None = None, dbkey: str = '?', info: str | None = None, ext: str = 'auto', space_to_tab: bool = False, to_posix_lines: bool = False, deferred: bool = False, tags: List[str] | None = None, created_from_basename: str | None = None, extra_files: ExtraFiles | None = None, auto_decompress: bool = False, elements_from: ElementsFromType | None = None, collection_type: str | None = None, MD5: str | None = None, description: str | None = None, elements: List[FileDataElement | galaxy.schema.fetch_data.PastedDataElement | galaxy.schema.fetch_data.UrlDataElement | galaxy.schema.fetch_data.PathDataElement | galaxy.schema.fetch_data.ServerDirElement | galaxy.schema.fetch_data.FtpImportElement | galaxy.schema.fetch_data.CompositeDataElement[FileDataElement | PastedDataElement | UrlDataElement | PathDataElement | ServerDirElement | FtpImportElement | CompositeDataElement] | NestedElement])[source]

Bases: BaseDataElement

items: List[AnyElement | NestedElement]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'forbid', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'MD5': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'created_from_basename': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'dbkey': FieldInfo(annotation=str, required=False, default='?'), 'deferred': FieldInfo(annotation=bool, required=False, default=False), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ext': FieldInfo(annotation=str, required=False, default='auto'), 'extra_files': FieldInfo(annotation=Union[ExtraFiles, NoneType], required=False, default=None), 'info': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items': FieldInfo(annotation=List[Union[Annotated[Union[galaxy.schema.fetch_data.FileDataElement, galaxy.schema.fetch_data.PastedDataElement, galaxy.schema.fetch_data.UrlDataElement, galaxy.schema.fetch_data.PathDataElement, galaxy.schema.fetch_data.ServerDirElement, galaxy.schema.fetch_data.FtpImportElement, galaxy.schema.fetch_data.CompositeDataElement], FieldInfo(annotation=NoneType, required=True, discriminator='src')], galaxy.schema.fetch_data.NestedElement]], required=True, alias='elements', alias_priority=2), 'items_from': FieldInfo(annotation=Union[ElementsFromType, NoneType], required=False, default=None, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[Annotated[Union[str, int, float, bool], AfterValidator(func=<function <lambda>>)], NoneType], required=False, default=None), 'space_to_tab': FieldInfo(annotation=bool, required=False, default=False), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'to_posix_lines': FieldInfo(annotation=bool, required=False, default=False)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.BaseDataTarget(*, auto_decompress: bool = False, destination: HdaDestination | LibraryFolderDestination | LibraryDestination)[source]

Bases: BaseFetchDataTarget

destination: HdaDestination | LibraryFolderDestination | LibraryDestination
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'destination': FieldInfo(annotation=Union[HdaDestination, LibraryFolderDestination, LibraryDestination], required=True, discriminator='type')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.DataElementsTarget(*, auto_decompress: bool = False, destination: HdaDestination | LibraryFolderDestination | LibraryDestination, elements: List[FileDataElement | galaxy.schema.fetch_data.PastedDataElement | galaxy.schema.fetch_data.UrlDataElement | galaxy.schema.fetch_data.PathDataElement | galaxy.schema.fetch_data.ServerDirElement | galaxy.schema.fetch_data.FtpImportElement | galaxy.schema.fetch_data.CompositeDataElement[FileDataElement | PastedDataElement | UrlDataElement | PathDataElement | ServerDirElement | FtpImportElement | CompositeDataElement] | NestedElement])[source]

Bases: BaseDataTarget

items: List[FileDataElement | galaxy.schema.fetch_data.PastedDataElement | galaxy.schema.fetch_data.UrlDataElement | galaxy.schema.fetch_data.PathDataElement | galaxy.schema.fetch_data.ServerDirElement | galaxy.schema.fetch_data.FtpImportElement | galaxy.schema.fetch_data.CompositeDataElement[FileDataElement | PastedDataElement | UrlDataElement | PathDataElement | ServerDirElement | FtpImportElement | CompositeDataElement] | NestedElement]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'destination': FieldInfo(annotation=Union[HdaDestination, LibraryFolderDestination, LibraryDestination], required=True, discriminator='type'), 'items': FieldInfo(annotation=List[Union[Annotated[Union[galaxy.schema.fetch_data.FileDataElement, galaxy.schema.fetch_data.PastedDataElement, galaxy.schema.fetch_data.UrlDataElement, galaxy.schema.fetch_data.PathDataElement, galaxy.schema.fetch_data.ServerDirElement, galaxy.schema.fetch_data.FtpImportElement, galaxy.schema.fetch_data.CompositeDataElement], FieldInfo(annotation=NoneType, required=True, discriminator='src')], galaxy.schema.fetch_data.NestedElement]], required=True, alias='elements', alias_priority=2)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.DataElementsFromTarget(*, src: ItemsFromSrc, path: str | None = None, ftp_path: str | None = None, server_dir: str | None = None, url: str | None = None, auto_decompress: bool = False, destination: HdaDestination | LibraryFolderDestination | LibraryDestination, elements_from: ElementsFromType)[source]

Bases: BaseDataTarget, ItemsFromModel

items_from: ElementsFromType
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'destination': FieldInfo(annotation=Union[HdaDestination, LibraryFolderDestination, LibraryDestination], required=True, discriminator='type'), 'ftp_path': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=ElementsFromType, required=True, alias='elements_from', alias_priority=2), 'path': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'server_dir': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'src': FieldInfo(annotation=ItemsFromSrc, required=True), 'url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.HdcaDataItemsTarget(*, auto_decompress: bool = False, destination: HdcaDestination, collection_type: str | None = None, tags: List[str] | None = None, name: str | None = None, elements: List[FileDataElement | galaxy.schema.fetch_data.PastedDataElement | galaxy.schema.fetch_data.UrlDataElement | galaxy.schema.fetch_data.PathDataElement | galaxy.schema.fetch_data.ServerDirElement | galaxy.schema.fetch_data.FtpImportElement | galaxy.schema.fetch_data.CompositeDataElement[FileDataElement | PastedDataElement | UrlDataElement | PathDataElement | ServerDirElement | FtpImportElement | CompositeDataElement] | NestedElement])[source]

Bases: BaseCollectionTarget

items: List[FileDataElement | galaxy.schema.fetch_data.PastedDataElement | galaxy.schema.fetch_data.UrlDataElement | galaxy.schema.fetch_data.PathDataElement | galaxy.schema.fetch_data.ServerDirElement | galaxy.schema.fetch_data.FtpImportElement | galaxy.schema.fetch_data.CompositeDataElement[FileDataElement | PastedDataElement | UrlDataElement | PathDataElement | ServerDirElement | FtpImportElement | CompositeDataElement] | NestedElement]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'destination': FieldInfo(annotation=HdcaDestination, required=True), 'items': FieldInfo(annotation=List[Union[Annotated[Union[galaxy.schema.fetch_data.FileDataElement, galaxy.schema.fetch_data.PastedDataElement, galaxy.schema.fetch_data.UrlDataElement, galaxy.schema.fetch_data.PathDataElement, galaxy.schema.fetch_data.ServerDirElement, galaxy.schema.fetch_data.FtpImportElement, galaxy.schema.fetch_data.CompositeDataElement], FieldInfo(annotation=NoneType, required=True, discriminator='src')], galaxy.schema.fetch_data.NestedElement]], required=True, alias='elements', alias_priority=2), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.HdcaDataItemsFromTarget(*, src: ItemsFromSrc, path: str | None = None, ftp_path: str | None = None, server_dir: str | None = None, url: str | None = None, auto_decompress: bool = False, destination: HdcaDestination, collection_type: str | None = None, tags: List[str] | None = None, name: str | None = None, elements_from: ElementsFromType)[source]

Bases: BaseCollectionTarget, ItemsFromModel

items_from: ElementsFromType
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'auto_decompress': FieldInfo(annotation=bool, required=False, default=False, description='Decompress compressed data before sniffing?'), 'collection_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'destination': FieldInfo(annotation=HdcaDestination, required=True), 'ftp_path': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'items_from': FieldInfo(annotation=ElementsFromType, required=True, alias='elements_from', alias_priority=2), 'name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'path': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'server_dir': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'src': FieldInfo(annotation=ItemsFromSrc, required=True), 'tags': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.FilesPayload(*, filename: str, local_filename: str)[source]

Bases: Model

filename: str
local_filename: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'filename': FieldInfo(annotation=str, required=True), 'local_filename': FieldInfo(annotation=str, required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.BaseDataPayload(*, history_id: int[int], **extra_data: Any)[source]

Bases: FetchBaseModel

history_id: int[int]
model_config: ClassVar[ConfigDict] = {'extra': 'allow', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

classmethod targets_string_to_json(v)[source]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_fields: ClassVar[dict[str, FieldInfo]] = {'history_id': FieldInfo(annotation=int, required=True, metadata=[BeforeValidator(func=<function <lambda>>), BeforeValidator(func=<function ensure_valid_id>), PlainSerializer(func=<function <lambda>>, return_type=<class 'str'>, when_used='json'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.FetchDataPayload(*, history_id: int[int], targets: List[DataElementsTarget | HdcaDataItemsTarget | DataElementsFromTarget | HdcaDataItemsFromTarget | FtpImportTarget], **extra_data: Any)[source]

Bases: BaseDataPayload

targets: List[DataElementsTarget | HdcaDataItemsTarget | DataElementsFromTarget | HdcaDataItemsFromTarget | FtpImportTarget]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'allow', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'history_id': FieldInfo(annotation=int, required=True, metadata=[BeforeValidator(func=<function <lambda>>), BeforeValidator(func=<function ensure_valid_id>), PlainSerializer(func=<function <lambda>>, return_type=<class 'str'>, when_used='json'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'targets': FieldInfo(annotation=List[Union[galaxy.schema.fetch_data.DataElementsTarget, galaxy.schema.fetch_data.HdcaDataItemsTarget, galaxy.schema.fetch_data.DataElementsFromTarget, galaxy.schema.fetch_data.HdcaDataItemsFromTarget, galaxy.schema.fetch_data.FtpImportTarget]], required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.fetch_data.FetchDataFormPayload(*, history_id: int[int], targets: List[galaxy.schema.fetch_data.DataElementsTarget | galaxy.schema.fetch_data.HdcaDataItemsTarget | galaxy.schema.fetch_data.DataElementsFromTarget | galaxy.schema.fetch_data.HdcaDataItemsFromTarget | galaxy.schema.fetch_data.FtpImportTarget][List[DataElementsTarget | HdcaDataItemsTarget | DataElementsFromTarget | HdcaDataItemsFromTarget | FtpImportTarget]] | List[DataElementsTarget | HdcaDataItemsTarget | DataElementsFromTarget | HdcaDataItemsFromTarget | FtpImportTarget], **extra_data: Any)[source]

Bases: BaseDataPayload

targets: List[galaxy.schema.fetch_data.DataElementsTarget | galaxy.schema.fetch_data.HdcaDataItemsTarget | galaxy.schema.fetch_data.DataElementsFromTarget | galaxy.schema.fetch_data.HdcaDataItemsFromTarget | galaxy.schema.fetch_data.FtpImportTarget][List[DataElementsTarget | HdcaDataItemsTarget | DataElementsFromTarget | HdcaDataItemsFromTarget | FtpImportTarget]] | List[DataElementsTarget | HdcaDataItemsTarget | DataElementsFromTarget | HdcaDataItemsFromTarget | FtpImportTarget]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'extra': 'allow', 'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'history_id': FieldInfo(annotation=int, required=True, metadata=[BeforeValidator(func=<function <lambda>>), BeforeValidator(func=<function ensure_valid_id>), PlainSerializer(func=<function <lambda>>, return_type=<class 'str'>, when_used='json'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'targets': FieldInfo(annotation=Union[Annotated[List[Union[galaxy.schema.fetch_data.DataElementsTarget, galaxy.schema.fetch_data.HdcaDataItemsTarget, galaxy.schema.fetch_data.DataElementsFromTarget, galaxy.schema.fetch_data.HdcaDataItemsFromTarget, galaxy.schema.fetch_data.FtpImportTarget]], Json], List[Union[galaxy.schema.fetch_data.DataElementsTarget, galaxy.schema.fetch_data.HdcaDataItemsTarget, galaxy.schema.fetch_data.DataElementsFromTarget, galaxy.schema.fetch_data.HdcaDataItemsFromTarget, galaxy.schema.fetch_data.FtpImportTarget]]], required=True)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

galaxy.schema.fields module

class galaxy.schema.fields.Security[source]

Bases: object

security: IdEncodingHelper
galaxy.schema.fields.ensure_valid_id(v: str) str[source]
galaxy.schema.fields.ensure_valid_folder_id(v)[source]
galaxy.schema.fields.literal_to_value(arg)[source]
galaxy.schema.fields.is_optional(field)[source]
galaxy.schema.fields.ModelClassField(default_value)[source]

Represents a database model class name annotated as a constant pydantic Field. :param class_name: The name of the database class. :return: A constant pydantic Field with default annotations for model classes.

galaxy.schema.remote_files module

class galaxy.schema.remote_files.RemoteFilesTarget(value)[source]

Bases: str, Enum

An enumeration.

ftpdir = 'ftpdir'
userdir = 'userdir'
importdir = 'importdir'
class galaxy.schema.remote_files.RemoteFilesFormat(value)[source]

Bases: str, Enum

An enumeration.

flat = 'flat'
jstree = 'jstree'
uri = 'uri'
class galaxy.schema.remote_files.RemoteFilesDisableMode(value)[source]

Bases: str, Enum

An enumeration.

folders = 'folders'
files = 'files'
class galaxy.schema.remote_files.FilesSourceSupports(*, pagination: bool = False, search: bool = False, sorting: bool = False)[source]

Bases: Model

pagination: bool[bool]
search: bool[bool]
sorting: bool[bool]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'pagination': FieldInfo(annotation=bool, required=False, default=False, description='Whether this file source supports server-side pagination.'), 'search': FieldInfo(annotation=bool, required=False, default=False, description='Whether this file source supports server-side search.'), 'sorting': FieldInfo(annotation=bool, required=False, default=False, description='Whether this file source supports server-side sorting.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.FilesSourcePlugin(*, id: str, type: str, label: str, doc: str | None = None, browsable: bool, writable: bool, requires_roles: str | None = None, requires_groups: str | None = None, url: str | None = None, supports: FilesSourceSupports = FilesSourceSupports(pagination=False, search=False, sorting=False))[source]

Bases: Model

id: str
type: str
label: str
doc: str | None
browsable: bool
writable: bool
requires_roles: str | None
requires_groups: str | None
url: str | None
supports: FilesSourceSupports[FilesSourceSupports]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'browsable': FieldInfo(annotation=bool, required=True, title='Browsable', description='Whether this file source plugin can list items.'), 'doc': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Documentation', description='Documentation or extended description for this plugin.', examples=["Galaxy's library import directory"]), 'id': FieldInfo(annotation=str, required=True, title='ID', description='The `FilesSource` plugin identifier', examples=['_import']), 'label': FieldInfo(annotation=str, required=True, title='Label', description='The display label for this plugin.', examples=['Library Import Directory']), 'requires_groups': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Requires groups', description='Only users belonging to the groups specified here can access this files source.'), 'requires_roles': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Requires roles', description='Only users with the roles specified here can access this files source.'), 'supports': FieldInfo(annotation=FilesSourceSupports, required=False, default=FilesSourceSupports(pagination=False, search=False, sorting=False), description='Features supported by this file source.'), 'type': FieldInfo(annotation=str, required=True, title='Type', description='The type of the plugin.', examples=['gximport']), 'url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='URL', description='Optional URL that might be provided by some plugins to link to the remote source.'), 'writable': FieldInfo(annotation=bool, required=True, title='Writeable', description='Whether this files source plugin allows write access.', examples=[False])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.BrowsableFilesSourcePlugin(*, id: str, type: str, label: str, doc: str | None = None, browsable: typing_extensions.Literal[True], writable: bool, requires_roles: str | None = None, requires_groups: str | None = None, url: str | None = None, supports: FilesSourceSupports = FilesSourceSupports(pagination=False, search=False, sorting=False), uri_root: str)[source]

Bases: FilesSourcePlugin

browsable: typing_extensions.Literal[True]
uri_root: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'browsable': FieldInfo(annotation=Literal[True], required=True), 'doc': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Documentation', description='Documentation or extended description for this plugin.', examples=["Galaxy's library import directory"]), 'id': FieldInfo(annotation=str, required=True, title='ID', description='The `FilesSource` plugin identifier', examples=['_import']), 'label': FieldInfo(annotation=str, required=True, title='Label', description='The display label for this plugin.', examples=['Library Import Directory']), 'requires_groups': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Requires groups', description='Only users belonging to the groups specified here can access this files source.'), 'requires_roles': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Requires roles', description='Only users with the roles specified here can access this files source.'), 'supports': FieldInfo(annotation=FilesSourceSupports, required=False, default=FilesSourceSupports(pagination=False, search=False, sorting=False), description='Features supported by this file source.'), 'type': FieldInfo(annotation=str, required=True, title='Type', description='The type of the plugin.', examples=['gximport']), 'uri_root': FieldInfo(annotation=str, required=True, title='URI root', description='The URI root used by this type of plugin.', examples=['gximport://']), 'url': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='URL', description='Optional URL that might be provided by some plugins to link to the remote source.'), 'writable': FieldInfo(annotation=bool, required=True, title='Writeable', description='Whether this files source plugin allows write access.', examples=[False])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.FilesSourcePluginList(root: RootModelRootType = PydanticUndefined)[source]

Bases: RootModel

root: List[BrowsableFilesSourcePlugin | FilesSourcePlugin]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'root': FieldInfo(annotation=List[Union[galaxy.schema.remote_files.BrowsableFilesSourcePlugin, galaxy.schema.remote_files.FilesSourcePlugin]], required=False, default=[], title='List of files source plugins', examples=[{'id': '_import', 'type': 'gximport', 'uri_root': 'gximport://', 'label': 'Library Import Directory', 'doc': "Galaxy's library import directory", 'writable': False, 'browsable': True}])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.RemoteEntry(*, name: str, uri: str, path: str)[source]

Bases: Model

name: str
uri: str
path: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the entry.'), 'path': FieldInfo(annotation=str, required=True, title='Path', description='The path of the entry.'), 'uri': FieldInfo(annotation=str, required=True, title='URI', description='The URI of the entry.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.RemoteDirectory(*, name: str, uri: str, path: str, class_: typing_extensions.Literal[Directory])[source]

Bases: RemoteEntry

class_: typing_extensions.Literal[Directory]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'class_': FieldInfo(annotation=Literal['Directory'], required=True, alias='class', alias_priority=2), 'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the entry.'), 'path': FieldInfo(annotation=str, required=True, title='Path', description='The path of the entry.'), 'uri': FieldInfo(annotation=str, required=True, title='URI', description='The URI of the entry.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.RemoteFile(*, name: str, uri: str, path: str, class_: typing_extensions.Literal[File], size: int, ctime: str)[source]

Bases: RemoteEntry

class_: typing_extensions.Literal[File]
size: int
ctime: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'class_': FieldInfo(annotation=Literal['File'], required=True, alias='class', alias_priority=2), 'ctime': FieldInfo(annotation=str, required=True, title='Creation time', description='The creation time of the file.'), 'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the entry.'), 'path': FieldInfo(annotation=str, required=True, title='Path', description='The path of the entry.'), 'size': FieldInfo(annotation=int, required=True, title='Size', description='The size of the file in bytes.'), 'uri': FieldInfo(annotation=str, required=True, title='URI', description='The URI of the entry.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.ListJstreeResponse(root: RootModelRootType = PydanticUndefined)[source]

Bases: RootModel

root: List[Any]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'root': FieldInfo(annotation=List[Any], required=False, default=[], title='List of files', description='List of files in Jstree format.', json_schema_extra={'deprecated': True})}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.ListUriResponse(root: RootModelRootType = PydanticUndefined)[source]

Bases: RootModel

root: List[RemoteFile | galaxy.schema.remote_files.RemoteDirectory[RemoteFile | RemoteDirectory]]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'root': FieldInfo(annotation=List[Annotated[Union[galaxy.schema.remote_files.RemoteFile, galaxy.schema.remote_files.RemoteDirectory], FieldInfo(annotation=NoneType, required=True, discriminator='class_')]], required=False, default=[], title='List of remote entries', description='List of directories and files.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.CreateEntryPayload(*, target: str, name: str)[source]

Bases: Model

target: str
name: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the entry to create.', examples=['my_new_entry']), 'target': FieldInfo(annotation=str, required=True, title='Target', description='The target file source to create the entry in.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.remote_files.CreatedEntryResponse(*, name: str, uri: str, external_link: str | None = None)[source]

Bases: Model

name: str
uri: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'external_link': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='External link', description='An optional external link to the created entry if available.'), 'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the created entry.', examples=['my_new_entry']), 'uri': FieldInfo(annotation=str, required=True, title='URI', description='The URI of the created entry.', examples=['gxfiles://my_new_entry'])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

galaxy.schema.schema module

This module contains general pydantic models and common schema field annotations for them.

class galaxy.schema.schema.DatasetState(value)[source]

Bases: str, Enum

An enumeration.

NEW = 'new'
UPLOAD = 'upload'
QUEUED = 'queued'
RUNNING = 'running'
OK = 'ok'
EMPTY = 'empty'
ERROR = 'error'
PAUSED = 'paused'
SETTING_METADATA = 'setting_metadata'
FAILED_METADATA = 'failed_metadata'
DEFERRED = 'deferred'
DISCARDED = 'discarded'
classmethod values()[source]
class galaxy.schema.schema.JobState(value)[source]

Bases: str, Enum

An enumeration.

NEW = 'new'
RESUBMITTED = 'resubmitted'
UPLOAD = 'upload'
WAITING = 'waiting'
QUEUED = 'queued'
RUNNING = 'running'
OK = 'ok'
ERROR = 'error'
FAILED = 'failed'
PAUSED = 'paused'
DELETING = 'deleting'
DELETED = 'deleted'
STOPPING = 'stop'
STOPPED = 'stopped'
SKIPPED = 'skipped'
class galaxy.schema.schema.DatasetCollectionPopulatedState(value)[source]

Bases: str, Enum

An enumeration.

NEW = 'new'
OK = 'ok'
FAILED = 'failed'
class galaxy.schema.schema.HashFunctionNames(value)[source]

Bases: str, Enum

Hash function names that can be used to generate checksums for datasets.

md5 = 'MD5'
sha1 = 'SHA-1'
sha256 = 'SHA-256'
sha512 = 'SHA-512'
class galaxy.schema.schema.Model[source]

Bases: BaseModel

Base model definition with common configuration used by all derived models.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_fields: ClassVar[dict[str, FieldInfo]] = {}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.RequireOneSetOption[source]

Bases: Model

check_some_ids_passed()[source]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.BaseUserModel(*, id: str[str], username: str, email: str, deleted: bool)[source]

Bases: Model

id: str[str]
username: str
email: str
deleted: bool
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'deleted': FieldInfo(annotation=bool, required=True, title='Deleted', description=' User is deleted'), 'email': FieldInfo(annotation=str, required=True, title='Email', description='Email of the user'), 'id': FieldInfo(annotation=str, required=True, title='ID', description='Encoded ID of the user', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'username': FieldInfo(annotation=str, required=True, title='user_name', description='The name of the user.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.WithModelClass[source]

Bases: object

model_class: str
classmethod set_default(data)[source]
class galaxy.schema.schema.UserModel(*, model_class: typing_extensions.Literal[User], id: str[str], username: str, email: str, deleted: bool, active: bool, last_password_change: datetime | None)[source]

Bases: BaseUserModel, WithModelClass

User in a transaction context.

active: bool
model_class: typing_extensions.Literal[User]
last_password_change: datetime | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'active': FieldInfo(annotation=bool, required=True, title='Active', description='User is active'), 'deleted': FieldInfo(annotation=bool, required=True, title='Deleted', description=' User is deleted'), 'email': FieldInfo(annotation=str, required=True, title='Email', description='Email of the user'), 'id': FieldInfo(annotation=str, required=True, title='ID', description='Encoded ID of the user', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'last_password_change': FieldInfo(annotation=Union[datetime, NoneType], required=True, title='Last password change', description=''), 'model_class': FieldInfo(annotation=Literal['User'], required=True, title='Model class', description='The name of the database model class.', json_schema_extra={'const': 'User', 'type': 'string'}), 'username': FieldInfo(annotation=str, required=True, title='user_name', description='The name of the user.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.LimitedUserModel(*, id: str[str], username: str | None = None, email: str | None = None)[source]

Bases: Model

This is used when config options (expose_user_name and expose_user_email) are in place.

id: str[str]
username: str | None
email: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'email': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'id': FieldInfo(annotation=str, required=True, title='ID', description='Encoded ID of the user', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'username': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.DiskUsageUserModel(*, total_disk_usage: float, nice_total_disk_usage: str)[source]

Bases: Model

total_disk_usage: float
nice_total_disk_usage: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'nice_total_disk_usage': FieldInfo(annotation=str, required=True, title='Nice total disc usage', description='Size of all non-purged, unique datasets of the user in a nice format.'), 'total_disk_usage': FieldInfo(annotation=float, required=True, title='Total disk usage', description='Size of all non-purged, unique datasets of the user in bytes.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.CreatedUserModel(*, model_class: typing_extensions.Literal[User], total_disk_usage: float, nice_total_disk_usage: str, id: str[str], username: str, email: str, deleted: bool, active: bool, last_password_change: datetime | None, preferred_object_store_id: str | None = None)[source]

Bases: UserModel, DiskUsageUserModel

preferred_object_store_id: str | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'active': FieldInfo(annotation=bool, required=True, title='Active', description='User is active'), 'deleted': FieldInfo(annotation=bool, required=True, title='Deleted', description=' User is deleted'), 'email': FieldInfo(annotation=str, required=True, title='Email', description='Email of the user'), 'id': FieldInfo(annotation=str, required=True, title='ID', description='Encoded ID of the user', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'last_password_change': FieldInfo(annotation=Union[datetime, NoneType], required=True, title='Last password change', description=''), 'model_class': FieldInfo(annotation=Literal['User'], required=True, title='Model class', description='The name of the database model class.', json_schema_extra={'const': 'User', 'type': 'string'}), 'nice_total_disk_usage': FieldInfo(annotation=str, required=True, title='Nice total disc usage', description='Size of all non-purged, unique datasets of the user in a nice format.'), 'preferred_object_store_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Preferred Object Store ID', description='The ID of the object store that should be used to store new datasets in this history.'), 'total_disk_usage': FieldInfo(annotation=float, required=True, title='Total disk usage', description='Size of all non-purged, unique datasets of the user in bytes.'), 'username': FieldInfo(annotation=str, required=True, title='user_name', description='The name of the user.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.AnonUserModel(*, total_disk_usage: float, nice_total_disk_usage: str, quota_percent: Any = None)[source]

Bases: DiskUsageUserModel

quota_percent: Any
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'nice_total_disk_usage': FieldInfo(annotation=str, required=True, title='Nice total disc usage', description='Size of all non-purged, unique datasets of the user in a nice format.'), 'quota_percent': FieldInfo(annotation=Any, required=False, default=None, title='Quota percent', description='Percentage of the storage quota applicable to the user.'), 'total_disk_usage': FieldInfo(annotation=float, required=True, title='Total disk usage', description='Size of all non-purged, unique datasets of the user in bytes.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.DetailedUserModel(*, total_disk_usage: float, nice_total_disk_usage: str, quota_percent: Any = None, id: str[str], username: str, email: str, deleted: bool, is_admin: bool, purged: bool, preferences: Dict[Any, Any], preferred_object_store_id: str | None = None, quota: str, quota_bytes: Any, tags_used: List[str])[source]

Bases: BaseUserModel, AnonUserModel

is_admin: bool
purged: bool
preferences: Dict[Any, Any]
preferred_object_store_id: str | None
quota: str
quota_bytes: Any
tags_used: List[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'deleted': FieldInfo(annotation=bool, required=True, title='Deleted', description=' User is deleted'), 'email': FieldInfo(annotation=str, required=True, title='Email', description='Email of the user'), 'id': FieldInfo(annotation=str, required=True, title='ID', description='Encoded ID of the user', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'is_admin': FieldInfo(annotation=bool, required=True, title='Is admin', description='User is admin'), 'nice_total_disk_usage': FieldInfo(annotation=str, required=True, title='Nice total disc usage', description='Size of all non-purged, unique datasets of the user in a nice format.'), 'preferences': FieldInfo(annotation=Dict[Any, Any], required=True, title='Preferences', description='Preferences of the user'), 'preferred_object_store_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Preferred Object Store ID', description='The ID of the object store that should be used to store new datasets in this history.'), 'purged': FieldInfo(annotation=bool, required=True, title='Purged', description='User is purged'), 'quota': FieldInfo(annotation=str, required=True, title='Quota', description='Quota applicable to the user'), 'quota_bytes': FieldInfo(annotation=Any, required=True, title='Quota in bytes', description='Quota applicable to the user in bytes.'), 'quota_percent': FieldInfo(annotation=Any, required=False, default=None, title='Quota percent', description='Percentage of the storage quota applicable to the user.'), 'tags_used': FieldInfo(annotation=List[str], required=True, title='Tags used', description='Tags used by the user'), 'total_disk_usage': FieldInfo(annotation=float, required=True, title='Total disk usage', description='Size of all non-purged, unique datasets of the user in bytes.'), 'username': FieldInfo(annotation=str, required=True, title='user_name', description='The name of the user.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.UserCreationPayload(*, password: str, email: str, username: str)[source]

Bases: Model

password: str
email: str
username: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'email': FieldInfo(annotation=str, required=True, title='Email', description='Email of the user'), 'password': FieldInfo(annotation=str, required=True, title='user_password', description='The password of the user.'), 'username': FieldInfo(annotation=str, required=True, title='user_name', description='The name of the user.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.RemoteUserCreationPayload(*, remote_user_email: str)[source]

Bases: Model

remote_user_email: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'remote_user_email': FieldInfo(annotation=str, required=True, title='Email', description='Email of the user')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.UserDeletionPayload(*, purge: bool = False)[source]

Bases: Model

purge: bool
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'purge': FieldInfo(annotation=bool, required=False, default=False, title='Purge user', description='Purge the user. Deprecated, please use the `purge` query parameter instead.', json_schema_extra={'deprecated': True})}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.FavoriteObject(*, object_id: str)[source]

Bases: Model

object_id: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'object_id': FieldInfo(annotation=str, required=True, title='Object ID', description='The id of an object the user wants to favorite.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.FavoriteObjectsSummary(*, tools: List[str])[source]

Bases: Model

tools: List[str]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'tools': FieldInfo(annotation=List[str], required=True, title='Favorite tools', description='The name of the tools the user favored.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.FavoriteObjectType(value)[source]

Bases: str, Enum

An enumeration.

tools = 'tools'
class galaxy.schema.schema.DeletedCustomBuild(*, message: str)[source]

Bases: Model

message: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'message': FieldInfo(annotation=str, required=True, title='Deletion message', description='Confirmation of the custom build deletion.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.CustomBuildBaseModel(*, name: str)[source]

Bases: Model

name: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the custom build.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.CustomBuildLenType(value)[source]

Bases: str, Enum

An enumeration.

file = 'file'
fasta = 'fasta'
text = 'text'
class galaxy.schema.schema.CustomBuildCreationPayload(*, name: str, len_type: CustomBuildLenType, len_value: str)[source]

Bases: CustomBuildBaseModel

len_type: CustomBuildLenType
len_value: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'len_type': FieldInfo(annotation=CustomBuildLenType, required=True, alias='len|type', alias_priority=2, title='Length type', description='The type of the len file.'), 'len_value': FieldInfo(annotation=str, required=True, alias='len|value', alias_priority=2, title='Length value', description='The content of the length file.'), 'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the custom build.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.CreatedCustomBuild(*, name: str, len: str[str], count: str | None = None, fasta: str[str] | None = None, linecount: str[str] | None = None)[source]

Bases: CustomBuildBaseModel

len: str[str]
count: str | None
fasta: str[str] | None
linecount: str[str] | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'count': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Count', description='The number of chromosomes/contigs.'), 'fasta': FieldInfo(annotation=Union[Annotated[str, BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')], NoneType], required=False, default=None, title='Fasta', description='The primary id of the fasta file from a history.'), 'len': FieldInfo(annotation=str, required=True, title='Length', description='The primary id of the len file.', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'linecount': FieldInfo(annotation=Union[Annotated[str, BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')], NoneType], required=False, default=None, title='Line count', description='The primary id of a linecount dataset.'), 'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the custom build.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.CustomBuildModel(*, name: str, len: str[str], count: str | None = None, fasta: str[str] | None = None, linecount: str[str] | None = None, id: str)[source]

Bases: CreatedCustomBuild

id: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'count': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Count', description='The number of chromosomes/contigs.'), 'fasta': FieldInfo(annotation=Union[Annotated[str, BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')], NoneType], required=False, default=None, title='Fasta', description='The primary id of the fasta file from a history.'), 'id': FieldInfo(annotation=str, required=True, title='ID', description='The ID of the custom build.'), 'len': FieldInfo(annotation=str, required=True, title='Length', description='The primary id of the len file.', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'linecount': FieldInfo(annotation=Union[Annotated[str, BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')], NoneType], required=False, default=None, title='Line count', description='The primary id of a linecount dataset.'), 'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the custom build.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.CustomBuildsCollection(root: RootModelRootType = PydanticUndefined)[source]

Bases: RootModel

root: List[CustomBuildModel]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'root': FieldInfo(annotation=List[galaxy.schema.schema.CustomBuildModel], required=True, title='Custom builds collection', description='The custom builds associated with the user.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.GroupModel(*, model_class: typing_extensions.Literal[Group], id: int[int], name: str)[source]

Bases: Model, WithModelClass

User group model

model_class: typing_extensions.Literal[Group]
id: int[int]
name: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'id': FieldInfo(annotation=int, required=True, title='ID', description='Encoded group ID', metadata=[BeforeValidator(func=<function <lambda>>), BeforeValidator(func=<function ensure_valid_id>), PlainSerializer(func=<function <lambda>>, return_type=<class 'str'>, when_used='json'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'model_class': FieldInfo(annotation=Literal['Group'], required=True, title='Model class', description='The name of the database model class.', json_schema_extra={'const': 'Group', 'type': 'string'}), 'name': FieldInfo(annotation=str, required=True, title='Name', description='The name of the group.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.JobSourceType(value)[source]

Bases: str, Enum

Available types of job sources (model classes) that produce dataset collections.

Job = 'Job'
ImplicitCollectionJobs = 'ImplicitCollectionJobs'
WorkflowInvocation = 'WorkflowInvocation'
class galaxy.schema.schema.HistoryContentType(value)[source]

Bases: str, Enum

Available types of History contents.

dataset = 'dataset'
dataset_collection = 'dataset_collection'
class galaxy.schema.schema.HistoryImportArchiveSourceType(value)[source]

Bases: str, Enum

Available types of History archive sources.

url = 'url'
file = 'file'
class galaxy.schema.schema.DCEType(value)[source]

Bases: str, Enum

Available types of dataset collection elements.

hda = 'hda'
dataset_collection = 'dataset_collection'
class galaxy.schema.schema.DatasetSourceType(value)[source]

Bases: str, Enum

An enumeration.

hda = 'hda'
ldda = 'ldda'
class galaxy.schema.schema.DataItemSourceType(value)[source]

Bases: str, Enum

An enumeration.

hda = 'hda'
ldda = 'ldda'
hdca = 'hdca'
dce = 'dce'
dc = 'dc'
class galaxy.schema.schema.ColletionSourceType(value)[source]

Bases: str, Enum

An enumeration.

hda = 'hda'
ldda = 'ldda'
hdca = 'hdca'
new_collection = 'new_collection'
class galaxy.schema.schema.HistoryContentSource(value)[source]

Bases: str, Enum

An enumeration.

hda = 'hda'
hdca = 'hdca'
library = 'library'
library_folder = 'library_folder'
new_collection = 'new_collection'
class galaxy.schema.schema.TagCollection(root: RootModelRootType = PydanticUndefined)[source]

Bases: RootModel

Represents the collection of tags associated with an item.

root: List[str[str]]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'root': FieldInfo(annotation=List[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[_PydanticGeneralMetadata(pattern='^([^\\s.:])+(\\.[^\\s.:]+)*(:\\S+)?$')])]], required=True, title='Tags', description='The collection of tags associated with an item.', examples=['COVID-19', '#myFancyTag', 'covid19.galaxyproject.org'])}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.MetadataFile(*, file_type: str, download_url: str)[source]

Bases: Model

Metadata file associated with a dataset.

file_type: str
download_url: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'download_url': FieldInfo(annotation=str, required=True, title='Download URL', description='The URL to download this item from the server.'), 'file_type': FieldInfo(annotation=str, required=True, title='File Type', description='TODO')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.DatasetPermissions(*, manage: List[int[int]] = [], access: List[int[int]] = [])[source]

Bases: Model

Role-based permissions for accessing and managing a dataset.

manage: List[int[int]]
access: List[int[int]]
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'access': FieldInfo(annotation=List[Annotated[int, BeforeValidator(func=<function <lambda>>), BeforeValidator(func=<function ensure_valid_id>), PlainSerializer(func=<function <lambda>>, return_type=<class 'str'>, when_used='json'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]], required=False, default=[], title='Access', description='The set of roles (encoded IDs) that can access this dataset.'), 'manage': FieldInfo(annotation=List[Annotated[int, BeforeValidator(func=<function <lambda>>), BeforeValidator(func=<function ensure_valid_id>), PlainSerializer(func=<function <lambda>>, return_type=<class 'str'>, when_used='json'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]], required=False, default=[], title='Management', description='The set of roles (encoded IDs) that can manage this dataset.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

Bases: Model

Represents some text with an Hyperlink.

target: str
href: str[str]
text: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'href': FieldInfo(annotation=str, required=True, title='Href', description='The URL of the linked document.'), 'target': FieldInfo(annotation=str, required=True, title='Target', description='Specifies where to open the linked document.', examples=['_blank']), 'text': FieldInfo(annotation=str, required=True, title='Text', description='The text placeholder for the link.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.DisplayApp(*, label: str, links: List[Hyperlink])[source]

Bases: Model

Basic linked information about an application that can display certain datatypes.

label: str
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'label': FieldInfo(annotation=str, required=True, title='Label', description='The label or title of the Display Application.'), 'links': FieldInfo(annotation=List[galaxy.schema.schema.Hyperlink], required=True, title='Links', description='The collection of link details for this Display Application.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.Visualization[source]

Bases: Model

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_fields: ClassVar[dict[str, FieldInfo]] = {}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.HistoryItemBase(*, id: str[str], name: str | None, history_id: str[str], hid: int, deleted: bool, visible: bool)[source]

Bases: Model

Basic information provided by items contained in a History.

id: str[str]
name: str | None
history_id: str[str]
hid: int
deleted: bool
visible: bool
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'deleted': FieldInfo(annotation=bool, required=True, title='Deleted', description='Whether this item is marked as deleted.'), 'hid': FieldInfo(annotation=int, required=True, title='HID', description='The index position of this item in the History.'), 'history_id': FieldInfo(annotation=str, required=True, title='History ID', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'id': FieldInfo(annotation=str, required=True, metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'name': FieldInfo(annotation=Union[str, NoneType], required=True, title='Name', description='The name of the item.'), 'visible': FieldInfo(annotation=bool, required=True, title='Visible', description='Whether this item is visible or hidden to the user by default.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.HistoryItemCommon(*, id: str[str], name: str | None, history_id: str[str], hid: int, deleted: bool, visible: bool, type_id: str | None = None, type: str, create_time: datetime | None, update_time: datetime | None, url: str, tags: TagCollection)[source]

Bases: HistoryItemBase

Common information provided by items contained in a History.

type_id: str | None
type: str
create_time: datetime | None
update_time: datetime | None
url: str[str]
tags: TagCollection
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'create_time': FieldInfo(annotation=Union[datetime, NoneType], required=True, title='Create Time', description='The time and date this item was created.'), 'deleted': FieldInfo(annotation=bool, required=True, title='Deleted', description='Whether this item is marked as deleted.'), 'hid': FieldInfo(annotation=int, required=True, title='HID', description='The index position of this item in the History.'), 'history_id': FieldInfo(annotation=str, required=True, title='History ID', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'id': FieldInfo(annotation=str, required=True, metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'name': FieldInfo(annotation=Union[str, NoneType], required=True, title='Name', description='The name of the item.'), 'tags': FieldInfo(annotation=TagCollection, required=True), 'type': FieldInfo(annotation=str, required=True, title='Type', description='The type of this item.'), 'type_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Type - ID', description='The type and the encoded ID of this item. Used for caching.', examples=['dataset-616e371b2cc6c62e']), 'update_time': FieldInfo(annotation=Union[datetime, NoneType], required=True, title='Update Time', description='The last time and date this item was updated.'), 'url': FieldInfo(annotation=str, required=True, title='URL', description='The relative URL to access this item.', json_schema_extra={'deprecated': True}), 'visible': FieldInfo(annotation=bool, required=True, title='Visible', description='Whether this item is visible or hidden to the user by default.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.HDACommon(*, id: str[str], name: str | None, history_id: str[str], hid: int, deleted: bool, visible: bool, type_id: str | None = None, type: str, create_time: datetime | None, update_time: datetime | None, url: str, tags: TagCollection, history_content_type: typing_extensions.Literal[dataset], copied_from_ldda_id: str[str] | None = None)[source]

Bases: HistoryItemCommon

history_content_type: typing_extensions.Literal[dataset][typing_extensions.Literal[dataset]]
copied_from_ldda_id: str[str] | None
model_computed_fields: ClassVar[dict[str, ComputedFieldInfo]] = {}

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {'populate_by_name': True, 'protected_namespaces': (), 'use_enum_values': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_fields: ClassVar[dict[str, FieldInfo]] = {'copied_from_ldda_id': FieldInfo(annotation=Union[Annotated[str, BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')], NoneType], required=False, default=None), 'create_time': FieldInfo(annotation=Union[datetime, NoneType], required=True, title='Create Time', description='The time and date this item was created.'), 'deleted': FieldInfo(annotation=bool, required=True, title='Deleted', description='Whether this item is marked as deleted.'), 'hid': FieldInfo(annotation=int, required=True, title='HID', description='The index position of this item in the History.'), 'history_content_type': FieldInfo(annotation=Literal['dataset'], required=True, title='History Content Type', description='This is always `dataset` for datasets.'), 'history_id': FieldInfo(annotation=str, required=True, title='History ID', metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'id': FieldInfo(annotation=str, required=True, metadata=[BeforeValidator(func=<function <lambda>>), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='serialization'), WithJsonSchema(json_schema={'type': 'string', 'example': '0123456789ABCDEF', 'pattern': '[0-9a-fA-F]+', 'minLength': 16}, mode='validation')]), 'name': FieldInfo(annotation=Union[str, NoneType], required=True, title='Name', description='The name of the item.'), 'tags': FieldInfo(annotation=TagCollection, required=True), 'type': FieldInfo(annotation=str, required=True, title='Type', description='The type of this item.'), 'type_id': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, title='Type - ID', description='The type and the encoded ID of this item. Used for caching.', examples=['dataset-616e371b2cc6c62e']), 'update_time': FieldInfo(annotation=Union[datetime, NoneType], required=True, title='Update Time', description='The last time and date this item was updated.'), 'url': FieldInfo(annotation=str, required=True, title='URL', description='The relative URL to access this item.', json_schema_extra={'deprecated': True}), 'visible': FieldInfo(annotation=bool, required=True, title='Visible', description='Whether this item is visible or hidden to the user by default.')}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

class galaxy.schema.schema.HDASummary(*, id: str[str], name: str | None, history_id: str[str], hid: int, deleted: bool, visible: bool, type_id: str | Non