Source code for galaxy.tool_util.toolbox.panel

from abc import abstractmethod
from enum import Enum
from typing import (
    Dict,
    Optional,
    Tuple,
)

from galaxy.util.dictifiable import Dictifiable
from galaxy.util.odict import odict
from .parser import ensure_tool_conf_item


[docs]class panel_item_types(str, Enum): TOOL = "TOOL" WORKFLOW = "WORKFLOW" SECTION = "SECTION" LABEL = "LABEL"
[docs]class HasPanelItems: """ """
[docs] @abstractmethod def panel_items(self): """Return an ordered dictionary-like object describing tool panel items (such as workflows, tools, labels, and sections). """
[docs] def panel_items_iter(self): """Iterate through panel items each represented as a tuple of (panel_key, panel_type, panel_content). """ for panel_key, panel_value in self.panel_items().items(): if panel_value is None: continue panel_type = panel_item_types.SECTION if panel_key.startswith("tool_"): panel_type = panel_item_types.TOOL elif panel_key.startswith("label_"): panel_type = panel_item_types.LABEL elif panel_key.startswith("workflow_"): panel_type = panel_item_types.WORKFLOW yield (panel_key, panel_type, panel_value)
[docs]class ToolSection(Dictifiable, HasPanelItems): """ A group of tools with similar type/purpose that will be displayed as a group in the user interface. """ dict_collection_visible_keys = ["id", "name", "version", "description", "links"]
[docs] def __init__(self, item=None): """Build a ToolSection from an ElementTree element or a dictionary.""" if item is None: item = dict() self.name = item.get("name") or "" self.id = item.get("id") or "" self.version = item.get("version") or "" self.description = item.get("description") or None self.links = item.get("links") or None self.elems = ToolPanelElements()
[docs] def copy(self): copy = ToolSection() copy.name = self.name copy.id = self.id copy.version = self.version copy.description = self.description copy.links = self.links copy.elems.update(self.elems) return copy
[docs] def to_dict(self, trans, link_details=False, tool_help=False, toolbox=None): """Return a dict that includes section's attributes.""" section_dict = super().to_dict() section_elts = [] kwargs = dict(trans=trans, link_details=link_details, tool_help=tool_help) for elt in self.elems.values(): if hasattr(elt, "tool_type") and toolbox: section_elts.append(toolbox.get_tool_to_dict(trans, elt, tool_help=tool_help)) else: section_elts.append(elt.to_dict(**kwargs)) section_dict["elems"] = section_elts return section_dict
[docs] def panel_items(self): return self.elems
[docs]class ToolSectionLabel(Dictifiable): """ A label for a set of tools that can be displayed above groups of tools and sections in the user interface """ dict_collection_visible_keys = ["id", "text", "version", "description", "links"]
[docs] def __init__(self, item): """Build a ToolSectionLabel from an ElementTree element or a dictionary. """ item = ensure_tool_conf_item(item) self.text = item.get("text") self.id = item.get("id") self.version = item.get("version") or "" self.description = item.get("description") or None self.links = item.get("links", None)
[docs] def to_dict(self, **kwds): return super().to_dict()
[docs]class ToolPanelElements(odict, HasPanelItems): """Represents an ordered dictionary of tool entries - abstraction used both by tool panel itself (normal and integrated) and its sections. """ _section_by_tool: Dict[str, Tuple[str, str]] = {}
[docs] def record_section_for_tool_id(self, tool_id: str, key: str, val: str): self._section_by_tool[tool_id] = (key, val)
[docs] def get_section_for_tool_id(self, tool_id: str) -> Tuple[Optional[str], Optional[str]]: if tool_id in self._section_by_tool: return self._section_by_tool[tool_id] return (None, None)
[docs] def replace_tool_for_id(self, tool_id: str, new_tool) -> None: tool_key = f"tool_{tool_id}" for key, val in self.items(): if key == tool_key: self[key] = new_tool break elif key.startswith("section"): if tool_key in val.elems: self[key].elems[tool_key] = new_tool break
[docs] def get_or_create_section( self, sec_id: str, sec_nm: str, description: Optional[str] = None, links: Optional[Dict[str, str]] = None ) -> ToolSection: if sec_id not in self: section = ToolSection( {"id": sec_id, "name": sec_nm, "description": description, "version": "", "links": links} ) self[sec_id] = section else: section = self[sec_id] return section
[docs] def remove_tool(self, tool_id: str) -> None: tool_key = f"tool_{tool_id}" for key, val in self.items(): if key == tool_key: del self[key] break elif key.startswith("section"): if tool_key in val.elems: del self[key].elems[tool_key] break
[docs] def update_or_append(self, index: int, key: str, value) -> None: if key in self or index is None: self[key] = value else: self.insert(index, key, value)
[docs] def get_label(self, label: str) -> Optional[ToolSection]: for element in self.values(): if isinstance(element, ToolSection) and element.name == label: return element return None
[docs] def has_tool_with_id(self, tool_id: str) -> bool: key = f"tool_{tool_id}" return key in self
[docs] def replace_tool(self, previous_tool_id: str, new_tool_id: str, tool) -> None: previous_key = f"tool_{previous_tool_id}" new_key = f"tool_{new_tool_id}" index = self.keys().index(previous_key) del self[previous_key] self.insert(index, new_key, tool)
[docs] def index_of_tool_id(self, tool_id: str) -> Optional[int]: query_key = f"tool_{tool_id}" for index, target_key in enumerate(self.keys()): if query_key == target_key: return index return None
[docs] def insert_tool(self, index: int, tool) -> None: key = f"tool_{tool.id}" self.insert(index, key, tool)
[docs] def get_tool_with_id(self, tool_id: str): key = f"tool_{tool_id}" return self[key]
[docs] def append_tool(self, tool) -> None: key = f"tool_{tool.id}" self[key] = tool
[docs] def stub_tool(self, key: str) -> None: key = f"tool_{key}" self[key] = None
[docs] def stub_workflow(self, key: str) -> None: key = f"workflow_{key}" self[key] = None
[docs] def stub_label(self, key: str) -> None: key = f"label_{key}" self[key] = None
[docs] def append_section(self, key: str, section: ToolSection) -> None: self[key] = section
[docs] def panel_items(self): return self
[docs] def walk_sections(self): for key, item in self.items(): if isinstance(item, ToolSection): yield (key, item)
[docs] def closest_section(self, target_section_id: Optional[str], target_section_name: Optional[str]): for (section_id, section) in self.walk_sections(): if section_id == target_section_id: return section for (_, section) in self.walk_sections(): if section.name == target_section_name: return section return None
[docs] def apply_filter(self, f): to_remove = [] for key, item in self.items(): if not f(key, item): to_remove.append(key) for key in to_remove: del self[key]
[docs] def copy(self) -> "ToolPanelElements": the_copy = ToolPanelElements() the_copy.update(self) return the_copy
[docs] def has_item_recursive(self, item): """Check panel and section elements for supplied item.""" for value in self.values(): if value == item: return True if isinstance(value, ToolSection): if item in value.elems.values(): return True return False