def list_docs(self):
""" List documents into the left scrolling area """
search_keyword = self.filter_input.text().strip('|')
try:
reg = re.compile(search_keyword, re.IGNORECASE)
except sre_constants.error:
return
def is_match(x):
return not bool(search_keyword) or reg.search(x)
self.output_mask.clear()
self.doc_list_model.clear()
for i, (doc, title, content) in enumerate(zip(self.corpus, self.corpus.titles,
self.corpus_docs)):
if is_match(content):
item = QStandardItem()
item.setData(title, Qt.DisplayRole)
item.setData(doc, Qt.UserRole)
self.doc_list_model.appendRow(item)
self.output_mask.append(i)
if self.doc_list_model.rowCount() > 0:
self.doc_list.selectRow(0) # Select the first document
else:
self.doc_webview.setHtml('')
self.commit()
def _cat_desc_to_std_item(self, desc):
"""
Create a QStandardItem for the category description.
"""
item = QStandardItem()
item.setText(desc.name)
if desc.icon:
icon = desc.icon
else:
icon = "icons/default-category.svg"
icon = icon_loader.from_description(desc).get(icon)
item.setIcon(icon)
if desc.background:
background = desc.background
else:
background = DEFAULT_COLOR
background = NAMED_COLORS.get(background, background)
brush = QBrush(QColor(background))
item.setData(brush, self.BACKGROUND_ROLE)
tooltip = desc.description if desc.description else desc.name
item.setToolTip(tooltip)
item.setFlags(Qt.ItemIsEnabled)
item.setData(desc, self.CATEGORY_DESC_ROLE)
return item
def _initialize(self):
for pp_def in PREPROCESSORS:
description = pp_def.description
if description.icon:
icon = QIcon(description.icon)
else:
icon = QIcon()
item = QStandardItem(icon, description.title)
item.setToolTip(description.summary or "")
item.setData(pp_def, DescriptionRole)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsDragEnabled)
self.preprocessors.appendRow([item])
try:
model = self.load(self.storedsettings)
except Exception:
model = self.load({})
self.set_model(model)
if not model.rowCount():
# enforce default width constraint if no preprocessors
# are instantiated (if the model is not empty the constraints
# will be triggered by LayoutRequest event on the `flow_view`)
self.__update_size_constraint()
self.apply()
def color_palette_model(palettes, iconsize=QSize(64, 16)):
model = QStandardItemModel()
for name, palette in palettes:
_, colors = max(palette.items())
colors = [QColor(*c) for c in colors]
item = QStandardItem(name)
item.setIcon(QIcon(palette_pixmap(colors, iconsize)))
item.setData(palette, Qt.UserRole)
model.appendRow([item])
return model
def row_for_state(self, score, state):
"""The row consists of attributes sorted by name; class is at the
beginning, if present, so it's on the x-axis and not lost somewhere."""
class_var = self.master.color_data.domain.class_var
attrs = tuple(
sorted((self.attr_ordering[x] for x in state),
key=lambda attr: (1 - (attr is class_var), attr.name)))
item = QStandardItem(", ".join(a.name for a in attrs))
item.setData(attrs, self._AttrRole)
return [item]
def RecentPath_asqstandarditem(pathitem):
icon_provider = QFileIconProvider()
# basename of a normalized name (strip right path component separators)
basename = os.path.basename(os.path.normpath(pathitem.abspath))
item = QStandardItem(
icon_provider.icon(QFileInfo(pathitem.abspath)),
basename
)
item.setToolTip(pathitem.abspath)
item.setData(pathitem, Qt.UserRole)
return item
def row_for_state(self, score, state):
attrs = sorted((self.attrs[x] for x in state), key=attrgetter("name"))
attr_items = []
for attr in attrs:
item = QStandardItem(attr.name)
item.setData(attrs, self._AttrRole)
item.setData(Qt.AlignLeft + Qt.AlignTop, Qt.TextAlignmentRole)
item.setToolTip(attr.name)
attr_items.append(item)
correlation_item = QStandardItem("{:+.3f}".format(score[1]))
correlation_item.setData(score[2], self.PValRole)
correlation_item.setData(attrs, self._AttrRole)
correlation_item.setData(
self.NEGATIVE_COLOR if score[1] < 0 else self.POSITIVE_COLOR,
gui.TableBarItem.BarColorRole)
return [correlation_item] + attr_items
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
def row_for_state(self, score, state):
attrs = sorted((self.attrs[x] for x in state), key=attrgetter("name"))
attrs_item = QStandardItem(
"{}, {}".format(attrs[0].name, attrs[1].name))
attrs_item.setData(attrs, self._AttrRole)
attrs_item.setData(Qt.AlignLeft + Qt.AlignTop, Qt.TextAlignmentRole)
correlation_item = QStandardItem("{:+.3f}".format(score[1]))
correlation_item.setData(attrs, self._AttrRole)
correlation_item.setData(
self.NEGATIVE_COLOR if score[1] < 0 else self.POSITIVE_COLOR,
gui.TableBarItem.BarColorRole)
return [correlation_item, attrs_item]
def test_tooltree(self):
tree = ToolTree()
role = tree.actionRole()
model = QStandardItemModel()
tree.setModel(model)
item = QStandardItem("One")
item.setData(QAction("One", tree), role)
model.appendRow([item])
cat = QStandardItem("A Category")
item = QStandardItem("Two")
item.setData(QAction("Two", tree), role)
cat.appendRow([item])
item = QStandardItem("Three")
item.setData(QAction("Three", tree), role)
cat.appendRow([item])
model.appendRow([cat])
def p(action):
print("triggered", action.text())
tree.triggered.connect(p)
tree.show()
self.app.exec_()
def __activated(self, index):
item = self.preprocessors.itemFromIndex(index)
action = item.data(DescriptionRole)
item = QStandardItem()
item.setData({}, ParametersRole)
item.setData(action.description.title, Qt.DisplayRole)
item.setData(action, DescriptionRole)
self.preprocessormodel.appendRow([item])
def load(self, saved):
"""Load a preprocessor list from a dict."""
name = saved.get("name", "")
preprocessors = saved.get("preprocessors", [])
model = StandardItemModel()
def dropMimeData(data, action, row, column, parent):
if data.hasFormat("application/x-qwidget-ref") and \
action == Qt.CopyAction:
qname = bytes(data.data("application/x-qwidget-ref")).decode()
ppdef = self._qname2ppdef[qname]
item = QStandardItem(ppdef.description.title)
item.setData({}, ParametersRole)
item.setData(ppdef.description.title, Qt.DisplayRole)
item.setData(ppdef, DescriptionRole)
self.preprocessormodel.insertRow(row, [item])
return True
else:
return False
model.dropMimeData = dropMimeData
for qualname, params in preprocessors:
pp_def = self._qname2ppdef[qualname]
description = pp_def.description
item = QStandardItem(description.title)
if description.icon:
icon = QIcon(description.icon)
else:
icon = QIcon()
item.setIcon(icon)
item.setToolTip(description.summary)
item.setData(pp_def, DescriptionRole)
item.setData(params, ParametersRole)
model.appendRow(item)
return model
def load(self, saved):
"""Load a preprocessor list from a dict."""
preprocessors = saved.get("preprocessors", [])
model = StandardItemModel()
def dropMimeData(data, action, row, _column, _parent):
if data.hasFormat("application/x-qwidget-ref") and \
action == Qt.CopyAction:
qname = bytes(data.data("application/x-qwidget-ref")).decode()
ppdef = self._qname2ppdef[qname]
item = QStandardItem(ppdef.description.title)
item.setData({}, ParametersRole)
item.setData(ppdef.description.title, Qt.DisplayRole)
item.setData(ppdef, DescriptionRole)
self.preprocessormodel.insertRow(row, [item])
return True
else:
return False
model.dropMimeData = dropMimeData
for qualname, params in preprocessors:
pp_def = self._qname2ppdef[qualname]
description = pp_def.description
item = QStandardItem(description.title)
if description.icon:
icon = QIcon(description.icon)
else:
icon = QIcon()
item.setIcon(icon)
item.setToolTip(description.summary)
item.setData(pp_def, DescriptionRole)
item.setData(params, ParametersRole)
model.appendRow(item)
return model
def _sum_item(value, border=""):
item = QStandardItem()
item.setData(value, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
item.setFont(bold_font)
item.setData(border, BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
return item
def list_docs(self):
""" List documents into the left scrolling area """
if self.corpus_docs is None:
return
# TODO: remove search_keyword??
search_keyword = self.regexp_filter.strip('|')
matches = 0
try:
reg = re.compile(search_keyword, re.IGNORECASE)
except sre_constants.error:
return
self.doc_list_model.clear()
for i, (doc, title, content) in enumerate(zip(self.corpus, self.corpus.titles,
self.corpus_docs)):
res = len(list(reg.finditer(content))) if self.regexp_filter else 0
if not self.regexp_filter or res:
matches += res
item = QStandardItem()
item.setData(str(title), Qt.DisplayRole)
item.setData(doc, Qt.UserRole)
self.doc_list_model.appendRow(item)
self.matches = matches
def test_sorting(self):
def order(n=5):
return "".join(model.index(i, 0).data() for i in range(n))
score_table = ScoreTable(None)
data = [["D", 11.0, 15.3], ["C", 5.0, -15.4], ["b", 20.0, np.nan],
["A", None, None], ["E", "", 0.0]]
for data_row in data:
row = []
for x in data_row:
item = QStandardItem()
if x is not None:
item.setData(x, Qt.DisplayRole)
row.append(item)
score_table.model.appendRow(row)
model = score_table.view.model()
model.sort(0, Qt.AscendingOrder)
self.assertEqual(order(), "AbCDE")
model.sort(0, Qt.DescendingOrder)
self.assertEqual(order(), "EDCbA")
model.sort(1, Qt.AscendingOrder)
self.assertEqual(order(3), "CDb")
model.sort(1, Qt.DescendingOrder)
self.assertEqual(order(3), "bDC")
model.sort(2, Qt.AscendingOrder)
self.assertEqual(order(3), "CED")
model.sort(2, Qt.DescendingOrder)
self.assertEqual(order(3), "DEC")
def list_docs(self):
""" List documents into the left scrolling area """
if self.corpus_docs is None:
return
search_keyword = self.regexp_filter.strip('|')
try:
reg = re.compile(search_keyword, re.IGNORECASE)
except sre_constants.error:
return
def is_match(x):
return not bool(search_keyword) or reg.search(x)
self.output_mask.clear()
self.doc_list_model.clear()
for i, (doc, title, content) in enumerate(zip(self.corpus, self.corpus.titles,
self.corpus_docs)):
if is_match(content):
item = QStandardItem()
item.setData(title, Qt.DisplayRole)
item.setData(doc, Qt.UserRole)
self.doc_list_model.appendRow(item)
self.output_mask.append(i)
def list_docs(self):
""" List documents into the left scrolling area """
if self.corpus_docs is None:
return
search_keyword = self.regexp_filter.strip('|')
try:
reg = re.compile(search_keyword, re.IGNORECASE)
except sre_constants.error:
return
def is_match(x):
return not bool(search_keyword) or reg.search(x)
self.output_mask.clear()
self.doc_list_model.clear()
for i, (doc, title, content) in enumerate(
zip(self.corpus, self.corpus.titles, self.corpus_docs)):
if is_match(content):
item = QStandardItem()
item.setData(title, Qt.DisplayRole)
item.setData(doc, Qt.UserRole)
self.doc_list_model.appendRow(item)
self.output_mask.append(i)
def createRow(item):
# type: (Item) -> List[QStandardItem]
dist = None # type: Optional[Distribution]
if isinstance(item, Installed):
installed = True
ins, dist = item.installable, item.local
name = dist.project_name
summary = get_dist_meta(dist).get("Summary", "")
version = ins.version if ins is not None else dist.version
item_is_core = item.required
else:
installed = False
ins = item.installable
dist = None
name = ins.name
summary = ins.summary
version = ins.version
item_is_core = False
updatable = is_updatable(item)
item1 = QStandardItem()
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable |
(Qt.ItemIsUserTristate if updatable else 0))
item1.setEnabled(not (item_is_core and not updatable))
item1.setData(item_is_core, HasConstraintRole)
if installed and updatable:
item1.setCheckState(Qt.PartiallyChecked)
elif installed:
item1.setCheckState(Qt.Checked)
else:
item1.setCheckState(Qt.Unchecked)
item1.setData(item, Qt.UserRole)
item2 = QStandardItem(name)
item2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item2.setToolTip(summary)
item2.setData(item, Qt.UserRole)
if updatable:
assert dist is not None
assert ins is not None
version = "{} < {}".format(dist.version, ins.version)
item3 = QStandardItem(version)
item3.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item4 = QStandardItem()
item4.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
return [item1, item2, item3, item4]
def create_model(self):
allkeys = set(self.allinfo_local)
if self.allinfo_remote is not None:
allkeys = allkeys | set(self.allinfo_remote)
allkeys = sorted(allkeys)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(self._header_labels)
current_index = -1
for i, file_path in enumerate(allkeys):
data_info = self._parse_info(file_path)
row = []
for info_tag, header_setting in self.HEADER_SCHEMA:
item = QStandardItem()
try:
data = data_info.__getattribute__(info_tag)
except AttributeError:
# unknown tag in JSON
data = ''
# first column indicating cached data sets
if info_tag == 'islocal':
item.setData(' ' if data else '', Qt.DisplayRole)
item.setData(data_info, Qt.UserRole)
else:
# parse taxid to common name
if info_tag == 'taxid' and data in common_taxids():
data = shortname(data)[0].title()
if info_tag == 'tags':
data = ', '.join(data) if data else ''
item.setData(data, Qt.DisplayRole)
# set icon to Target column
if info_tag == 'target' and data:
item.setIcon(
Orange.widgets.data.owdatasets.variable_icon(data))
row.append(item)
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
return model, current_index
def _set_values(self, matrix, colors, formatstr, tooltip):
"""
Set content of cells which aren't headers and don't represent aggregate values.
Parameters
----------
matrix : numpy.array
2D array to be set as data.
colors : :obj:`numpy.array`
2D array with color values.
formatstr : :obj:`str`, optional
Format string for cell data.
tooltip : :obj:`(int, int) -> str`
Function which takes vertical index and horizontal index as arguments and returns
desired tooltip as a string.
"""
def _isinvalid(x):
return isnan(x) or isinf(x)
for i in range(len(self.classesv)):
for j in range(len(self.classesh)):
val = matrix[i, j]
col_val = float('nan') if colors is None else colors[i, j]
item = QStandardItem()
if self.circles:
item.setData(val, CircleAreaRole)
else:
item.setData(
"NA" if _isinvalid(val) else formatstr.format(val),
Qt.DisplayRole)
bkcolor = QColor.fromHsl(
[0, 240][i == j], 160,
255 if _isinvalid(col_val) else int(255 -
30 * col_val))
item.setData(QBrush(bkcolor), Qt.BackgroundRole)
item.setData("trbl", BorderRole)
if tooltip is not None:
item.setToolTip(tooltip(i, j))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
def dropMimeData(data, action, row, column, parent):
if data.hasFormat("application/x-qwidget-ref") and \
action == Qt.CopyAction:
qname = bytes(data.data("application/x-qwidget-ref")).decode()
ppdef = self._qname2ppdef[qname]
item = QStandardItem(ppdef.description.title)
item.setData({}, ParametersRole)
item.setData(ppdef.description.title, Qt.DisplayRole)
item.setData(ppdef, DescriptionRole)
self.preprocessormodel.insertRow(row, [item])
return True
else:
return False
def dropMimeData(data, action, row, _column, _parent):
if data.hasFormat("application/x-qwidget-ref") and \
action == Qt.CopyAction:
qname = bytes(data.data("application/x-qwidget-ref")).decode()
ppdef = self._qname2ppdef[qname]
item = QStandardItem(ppdef.description.title)
item.setData({}, ParametersRole)
item.setData(ppdef.description.title, Qt.DisplayRole)
item.setData(ppdef, DescriptionRole)
self.preprocessormodel.insertRow(row, [item])
return True
else:
return False
def createRow(item):
# type: (Item) -> List[QStandardItem]
if isinstance(item, Installed):
installed = True
ins, dist = item.installable, item.local
name = dist.project_name
summary = get_dist_meta(dist).get("Summary", "")
version = ins.version if ins is not None else dist.version
item_is_core = item.required
else:
installed = False
ins = item.installable
dist = None
name = ins.name
summary = ins.summary
version = ins.version
item_is_core = False
updatable = is_updatable(item)
item1 = QStandardItem()
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable |
(Qt.ItemIsUserTristate if updatable else 0))
item1.setEnabled(not (item_is_core and not updatable))
item1.setData(item_is_core, HasConstraintRole)
if installed and updatable:
item1.setCheckState(Qt.PartiallyChecked)
elif installed:
item1.setCheckState(Qt.Checked)
else:
item1.setCheckState(Qt.Unchecked)
item1.setData(item, Qt.UserRole)
item2 = QStandardItem(name)
item2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item2.setToolTip(summary)
item2.setData(item, Qt.UserRole)
if updatable:
version = "{} < {}".format(dist.version, ins.version)
item3 = QStandardItem(version)
item3.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item4 = QStandardItem()
item4.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
return [item1, item2, item3, item4]
def _add_row(self, variable: Variable, values: np.ndarray, color: QColor,
saved_value: Optional[Union[int, float, str]]):
var_item = QStandardItem()
var_item.setData(variable.name, Qt.DisplayRole)
var_item.setToolTip(variable.name)
var_item.setIcon(self._variable_icon(variable))
var_item.setEditable(False)
if color:
var_item.setBackground(color)
control_item = QStandardItem()
control_item.setData(variable, VariableRole)
control_item.setData(values, ValuesRole)
if color:
control_item.setBackground(color)
value = self._default_for_variable(variable, values)
if saved_value is not None and not \
(variable.is_discrete and saved_value >= len(variable.values)):
value = saved_value
control_item.setData(value, ValueRole)
self.appendRow([var_item, control_item])
def _widget_desc_to_std_item(self, desc, category):
# type: (WidgetDescription, CategoryDescription) -> QStandardItem
"""
Create a QStandardItem for the widget description.
"""
item = QStandardItem(desc.name)
item.setText(desc.name)
if desc.icon:
icon = desc.icon
else:
icon = "icons/default-widget.svg"
icon = icon_loader.from_description(desc).get(icon)
item.setIcon(icon)
# This should be inherited from the category.
background = None
if desc.background:
background = desc.background
elif category.background:
background = category.background
else:
background = DEFAULT_COLOR
if background is not None:
background = NAMED_COLORS.get(background, background)
brush = QBrush(QColor(background))
item.setData(brush, self.BACKGROUND_ROLE)
tooltip = tooltip_helper(desc)
style = "ul { margin-top: 1px; margin-bottom: 1px; }"
tooltip = TOOLTIP_TEMPLATE.format(style=style, tooltip=tooltip)
item.setToolTip(tooltip)
item.setWhatsThis(whats_this_helper(desc))
item.sizeHint()
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setData(desc, self.WIDGET_DESC_ROLE)
# Create the action for the widget_item
action = self.create_action_for_item(item)
item.setData(action, self.WIDGET_ACTION_ROLE)
return item
def _widget_desc_to_std_item(self, desc, category):
"""
Create a QStandardItem for the widget description.
"""
item = QStandardItem(desc.name)
item.setText(desc.name)
if desc.icon:
icon = desc.icon
else:
icon = "icons/default-widget.svg"
icon = icon_loader.from_description(desc).get(icon)
item.setIcon(icon)
# This should be inherited from the category.
background = None
if desc.background:
background = desc.background
elif category.background:
background = category.background
else:
background = DEFAULT_COLOR
if background is not None:
background = NAMED_COLORS.get(background, background)
brush = QBrush(QColor(background))
item.setData(brush, self.BACKGROUND_ROLE)
tooltip = tooltip_helper(desc)
style = "ul { margin-top: 1px; margin-bottom: 1px; }"
tooltip = TOOLTIP_TEMPLATE.format(style=style, tooltip=tooltip)
item.setToolTip(tooltip)
item.setWhatsThis(whats_this_helper(desc))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setData(desc, self.WIDGET_DESC_ROLE)
# Create the action for the widget_item
action = self.create_action_for_item(item)
item.setData(action, self.WIDGET_ACTION_ROLE)
return item
def show_results(self):
minimize = self.SCORING_METHODS[self.scoring][2]
k_scores = [(k, self.SCORING_METHODS[self.scoring][1](run)) for
k, run in self.optimization_runs]
scores = list(zip(*k_scores))[1]
if minimize:
best_score, worst_score = min(scores), max(scores)
else:
best_score, worst_score = max(scores), min(scores)
best_run = scores.index(best_score)
score_span = (best_score - worst_score) or 1
max_score = max(scores)
nplaces = min(5, np.floor(abs(math.log(max(max_score, 1e-10)))) + 2)
fmt = "{{:.{}f}}".format(int(nplaces))
model = self.table_model
model.setRowCount(len(k_scores))
for i, (k, score) in enumerate(k_scores):
item = model.item(i, 0)
if item is None:
item = QStandardItem()
item.setData(k, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
model.setItem(i, 0, item)
item = model.item(i, 1)
if item is None:
item = QStandardItem()
item.setData(fmt.format(score) if not np.isnan(score) else 'out-of-memory error',
Qt.DisplayRole)
bar_ratio = 0.95 * (score - worst_score) / score_span
item.setData(bar_ratio, gui.TableBarItem.BarRole)
model.setItem(i, 1, item)
self.table_view.resizeRowsToContents()
self.table_view.selectRow(best_run)
self.table_view.show()
if minimize:
self.table_box.setTitle("Scoring (smaller is better)")
else:
self.table_box.setTitle("Scoring (bigger is better)")
QTimer.singleShot(0, self.adjustSize)
def row_for_state(self, score, state):
attrs = [self.attrs[i] for i in state]
item = QStandardItem(", ".join(a.name for a in attrs))
item.setData(attrs, self._AttrRole)
return [item]
def row_for_state(self, score, state):
attr = self.attrs[state]
item = QStandardItem(attr.name)
item.setData(attr, self._AttrRole)
return [item]
def set_groups(self, keys, groups, relevant_keys, relevant_items,
all_values, uniquepos):
"""Set the current data groups and update the Group widget
"""
layout = QVBoxLayout()
header_widths = []
header_views = []
palette = self.palette()
all_values = all_values.keys()
def for_print(rd):
attrs = []
for d in rd:
attr = Orange.data.ContinuousVariable(next(inactive_name_gen))
attr.attributes.update(d)
attrs.append(attr)
return Orange.data.Domain(attrs, None)
for separatev, domain in [(None, for_print(relevant_items))] + groups:
label = None
if separatev is not None:
ann_vals = " <b>|</b> ".join(["<b>{0}</b> = {1}".format(key,val) \
for key, val in zip(keys, separatev)])
label = QLabel(ann_vals)
model = QStandardItemModel()
for i, attr in enumerate(domain.attributes):
item = QStandardItem()
if separatev is not None:
isunique = uniquepos[separatev][i]
else:
isunique = all(a[i] for a in uniquepos.values())
if str(attr.name).startswith("!!missing "): # TODO: Change this to not depend on name
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setFlags(Qt.NoItemFlags)
item.setData(QColor(Qt.red), Qt.ForegroundRole)
item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole)
item.setData("Missing feature.", Qt.ToolTipRole)
elif str(attr.name).startswith("!!inactive "):
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "No descriptor"
item.setData(header_text, Qt.DisplayRole)
item.setData(palette.color(QPalette.Disabled, QPalette.Window), Qt.BackgroundRole)
else:
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setData(attr.name, Qt.ToolTipRole)
if not isunique:
item.setData(QColor(Qt.red), Qt.ForegroundRole)
model.setHorizontalHeaderItem(i, item)
attr_count = len(domain.attributes)
view = MyHeaderView(Qt.Horizontal)
view.setResizeMode(QHeaderView.Fixed)
view.setModel(model)
hint = view.sizeHint()
view.setMaximumHeight(hint.height())
widths = [view.sectionSizeHint(i) for i in range(attr_count)]
header_widths.append(widths)
header_views.append(view)
if label:
layout.addWidget(label)
layout.addWidget(view)
layout.addSpacing(8)
# Make all header sections the same width
width_sum = 0
max_header_count = max([h.count() for h in header_views])
for i in range(max_header_count):
max_width = max([w[i] for w in header_widths if i < len(w)] or [0])
for view in header_views:
if i < view.count():
view.resizeSection(i, max_width)
width_sum += max_width + 2
for h in header_views:
h.setMinimumWidth(h.length() + 4)
widget = QWidget()
widget.setLayout(layout)
widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum)
layout.activate()
max_width = max(h.length() for h in header_views) + 20
left, _, right, _ = self.getContentsMargins()
widget.setMinimumWidth(width_sum)
widget.setMinimumWidth(max_width + left + right)
self.groups_scroll_area.setWidget(widget)
def set_items(gene_sets, sets_to_display, genes, callback):
model_items = []
if not genes:
return
for gene_set in sorted(gene_sets):
if gene_set.hierarchy not in sets_to_display:
continue
callback()
matched_set = gene_set.genes & genes
if len(matched_set) > 0:
category_column = QStandardItem()
term_column = QStandardItem()
count_column = QStandardItem()
genes_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy), Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.ToolTipRole)
term_column.setData(gene_set.link, LinkRole)
term_column.setForeground(QColor(Qt.blue))
count_column.setData(matched_set, Qt.UserRole)
count_column.setData(len(matched_set), Qt.DisplayRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(
set(gene_set.genes), Qt.UserRole
) # store genes to get then on output on selection
model_items.append([count_column, genes_column, category_column, term_column])
return model_items
def row_for_state(self, score, state):
attrs = [self.attrs[i] for i in state]
item = QStandardItem(", ".join(a.name for a in attrs))
item.setData(attrs, self._AttrRole)
return [item]
def __set_index(self, f):
# type: (Future) -> None
# set results from `list_remote` query.
assert QThread.currentThread() is self.thread()
assert f.done()
self.setBlocking(False)
self.setStatusMessage("")
allinfolocal = self.list_local()
try:
res = f.result()
except Exception:
log.exception("Error while fetching updated index")
if not allinfolocal:
self.Error.no_remote_datasets()
else:
self.Warning.only_local_datasets()
res = {}
allinforemote = res # type: Dict[Tuple[str, str], dict]
allkeys = set(allinfolocal)
if allinforemote is not None:
allkeys = allkeys | set(allinforemote)
allkeys = sorted(allkeys)
def info(file_path):
if file_path in allinforemote:
info = allinforemote[file_path]
else:
info = allinfolocal[file_path]
islocal = file_path in allinfolocal
isremote = file_path in allinforemote
outdated = islocal and isremote and (
allinforemote[file_path].get('version', '') !=
allinfolocal[file_path].get('version', ''))
islocal &= not outdated
prefix = os.path.join('', *file_path[:-1])
filename = file_path[-1]
return namespace(
prefix=prefix, filename=filename,
title=info.get("title", filename),
datetime=info.get("datetime", None),
description=info.get("description", None),
references=info.get("references", []),
seealso=info.get("seealso", []),
source=info.get("source", None),
year=info.get("year", None),
instances=info.get("instances", None),
variables=info.get("variables", None),
target=info.get("target", None),
missing=info.get("missing", None),
tags=info.get("tags", []),
size=info.get("size", None),
islocal=islocal,
outdated=outdated
)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(HEADER)
current_index = -1
for i, file_path in enumerate(allkeys):
datainfo = info(file_path)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
if datainfo.target:
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags) if datainfo.tags else "",
Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
hs = self.view.header().saveState()
model_ = self.view.model().sourceModel()
self.view.model().setSourceModel(model)
self.view.header().restoreState(hs)
model_.deleteLater()
model_.setParent(None)
self.view.selectionModel().selectionChanged.connect(
self.__on_selection
)
# Update the info text
self.infolabel.setText(format_info(model.rowCount(), len(allinfolocal)))
if current_index != -1:
selmodel = self.view.selectionModel()
selmodel.select(
self.view.model().mapFromSource(model.index(current_index, 0)),
QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
def row_for_state(self, score, state):
attrs = sorted((self.attrs[x] for x in state), key=attrgetter("name"))
item = QStandardItem(", ".join(a.name for a in attrs))
item.setData(attrs, self._AttrRole)
return [item]
def run(gene_sets: GeneSets, selected_gene_sets: List[Tuple[str, ...]], genes,
state: TaskState) -> Results:
results = Results()
items = []
step, steps = 0, len(gene_sets)
if not genes:
return results
state.set_status('Calculating...')
for gene_set in sorted(gene_sets):
step += 1
if step % (steps / 10) == 0:
state.set_progress_value(100 * step / steps)
if gene_set.hierarchy not in selected_gene_sets:
continue
if state.is_interruption_requested():
return results
matched_set = gene_set.genes & genes
if len(matched_set) > 0:
category_column = QStandardItem()
term_column = QStandardItem()
count_column = QStandardItem()
genes_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy),
Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.DisplayRole)
term_column.setData(gene_set.name, Qt.ToolTipRole)
# there was some cases when link string was not empty string but not valid (e.g. "_")
if gene_set.link and urlparse(gene_set.link).scheme:
term_column.setData(gene_set.link, LinkRole)
term_column.setForeground(QColor(Qt.blue))
count_column.setData(matched_set, Qt.UserRole)
count_column.setData(len(matched_set), Qt.DisplayRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(
set(gene_set.genes),
Qt.UserRole) # store genes to get then on output on selection
items.append(
[count_column, genes_column, category_column, term_column])
results.items = items
return results
def set_groups(self, keys, groups, relevant_keys, relevant_items,
all_values, uniquepos):
"""Set the current data groups and update the Group widget
"""
layout = QVBoxLayout()
header_widths = []
header_views = []
palette = self.palette()
all_values = all_values.keys()
def for_print(rd):
attrs = []
for d in rd:
attr = Orange.data.ContinuousVariable(next(inactive_name_gen))
attr.attributes.update(d)
attrs.append(attr)
return Orange.data.Domain(attrs, None)
for separatev, domain in [(None, for_print(relevant_items))] + groups:
label = None
if separatev is not None:
ann_vals = " <b>|</b> ".join(["<b>{0}</b> = {1}".format(key,val) \
for key, val in zip(keys, separatev)])
label = QLabel(ann_vals)
model = QStandardItemModel()
for i, attr in enumerate(domain.attributes):
item = QStandardItem()
if separatev is not None:
isunique = uniquepos[separatev][i]
else:
isunique = all(a[i] for a in uniquepos.values())
if str(attr.name).startswith(
"!!missing "
): # TODO: Change this to not depend on name
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(
header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setFlags(Qt.NoItemFlags)
item.setData(QColor(Qt.red), Qt.ForegroundRole)
item.setData(
palette.color(QPalette.Disabled, QPalette.Window),
Qt.BackgroundRole)
item.setData("Missing feature.", Qt.ToolTipRole)
elif str(attr.name).startswith("!!inactive "):
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key in relevant_items[i]]
header_text = "\n".join(
header_text) if header_text else "No descriptor"
item.setData(header_text, Qt.DisplayRole)
item.setData(
palette.color(QPalette.Disabled, QPalette.Window),
Qt.BackgroundRole)
else:
header_text = ["{0}={1}".format(key, attr.attributes.get(key, "?")) \
for key in all_values if key not in relevant_items[i]]
header_text = "\n".join(
header_text) if header_text else "Empty"
item.setData(header_text, Qt.DisplayRole)
item.setData(attr.name, Qt.ToolTipRole)
if not isunique:
item.setData(QColor(Qt.red), Qt.ForegroundRole)
model.setHorizontalHeaderItem(i, item)
attr_count = len(domain.attributes)
view = MyHeaderView(Qt.Horizontal)
view.setResizeMode(QHeaderView.Fixed)
view.setModel(model)
hint = view.sizeHint()
view.setMaximumHeight(hint.height())
widths = [view.sectionSizeHint(i) for i in range(attr_count)]
header_widths.append(widths)
header_views.append(view)
if label:
layout.addWidget(label)
layout.addWidget(view)
layout.addSpacing(8)
# Make all header sections the same width
width_sum = 0
max_header_count = max([h.count() for h in header_views])
for i in range(max_header_count):
max_width = max([w[i] for w in header_widths if i < len(w)] or [0])
for view in header_views:
if i < view.count():
view.resizeSection(i, max_width)
width_sum += max_width + 2
for h in header_views:
h.setMinimumWidth(h.length() + 4)
widget = QWidget()
widget.setLayout(layout)
widget.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Maximum)
layout.activate()
max_width = max(h.length() for h in header_views) + 20
left, _, right, _ = self.getContentsMargins()
widget.setMinimumWidth(width_sum)
widget.setMinimumWidth(max_width + left + right)
self.groups_scroll_area.setWidget(widget)
def update_stats_model(self):
# Update the results_model with up to date scores.
# Note: The target class specific scores (if requested) are
# computed as needed in this method.
model = self.score_table.model
# clear the table model, but preserving the header labels
for r in reversed(range(model.rowCount())):
model.takeRow(r)
target_index = None
if self.data is not None:
class_var = self.data.domain.class_var
if self.data.domain.has_discrete_class and \
self.class_selection != self.TARGET_AVERAGE:
target_index = class_var.values.index(self.class_selection)
else:
class_var = None
errors = []
has_missing_scores = False
names = []
for key, slot in self.learners.items():
name = learner_name(slot.learner)
names.append(name)
head = QStandardItem(name)
head.setData(key, Qt.UserRole)
results = slot.results
if results is not None and results.success:
train = QStandardItem("{:.3f}".format(
results.value.train_time))
train.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
train.setData(key, Qt.UserRole)
test = QStandardItem("{:.3f}".format(results.value.test_time))
test.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
test.setData(key, Qt.UserRole)
row = [head, train, test]
else:
row = [head]
if isinstance(results, Try.Fail):
head.setToolTip(str(results.exception))
head.setText("{} (error)".format(name))
head.setForeground(QtGui.QBrush(Qt.red))
if isinstance(results.exception, DomainTransformationError) \
and self.resampling == self.TestOnTest:
self.Error.test_data_incompatible()
self.Information.test_data_transformed.clear()
else:
errors.append("{name} failed with error:\n"
"{exc.__class__.__name__}: {exc!s}".format(
name=name, exc=slot.results.exception))
if class_var is not None and class_var.is_discrete and \
target_index is not None:
if slot.results is not None and slot.results.success:
ovr_results = results_one_vs_rest(slot.results.value,
target_index)
# Cell variable is used immediatelly, it's not stored
# pylint: disable=cell-var-from-loop
stats = [
Try(scorer_caller(scorer, ovr_results, target=1))
for scorer in self.scorers
]
else:
stats = None
else:
stats = slot.stats
if stats is not None:
for stat, scorer in zip(stats, self.scorers):
item = QStandardItem()
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
if stat.success:
item.setData(float(stat.value[0]), Qt.DisplayRole)
else:
item.setToolTip(str(stat.exception))
if scorer.name in self.score_table.shown_scores:
has_missing_scores = True
row.append(item)
model.appendRow(row)
# Resort rows based on current sorting
header = self.score_table.view.horizontalHeader()
model.sort(header.sortIndicatorSection(), header.sortIndicatorOrder())
self._set_comparison_headers(names)
self.error("\n".join(errors), shown=bool(errors))
self.Warning.scores_not_computed(shown=has_missing_scores)
def create_model(self):
allkeys = set(self.allinfo_local)
if self.allinfo_remote is not None:
allkeys = allkeys | set(self.allinfo_remote)
allkeys = sorted(allkeys)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(self._header_labels)
current_index = -1
for i, file_path in enumerate(allkeys):
datainfo = self._parse_info(file_path)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
if datainfo.target:
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags) if datainfo.tags else "",
Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
return model, current_index
def __set_index(self, f):
# type: (Future) -> None
# set results from `list_remote` query.
assert QThread.currentThread() is self.thread()
assert f.done()
self.setBlocking(False)
self.setStatusMessage("")
allinfolocal = list_local()
try:
res = f.result()
except Exception as er:
log = logging.getLogger(__name__)
log.exception("Error while fetching updated index")
if not allinfolocal:
self.error("Could not fetch data set list")
else:
self.warning("Could not fetch data sets list, only local "
"cached data sets are shown")
res = {}
allinforemote = res # type: Dict[Tuple[str, str], dict]
allkeys = set(allinfolocal)
if allinforemote is not None:
allkeys = allkeys | set(allinforemote)
allkeys = sorted(allkeys)
def info(prefix, filename):
if (prefix, filename) in allinforemote:
info = allinforemote[prefix, filename]
else:
info = allinfolocal[prefix, filename]
islocal = (prefix, filename) in allinfolocal
return namespace(prefix=prefix,
filename=filename,
title=info.get("title", filename),
datetime=info.get("datetime", None),
description=info.get("description", None),
reference=info.get("reference", None),
instances=info.get("instances", None),
variables=info.get("variables", None),
target=info.get("target", None),
missing=info.get("missing", None),
tags=info.get("tags", []),
size=info.get("size", None),
islocal=islocal)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(HEADER)
current_index = -1
for i, (prefix, filename) in enumerate(allkeys):
datainfo = info(prefix, filename)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags), Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if (prefix, filename) == self.selected_id:
current_index = i
hs = self.view.header().saveState()
model_ = self.view.model()
self.view.setModel(model)
self.view.header().restoreState(hs)
model_.deleteLater()
model_.setParent(None)
self.view.selectionModel().selectionChanged.connect(
self.__on_selection)
# Update the info text
self.infolabel.setText("{} datasets \n{} datasets cached".format(
model.rowCount(), len(allinfolocal)))
if current_index != -1:
selmodel = self.view.selectionModel()
selmodel.select(
model.index(current_index, 0),
QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
def row_for_state(self, score, state):
attr = self.attrs[state]
item = QStandardItem(attr.name)
item.setData(attr, self._AttrRole)
return [item]
def create_model(self):
allkeys = set(self.allinfo_local) | set(self.allinfo_remote)
allkeys = sorted(allkeys)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(self._header_labels)
current_index = -1
for i, file_path in enumerate(allkeys):
datainfo = self._parse_info(file_path)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(self.IndicatorBrushes[0], Qt.ForegroundRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
if datainfo.target:
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags) if datainfo.tags else "",
Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
return model, current_index
def row_for_state(self, score, state):
attrs = [self.attrs[s] for s in state]
item = QStandardItem("[{:0.6f}] ".format(-score) +
", ".join(a.name for a in attrs))
item.setData(attrs, self._AttrRole)
return [item]
def item(displayvalue, item_values={}):
item = QStandardItem()
item.setData(displayvalue, Qt.DisplayRole)
for role, value in item_values.items():
item.setData(value, role)
return item
def encodings_model():
# type: () -> QAbstractItemModel
"""
Return a list model of text encodings.
The items are checkable and initialized based on current stored user
preferences. Any change in check state is stored and writen back
immediately.
The normalized encoding (codec) names are accessible using `Qt.UserRole`
Returns
-------
model : QAbstractItemModel
"""
m = QStandardItemModel()
items = []
settings = QSettings()
settings.beginGroup(SettingsGroup)
def is_selected(co):
# type: (codecs.CodecInfo) -> bool
return settings.value(co.name,
defaultValue=co.name in DEFAULT_ENCODINGS,
type=bool)
def store_selected(index):
# type: (QModelIndex) -> None
# write back the selected state for index
co = index.data(CodecInfoRole)
state = index.data(Qt.CheckStateRole)
if isinstance(co, codecs.CodecInfo):
settings.setValue(co.name, state == Qt.Checked)
for encoding, name in ENCODING_DISPLAY_NAME:
try:
co = codecs.lookup(encoding)
except LookupError:
continue
item = QStandardItem(name)
item.setData(co.name, EncodingNameRole)
item.setData(co, CodecInfoRole)
item.setToolTip(name + "; " + encoding)
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled
| Qt.ItemIsSelectable)
item.setCheckState(Qt.Checked if is_selected(co) else Qt.Unchecked)
items.append(item)
def on_data_changed(first, last, roles=()):
# type: (QModelIndex, QModelIndex, Iterable[int]) -> None
if roles and Qt.CheckStateRole not in roles:
return
assert first.column() == last.column()
for i in range(first.row(), last.row() + 1):
index = first.sibling(i, first.column())
store_selected(index)
m.invisibleRootItem().appendRows(items)
m.dataChanged.connect(on_data_changed)
return m
def item(displayvalue, item_values={}):
item = QStandardItem()
item.setData(displayvalue, Qt.DisplayRole)
for role, value in item_values.items():
item.setData(value, role)
return item
def _update_stats_model(self):
# Update the results_model with up to date scores.
# Note: The target class specific scores (if requested) are
# computed as needed in this method.
model = self.view.model()
# clear the table model, but preserving the header labels
for r in reversed(range(model.rowCount())):
model.takeRow(r)
target_index = None
if self.data is not None:
class_var = self.data.domain.class_var
if self.data.domain.has_discrete_class and \
self.class_selection != self.TARGET_AVERAGE:
target_index = class_var.values.index(self.class_selection)
else:
class_var = None
errors = []
has_missing_scores = False
for key, slot in self.learners.items():
name = learner_name(slot.learner)
head = QStandardItem(name)
head.setData(key, Qt.UserRole)
if isinstance(slot.results, Try.Fail):
head.setToolTip(str(slot.results.exception))
head.setText("{} (error)".format(name))
head.setForeground(QtGui.QBrush(Qt.red))
errors.append("{name} failed with error:\n"
"{exc.__class__.__name__}: {exc!s}"
.format(name=name, exc=slot.results.exception))
row = [head]
if class_var is not None and class_var.is_discrete and \
target_index is not None:
if slot.results is not None and slot.results.success:
ovr_results = results_one_vs_rest(
slot.results.value, target_index)
# Cell variable is used immediatelly, it's not stored
# pylint: disable=cell-var-from-loop
stats = [Try(scorer_caller(scorer, ovr_results))
for scorer in self.scorers]
else:
stats = None
else:
stats = slot.stats
if stats is not None:
for stat in stats:
item = QStandardItem()
if stat.success:
item.setText("{:.3f}".format(stat.value[0]))
else:
item.setToolTip(str(stat.exception))
has_missing_scores = True
row.append(item)
model.appendRow(row)
self.error("\n".join(errors), shown=bool(errors))
self.Warning.scores_not_computed(shown=has_missing_scores)
def set_items(self, items):
# type: (List[Item]) -> None
self.__items = items
model = self.__model
model.setRowCount(0)
for item in items:
if isinstance(item, Installed):
installed = True
ins, dist = item
name = dist.project_name
summary = get_dist_meta(dist).get("Summary", "")
version = ins.version if ins is not None else dist.version
else:
installed = False
(ins,) = item
dist = None
name = ins.name
summary = ins.summary
version = ins.version
updatable = is_updatable(item)
item1 = QStandardItem()
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable |
(Qt.ItemIsTristate if updatable else 0))
if installed and updatable:
item1.setCheckState(Qt.PartiallyChecked)
elif installed:
item1.setCheckState(Qt.Checked)
else:
item1.setCheckState(Qt.Unchecked)
item1.setData(item, Qt.UserRole)
item2 = QStandardItem(cleanup(name))
item2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item2.setToolTip(summary)
item2.setData(item, Qt.UserRole)
if updatable:
version = "{} < {}".format(dist.version, ins.version)
item3 = QStandardItem(version)
item3.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item4 = QStandardItem()
item4.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
model.appendRow([item1, item2, item3, item4])
model.sort(1)
self.__view.resizeColumnToContents(0)
self.__view.setColumnWidth(
1, max(150, self.__view.sizeHintForColumn(1)))
self.__view.setColumnWidth(
2, max(150, self.__view.sizeHintForColumn(2)))
if self.__items:
self.__view.selectionModel().select(
self.__view.model().index(0, 0),
QItemSelectionModel.Select | QItemSelectionModel.Rows
)
self.__proxy.sort(1) # sorting list of add-ons in alphabetical order
def set_items(gene_sets,
sets_to_display,
genes,
callback,
reference_genes=None):
model_items = []
if not genes:
return
for gene_set in sorted(gene_sets):
if gene_set.hierarchy not in sets_to_display:
continue
reference_genes = [] if reference_genes is None else reference_genes
enrichemnt_result = gene_set.set_enrichment(
reference_genes, genes.intersection(reference_genes))
callback()
if len(enrichemnt_result.query) > 0:
category_column = QStandardItem()
name_column = QStandardItem()
count_column = QStandardItem()
genes_column = QStandardItem()
ref_column = QStandardItem()
pval_column = QStandardItem()
fdr_column = QStandardItem()
enrichment_column = QStandardItem()
category_column.setData(", ".join(gene_set.hierarchy),
Qt.DisplayRole)
name_column.setData(gene_set.name, Qt.DisplayRole)
name_column.setData(gene_set.name, Qt.ToolTipRole)
name_column.setData(gene_set.link, LinkRole)
name_column.setForeground(QColor(Qt.blue))
count_column.setData(len(enrichemnt_result.query),
Qt.DisplayRole)
count_column.setData(set(enrichemnt_result.query), Qt.UserRole)
genes_column.setData(len(gene_set.genes), Qt.DisplayRole)
genes_column.setData(
set(gene_set.genes), Qt.UserRole
) # store genes to get then on output on selection
ref_column.setData(len(enrichemnt_result.reference),
Qt.DisplayRole)
pval_column.setData(enrichemnt_result.p_value, Qt.DisplayRole)
pval_column.setData(enrichemnt_result.p_value, Qt.ToolTipRole)
enrichment_column.setData(enrichemnt_result.enrichment_score,
Qt.DisplayRole)
enrichment_column.setData(enrichemnt_result.enrichment_score,
Qt.ToolTipRole)
model_items.append([
count_column,
ref_column,
pval_column,
fdr_column,
enrichment_column,
genes_column,
category_column,
name_column,
])
return model_items
def set_items(self, items):
self.__items = items
model = self.__model
model.clear()
model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"])
for item in items:
if isinstance(item, Installed):
installed = True
ins, dist = item
name = dist.project_name
summary = get_dist_meta(dist).get("Summary", "")
version = ins.version if ins is not None else dist.version
else:
installed = False
(ins, ) = item
dist = None
name = ins.name
summary = ins.summary
version = ins.version
updatable = is_updatable(item)
item1 = QStandardItem()
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable
| (Qt.ItemIsTristate if updatable else 0))
if installed and updatable:
item1.setCheckState(Qt.PartiallyChecked)
elif installed:
item1.setCheckState(Qt.Checked)
else:
item1.setCheckState(Qt.Unchecked)
item2 = QStandardItem(cleanup(name))
item2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item2.setToolTip(summary)
item2.setData(item, Qt.UserRole)
if updatable:
version = "{} < {}".format(dist.version, ins.version)
item3 = QStandardItem(version)
item3.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item4 = QStandardItem()
item4.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
model.appendRow([item1, item2, item3, item4])
self.__view.resizeColumnToContents(0)
self.__view.setColumnWidth(1, max(150,
self.__view.sizeHintForColumn(1)))
self.__view.setColumnWidth(2, max(150,
self.__view.sizeHintForColumn(2)))
if self.__items:
self.__view.selectionModel().select(
self.__view.model().index(0, 0),
QItemSelectionModel.Select | QItemSelectionModel.Rows)
def _update_stats_model(self):
# Update the results_model with up to date scores.
# Note: The target class specific scores (if requested) are
# computed as needed in this method.
model = self.view.model()
# clear the table model, but preserving the header labels
for r in reversed(range(model.rowCount())):
model.takeRow(r)
target_index = None
if self.data is not None:
class_var = self.data.domain.class_var
if self.data.domain.has_discrete_class and \
self.class_selection != self.TARGET_AVERAGE:
target_index = class_var.values.index(self.class_selection)
else:
class_var = None
errors = []
has_missing_scores = False
for key, slot in self.learners.items():
name = learner_name(slot.learner)
head = QStandardItem(name)
head.setData(key, Qt.UserRole)
if isinstance(slot.results, Try.Fail):
head.setToolTip(str(slot.results.exception))
head.setText("{} (error)".format(name))
head.setForeground(QtGui.QBrush(Qt.red))
errors.append("{name} failed with error:\n"
"{exc.__class__.__name__}: {exc!s}".format(
name=name, exc=slot.results.exception))
row = [head]
if class_var is not None and class_var.is_discrete and \
target_index is not None:
if slot.results is not None and slot.results.success:
ovr_results = results_one_vs_rest(slot.results.value,
target_index)
# Cell variable is used immediatelly, it's not stored
# pylint: disable=cell-var-from-loop
stats = [
Try(scorer_caller(scorer, ovr_results))
for scorer in self.scorers
]
else:
stats = None
else:
stats = slot.stats
if stats is not None:
for stat in stats:
item = QStandardItem()
if stat.success:
item.setText("{:.3f}".format(stat.value[0]))
else:
item.setToolTip(str(stat.exception))
has_missing_scores = True
row.append(item)
model.appendRow(row)
self.error("\n".join(errors), shown=bool(errors))
self.Warning.scores_not_computed(shown=has_missing_scores)
def row_for_state(self, score, state):
attrs = sorted((self.attrs[x] for x in state), key=attrgetter("name"))
item = QStandardItem(", ".join(a.name for a in attrs))
item.setData(attrs, self._AttrRole)
return [item]
def row_for_state(self, score, state):
attrs = [self.attrs[s] for s in state]
item = QStandardItem("[{:0.6f}] ".format(-score) + ", ".join(a.name for a in attrs))
item.setData(attrs, self._AttrRole)
return [item]
def _create_value_item(text):
item = QStandardItem()
item.setData(text, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
return item
def __set_horizontal_title(self, titleh):
item = QStandardItem()
item.setData(titleh, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
self.table_model.setItem(0, self._n_leading_cols, item)
self.setSpan(0, self._n_leading_cols, 1, self._n_classesh + 3)
def __sparsity_item(self):
item = QStandardItem()
item.setData(self._data_loader.sparsity, Qt.DisplayRole)
item.setEditable(False)
return item
