from typing import (
Optional,
Union,
)
from pydantic import TypeAdapter
from galaxy.datatypes._schema import (
DatatypeConverterList,
DatatypeDetails,
DatatypesCombinedMap,
DatatypesEDAMDetailsDict,
DatatypesMap,
DatatypeVisualizationMapping,
DatatypeVisualizationMappingsList,
)
from galaxy.datatypes.data import Data
from galaxy.datatypes.registry import Registry
[docs]
def view_index(
datatypes_registry: Registry, extension_only: Optional[bool] = True, upload_only: Optional[bool] = True
) -> Union[list[DatatypeDetails], list[str]]:
if extension_only:
if upload_only:
return datatypes_registry.upload_file_formats
else:
return list(datatypes_registry.datatypes_by_extension)
else:
rval = []
for datatype_info_dict in datatypes_registry.datatype_info_dicts:
if upload_only and not datatype_info_dict.get("display_in_upload"):
continue
rval.append(datatype_info_dict)
return rval
[docs]
def view_mapping(datatypes_registry: Registry) -> DatatypesMap:
ext_to_class_name: dict[str, str] = {}
classes = []
for k, v in datatypes_registry.datatypes_by_extension.items():
c = v.__class__
ext_to_class_name[k] = f"{c.__module__}.{c.__name__}"
classes.append(c)
class_to_classes: dict[str, dict[str, bool]] = {}
def visit_bases(types, cls):
for base in cls.__bases__:
if issubclass(base, Data):
types.add(f"{base.__module__}.{base.__name__}")
visit_bases(types, base)
for c in classes:
n = f"{c.__module__}.{c.__name__}"
types = {n}
visit_bases(types, c)
class_to_classes[n] = dict.fromkeys(types, True)
return DatatypesMap(ext_to_class_name=ext_to_class_name, class_to_classes=class_to_classes)
[docs]
def view_types_and_mapping(
datatypes_registry: Registry, extension_only: Optional[bool] = True, upload_only: Optional[bool] = True
) -> DatatypesCombinedMap:
return DatatypesCombinedMap(
datatypes=view_index(datatypes_registry, extension_only, upload_only),
datatypes_mapping=view_mapping(datatypes_registry),
)
[docs]
def view_sniffers(datatypes_registry: Registry) -> list[str]:
rval: list[str] = []
for sniffer_elem in datatypes_registry.sniffer_elems:
datatype = sniffer_elem.get("type")
if datatype is not None:
rval.append(datatype)
return rval
[docs]
def view_converters(datatypes_registry: Registry) -> DatatypeConverterList:
converters = []
for source_type, targets in datatypes_registry.datatype_converters.items():
for target_type in targets:
converters.append(
{
"source": source_type,
"target": target_type,
"tool_id": targets[target_type].id,
}
)
return TypeAdapter(DatatypeConverterList).validate_python(converters)
def _get_edam_details(datatypes_registry: Registry, edam_ids: dict[str, str]) -> dict[str, dict]:
details_dict = {}
for format, edam_iri in edam_ids.items():
edam_details = datatypes_registry.edam.get(edam_iri, {})
details_dict[format] = {
"prefix_IRI": edam_iri,
"label": edam_details.get("label", None),
"definition": edam_details.get("definition", None),
}
return details_dict
[docs]
def view_edam_data(
datatypes_registry: Registry, detailed: Optional[bool] = False
) -> Union[dict[str, str], dict[str, dict[str, str]]]:
if detailed:
return _get_edam_details(datatypes_registry, datatypes_registry.edam_data)
else:
return datatypes_registry.edam_data
[docs]
def view_visualization_mappings(
datatypes_registry: Registry, datatype: Optional[str] = None
) -> DatatypeVisualizationMappingsList:
"""
Get datatype visualization mappings from the registry.
Args:
datatypes_registry: The datatypes registry
datatype: If provided, return only the mapping for this datatype extension
Returns:
A list of datatype visualization mappings
"""
mappings = []
# Get all mappings
all_mappings = datatypes_registry.get_all_visualization_mappings()
# Filter for a specific datatype if requested
if datatype and datatype in all_mappings:
mapping_info = all_mappings[datatype]
mappings.append(
{
"datatype": datatype,
"visualization": mapping_info["visualization"],
}
)
elif not datatype:
for dt, mapping_info in all_mappings.items():
mappings.append(
{
"datatype": dt,
"visualization": mapping_info["visualization"],
}
)
return TypeAdapter(DatatypeVisualizationMappingsList).validate_python(mappings)
[docs]
def get_preferred_visualization(datatypes_registry: Registry, datatype_extension: str) -> Optional[dict[str, str]]:
"""
Get the preferred visualization mapping for a specific datatype extension.
Returns a dictionary with 'visualization' and 'default_params' keys, or None if no mapping exists.
Preferred visualizations are defined inline within each datatype definition in the
datatypes_conf.xml configuration file. These mappings determine which visualization plugin
should be used by default when viewing datasets of a specific type.
If no direct mapping exists for the extension, this method walks the datatype's class
inheritance chain (its MRO) and returns the mapping of the nearest ancestor class that
has one. Datatypes declared with ``subclass="true"`` each get their own class derived
from the parent, so they inherit the parent's mapping but not the mappings of sibling
``subclass="true"`` datatypes of the same parent.
Example configuration:
<datatype extension="bam" type="galaxy.datatypes.binary:Bam" mimetype="application/octet-stream" display_in_upload="true">
<visualization plugin="igv" />
</datatype>
"""
direct_mapping = datatypes_registry.visualization_mappings.get(datatype_extension)
if direct_mapping:
return direct_mapping
current_datatype = datatypes_registry.get_datatype_by_extension(datatype_extension)
if not current_datatype:
return None
mapping_by_class: dict[type, dict[str, str]] = {}
for ext, visualization_mapping in datatypes_registry.visualization_mappings.items():
datatype = datatypes_registry.get_datatype_by_extension(ext)
if datatype:
mapping_by_class.setdefault(type(datatype), visualization_mapping)
for cls in type(current_datatype).__mro__:
if cls in mapping_by_class:
return mapping_by_class[cls]
return None
__all__ = (
"DatatypeConverterList",
"DatatypeDetails",
"DatatypesCombinedMap",
"DatatypesEDAMDetailsDict",
"DatatypesMap",
"DatatypeVisualizationMapping",
"DatatypeVisualizationMappingsList",
"view_index",
"view_mapping",
"view_types_and_mapping",
"view_sniffers",
"view_converters",
"view_edam_formats",
"view_edam_data",
"view_visualization_mappings",
"get_preferred_visualization",
)