def test_dock_standalone(self):
widget = QWidget()
layout = QHBoxLayout()
widget.setLayout(layout)
layout.addStretch(1)
widget.show()
dock = CollapsibleDockWidget()
layout.addWidget(dock)
list_view = QListView()
list_view.setModel(QStringListModel(["a", "b"], list_view))
label = QLabel("A label. ")
label.setWordWrap(True)
dock.setExpandedWidget(label)
dock.setCollapsedWidget(list_view)
dock.setExpanded(True)
self.app.processEvents()
def toogle():
dock.setExpanded(not dock.expanded())
self.singleShot(2000, toogle)
toogle()
self.app.exec_()
def test_dock_standalone(self):
widget = QWidget()
layout = QHBoxLayout()
widget.setLayout(layout)
layout.addStretch(1)
widget.show()
dock = CollapsibleDockWidget()
layout.addWidget(dock)
list_view = QListView()
list_view.setModel(QStringListModel(["a", "b"], list_view))
label = QLabel("A label. ")
label.setWordWrap(True)
dock.setExpandedWidget(label)
dock.setCollapsedWidget(list_view)
dock.setExpanded(True)
dock.setExpanded(False)
timer = QTimer(dock, interval=50)
timer.timeout.connect(lambda: dock.setExpanded(not dock.expanded()))
timer.start()
self.qWait()
timer.stop()
def __init__(self, tree, dataset, master, parent=None):
QComboBox.__init__(self, parent)
Control.__init__(self, tree, dataset, master)
self.setSelectionMode(QListView.ExtendedSelection)
model = QStringListModel(self)
self.setModel(model)
self.setOptions(tree.subelements_top("Option"))
def __init__(self, *args, **kwargs):
separator = kwargs.pop("separator", " ")
super().__init__(*args, **kwargs)
self.__tokenList = []
self.__completerModel = None
self.__separator = separator
# The current 'known' completion prefix (tracked in splitPath)
self.__currentKnownPrefix = ""
self.setModelSorting(QCompleter.CaseSensitivelySortedModel)
super().setModel(QStringListModel(self))
def test_empty(self):
self.lv.setModel(QStringListModel([]))
self.assertEqual(0, self.lv.model().rowCount())
filter_row = self.lv.findChild(QLineEdit)
filter_row.grab()
self.lv.grab()
QTest.keyClick(filter_row, Qt.Key_T)
QTest.keyClick(filter_row, Qt.Key_Backspace)
def test_setModel(self):
w = ColorGradientSelection()
model = QStringListModel(["A", "B"])
w.setModel(model)
self.assertIs(w.model(), model)
self.assertEqual(w.findData("B", Qt.DisplayRole), 1)
current = QSignalSpy(w.currentIndexChanged)
w.setCurrentIndex(1)
self.assertEqual(w.currentIndex(), 1)
self.assertSequenceEqual(list(current), [[1]])
def test_qabstratitemview_item_delegate_for_index(self):
view = QTableView()
model = QStringListModel()
model.setStringList(["AA", "BB"])
view.setModel(model)
idx1 = model.index(0, 0)
idx2 = model.index(1, 0)
delegate = QStyledItemDelegate()
view.setItemDelegate(delegate)
with warnings.catch_warnings(record=True):
self.assertIs(view.itemDelegate(idx1), delegate)
self.assertIs(view.itemDelegate(idx2), delegate)
def test_flattened_model(self):
model = QStringListModel(["0", "1", "2", "3"])
flat = FlattenedTreeItemModel()
flat.setSourceModel(model)
def get(row):
return flat.index(row, 0).data()
self.assertEqual(get(0), "0")
self.assertEqual(get(1), "1")
self.assertEqual(get(3), "3")
self.assertEqual(flat.rowCount(), model.rowCount())
self.assertEqual(flat.columnCount(), 1)
def setTokenList(self, tokenList):
"""
Set the token word completion list
Equivalent to
`completer.setModel(QStringListModel(tokenList, completer))`
Note that this is the preferred method for setting the completion
model.
Parameters
----------
tokenList : List[str]
"""
tokenList = list(sorted(set(tokenList)))
self.setModel(QStringListModel(tokenList, self))
def main():
from itertools import cycle
from AnyQt.QtCore import QStringListModel
from AnyQt.QtWidgets import QApplication, QWidget, QVBoxLayout
app = QApplication([])
w = QWidget()
w.setLayout(QVBoxLayout())
lv = ListViewSearch()
lv.setUniformItemSizes(True)
w.layout().addWidget(lv)
c = cycle(list(map(chr, range(ord("A"), ord("Z")))))
s = [f"{next(c)}{next(c)}{next(c)}{next(c)}" for _ in range(50000)]
model = QStringListModel(s)
lv.setModel(model)
w.show()
app.exec()
def test_token_list_completer(self):
from Orange.widgets.utils.itemmodels import PyListModel
completer = TokenListCompleter()
completer.setTokenList(["foo", "bar", "baz"])
completer.setCompletionPrefix("foo b")
def completions(completer):
current = completer.currentRow()
items = []
for i in range(completer.completionCount()):
completer.setCurrentRow(i)
items.append(completer.currentCompletion())
completer.setCurrentRow(current)
return items
self.assertSequenceEqual(completions(completer),
["foo bar", "foo baz"])
completer.setModel(None)
self.assertSequenceEqual(completer.tokenList(), [])
self.assertSequenceEqual(completions(completer), [])
completer.setModel(QStringListModel(["a", "ab", "b"]))
self.assertSequenceEqual(completer.tokenList(), ["a", "ab", "b"])
completer.setCompletionPrefix("a a")
self.assertSequenceEqual(completions(completer), ["a a", "a ab"])
completer.setModel(PyListModel(["a", "aa", "ab", "ad"]))
self.assertSequenceEqual(completer.tokenList(),
["a", "aa", "ab", "ad"])
completer.model()[-1] = "z"
self.assertSequenceEqual(completer.tokenList(), ["a", "aa", "ab", "z"])
completer.model()[-2:] = ["ax", "az"]
self.assertSequenceEqual(completer.tokenList(),
["a", "aa", "ax", "az"])
completer.setSeparator(",")
completer.setCompletionPrefix("a, a")
self.assertSequenceEqual(completions(completer),
["a, a", "a, aa", "a, ax", "a, az"])
def test_menu(self):
menu = QuickMenu()
def triggered(action):
print("Triggered", action.text())
def hovered(action):
print("Hover", action.text())
menu.triggered.connect(triggered)
menu.hovered.connect(hovered)
items_page = MenuPage()
model = QStringListModel(["one", "two", "file not found"])
items_page.setModel(model)
menu.addPage("w", items_page)
page_c = MenuPage()
menu.addPage("c", page_c)
menu.popup(QPoint(200, 200))
menu.activateWindow()
self.qWait()
def setItems(self, items):
# type: (Iterable[str]) -> None
"""Set the items (a list of strings) for preview/selection.
"""
model = QStringListModel(items)
self.setModel(model)
def __init__(self):
super().__init__()
self.controlArea = QWidget(self.controlArea)
self.layout().addWidget(self.controlArea)
layout = QGridLayout()
self.controlArea.setLayout(layout)
layout.setContentsMargins(4, 4, 4, 4)
box = gui.vBox(self.controlArea,
"Available Variables",
addToLayout=False)
self.filter_edit = QLineEdit()
self.filter_edit.setToolTip("Filter the list of available variables.")
box.layout().addWidget(self.filter_edit)
if hasattr(self.filter_edit, "setPlaceholderText"):
self.filter_edit.setPlaceholderText("Filter")
self.completer = QCompleter()
self.completer.setCompletionMode(QCompleter.InlineCompletion)
self.completer_model = QStringListModel()
self.completer.setModel(self.completer_model)
self.completer.setModelSorting(QCompleter.CaseSensitivelySortedModel)
self.filter_edit.setCompleter(self.completer)
self.completer_navigator = CompleterNavigator(self)
self.filter_edit.installEventFilter(self.completer_navigator)
def dropcompleted(action):
if action == Qt.MoveAction:
self.commit()
self.available_attrs = VariableListModel(enable_dnd=True)
self.available_attrs_proxy = VariableFilterProxyModel()
self.available_attrs_proxy.setSourceModel(self.available_attrs)
self.available_attrs_view = VariablesListItemView(
acceptedType=Orange.data.Variable)
self.available_attrs_view.setModel(self.available_attrs_proxy)
aa = self.available_attrs
aa.dataChanged.connect(self.update_completer_model)
aa.rowsInserted.connect(self.update_completer_model)
aa.rowsRemoved.connect(self.update_completer_model)
self.available_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.available_attrs_view))
self.available_attrs_view.dragDropActionDidComplete.connect(
dropcompleted)
self.filter_edit.textChanged.connect(self.update_completer_prefix)
self.filter_edit.textChanged.connect(
self.available_attrs_proxy.set_filter_string)
box.layout().addWidget(self.available_attrs_view)
layout.addWidget(box, 0, 0, 3, 1)
box = gui.vBox(self.controlArea, "Features", addToLayout=False)
self.used_attrs = VariableListModel(enable_dnd=True)
self.used_attrs_view = VariablesListItemView(
acceptedType=(Orange.data.DiscreteVariable,
Orange.data.ContinuousVariable))
self.used_attrs_view.setModel(self.used_attrs)
self.used_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.used_attrs_view))
self.used_attrs_view.dragDropActionDidComplete.connect(dropcompleted)
box.layout().addWidget(self.used_attrs_view)
layout.addWidget(box, 0, 2, 1, 1)
box = gui.vBox(self.controlArea, "Target Variable", addToLayout=False)
self.class_attrs = ClassVarListItemModel(enable_dnd=True)
self.class_attrs_view = ClassVariableItemView(
acceptedType=(Orange.data.DiscreteVariable,
Orange.data.ContinuousVariable))
self.class_attrs_view.setModel(self.class_attrs)
self.class_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.class_attrs_view))
self.class_attrs_view.dragDropActionDidComplete.connect(dropcompleted)
self.class_attrs_view.setMaximumHeight(72)
box.layout().addWidget(self.class_attrs_view)
layout.addWidget(box, 1, 2, 1, 1)
box = gui.vBox(self.controlArea, "Meta Attributes", addToLayout=False)
self.meta_attrs = VariableListModel(enable_dnd=True)
self.meta_attrs_view = VariablesListItemView(
acceptedType=Orange.data.Variable)
self.meta_attrs_view.setModel(self.meta_attrs)
self.meta_attrs_view.selectionModel().selectionChanged.connect(
partial(self.update_interface_state, self.meta_attrs_view))
self.meta_attrs_view.dragDropActionDidComplete.connect(dropcompleted)
box.layout().addWidget(self.meta_attrs_view)
layout.addWidget(box, 2, 2, 1, 1)
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 0, 1, 1, 1)
self.up_attr_button = gui.button(bbox,
self,
"Up",
callback=partial(
self.move_up,
self.used_attrs_view))
self.move_attr_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.used_attrs_view))
self.down_attr_button = gui.button(bbox,
self,
"Down",
callback=partial(
self.move_down,
self.used_attrs_view))
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 1, 1, 1, 1)
self.up_class_button = gui.button(bbox,
self,
"Up",
callback=partial(
self.move_up,
self.class_attrs_view))
self.move_class_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.class_attrs_view,
exclusive=False))
self.down_class_button = gui.button(bbox,
self,
"Down",
callback=partial(
self.move_down,
self.class_attrs_view))
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 2, 1, 1, 1)
self.up_meta_button = gui.button(bbox,
self,
"Up",
callback=partial(
self.move_up,
self.meta_attrs_view))
self.move_meta_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.meta_attrs_view))
self.down_meta_button = gui.button(bbox,
self,
"Down",
callback=partial(
self.move_down,
self.meta_attrs_view))
autobox = gui.auto_commit(None, self, "auto_commit", "Send")
layout.addWidget(autobox, 3, 0, 1, 3)
reset = gui.button(None, self, "Reset", callback=self.reset)
autobox.layout().insertWidget(0, self.report_button)
autobox.layout().insertWidget(1, reset)
autobox.layout().insertSpacing(2, 10)
reset.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
self.report_button.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Preferred)
layout.setRowStretch(0, 4)
layout.setRowStretch(1, 0)
layout.setRowStretch(2, 2)
layout.setHorizontalSpacing(0)
self.controlArea.setLayout(layout)
self.data = None
self.output_data = None
self.original_completer_items = []
self.resize(500, 600)
def variables_filter(model, parent=None):
"""
GUI components: ListView with a lineedit which works as a filter. One can write
a variable name in a edit box and possible matches are then shown in a listview.
"""
def update_completer_model():
""" This gets called when the model for available attributes changes
through either drag/drop or the left/right button actions.
"""
nonlocal original_completer_items
items = [var.name for var in model]
items += [
"%s=%s" % item for v in model for item in v.attributes.items()
]
new = sorted(set(items))
if new != original_completer_items:
original_completer_items = new
completer_model.setStringList(original_completer_items)
def update_completer_prefix():
""" Prefixes all items in the completer model with the current
already done completion to enable the completion of multiple keywords.
"""
nonlocal original_completer_items
prefix = str(completer.completionPrefix())
if not prefix.endswith(" ") and " " in prefix:
prefix, _ = prefix.rsplit(" ", 1)
items = [prefix + " " + item for item in original_completer_items]
else:
items = original_completer_items
old = list(map(str, completer_model.stringList()))
if set(old) != set(items):
completer_model.setStringList(items)
original_completer_items = []
filter_edit = QLineEdit()
filter_edit.setToolTip("Filter the list of available variables.")
filter_edit.setPlaceholderText("Filter")
completer_model = QStringListModel()
completer = QCompleter(completer_model)
completer.setCompletionMode(QCompleter.InlineCompletion)
completer.setModelSorting(QCompleter.CaseSensitivelySortedModel)
filter_edit.setCompleter(completer)
completer_navigator = CompleterNavigator(parent)
filter_edit.installEventFilter(completer_navigator)
proxy = VariableFilterProxyModel()
proxy.setSourceModel(model)
view = VariablesListItemView(acceptedType=Orange.data.Variable)
view.setModel(proxy)
model.dataChanged.connect(update_completer_model)
model.rowsInserted.connect(update_completer_model)
model.rowsRemoved.connect(update_completer_model)
filter_edit.textChanged.connect(update_completer_prefix)
filter_edit.textChanged.connect(proxy.set_filter_string)
return filter_edit, view
def setItems(self, items):
"""Set the items (a list of strings) for preview/selection.
"""
model = QStringListModel(items)
self.setModel(model)
def __init__(self, parent=None):
super().__init__(parent)
self.servers = [
('https://dictyexpress.research.bcm.edu/', 'dictyExpress'),
('https://cloud.genialis.com/', 'Genialis'),
]
self.selectedExperiments = []
self.buffer = dicty.CacheSQLite(bufferfile)
self.searchString = ""
self.items = []
self.result_types = []
self.controlArea.setMaximumWidth(250)
self.controlArea.setMinimumWidth(250)
box = gui.widgetBox(self.controlArea, 'Project')
self.projectCB = gui.comboBox(box,
self,
"projecti",
items=[],
callback=self.ProjectChosen)
self.projects = []
b = gui.widgetBox(self.controlArea, "Selection bookmarks")
self.selectionSetsWidget = SelectionSetsWidget(self)
self.selectionSetsWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
def store_selections(modified):
if not modified:
self.storedSelections = self.selectionSetsWidget.selections
self.selectionSetsWidget.selectionModified.connect(store_selections)
b.layout().addWidget(self.selectionSetsWidget)
gui.separator(self.controlArea)
b = gui.widgetBox(self.controlArea, "Sort output columns")
self.columnsSortingWidget = SortedListWidget(self)
self.columnsSortingWidget.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Maximum)
box = gui.widgetBox(self.controlArea, 'Experiment name')
self.experimentNameCB = gui.comboBox(box,
self,
"exnamei",
items=SORTING_MODEL_LIST)
b.layout().addWidget(self.columnsSortingWidget)
sorting_model = QStringListModel(SORTING_MODEL_LIST)
self.columnsSortingWidget.setModel(sorting_model)
self.columnsSortingWidget.sortingOrder = self.storedSortOrder
def store_sort_order():
self.storedSortOrder = self.columnsSortingWidget.sortingOrder
self.columnsSortingWidget.sortingOrderChanged.connect(store_sort_order)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Expression Type')
self.expressionTypesCB = gui.comboBox(box,
self,
"rtypei",
items=[],
callback=self.UpdateResultsList)
gui.checkBox(self.controlArea, self, "excludeconstant",
"Exclude labels with constant values")
gui.checkBox(self.controlArea, self, "joinreplicates",
"Average replicates (use median)")
gui.checkBox(self.controlArea, self, "log2",
"Logarithmic (base 2) transformation")
gui.checkBox(self.controlArea, self, "transpose", "Genes as columns")
self.commit_button = gui.button(self.controlArea,
self,
"&Commit",
callback=self.Commit)
self.commit_button.setDisabled(True)
gui.rubber(self.controlArea)
box = gui.widgetBox(self.controlArea, 'Server')
gui.comboBox(box,
self,
"serveri",
items=[title for url, title in self.servers],
callback=self.ServerChosen)
gui.lineEdit(box,
self,
"username",
"Username:"******"password",
"Password:"******"Clear cache",
callback=self.clear_cache)
gui.lineEdit(self.mainArea,
self,
"searchString",
"Search",
callbackOnType=True,
callback=self.SearchUpdate)
self.headerLabels = [t[1] for t in HEADER]
self.experimentsWidget = QTreeWidget()
self.experimentsWidget.setHeaderLabels(self.headerLabels)
self.experimentsWidget.setSelectionMode(QTreeWidget.ExtendedSelection)
self.experimentsWidget.setRootIsDecorated(False)
self.experimentsWidget.setSortingEnabled(True)
contextEventFilter = gui.VisibleHeaderSectionContextEventFilter(
self.experimentsWidget, self.experimentsWidget)
self.experimentsWidget.header().installEventFilter(contextEventFilter)
self.experimentsWidget.setItemDelegateForColumn(
0, gui.IndicatorItemDelegate(self, role=Qt.DisplayRole))
self.experimentsWidget.setAlternatingRowColors(True)
self.experimentsWidget.selectionModel().selectionChanged.connect(
self.onSelectionChanged)
self.selectionSetsWidget.setSelectionModel(
self.experimentsWidget.selectionModel())
self.selectionSetsWidget.setSelections(self.storedSelections)
self.mainArea.layout().addWidget(self.experimentsWidget)
self.restoreHeaderState()
self.experimentsWidget.header().geometriesChanged.connect(
self.saveHeaderState)
self.dbc = None
self.AuthSet()
QTimer.singleShot(100, self.ConnectAndUpdate)
def __on_enrichment_finished(self, results):
assert QThread.currentThread() is self.thread()
self.__state &= ~OWSetEnrichment.RunningEnrichment
query, reference, results = results
results = results # type: List[Tuple[geneset.GeneSet, enrichment_res]]
nquery = len(query)
nref = len(reference)
maxcount = max((len(e.query_mapped) for _, e in results),
default=1)
maxrefcount = max((len(e.reference_mapped) for _, e in results),
default=1)
nspaces = int(math.ceil(math.log10(maxcount or 1)))
refspaces = int(math.ceil(math.log(maxrefcount or 1)))
query_fmt = "%" + str(nspaces) + "s (%.2f%%)"
ref_fmt = "%" + str(refspaces) + "s (%.2f%%)"
def fmt_count(fmt, count, total):
return fmt % (count, 100.0 * count / (total or 1))
fmt_query_count = partial(fmt_count, query_fmt, total=nquery)
fmt_ref_count = partial(fmt_count, ref_fmt, total=nref)
view = self.annotationsChartView
delegate = view.itemDelegateForColumn(ResultsModel.Count)
if delegate is not None:
delegate.deleteLater()
delegate = view.itemDelegateForColumn(ResultsModel.Reference)
if delegate is not None:
delegate.deleteLater()
view.setItemDelegateForColumn(
ResultsModel.Count, FormatItemDelegate(fmt_query_count, self)
)
view.setItemDelegateForColumn(
ResultsModel.Reference, FormatItemDelegate(fmt_ref_count, self)
)
linkFont = QFont(self.annotationsChartView.viewOptions().font)
linkFont.setUnderline(True)
def item(value=None, tooltip=None, user=None):
si = QStandardItem()
if value is not None:
si.setData(value, Qt.DisplayRole)
if tooltip is not None:
si.setData(tooltip, Qt.ToolTipRole)
if user is not None:
si.setData(user, Qt.UserRole)
else:
si.setData(value, Qt.UserRole)
return si
model = ResultsModel(parent=self)
for i, (gset, enrich) in enumerate(results):
if len(enrich.query_mapped) == 0:
continue
nquery_mapped = len(enrich.query_mapped)
nref_mapped = len(enrich.reference_mapped)
row = [
item(", ".join(gset.hierarchy)),
item(gsname(gset), tooltip=gset.link),
item(nquery_mapped, tooltip=nquery_mapped, user=nquery_mapped),
item(nref_mapped, tooltip=nref_mapped, user=nref_mapped),
item(enrich.p_value, user=enrich.p_value),
item(np.nan), # column 5, FDR, is computed in _updateFDR
item(enrich.enrichment_score,
tooltip="%.3f" % enrich.enrichment_score,
user=enrich.enrichment_score)
]
row[0].geneset = gset
row[0].enrichment = enrich
if gset.link:
row[1].setData(gset.link, gui.LinkRole)
row[1].setFont(linkFont)
row[1].setForeground(QColor(Qt.blue))
model.appendRow(row)
currmodel = self.proxy.sourceModel()
currmodel.deleteLater()
self.proxy.setSourceModel(model)
if not model.rowCount():
self.warning(0, "No enriched sets found.")
else:
self.warning(0)
allnames = set(gsname(geneset)
for geneset, (count, _, _, _) in results if count)
allnames |= reduce(operator.ior,
(set(word_split(name)) for name in allnames),
set())
self.filterCompleter.setModel(None)
self.completerModel = QStringListModel(sorted(allnames))
self.filterCompleter.setModel(self.completerModel)
if results:
max_score = max((e.enrichment_score for _, e in results
if np.isfinite(e.enrichment_score)),
default=1)
self.annotationsChartView.setItemDelegateForColumn(
ResultsModel.Enrichment,
BarItemDelegate(self, scale=(0.0, max_score))
)
self.annotationsChartView.setItemDelegateForColumn(
ResultsModel.TermID,
gui.LinkStyledItemDelegate(self.annotationsChartView)
)
self._updateFDR()
self.filterAnnotationsChartView()
header = self.annotationsChartView.header()
for i in range(model.columnCount()):
sh = self.annotationsChartView.sizeHintForColumn(i)
sh = max(header.sectionSizeHint(i), sh)
width = self.annotationsChartView.columnWidth(i)
if min(sh, 300) > width:
self.annotationsChartView.setColumnWidth(i, max(min(sh, 300), 30))
self.progressBarFinished()
self.setStatusMessage("")
def __on_enrichment_finished(self, results):
assert QThread.currentThread() is self.thread()
self.__state &= ~OWSetEnrichment.RunningEnrichment
query, reference, results = results
if self.annotationsChartView.model():
self.annotationsChartView.model().clear()
nquery = len(query)
nref = len(reference)
maxcount = max((len(e.query_mapped) for _, e in results), default=1)
maxrefcount = max((len(e.reference_mapped) for _, e in results),
default=1)
nspaces = int(math.ceil(math.log10(maxcount or 1)))
refspaces = int(math.ceil(math.log(maxrefcount or 1)))
query_fmt = "%" + str(nspaces) + "s (%.2f%%)"
ref_fmt = "%" + str(refspaces) + "s (%.2f%%)"
def fmt_count(fmt, count, total):
return fmt % (count, 100.0 * count / (total or 1))
fmt_query_count = partial(fmt_count, query_fmt)
fmt_ref_count = partial(fmt_count, ref_fmt)
linkFont = QFont(self.annotationsChartView.viewOptions().font)
linkFont.setUnderline(True)
def item(value=None, tooltip=None, user=None):
si = QStandardItem()
if value is not None:
si.setData(value, Qt.DisplayRole)
if tooltip is not None:
si.setData(tooltip, Qt.ToolTipRole)
if user is not None:
si.setData(user, Qt.UserRole)
else:
si.setData(value, Qt.UserRole)
return si
model = QStandardItemModel()
model.setSortRole(Qt.UserRole)
model.setHorizontalHeaderLabels([
"Category", "Term", "Count", "Reference count", "p-value", "FDR",
"Enrichment"
])
for i, (gset, enrich) in enumerate(results):
if len(enrich.query_mapped) == 0:
continue
nquery_mapped = len(enrich.query_mapped)
nref_mapped = len(enrich.reference_mapped)
row = [
item(", ".join(gset.hierarchy)),
item(gsname(gset), tooltip=gset.link),
item(fmt_query_count(nquery_mapped, nquery),
tooltip=nquery_mapped,
user=nquery_mapped),
item(fmt_ref_count(nref_mapped, nref),
tooltip=nref_mapped,
user=nref_mapped),
item(fmtp(enrich.p_value), user=enrich.p_value),
item(
), # column 5, FDR, is computed in filterAnnotationsChartView
item(enrich.enrichment_score,
tooltip="%.3f" % enrich.enrichment_score,
user=enrich.enrichment_score)
]
row[0].geneset = gset
row[0].enrichment = enrich
row[1].setData(gset.link, gui.LinkRole)
row[1].setFont(linkFont)
row[1].setForeground(QColor(Qt.blue))
model.appendRow(row)
self.annotationsChartView.setModel(model)
self.annotationsChartView.selectionModel().selectionChanged.connect(
self.commit)
if not model.rowCount():
self.warning(0, "No enriched sets found.")
else:
self.warning(0)
allnames = set(
gsname(geneset) for geneset, (count, _, _, _) in results if count)
allnames |= reduce(operator.ior,
(set(word_split(name)) for name in allnames), set())
self.filterCompleter.setModel(None)
self.completerModel = QStringListModel(sorted(allnames))
self.filterCompleter.setModel(self.completerModel)
if results:
max_score = max(
(e.enrichment_score
for _, e in results if np.isfinite(e.enrichment_score)),
default=1)
self.annotationsChartView.setItemDelegateForColumn(
6, BarItemDelegate(self, scale=(0.0, max_score)))
self.annotationsChartView.setItemDelegateForColumn(
1, gui.LinkStyledItemDelegate(self.annotationsChartView))
header = self.annotationsChartView.header()
for i in range(model.columnCount()):
sh = self.annotationsChartView.sizeHintForColumn(i)
sh = max(sh, header.sectionSizeHint(i))
self.annotationsChartView.setColumnWidth(i, max(min(sh, 300), 30))
# self.annotationsChartView.resizeColumnToContents(i)
self.filterAnnotationsChartView()
self.progressBarFinished()
self.setStatusMessage("")
def setUp(self) -> None:
super().setUp()
self.lv = ListViewSearch()
s = ["one", "two", "three", "four"]
model = QStringListModel(s)
self.lv.setModel(model)
