def find_patterns(self):
print(self.sampling_type)
db = self.data
ps = PrefixSpan(db)
n_items = len(db)
result = None
opts = {
"closed": self.closed,
# Somehow does not work
#"generator": self.generator
}
from pprint import pprint
pprint(opts)
if self.sampling_type:
result = ps.topk(self.k, **opts)
else:
print("Support value:", self.min_support)
print("Size:", n_items)
print("Support:", n_items * self.min_support / 100)
result = ps.frequent((self.min_support * n_items / 100.0), **opts)
self.table.model().clear()
model = QStandardItemModel(self.table)
model.clear()
for col, label in enumerate(["Support", "Pattern"]):
item = QStandardItem(label)
model.setHorizontalHeaderItem(col, item)
sequences = []
for support, pattern in result:
if len(pattern) < self.min_len:
continue
support /= n_items
sequences.append((support, pattern))
sitem = self.NumericItem(support)
pitem = QStandardItem(str(pattern))
model.appendRow([sitem, pitem])
self.Outputs.object.send(sequences)
self.table.setModel(model)
class VizRankDialog(QDialog, ProgressBarMixin, WidgetMessagesMixin):
"""
Base class for VizRank dialogs, providing a GUI with a table and a button,
and the skeleton for managing the evaluation of visualizations.
Derived classes must provide methods
- `iterate_states` for generating combinations (e.g. pairs of attritutes),
- `compute_score(state)` for computing the score of a combination,
- `row_for_state(state)` that returns a list of items inserted into the
table for the given state.
and, optionally,
- `state_count` that returns the number of combinations (used for progress
bar)
- `on_selection_changed` that handles event triggered when the user selects
a table row. The method should emit signal
`VizRankDialog.selectionChanged(object)`.
The class provides a table and a button. A widget constructs a single
instance of this dialog in its `__init__`, like (in Sieve) by using a
convenience method :obj:`add_vizrank`::
self.vizrank, self.vizrank_button = SieveRank.add_vizrank(
box, self, "Score Combinations", self.set_attr)
When the widget receives new data, it must call the VizRankDialog's
method :obj:`VizRankDialog.initialize()` to clear the GUI and reset the
state.
Clicking the Start button calls method `run` (and renames the button to
Pause). Run sets up a progress bar by getting the number of combinations
from :obj:`VizRankDialog.state_count()`. It restores the paused state
(if any) and calls generator :obj:`VizRankDialog.iterate_states()`. For
each generated state, it calls :obj:`VizRankDialog.score(state)`, which
must return the score (lower is better) for this state. If the returned
state is not `None`, the data returned by `row_for_state` is inserted at
the appropriate place in the table.
Args:
master (Orange.widget.OWWidget): widget to which the dialog belongs
Attributes:
master (Orange.widget.OWWidget): widget to which the dialog belongs
captionTitle (str): the caption for the dialog. This can be a class
attribute. `captionTitle` is used by the `ProgressBarMixin`.
"""
captionTitle = ""
processingStateChanged = Signal(int)
progressBarValueChanged = Signal(float)
messageActivated = Signal(Msg)
messageDeactivated = Signal(Msg)
selectionChanged = Signal(object)
class Information(WidgetMessagesMixin.Information):
nothing_to_rank = Msg("There is nothing to rank.")
def __init__(self, master):
"""Initialize the attributes and set up the interface"""
QDialog.__init__(self, windowTitle=self.captionTitle)
WidgetMessagesMixin.__init__(self)
self.setLayout(QVBoxLayout())
self.insert_message_bar()
self.layout().insertWidget(0, self.message_bar)
self.master = master
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.scores = []
self.rank_model = QStandardItemModel(self)
self.rank_table = view = QTableView(
selectionBehavior=QTableView.SelectRows,
selectionMode=QTableView.SingleSelection,
showGrid=False)
view.setItemDelegate(HorizontalGridDelegate())
view.setModel(self.rank_model)
view.selectionModel().selectionChanged.connect(
self.on_selection_changed)
view.horizontalHeader().setStretchLastSection(True)
view.horizontalHeader().hide()
self.layout().addWidget(view)
self.button = gui.button(self,
self,
"Start",
callback=self.toggle,
default=True)
@classmethod
def add_vizrank(cls, widget, master, button_label, set_attr_callback):
"""
Equip the widget with VizRank button and dialog, and monkey patch the
widget's `closeEvent` and `hideEvent` to close/hide the vizrank, too.
Args:
widget (QWidget): the widget into whose layout to insert the button
master (Orange.widgets.widget.OWWidget): the master widget
button_label: the label for the button
set_attr_callback: the callback for setting the projection chosen
in the vizrank
Returns:
tuple with Vizrank dialog instance and push button
"""
# Monkey patching could be avoided by mixing-in the class (not
# necessarily a good idea since we can make a mess of multiple
# defined/derived closeEvent and hideEvent methods). Furthermore,
# per-class patching would be better than per-instance, but we don't
# want to mess with meta-classes either.
vizrank = cls(master)
button = gui.button(widget,
master,
button_label,
callback=vizrank.reshow,
enabled=False)
vizrank.selectionChanged.connect(lambda args: set_attr_callback(*args))
master_close_event = master.closeEvent
master_hide_event = master.hideEvent
def closeEvent(event):
vizrank.close()
master_close_event(event)
def hideEvent(event):
vizrank.hide()
master_hide_event(event)
master.closeEvent = closeEvent
master.hideEvent = hideEvent
return vizrank, button
def reshow(self):
"""Put the widget on top of all windows
"""
self.show()
self.raise_()
self.activateWindow()
def initialize(self):
"""
Clear and initialize the dialog.
This method must be called by the widget when the data is reset,
e.g. from `set_data` handler.
"""
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.scores = []
self.rank_model.clear()
self.button.setText("Start")
self.button.setEnabled(self.check_preconditions())
def stop_and_reset(self, reset_method=None):
if self.keep_running:
self.scheduled_call = reset_method or self.initialize
self.keep_running = False
else:
self.initialize()
def check_preconditions(self):
"""Check whether there is sufficient data for ranking."""
return True
def on_selection_changed(self, selected, deselected):
"""
Set the new visualization in the widget when the user select a
row in the table.
If derived class does not reimplement this, the table gives the
information but the user can't click it to select the visualization.
Args:
selected: the index of the selected item
deselected: the index of the previously selected item
"""
pass
def iterate_states(self, initial_state):
"""
Generate all possible states (e.g. attribute combinations) for the
given data. The content of the generated states is specific to the
visualization.
This method must be defined in the derived classes.
Args:
initial_state: initial state; None if this is the first call
"""
raise NotImplementedError
def state_count(self):
"""
Return the number of states for the progress bar.
Derived classes should implement this to ensure the proper behaviour of
the progress bar"""
return 0
def compute_score(self, state):
"""
Abstract method for computing the score for the given state. Smaller
scores are better.
Args:
state: the state, e.g. the combination of attributes as generated
by :obj:`state_count`.
"""
raise NotImplementedError
def row_for_state(self, score, state):
"""
Abstract method that return the items that are inserted into the table.
Args:
score: score, computed by :obj:`compute_score`
state: the state, e.g. combination of attributes
"""
raise NotImplementedError
def _select_first_if_none(self):
if not self.rank_table.selectedIndexes():
self.rank_table.selectRow(0)
def run(self):
"""Compute and show scores"""
with self.progressBar(self.state_count()) as progress:
progress.advance(self.saved_progress)
for state in self.iterate_states(self.saved_state):
if not self.keep_running:
if self.scheduled_call:
self.scheduled_call()
else:
self.saved_state = state
self.saved_progress = progress.count
self._select_first_if_none()
return
score = self.compute_score(state)
if score is not None:
pos = bisect_left(self.scores, score)
self.rank_model.insertRow(pos,
self.row_for_state(score, state))
self.scores.insert(pos, score)
progress.advance()
self._select_first_if_none()
self.button.setText("Finished")
self.button.setEnabled(False)
self.keep_running = False
self.saved_state = None
def toggle(self):
"""Start or pause the computation."""
self.keep_running = not self.keep_running
if self.keep_running:
self.button.setText("Pause")
self.run()
else:
self._select_first_if_none()
self.button.setText("Continue")
class SelectionSetsWidget(QFrame):
"""
Widget for managing multiple stored item selections
"""
selectionModified = Signal(bool)
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setContentsMargins(0, 0, 0, 0)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(1)
self._setNameLineEdit = QLineEdit(self)
layout.addWidget(self._setNameLineEdit)
self._setListView = QListView(self)
self._listModel = QStandardItemModel(self)
self._proxyModel = QSortFilterProxyModel(self)
self._proxyModel.setSourceModel(self._listModel)
self._setListView.setModel(self._proxyModel)
self._setListView.setItemDelegate(ListItemDelegate(self))
self._setNameLineEdit.textChanged.connect(
self._proxyModel.setFilterFixedString)
self._completer = QCompleter(self._listModel, self)
self._setNameLineEdit.setCompleter(self._completer)
self._listModel.itemChanged.connect(self._onSetNameChange)
layout.addWidget(self._setListView)
buttonLayout = QHBoxLayout()
self._addAction = QAction(
"+", self, toolTip="Add a new sort key")
self._updateAction = QAction(
"Update", self, toolTip="Update/save current selection")
self._removeAction = QAction(
"\u2212", self, toolTip="Remove selected sort key.")
self._addToolButton = QToolButton(self)
self._updateToolButton = QToolButton(self)
self._removeToolButton = QToolButton(self)
self._updateToolButton.setSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.Minimum)
self._addToolButton.setDefaultAction(self._addAction)
self._updateToolButton.setDefaultAction(self._updateAction)
self._removeToolButton.setDefaultAction(self._removeAction)
buttonLayout.addWidget(self._addToolButton)
buttonLayout.addWidget(self._updateToolButton)
buttonLayout.addWidget(self._removeToolButton)
layout.addLayout(buttonLayout)
self.setLayout(layout)
self._addAction.triggered.connect(self.addCurrentSelection)
self._updateAction.triggered.connect(self.updateSelectedSelection)
self._removeAction.triggered.connect(self.removeSelectedSelection)
self._setListView.selectionModel().selectionChanged.connect(
self._onListViewSelectionChanged)
self.selectionModel = None
self._selections = []
def sizeHint(self):
size = QFrame.sizeHint(self)
return QSize(size.width(), 150)
def _onSelectionChanged(self, selected, deselected):
self.setSelectionModified(True)
def _onListViewSelectionChanged(self, selected, deselected):
try:
index = self._setListView.selectedIndexes()[0]
except IndexError:
return
self.commitSelection(self._proxyModel.mapToSource(index).row())
def _onSetNameChange(self, item):
self.selections[item.row()].name = str(item.text())
def _setButtonStates(self, val):
self._updateToolButton.setEnabled(val)
def setSelectionModel(self, selectionModel):
if self.selectionModel:
self.selectionModel.selectionChanged.disconnect(
self._onSelectionChanged)
self.selectionModel = selectionModel
self.selectionModel.selectionChanged.connect(self._onSelectionChanged)
def addCurrentSelection(self):
item = self.addSelection(
SelectionByKey(self.selectionModel.selection(),
name="New selection",
key=(1, 2, 3, 10)))
index = self._proxyModel.mapFromSource(item.index())
self._setListView.setCurrentIndex(index)
self._setListView.edit(index)
self.setSelectionModified(False)
def removeSelectedSelection(self):
i = self._proxyModel.mapToSource(self._setListView.currentIndex()).row()
self._listModel.takeRow(i)
del self.selections[i]
def updateCurentSelection(self):
i = self._proxyModel.mapToSource(self._setListView.selectedIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def addSelection(self, selection, name=""):
self._selections.append(selection)
item = QStandardItem(selection.name)
item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled)
self._listModel.appendRow(item)
self.setSelectionModified(False)
return item
def updateSelectedSelection(self):
i = self._proxyModel.mapToSource(self._setListView.currentIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def setSelectionModified(self, val):
self._selectionModified = val
self._setButtonStates(val)
self.selectionModified.emit(bool(val))
def commitSelection(self, index):
selection = self.selections[index]
selection.select(self.selectionModel)
def setSelections(self, selections):
self._listModel.clear()
for selection in selections:
self.addSelection(selection)
def selections(self):
return self._selections
selections = property(selections, setSelections)
class ContingencyTable(QTableView):
"""
A contingency table widget which can be used wherever ``QTableView`` could be used.
Parameters
----------
parent : Orange.widgets.widget.OWWidget
The containing widget to which the table is connected.
Attributes
----------
classesv : :obj:`list` of :obj:`str`
Vertical class headers.
classesh : :obj:`list` of :obj:`str`
Horizontal class headers.
headerv : :obj:`str`, optional
Vertical top header.
headerh : :obj:`str`, optional
Horizontal top header.
corner_string : str
String that is top right and bottom left corner of the table.
Default is ``unicodedata.lookup("N-ARY SUMMATION")``.
"""
def __init__(self, parent):
super().__init__(editTriggers=QTableView.NoEditTriggers)
self.bold_headers = None
self.circles = False
self.classesv = None
self.classesh = None
self.headerv = None
self.headerh = None
self.parent = parent
self.corner_string = unicodedata.lookup("N-ARY SUMMATION")
self.tablemodel = QStandardItemModel(self)
self.setModel(self.tablemodel)
self.horizontalHeader().hide()
self.verticalHeader().hide()
self.horizontalHeader().setMinimumSectionSize(60)
self.setShowGrid(False)
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.clicked.connect(self._cell_clicked)
def mouseReleaseEvent(self, e):
super().mouseReleaseEvent(e)
self.parent._invalidate()
def keyPressEvent(self, event):
super().keyPressEvent(event)
self.parent._invalidate()
def _cell_clicked(self, model_index):
"""Handle cell click event"""
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
m = self.tablemodel.columnCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or not self.circles and i == n - 1 and j == m - 1:
selection = QItemSelection(index(2, 2), index(n - 1, m - 1))
elif i == 1 or not self.circles and i == n - 1:
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j == 1 or not self.circles and j == m - 1:
selection = QItemSelection(index(i, 2), index(i, m - 1))
if selection is not None:
self.selectionModel().select(selection,
QItemSelectionModel.ClearAndSelect)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def set_variables(self, variablev, variableh, **kwargs):
"""
Sets class headers and top headers and initializes table structure.
Parameters
----------
variablev : Orange.data.variable.DiscreteVariable
Class headers are set to ``variablev.values``, top header is set to ``variablev.name``.
variableh : Orange.data.variable.DiscreteVariable
Class headers are set to ``variableh.values``, top header is set to ``variableh.name``.
"""
self.classesv = variablev.values
self.classesh = variableh.values
self.headerv = variablev.name
self.headerh = variableh.name
self.initialize(**kwargs)
def set_headers(self,
classesv,
classesh,
headerv=None,
headerh=None,
**kwargs):
"""
Sets class headers and top headers and initializes table structure.
Parameters
----------
classesv : :obj:`list` of :obj:`str`
Vertical class headers.
classesh : :obj:`list` of :obj:`str`
Horizontal class headers.
headerv : :obj:`str`, optional
Vertical top header.
headerh : :obj:`str`, optional
Horizontal top header.
"""
self.classesv = classesv
self.classesh = classesh
self.headerv = headerv
self.headerh = headerh
self.initialize(**kwargs)
def _style_cells(self):
"""
Style all cells.
"""
if self.circles:
self.setItemDelegate(CircleItemDelegate(Qt.white))
else:
self.setItemDelegate(BorderedItemDelegate(Qt.white))
item = self._item(0, 2)
item.setData(self.headerh, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData(self.headerv, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.setItemDelegateForColumn(0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.setSpan(0, 2, 1, len(self.classesh) + 1)
self.setSpan(2, 0, len(self.classesv) + 1, 1)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
def _initialize_headers(self):
"""
Fill headers with content and style them.
"""
font = self.tablemodel.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
for headers, ix in ((self.classesv + [self.corner_string], lambda p:
(p + 2, 1)),
(self.classesh + [self.corner_string], lambda p:
(1, p + 2))):
for p, label in enumerate(headers):
i, j = ix(p)
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
if self.bold_headers:
item.setFont(bold_font)
if not (i == 1 and self.circles):
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
if p < len(headers) - 1:
item.setData("br"[j == 1], BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
else:
item.setData("", BorderRole)
self._set_item(i, j, item)
def _resize(self):
"""
Resize table to fit new contents and style.
"""
if self.circles:
self.resizeRowToContents(1)
self.horizontalHeader().setDefaultSectionSize(self.rowHeight(2))
self.resizeColumnToContents(1)
self.tablemodel.setRowCount(len(self.classesv) + 2)
self.tablemodel.setColumnCount(len(self.classesh) + 2)
else:
if len(' '.join(self.classesh + [self.corner_string])) < 120:
self.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
else:
self.horizontalHeader().setDefaultSectionSize(60)
self.tablemodel.setRowCount(len(self.classesv) + 3)
self.tablemodel.setColumnCount(len(self.classesh) + 3)
def initialize(self, circles=False, bold_headers=True):
"""
Initializes table structure. Class headers must be set beforehand.
Parameters
----------
circles : :obj:`bool`, optional
Turns on circle display. All table values should be between 0 and 1 (inclusive). Defaults to False.
bold_headers : :obj:`bool`, optional
Whether the headers are bold or not. Defaults to True.
"""
assert self.classesv is not None and self.classesh is not None
self.circles = circles
self.bold_headers = bold_headers
self._style_cells()
self._initialize_headers()
self._resize()
def get_selection(self):
"""
Get indexes of selected cells.
Returns
-------
:obj:`set` of :obj:`tuple` of :obj:`int`
Set of pairs of indexes.
"""
return {(ind.row() - 2, ind.column() - 2)
for ind in self.selectedIndexes()}
def set_selection(self, indexes):
"""
Set indexes of selected cells.
Parameters
----------
indexes : :obj:`set` of :obj:`tuple` of :obj:`int`
Set of pairs of indexes.
"""
selection = QItemSelection()
index = self.model().index
for row, col in indexes:
sel = index(row + 2, col + 2)
selection.select(sel, sel)
self.selectionModel().select(selection,
QItemSelectionModel.ClearAndSelect)
def _set_sums(self, colsum, rowsum):
"""
Set content of cells on bottom and right edge.
Parameters
----------
colsum : numpy.array
Content of cells on bottom edge.
rowsum : numpy.array
Content of cells on right edge.
"""
bold_font = self.tablemodel.invisibleRootItem().font()
bold_font.setBold(True)
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
for i in range(len(self.classesh)):
self._set_item(
len(self.classesv) + 2, i + 2, _sum_item(int(colsum[i]), "t"))
for i in range(len(self.classesv)):
self._set_item(i + 2,
len(self.classesh) + 2,
_sum_item(int(rowsum[i]), "l"))
self._set_item(
len(self.classesv) + 2,
len(self.classesh) + 2, _sum_item(int(rowsum.sum())))
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 update_table(self,
matrix,
colsum=None,
rowsum=None,
colors=None,
formatstr="{}",
tooltip=None):
"""
Sets ``matrix`` as data of the table.
Parameters
----------
matrix : numpy.array
2D array to be set as data.
colsum : :obj:`numpy.array`, optional
1D optional array with aggregate values of columns, defaults to sum.
rowsum : :obj:`numpy.array`, optional
1D optional array with aggregate values of rows, defaults to sum.
colors : :obj:`numpy.array`, optional
2D array with color values, defaults to no color.
formatstr : :obj:`str`, optional
Format string for cell data, defaults to ``"{}"``.
tooltip : :obj:`(int, int) -> str`, optional
Function which takes vertical index and horizontal index as arguments and returns
desired tooltip as a string. Defaults to no tooltips.
"""
selected_indexes = self.get_selection()
self._set_values(matrix, colors, formatstr, tooltip)
if not self.circles:
if colsum is None:
colsum = matrix.sum(axis=0)
if rowsum is None:
rowsum = matrix.sum(axis=1)
self._set_sums(colsum, rowsum)
self.set_selection(selected_indexes)
def clear(self):
"""
Clears the table.
"""
self.tablemodel.clear()
class VizRankDialog(QDialog, ProgressBarMixin, WidgetMessagesMixin):
"""
Base class for VizRank dialogs, providing a GUI with a table and a button,
and the skeleton for managing the evaluation of visualizations.
Derived classes must provide methods
- `iterate_states` for generating combinations (e.g. pairs of attritutes),
- `compute_score(state)` for computing the score of a combination,
- `row_for_state(state)` that returns a list of items inserted into the
table for the given state.
and, optionally,
- `state_count` that returns the number of combinations (used for progress
bar)
- `on_selection_changed` that handles event triggered when the user selects
a table row. The method should emit signal
`VizRankDialog.selectionChanged(object)`.
- `bar_length` returns the length of the bar corresponding to the score.
The class provides a table and a button. A widget constructs a single
instance of this dialog in its `__init__`, like (in Sieve) by using a
convenience method :obj:`add_vizrank`::
self.vizrank, self.vizrank_button = SieveRank.add_vizrank(
box, self, "Score Combinations", self.set_attr)
When the widget receives new data, it must call the VizRankDialog's
method :obj:`VizRankDialog.initialize()` to clear the GUI and reset the
state.
Clicking the Start button calls method `run` (and renames the button to
Pause). Run sets up a progress bar by getting the number of combinations
from :obj:`VizRankDialog.state_count()`. It restores the paused state
(if any) and calls generator :obj:`VizRankDialog.iterate_states()`. For
each generated state, it calls :obj:`VizRankDialog.score(state)`, which
must return the score (lower is better) for this state. If the returned
state is not `None`, the data returned by `row_for_state` is inserted at
the appropriate place in the table.
Args:
master (Orange.widget.OWWidget): widget to which the dialog belongs
Attributes:
master (Orange.widget.OWWidget): widget to which the dialog belongs
captionTitle (str): the caption for the dialog. This can be a class
attribute. `captionTitle` is used by the `ProgressBarMixin`.
"""
captionTitle = ""
NEGATIVE_COLOR = QColor(70, 190, 250)
POSITIVE_COLOR = QColor(170, 242, 43)
processingStateChanged = Signal(int)
progressBarValueChanged = Signal(float)
messageActivated = Signal(Msg)
messageDeactivated = Signal(Msg)
selectionChanged = Signal(object)
class Information(WidgetMessagesMixin.Information):
nothing_to_rank = Msg("There is nothing to rank.")
def __init__(self, master):
"""Initialize the attributes and set up the interface"""
QDialog.__init__(self, master, windowTitle=self.captionTitle)
WidgetMessagesMixin.__init__(self)
self.setLayout(QVBoxLayout())
self.insert_message_bar()
self.layout().insertWidget(0, self.message_bar)
self.master = master
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.scores = []
self.add_to_model = queue.Queue()
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self._update)
self.update_timer.setInterval(200)
self._thread = None
self._worker = None
self.filter = QLineEdit()
self.filter.setPlaceholderText("Filter ...")
self.filter.textChanged.connect(self.filter_changed)
self.layout().addWidget(self.filter)
# Remove focus from line edit
self.setFocus(Qt.ActiveWindowFocusReason)
self.rank_model = QStandardItemModel(self)
self.model_proxy = QSortFilterProxyModel(self,
filterCaseSensitivity=False)
self.model_proxy.setSourceModel(self.rank_model)
self.rank_table = view = QTableView(
selectionBehavior=QTableView.SelectRows,
selectionMode=QTableView.SingleSelection,
showGrid=False,
editTriggers=gui.TableView.NoEditTriggers)
if self._has_bars:
view.setItemDelegate(TableBarItem())
else:
view.setItemDelegate(HorizontalGridDelegate())
view.setModel(self.model_proxy)
view.selectionModel().selectionChanged.connect(
self.on_selection_changed)
view.horizontalHeader().setStretchLastSection(True)
view.horizontalHeader().hide()
self.layout().addWidget(view)
self.button = gui.button(self,
self,
"Start",
callback=self.toggle,
default=True)
@property
def _has_bars(self):
return type(self).bar_length is not VizRankDialog.bar_length
@classmethod
def add_vizrank(cls, widget, master, button_label, set_attr_callback):
"""
Equip the widget with VizRank button and dialog, and monkey patch the
widget's `closeEvent` and `hideEvent` to close/hide the vizrank, too.
Args:
widget (QWidget): the widget into whose layout to insert the button
master (Orange.widgets.widget.OWWidget): the master widget
button_label: the label for the button
set_attr_callback: the callback for setting the projection chosen
in the vizrank
Returns:
tuple with Vizrank dialog instance and push button
"""
# Monkey patching could be avoided by mixing-in the class (not
# necessarily a good idea since we can make a mess of multiple
# defined/derived closeEvent and hideEvent methods). Furthermore,
# per-class patching would be better than per-instance, but we don't
# want to mess with meta-classes either.
vizrank = cls(master)
button = gui.button(widget,
master,
button_label,
callback=vizrank.reshow,
enabled=False)
vizrank.selectionChanged.connect(lambda args: set_attr_callback(*args))
master_close_event = master.closeEvent
master_hide_event = master.hideEvent
master_delete_event = master.onDeleteWidget
def closeEvent(event):
vizrank.close()
master_close_event(event)
def hideEvent(event):
vizrank.hide()
master_hide_event(event)
def deleteEvent():
vizrank.keep_running = False
if vizrank._thread is not None and vizrank._thread.isRunning():
vizrank._thread.quit()
vizrank._thread.wait()
master_delete_event()
master.closeEvent = closeEvent
master.hideEvent = hideEvent
master.onDeleteWidget = deleteEvent
return vizrank, button
def reshow(self):
"""Put the widget on top of all windows
"""
self.show()
self.raise_()
self.activateWindow()
def initialize(self):
"""
Clear and initialize the dialog.
This method must be called by the widget when the data is reset,
e.g. from `set_data` handler.
"""
if self._thread is not None and self._thread.isRunning():
self.keep_running = False
self._thread.quit()
self._thread.wait()
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.update_timer.stop()
self.progressBarFinished()
self.scores = []
self._update_model() # empty queue
self.rank_model.clear()
self.button.setText("Start")
self.button.setEnabled(self.check_preconditions())
self._thread = QThread(self)
self._worker = Worker(self)
self._worker.moveToThread(self._thread)
self._worker.stopped.connect(self._thread.quit)
self._worker.stopped.connect(self._select_first_if_none)
self._worker.stopped.connect(self._stopped)
self._worker.done.connect(self._done)
self._thread.started.connect(self._worker.do_work)
def filter_changed(self, text):
self.model_proxy.setFilterFixedString(text)
def stop_and_reset(self, reset_method=None):
if self.keep_running:
self.scheduled_call = reset_method or self.initialize
self.keep_running = False
else:
self.initialize()
def check_preconditions(self):
"""Check whether there is sufficient data for ranking."""
return True
def on_selection_changed(self, selected, deselected):
"""
Set the new visualization in the widget when the user select a
row in the table.
If derived class does not reimplement this, the table gives the
information but the user can't click it to select the visualization.
Args:
selected: the index of the selected item
deselected: the index of the previously selected item
"""
pass
def iterate_states(self, initial_state):
"""
Generate all possible states (e.g. attribute combinations) for the
given data. The content of the generated states is specific to the
visualization.
This method must be defined in the derived classes.
Args:
initial_state: initial state; None if this is the first call
"""
raise NotImplementedError
def state_count(self):
"""
Return the number of states for the progress bar.
Derived classes should implement this to ensure the proper behaviour of
the progress bar"""
return 0
def compute_score(self, state):
"""
Abstract method for computing the score for the given state. Smaller
scores are better.
Args:
state: the state, e.g. the combination of attributes as generated
by :obj:`state_count`.
"""
raise NotImplementedError
def bar_length(self, score):
"""Compute the bar length (between 0 and 1) corresponding to the score.
Return `None` if the score cannot be normalized.
"""
return None
def row_for_state(self, score, state):
"""
Abstract method that return the items that are inserted into the table.
Args:
score: score, computed by :obj:`compute_score`
state: the state, e.g. combination of attributes
"""
raise NotImplementedError
def _select_first_if_none(self):
if not self.rank_table.selectedIndexes():
self.rank_table.selectRow(0)
def _done(self):
self.button.setText("Finished")
self.button.setEnabled(False)
self.keep_running = False
self.saved_state = None
def _stopped(self):
self.update_timer.stop()
self.progressBarFinished()
self._update_model()
self.stopped()
if self.scheduled_call:
self.scheduled_call()
def _update(self):
self._update_model()
self._update_progress()
def _update_progress(self):
self.progressBarSet(
int(self.saved_progress * 100 / max(1, self.state_count())))
def _update_model(self):
try:
while True:
pos, row_items = self.add_to_model.get_nowait()
self.rank_model.insertRow(pos, row_items)
except queue.Empty:
pass
def toggle(self):
"""Start or pause the computation."""
self.keep_running = not self.keep_running
if self.keep_running:
self.button.setText("Pause")
self.progressBarInit()
self.update_timer.start()
self.before_running()
self._thread.start()
else:
self.button.setText("Continue")
self._thread.quit()
# Need to sync state (the worker must read the keep_running
# state and stop) for reliable restart.
self._thread.wait()
def before_running(self):
"""Code that is run before running vizrank in its own thread"""
pass
def stopped(self):
"""Code that is run after stopping the vizrank thread"""
pass
class PivotTableView(QTableView):
selection_changed = pyqtSignal()
TOTAL_STRING = "Total"
def __init__(self):
super().__init__(editTriggers=QTableView.NoEditTriggers)
self._n_classesv = None # number of row_feature values
self._n_classesh = None # number of col_feature values
self._n_agg_func = None # number of aggregation functions
self._n_leading_rows = None # number of leading rows
self._n_leading_cols = None # number of leading columns
self.table_model = QStandardItemModel(self)
self.setModel(self.table_model)
self.horizontalHeader().hide()
self.verticalHeader().hide()
self.horizontalHeader().setMinimumSectionSize(60)
self.setShowGrid(False)
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
self.setItemDelegate(BorderedItemDelegate())
self.pressed.connect(self.__cell_clicked)
self.clicked.connect(self.__cell_clicked)
self.entered.connect(self.__cell_entered)
self.__clicked_cell = None
@property
def add_agg_column(self) -> bool:
return self._n_agg_func > 1
def __cell_entered(self, model_index):
if self.__clicked_cell is None:
return
index = self.table_model.index
selection = None
i_end, j_end = model_index.row(), model_index.column()
i_start, j_start = self.__clicked_cell
i_start, i_end = sorted([i_start, i_end])
j_start, j_end = sorted([j_start, j_end])
if i_start >= self._n_leading_rows and j_start >= self._n_leading_cols:
i_start = (i_start - self._n_leading_rows) // self._n_agg_func * \
self._n_agg_func + self._n_leading_rows
i_end = (i_end - self._n_leading_rows) // self._n_agg_func * \
self._n_agg_func + self._n_leading_rows + self._n_agg_func - 1
start, end = index(i_start, j_start), index(i_end, j_end)
selection = QItemSelection(start, end)
if selection is not None:
self.selectionModel().select(selection,
QItemSelectionModel.ClearAndSelect)
self.selection_changed.emit()
def __cell_clicked(self, model_index):
i, j = model_index.row(), model_index.column()
self.__clicked_cell = (i, j)
m, n = self.table_model.rowCount(), self.table_model.columnCount()
index = self.table_model.index
selection = None
if i > m - self._n_agg_func - 1 and j == n - 1:
start_index = index(self._n_leading_rows, self._n_leading_cols)
selection = QItemSelection(start_index, index(m - 1, n - 1))
elif i == self._n_leading_rows - 1 or i > m - self._n_agg_func - 1:
start_index = index(self._n_leading_rows, j)
selection = QItemSelection(start_index, index(m - 1, j))
elif j in (self._n_leading_cols - 1, n - 1, 1):
i_start = (i - self._n_leading_rows) // self._n_agg_func * \
self._n_agg_func + self._n_leading_rows
i_end = i_start + self._n_agg_func - 1
start_index = index(i_start, self._n_leading_cols)
selection = QItemSelection(start_index, index(i_end, n - 1))
elif i >= self._n_leading_rows and j >= self._n_leading_cols:
i_start = (i - self._n_leading_rows) // self._n_agg_func * \
self._n_agg_func + self._n_leading_rows
i_end = i_start + self._n_agg_func - 1
selection = QItemSelection(index(i_start, j), index(i_end, j))
if selection is not None:
self.selectionModel().select(selection,
QItemSelectionModel.ClearAndSelect)
def mouseReleaseEvent(self, e):
super().mouseReleaseEvent(e)
self.selection_changed.emit()
def update_table(self, titleh: str, titlev: str, table: Table,
table_total_h: Table, table_total_v: Table,
table_total: Table):
self.clear()
if not table:
return
self._initialize(table, table_total_h)
self._set_headers(titleh, titlev, table)
self._set_values(table[:, 2:])
self._set_totals(table_total_h[:, 2:], table_total_v, table_total)
self._draw_lines()
self._resize(table)
def _initialize(self, table, table_total_h):
self._n_classesv = int(len(table) / len(table_total_h))
self._n_classesh = table.X.shape[1] - 2
self._n_agg_func = len(table_total_h)
self._n_leading_rows = 2
self._n_leading_cols = 2 + int(len(table_total_h) > 1)
def _set_headers(self, titleh, titlev, table):
self.__set_horizontal_title(titleh)
self.__set_vertical_title(titlev)
self.__set_flags_title()
self.__set_horizontal_headers(table)
self.__set_vertical_headers(table)
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 __set_vertical_title(self, titlev):
item = QStandardItem()
item.setData(titlev, Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
self.setItemDelegateForColumn(0, gui.VerticalItemDelegate(extend=True))
self.table_model.setItem(self._n_leading_rows, 0, item)
row_span = self._n_classesv * self._n_agg_func + 1
self.setSpan(self._n_leading_rows, 0, row_span, 1)
def __set_flags_title(self):
item = self.table_model.item(0, self._n_leading_cols)
item.setFlags(Qt.NoItemFlags)
item = self.table_model.item(self._n_leading_rows, 0)
item.setFlags(Qt.NoItemFlags)
for i, j in product(range(self._n_leading_rows),
range(self._n_leading_cols)):
item = QStandardItem()
item.setFlags(Qt.NoItemFlags)
self.table_model.setItem(i, j, item)
def __set_horizontal_headers(self, table):
labels = [a.name for a in table.domain[1:]] + [self.TOTAL_STRING]
if not self.add_agg_column:
labels[0] = str(table[0, 1])
for i, label in enumerate(labels, self._n_leading_cols - 1):
self.table_model.setItem(1, i, self._create_header_item(label))
def __set_vertical_headers(self, table):
labels = [(str(row[0]), str(row[1])) for row in table]
i = self._n_leading_rows - 1
for i, (l1, l2) in enumerate(labels, self._n_leading_rows):
l1 = "" if (i - self._n_leading_rows) % self._n_agg_func else l1
self.table_model.setItem(i, 1, self._create_header_item(l1))
if self.add_agg_column:
self.table_model.setItem(i, 2, self._create_header_item(l2))
if self.add_agg_column:
labels = [str(row[1]) for row in table[:self._n_agg_func]]
start = self._n_leading_rows + self._n_agg_func * self._n_classesv
for j, l2 in enumerate(labels, i + 1):
l1 = self.TOTAL_STRING if j == start else ""
self.table_model.setItem(j, 1, self._create_header_item(l1))
self.table_model.setItem(j, 2, self._create_header_item(l2))
else:
item = self._create_header_item(self.TOTAL_STRING)
self.table_model.setItem(i + 1, 1, item)
def _set_values(self, table):
for i, j in product(range(len(table)), range(len(table[0]))):
value = table[i, j]
item = self._create_value_item(str(value))
self.table_model.setItem(i + self._n_leading_rows,
j + self._n_leading_cols, item)
def _set_totals(self, table_total_h, table_total_v, table_total):
def set_total_item(table, get_row, get_col):
for i, j in product(range(len(table)), range(len(table[0]))):
item = self._create_header_item(str(table[i, j]))
self.table_model.setItem(get_row(i), get_col(j), item)
last_row = self._n_leading_rows + self._n_classesv * self._n_agg_func
last_col = self._n_leading_cols + self._n_classesh
set_total_item(table_total_v, lambda x: x + self._n_leading_rows,
lambda x: last_col)
set_total_item(table_total_h, lambda x: x + last_row,
lambda x: x + self._n_leading_cols)
set_total_item(table_total, lambda x: x + last_row, lambda x: last_col)
def _create_header_item(self, text):
bold_font = self.table_model.invisibleRootItem().font()
bold_font.setBold(True)
item = QStandardItem()
item.setData(text, Qt.DisplayRole)
item.setFont(bold_font)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
return item
@staticmethod
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 _draw_lines(self):
end_col = self._n_leading_cols + self._n_classesh + 1
total_row = self._n_leading_rows + self._n_classesv * self._n_agg_func
indices = [(total_row, j) for j in range(1, end_col)]
for i in range(self._n_classesv):
inner_row = self._n_agg_func * i + self._n_leading_rows
inner_indices = [(inner_row, j) for j in range(1, end_col)]
indices = indices + inner_indices
if not self.add_agg_column:
break
for i, j in indices:
item = self.table_model.item(i, j)
item.setData("t", BorderRole)
item.setData(QColor(160, 160, 160), BorderColorRole)
def _resize(self, table):
labels = [a.name for a in table.domain[1:]] + [self.TOTAL_STRING]
if len(' '.join(labels)) < 120:
self.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
else:
self.horizontalHeader().setDefaultSectionSize(60)
def get_selection(self) -> Set:
m, n = self._n_leading_rows, self._n_leading_cols
return {(ind.row() - m, ind.column() - n)
for ind in self.selectedIndexes()}
def set_selection(self, indexes: Set):
selection = QItemSelection()
index = self.model().index
for row, col in indexes:
sel = index(row + self._n_leading_rows, col + self._n_leading_cols)
selection.select(sel, sel)
self.selectionModel().select(selection,
QItemSelectionModel.ClearAndSelect)
def clear(self):
self.table_model.clear()
class VizRankDialog(QDialog, ProgressBarMixin, WidgetMessagesMixin):
"""
Base class for VizRank dialogs, providing a GUI with a table and a button,
and the skeleton for managing the evaluation of visualizations.
Derived classes must provide methods
- `iterate_states` for generating combinations (e.g. pairs of attritutes),
- `compute_score(state)` for computing the score of a combination,
- `row_for_state(state)` that returns a list of items inserted into the
table for the given state.
and, optionally,
- `state_count` that returns the number of combinations (used for progress
bar)
- `on_selection_changed` that handles event triggered when the user selects
a table row. The method should emit signal
`VizRankDialog.selectionChanged(object)`.
- `bar_length` returns the length of the bar corresponding to the score.
The class provides a table and a button. A widget constructs a single
instance of this dialog in its `__init__`, like (in Sieve) by using a
convenience method :obj:`add_vizrank`::
self.vizrank, self.vizrank_button = SieveRank.add_vizrank(
box, self, "Score Combinations", self.set_attr)
When the widget receives new data, it must call the VizRankDialog's
method :obj:`VizRankDialog.initialize()` to clear the GUI and reset the
state.
Clicking the Start button calls method `run` (and renames the button to
Pause). Run sets up a progress bar by getting the number of combinations
from :obj:`VizRankDialog.state_count()`. It restores the paused state
(if any) and calls generator :obj:`VizRankDialog.iterate_states()`. For
each generated state, it calls :obj:`VizRankDialog.score(state)`, which
must return the score (lower is better) for this state. If the returned
state is not `None`, the data returned by `row_for_state` is inserted at
the appropriate place in the table.
Args:
master (Orange.widget.OWWidget): widget to which the dialog belongs
Attributes:
master (Orange.widget.OWWidget): widget to which the dialog belongs
captionTitle (str): the caption for the dialog. This can be a class
attribute. `captionTitle` is used by the `ProgressBarMixin`.
"""
captionTitle = ""
processingStateChanged = Signal(int)
progressBarValueChanged = Signal(float)
messageActivated = Signal(Msg)
messageDeactivated = Signal(Msg)
selectionChanged = Signal(object)
class Information(WidgetMessagesMixin.Information):
nothing_to_rank = Msg("There is nothing to rank.")
def __init__(self, master):
"""Initialize the attributes and set up the interface"""
QDialog.__init__(self, master, windowTitle=self.captionTitle)
WidgetMessagesMixin.__init__(self)
self.setLayout(QVBoxLayout())
self.insert_message_bar()
self.layout().insertWidget(0, self.message_bar)
self.master = master
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.scores = []
self.add_to_model = queue.Queue()
self.update_timer = QTimer(self)
self.update_timer.timeout.connect(self._update)
self.update_timer.setInterval(200)
self._thread = None
self._worker = None
self.filter = QLineEdit()
self.filter.setPlaceholderText("Filter ...")
self.filter.textChanged.connect(self.filter_changed)
self.layout().addWidget(self.filter)
# Remove focus from line edit
self.setFocus(Qt.ActiveWindowFocusReason)
self.rank_model = QStandardItemModel(self)
self.model_proxy = QSortFilterProxyModel(
self, filterCaseSensitivity=False)
self.model_proxy.setSourceModel(self.rank_model)
self.rank_table = view = QTableView(
selectionBehavior=QTableView.SelectRows,
selectionMode=QTableView.SingleSelection,
showGrid=False,
editTriggers=gui.TableView.NoEditTriggers)
if self._has_bars:
view.setItemDelegate(TableBarItem())
else:
view.setItemDelegate(HorizontalGridDelegate())
view.setModel(self.model_proxy)
view.selectionModel().selectionChanged.connect(
self.on_selection_changed)
view.horizontalHeader().setStretchLastSection(True)
view.horizontalHeader().hide()
self.layout().addWidget(view)
self.button = gui.button(
self, self, "Start", callback=self.toggle, default=True)
@property
def _has_bars(self):
return type(self).bar_length is not VizRankDialog.bar_length
@classmethod
def add_vizrank(cls, widget, master, button_label, set_attr_callback):
"""
Equip the widget with VizRank button and dialog, and monkey patch the
widget's `closeEvent` and `hideEvent` to close/hide the vizrank, too.
Args:
widget (QWidget): the widget into whose layout to insert the button
master (Orange.widgets.widget.OWWidget): the master widget
button_label: the label for the button
set_attr_callback: the callback for setting the projection chosen
in the vizrank
Returns:
tuple with Vizrank dialog instance and push button
"""
# Monkey patching could be avoided by mixing-in the class (not
# necessarily a good idea since we can make a mess of multiple
# defined/derived closeEvent and hideEvent methods). Furthermore,
# per-class patching would be better than per-instance, but we don't
# want to mess with meta-classes either.
vizrank = cls(master)
button = gui.button(
widget, master, button_label, callback=vizrank.reshow,
enabled=False)
vizrank.selectionChanged.connect(lambda args: set_attr_callback(*args))
master_close_event = master.closeEvent
master_hide_event = master.hideEvent
master_delete_event = master.onDeleteWidget
def closeEvent(event):
vizrank.close()
master_close_event(event)
def hideEvent(event):
vizrank.hide()
master_hide_event(event)
def deleteEvent():
vizrank.keep_running = False
if vizrank._thread is not None and vizrank._thread.isRunning():
vizrank._thread.quit()
vizrank._thread.wait()
master_delete_event()
master.closeEvent = closeEvent
master.hideEvent = hideEvent
master.onDeleteWidget = deleteEvent
return vizrank, button
def reshow(self):
"""Put the widget on top of all windows
"""
self.show()
self.raise_()
self.activateWindow()
def initialize(self):
"""
Clear and initialize the dialog.
This method must be called by the widget when the data is reset,
e.g. from `set_data` handler.
"""
if self._thread is not None and self._thread.isRunning():
self.keep_running = False
self._thread.quit()
self._thread.wait()
self.keep_running = False
self.scheduled_call = None
self.saved_state = None
self.saved_progress = 0
self.update_timer.stop()
self.progressBarFinished()
self.scores = []
self._update_model() # empty queue
self.rank_model.clear()
self.button.setText("Start")
self.button.setEnabled(self.check_preconditions())
self._thread = QThread(self)
self._worker = Worker(self)
self._worker.moveToThread(self._thread)
self._worker.stopped.connect(self._thread.quit)
self._worker.stopped.connect(self._select_first_if_none)
self._worker.stopped.connect(self._stopped)
self._worker.done.connect(self._done)
self._thread.started.connect(self._worker.do_work)
def filter_changed(self, text):
self.model_proxy.setFilterFixedString(text)
def stop_and_reset(self, reset_method=None):
if self.keep_running:
self.scheduled_call = reset_method or self.initialize
self.keep_running = False
else:
self.initialize()
def check_preconditions(self):
"""Check whether there is sufficient data for ranking."""
return True
def on_selection_changed(self, selected, deselected):
"""
Set the new visualization in the widget when the user select a
row in the table.
If derived class does not reimplement this, the table gives the
information but the user can't click it to select the visualization.
Args:
selected: the index of the selected item
deselected: the index of the previously selected item
"""
pass
def iterate_states(self, initial_state):
"""
Generate all possible states (e.g. attribute combinations) for the
given data. The content of the generated states is specific to the
visualization.
This method must be defined in the derived classes.
Args:
initial_state: initial state; None if this is the first call
"""
raise NotImplementedError
def state_count(self):
"""
Return the number of states for the progress bar.
Derived classes should implement this to ensure the proper behaviour of
the progress bar"""
return 0
def compute_score(self, state):
"""
Abstract method for computing the score for the given state. Smaller
scores are better.
Args:
state: the state, e.g. the combination of attributes as generated
by :obj:`state_count`.
"""
raise NotImplementedError
def bar_length(self, score):
"""Compute the bar length (between 0 and 1) corresponding to the score.
Return `None` if the score cannot be normalized.
"""
return None
def row_for_state(self, score, state):
"""
Abstract method that return the items that are inserted into the table.
Args:
score: score, computed by :obj:`compute_score`
state: the state, e.g. combination of attributes
"""
raise NotImplementedError
def _select_first_if_none(self):
if not self.rank_table.selectedIndexes():
self.rank_table.selectRow(0)
def _done(self):
self.button.setText("Finished")
self.button.setEnabled(False)
self.keep_running = False
self.saved_state = None
def _stopped(self):
self.update_timer.stop()
self.progressBarFinished()
self._update_model()
self.stopped()
if self.scheduled_call:
self.scheduled_call()
def _update(self):
self._update_model()
self._update_progress()
def _update_progress(self):
self.progressBarSet(int(self.saved_progress * 100 / max(1, self.state_count())))
def _update_model(self):
try:
while True:
pos, row_items = self.add_to_model.get_nowait()
self.rank_model.insertRow(pos, row_items)
except queue.Empty:
pass
def toggle(self):
"""Start or pause the computation."""
self.keep_running = not self.keep_running
if self.keep_running:
self.button.setText("Pause")
self.progressBarInit()
self.update_timer.start()
self.before_running()
self._thread.start()
else:
self.button.setText("Continue")
self._thread.quit()
# Need to sync state (the worker must read the keep_running
# state and stop) for reliable restart.
self._thread.wait()
def before_running(self):
"""Code that is run before running vizrank in its own thread"""
pass
def stopped(self):
"""Code that is run after stopping the vizrank thread"""
pass
class SelectionSetsWidget(QFrame):
"""
Widget for managing multiple stored item selections
"""
selectionModified = Signal(bool)
def __init__(self, parent):
QFrame.__init__(self, parent)
self.setContentsMargins(0, 0, 0, 0)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(1)
self._setNameLineEdit = QLineEdit(self)
layout.addWidget(self._setNameLineEdit)
self._setListView = QListView(self)
self._listModel = QStandardItemModel(self)
self._proxyModel = QSortFilterProxyModel(self)
self._proxyModel.setSourceModel(self._listModel)
self._setListView.setModel(self._proxyModel)
self._setListView.setItemDelegate(ListItemDelegate(self))
self._setNameLineEdit.textChanged.connect(
self._proxyModel.setFilterFixedString)
self._completer = QCompleter(self._listModel, self)
self._setNameLineEdit.setCompleter(self._completer)
self._listModel.itemChanged.connect(self._onSetNameChange)
layout.addWidget(self._setListView)
buttonLayout = QHBoxLayout()
self._addAction = QAction("+", self, toolTip="Add a new sort key")
self._updateAction = QAction("Update",
self,
toolTip="Update/save current selection")
self._removeAction = QAction("\u2212",
self,
toolTip="Remove selected sort key.")
self._addToolButton = QToolButton(self)
self._updateToolButton = QToolButton(self)
self._removeToolButton = QToolButton(self)
self._updateToolButton.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
self._addToolButton.setDefaultAction(self._addAction)
self._updateToolButton.setDefaultAction(self._updateAction)
self._removeToolButton.setDefaultAction(self._removeAction)
buttonLayout.addWidget(self._addToolButton)
buttonLayout.addWidget(self._updateToolButton)
buttonLayout.addWidget(self._removeToolButton)
layout.addLayout(buttonLayout)
self.setLayout(layout)
self._addAction.triggered.connect(self.addCurrentSelection)
self._updateAction.triggered.connect(self.updateSelectedSelection)
self._removeAction.triggered.connect(self.removeSelectedSelection)
self._setListView.selectionModel().selectionChanged.connect(
self._onListViewSelectionChanged)
self.selectionModel = None
self._selections = []
def sizeHint(self):
size = QFrame.sizeHint(self)
return QSize(size.width(), 150)
def _onSelectionChanged(self, selected, deselected):
self.setSelectionModified(True)
def _onListViewSelectionChanged(self, selected, deselected):
try:
index = self._setListView.selectedIndexes()[0]
except IndexError:
return
self.commitSelection(self._proxyModel.mapToSource(index).row())
def _onSetNameChange(self, item):
self.selections[item.row()].name = str(item.text())
def _setButtonStates(self, val):
self._updateToolButton.setEnabled(val)
def setSelectionModel(self, selectionModel):
if self.selectionModel:
self.selectionModel.selectionChanged.disconnect(
self._onSelectionChanged)
self.selectionModel = selectionModel
self.selectionModel.selectionChanged.connect(self._onSelectionChanged)
def addCurrentSelection(self):
item = self.addSelection(
SelectionByKey(self.selectionModel.selection(),
name="New selection",
key=(1, 2, 3, 10)))
index = self._proxyModel.mapFromSource(item.index())
self._setListView.setCurrentIndex(index)
self._setListView.edit(index)
self.setSelectionModified(False)
def removeSelectedSelection(self):
i = self._proxyModel.mapToSource(
self._setListView.currentIndex()).row()
self._listModel.takeRow(i)
del self.selections[i]
def updateCurentSelection(self):
i = self._proxyModel.mapToSource(
self._setListView.selectedIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def addSelection(self, selection, name=""):
self._selections.append(selection)
item = QStandardItem(selection.name)
item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled)
self._listModel.appendRow(item)
self.setSelectionModified(False)
return item
def updateSelectedSelection(self):
i = self._proxyModel.mapToSource(
self._setListView.currentIndex()).row()
self.selections[i].setSelection(self.selectionModel.selection())
self.setSelectionModified(False)
def setSelectionModified(self, val):
self._selectionModified = val
self._setButtonStates(val)
self.selectionModified.emit(bool(val))
def commitSelection(self, index):
selection = self.selections[index]
selection.select(self.selectionModel)
def setSelections(self, selections):
self._listModel.clear()
for selection in selections:
self.addSelection(selection)
def selections(self):
return self._selections
selections = property(selections, setSelections)
class OWOntology(OWWidget, ConcurrentWidgetMixin):
name = "Ontology"
description = ""
icon = "icons/Ontology.svg"
priority = 1110
keywords = []
CACHED, LIBRARY = range(2) # library list modification types
RUN_BUTTON, INC_BUTTON = "Generate", "Include"
settingsHandler = DomainContextHandler()
ontology_library: List[Dict] = Setting([
{"name": Ontology.generate_name([]), "ontology": {}},
])
ontology_index: int = Setting(0)
ontology: OntoType = Setting((), schema_only=True)
include_children = Setting(True)
auto_commit = Setting(True)
class Inputs:
words = Input("Words", Table)
class Outputs:
words = Output("Words", Table, dynamic=False)
class Warning(OWWidget.Warning):
no_words_column = Msg("Input is missing 'Words' column.")
class Error(OWWidget.Error):
load_error = Msg("{}")
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.__onto_handler = OntologyHandler()
flags = Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable
self.__model = PyListModel([], self, flags=flags)
self.__input_model = QStandardItemModel()
self.__library_view: QListView = None
self.__input_view: ListViewSearch = None
self.__ontology_view: EditableTreeView = None
self.ontology_info = ""
self._setup_gui()
self._restore_state()
self.settingsAboutToBePacked.connect(self._save_state)
def _setup_gui(self):
# control area
library_box: QGroupBox = gui.vBox(self.controlArea, "Library")
library_box.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum)
edit_triggers = QListView.DoubleClicked | QListView.EditKeyPressed
self.__library_view = QListView(
editTriggers=int(edit_triggers),
minimumWidth=200,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Expanding),
)
self.__library_view.setFixedHeight(100)
self.__library_view.setItemDelegate(LibraryItemDelegate(self))
self.__library_view.setModel(self.__model)
self.__library_view.selectionModel().selectionChanged.connect(
self.__on_selection_changed
)
actions_widget = ModelActionsWidget()
actions_widget.layout().setSpacing(1)
tool_tip = "Add a new ontology to the library"
action = QAction("+", self, toolTip=tool_tip)
action.triggered.connect(self.__on_add)
actions_widget.addAction(action)
tool_tip = "Remove the ontology from the library"
action = QAction("\N{MINUS SIGN}", self, toolTip=tool_tip)
action.triggered.connect(self.__on_remove)
actions_widget.addAction(action)
tool_tip = "Save changes in the editor to the library"
action = QAction("Update", self, toolTip=tool_tip)
action.triggered.connect(self.__on_update)
actions_widget.addAction(action)
gui.rubber(actions_widget)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Ontology from File", self)
new_from_file.triggered.connect(self.__on_import_file)
new_from_url = QAction("Import Ontology from URL", self)
new_from_url.triggered.connect(self.__on_import_url)
save_to_file = QAction("Save Ontology to File", self)
save_to_file.triggered.connect(self.__on_save)
menu = QMenu(actions_widget)
menu.addAction(new_from_file)
menu.addAction(new_from_url)
menu.addAction(save_to_file)
action.setMenu(menu)
button = actions_widget.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
vlayout = QVBoxLayout()
vlayout.setSpacing(1)
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addWidget(self.__library_view)
vlayout.addWidget(actions_widget)
library_box.layout().setSpacing(1)
library_box.layout().addLayout(vlayout)
input_box: QGroupBox = gui.vBox(self.controlArea, "Input")
self.__input_view = ListViewSearch(
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Expanding),
selectionMode=QListView.ExtendedSelection,
dragEnabled=True,
)
self.__input_view.setModel(self.__input_model)
self.__input_view.selectionModel().selectionChanged.connect(
self._enable_include_button
)
self.__inc_button = gui.button(
None, self, self.INC_BUTTON, enabled=False,
toolTip="Include selected words into the ontology",
autoDefault=False, callback=self.__on_toggle_include
)
input_box.layout().setSpacing(1)
input_box.layout().addWidget(self.__input_view)
input_box.layout().addWidget(self.__inc_button)
self.__run_button = gui.button(
self.controlArea, self, self.RUN_BUTTON,
callback=self.__on_toggle_run
)
gui.checkBox(
self.controlArea, self, "include_children", "Include subtree",
box="Output", callback=self.commit.deferred
)
box = gui.vBox(self.controlArea, "Ontology info")
gui.label(box, self, "%(ontology_info)s")
gui.auto_send(self.buttonsArea, self, "auto_commit")
# main area
ontology_box: QGroupBox = gui.vBox(self.mainArea, box=True)
self.__ontology_view = EditableTreeView(self)
self.__ontology_view.dataChanged.connect(
self.__on_ontology_data_changed
)
self.__ontology_view.selectionChanged.connect(self.commit.deferred)
ontology_box.layout().setSpacing(1)
ontology_box.layout().addWidget(self.__ontology_view)
self._enable_include_button()
def __on_selection_changed(self, selection: QItemSelection, *_):
self.Error.load_error.clear()
if selection.indexes():
self.ontology_index = row = selection.indexes()[0].row()
data = self.__model[row].cached_word_tree
self.__ontology_view.set_data(data)
self.__update_score()
error_msg = self.__model[row].error_msg
if error_msg:
self.Error.load_error(error_msg)
def __on_add(self):
name = Ontology.generate_name([l.name for l in self.__model])
data = self.__ontology_view.get_data()
self.__model.append(Ontology(name, data))
self.__set_selected_row(len(self.__model) - 1)
def __on_remove(self):
index = self.__get_selected_row()
if index is not None:
del self.__model[index]
self.__set_selected_row(max(index - 1, 0))
def __on_update(self):
self.__set_current_modified(self.LIBRARY)
def __on_import_file(self):
ontology = read_from_file(self)
self._import_ontology(ontology)
def __on_import_url(self):
ontology = read_from_url(self)
self._import_ontology(ontology)
def __on_save(self):
index = self.__get_selected_row()
if index is not None:
filename = self.__model[index].filename
if filename:
filename, _ = os.path.splitext(filename)
else:
filename = os.path.expanduser("~/")
save_ontology(self, filename, self.__ontology_view.get_data())
QApplication.setActiveWindow(self)
def __on_toggle_include(self):
if self.task is not None:
self._cancel_tasks()
else:
self._run_insert()
def __on_toggle_run(self):
if self.task is not None:
self._cancel_tasks()
else:
self._run()
def __on_ontology_data_changed(self):
self.__set_current_modified(self.CACHED)
self.__update_score()
self._enable_include_button()
self.commit.deferred()
@Inputs.words
def set_words(self, words: Optional[Table]):
self.Warning.no_words_column.clear()
self.__input_model.clear()
if words:
if WORDS_COLUMN_NAME in words.domain and words.domain[
WORDS_COLUMN_NAME].attributes.get("type") == "words":
for word in words.get_column_view(WORDS_COLUMN_NAME)[0]:
self.__input_model.appendRow(QStandardItem(word))
else:
self.Warning.no_words_column()
@gui.deferred
def commit(self):
if self.include_children:
words = self.__ontology_view.get_selected_words_with_children()
else:
words = self.__ontology_view.get_selected_words()
words_table = self._create_output_table(sorted(words))
self.Outputs.words.send(words_table)
@staticmethod
def _create_output_table(words: List[str]) -> Optional[Table]:
if not words:
return None
return create_words_table(words)
def _cancel_tasks(self):
self.cancel()
self.__inc_button.setText(self.INC_BUTTON)
self.__run_button.setText(self.RUN_BUTTON)
def _run(self):
self.__run_button.setText("Stop")
words = self.__ontology_view.get_words()
handler = self.__onto_handler.generate
self.start(_run, handler, (words,))
def _run_insert(self):
self.__inc_button.setText("Stop")
tree = self.__ontology_view.get_data()
words = self.__get_selected_input_words()
handler = self.__onto_handler.insert
self.start(_run, handler, (tree, words))
def on_done(self, data: Dict):
self.__inc_button.setText(self.INC_BUTTON)
self.__run_button.setText(self.RUN_BUTTON)
self.__ontology_view.set_data(data, keep_history=True)
self.__set_current_modified(self.CACHED)
self.__update_score()
def __update_score(self):
tree = self.__ontology_view.get_data()
score = round(self.__onto_handler.score(tree), 2) \
if len(tree) == 1 and list(tree.values())[0] else "/"
self.ontology_info = f"Score: {score}"
def on_exception(self, ex: Exception):
raise ex
def on_partial_result(self, _: Any):
pass
def onDeleteWidget(self):
self.shutdown()
super().onDeleteWidget()
def __set_selected_row(self, row: int):
self.__library_view.selectionModel().select(
self.__model.index(row, 0), QItemSelectionModel.ClearAndSelect
)
def __get_selected_row(self) -> Optional[int]:
rows = self.__library_view.selectionModel().selectedRows()
return rows[0].row() if rows else None
def __set_current_modified(self, mod_type: int):
index = self.__get_selected_row()
if index is not None:
if mod_type == self.LIBRARY:
ontology = self.__ontology_view.get_data()
self.__model[index].word_tree = ontology
self.__model[index].cached_word_tree = ontology
self.__model[index].update_rule_flag = Ontology.NotModified
elif mod_type == self.CACHED:
ontology = self.__ontology_view.get_data()
self.__model[index].cached_word_tree = ontology
else:
raise NotImplementedError
self.__model.emitDataChanged(index)
self.__library_view.repaint()
def __get_selected_input_words(self) -> List[str]:
return [self.__input_view.model().data(index) for index in
self.__input_view.selectedIndexes()]
def _import_ontology(self, ontology: Ontology):
if ontology is not None:
self.__model.append(ontology)
self.__set_selected_row(len(self.__model) - 1)
QApplication.setActiveWindow(self)
def _restore_state(self):
source = [Ontology.from_dict(s) for s in self.ontology_library]
self.__model.wrap(source)
self.__set_selected_row(self.ontology_index)
if self.ontology:
self.__ontology_view.set_data(self.ontology)
self.__set_current_modified(self.CACHED)
self.__update_score()
self.commit.now()
def _save_state(self):
self.ontology_library = [s.as_dict() for s in self.__model]
self.ontology = self.__ontology_view.get_data(with_selection=True)
def _enable_include_button(self):
tree = self.__ontology_view.get_data()
words = self.__get_selected_input_words()
enabled = len(tree) == 1 and len(words) > 0
self.__inc_button.setEnabled(enabled)
def send_report(self):
model = self.__model
library = model[self.ontology_index].name if model else "/"
self.report_items("Settings", [("Library", library)])
ontology = self.__ontology_view.get_data()
style = """
<style>
ul {
padding-top: 0px;
padding-right: 0px;
padding-bottom: 0px;
padding-left: 20px;
}
</style>
"""
self.report_raw("Ontology", style + _tree_to_html(ontology))
class OWConfusionMatrix(widget.OWWidget):
"""Confusion matrix widget"""
name = "Confusion Matrix"
description = "Display a confusion matrix constructed from " \
"the results of classifier evaluations."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
class Inputs:
evaluation_results = Input("Evaluation Results", Orange.evaluation.Results)
class Outputs:
selected_data = Output("Selected Data", Orange.data.Table, default=True)
annotated_data = Output(ANNOTATED_DATA_SIGNAL_NAME, Orange.data.Table)
quantities = ["Number of instances",
"Proportion of predicted",
"Proportion of actual"]
settings_version = 1
settingsHandler = settings.ClassValuesContextHandler()
selected_learner = settings.Setting([0], schema_only=True)
selection = settings.ContextSetting(set())
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances",
"click_cell")]
class Error(widget.OWWidget.Error):
no_regression = Msg("Confusion Matrix cannot show regression results.")
invalid_values = Msg("Evaluation Results input contains invalid values")
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
self.learners_box = gui.listBox(
self.controlArea, self, "selected_learner", "learners", box=True,
callback=self._learner_changed
)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.outputbox, self, "autocommit",
"Send Selected", "Send Automatically", box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox, self, "selected_quantity",
items=self.quantities, label="Show: ",
orientation=Qt.Horizontal, callback=self._update)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
view.clicked.connect(self.cell_clicked)
box.layout().addWidget(view)
selbox = gui.hBox(box)
gui.button(selbox, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(selbox, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(selbox, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
def sizeHint(self):
"""Initial size"""
return QSize(750, 340)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def _init_table(self, nclasses):
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, nclasses)
self.tableview.setSpan(2, 0, nclasses, 1)
font = self.tablemodel.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setFont(bold_font)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
if p < len(self.headers) - 1:
item.setData("br"[j == 1], BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setSectionResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(nclasses + 3)
self.tablemodel.setColumnCount(nclasses + 3)
@Inputs.evaluation_results
def set_results(self, results):
"""Set the input results."""
prev_sel_learner = self.selected_learner.copy()
self.clear()
self.warning()
self.closeContext()
data = None
if results is not None and results.data is not None:
data = results.data[results.row_indices]
if data is not None and not data.domain.has_discrete_class:
self.Error.no_regression()
data = results = None
else:
self.Error.no_regression.clear()
nan_values = False
if results is not None:
assert isinstance(results, Orange.evaluation.Results)
if np.any(np.isnan(results.actual)) or \
np.any(np.isnan(results.predicted)):
# Error out here (could filter them out with a warning
# instead).
nan_values = True
results = data = None
if nan_values:
self.Error.invalid_values()
else:
self.Error.invalid_values.clear()
self.results = results
self.data = data
if data is not None:
class_values = data.domain.class_var.values
elif results is not None:
raise NotImplementedError
if results is None:
self.report_button.setDisabled(True)
else:
self.report_button.setDisabled(False)
nmodels = results.predicted.shape[0]
self.headers = class_values + \
[unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'learner_names' is set in 'Test Learners' widget.
if hasattr(results, "learner_names"):
self.learners = results.learner_names
else:
self.learners = ["Learner #{}".format(i + 1)
for i in range(nmodels)]
self._init_table(len(class_values))
self.openContext(data.domain.class_var)
if not prev_sel_learner or prev_sel_learner[0] >= len(self.learners):
if self.learners:
self.selected_learner[:] = [0]
else:
self.selected_learner[:] = prev_sel_learner
self._update()
self._set_selection()
self.unconditional_commit()
def clear(self):
"""Reset the widget, clear controls"""
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
self.learners = []
def select_correct(self):
"""Select the diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_wrong(self):
"""Select the off-diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
for j in range(i + 1, n):
index = self.tablemodel.index(i, j)
selection.select(index, index)
index = self.tablemodel.index(j, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_none(self):
"""Reset selection"""
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
"""Handle cell click event"""
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _prepare_data(self):
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
learner_name = self.learners[self.selected_learner[0]]
predicted = self.results.predicted[self.selected_learner[0]]
selected = [i for i, t in enumerate(zip(actual, predicted))
if t in indices]
extra = []
class_var = self.data.domain.class_var
metas = self.data.domain.metas
if self.append_predictions:
extra.append(predicted.reshape(-1, 1))
var = Orange.data.DiscreteVariable(
"{}({})".format(class_var.name, learner_name),
class_var.values
)
metas = metas + (var,)
if self.append_probabilities and \
self.results.probabilities is not None:
probs = self.results.probabilities[self.selected_learner[0]]
extra.append(np.array(probs, dtype=object))
pvars = [Orange.data.ContinuousVariable("p({})".format(value))
for value in class_var.values]
metas = metas + tuple(pvars)
domain = Orange.data.Domain(self.data.domain.attributes,
self.data.domain.class_vars,
metas)
data = self.data.transform(domain)
if len(extra):
data.metas[:, len(self.data.domain.metas):] = \
np.hstack(tuple(extra))
data.name = learner_name
if selected:
annotated_data = create_annotated_table(data, selected)
data = data[selected]
else:
annotated_data = create_annotated_table(data, [])
data = None
return data, annotated_data
def commit(self):
"""Output data instances corresponding to selected cells"""
if self.results is not None and self.data is not None \
and self.selected_learner:
data, annotated_data = self._prepare_data()
else:
data = None
annotated_data = None
self.Outputs.selected_data.send(data)
self.Outputs.annotated_data.send(annotated_data)
def _invalidate(self):
indices = self.tableview.selectedIndexes()
self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices}
self.commit()
def _set_selection(self):
selection = QItemSelection()
index = self.tableview.model().index
for row, col in self.selection:
sel = index(row + 2, col + 2)
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _learner_changed(self):
self._update()
self._set_selection()
self.commit()
def _update(self):
def _isinvalid(x):
return isnan(x) or isinf(x)
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
cmatrix = confusion_matrix(self.results, self.selected_learner[0])
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
n = len(cmatrix)
diag = np.diag_indices(n)
colors = cmatrix.astype(np.double)
colors[diag] = 0
if self.selected_quantity == 0:
normalized = cmatrix.astype(np.int)
formatstr = "{}"
div = np.array([colors.max()])
else:
if self.selected_quantity == 1:
normalized = 100 * cmatrix / colsum
div = colors.max(axis=0)
else:
normalized = 100 * cmatrix / rowsum[:, np.newaxis]
div = colors.max(axis=1)[:, np.newaxis]
formatstr = "{:2.1f} %"
div[div == 0] = 1
colors /= div
colors[diag] = normalized[diag] / normalized[diag].max()
for i in range(n):
for j in range(n):
val = normalized[i, j]
col_val = colors[i, j]
item = self._item(i + 2, j + 2)
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)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
bold_font = self.tablemodel.invisibleRootItem().font()
bold_font.setBold(True)
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
for i in range(n):
self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t"))
self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l"))
self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum())))
def send_report(self):
"""Send report"""
if self.results is not None and self.selected_learner:
self.report_table(
"Confusion matrix for {} (showing {})".
format(self.learners[self.selected_learner[0]],
self.quantities[self.selected_quantity].lower()),
self.tableview)
@classmethod
def migrate_settings(cls, settings, version):
if not version:
# For some period of time the 'selected_learner' property was
# changed from List[int] -> int
# (commit 4e49bb3fd0e11262f3ebf4b1116a91a4b49cc982) and then back
# again (commit 8a492d79a2e17154a0881e24a05843406c8892c0)
if "selected_learner" in settings and \
isinstance(settings["selected_learner"], int):
settings["selected_learner"] = [settings["selected_learner"]]
class OWCorpusViewer(OWWidget):
name = "Corpus Viewer"
description = "Display corpus contents."
icon = "icons/CorpusViewer.svg"
priority = 70
inputs = [(IO.DATA, Table, 'set_data')]
outputs = [(IO.MATCHED, Corpus, widget.Default), (IO.UNMATCHED, Corpus)]
search_indices = ContextSetting([0]) # features included in search
display_indices = ContextSetting([0]) # features for display
show_tokens = Setting(False)
autocommit = Setting(True)
class Warning(OWWidget.Warning):
no_feats_search = Msg('No features included in search.')
no_feats_display = Msg('No features selected for display.')
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.corpus_docs = None # Documents generated from Corpus
self.output_mask = [] # Output corpus indices
self.doc_webview = None # WebView for showing content
self.search_features = [
] # two copies are needed since Display allows drag & drop
self.display_features = []
# Info attributes
self.update_info()
info_box = gui.widgetBox(self.controlArea, 'Info')
gui.label(info_box, self, 'Documents: %(n_documents)s')
gui.label(info_box, self, 'Preprocessed: %(is_preprocessed)s')
gui.label(info_box, self, ' ◦ Tokens: %(n_tokens)s')
gui.label(info_box, self, ' ◦ Types: %(n_types)s')
gui.label(info_box, self, 'POS tagged: %(is_pos_tagged)s')
gui.label(info_box, self, 'N-grams range: %(ngram_range)s')
gui.label(info_box, self, 'Matching: %(n_matching)s')
# Search features
self.search_listbox = gui.listBox(
self.controlArea,
self,
'search_indices',
'search_features',
selectionMode=QListView.ExtendedSelection,
box='Search features',
callback=self.regenerate_docs,
)
# Display features
display_box = gui.widgetBox(self.controlArea, 'Display features')
self.display_listbox = gui.listBox(
display_box,
self,
'display_indices',
'display_features',
selectionMode=QListView.ExtendedSelection,
callback=self.show_docs,
enableDragDrop=True)
self.show_tokens_checkbox = gui.checkBox(display_box,
self,
'show_tokens',
'Show Tokens && Tags',
callback=self.show_docs)
# Auto-commit box
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data',
'Auto send is on')
# Search
self.filter_input = gui.lineEdit(self.mainArea,
self,
'',
orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(
QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed),
label='RegExp Filter:')
self.filter_input.textChanged.connect(self.refresh_search)
# Main area
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
)
# Document list
self.doc_list = QTableView()
self.doc_list.setSelectionBehavior(QTableView.SelectRows)
self.doc_list.setSelectionMode(QTableView.ExtendedSelection)
self.doc_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.doc_list.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.doc_list.horizontalHeader().setVisible(False)
self.splitter.addWidget(self.doc_list)
self.doc_list_model = QStandardItemModel(self)
self.doc_list.setModel(self.doc_list_model)
self.doc_list.selectionModel().selectionChanged.connect(self.show_docs)
# Document contents
self.doc_webview = gui.WebviewWidget(self.splitter, debug=False)
self.mainArea.layout().addWidget(self.splitter)
def copy_to_clipboard(self):
text = self.doc_webview.selectedText()
QApplication.clipboard().setText(text)
def set_data(self, data=None):
self.reset_widget()
self.corpus = data
if data is not None:
if not isinstance(data, Corpus):
self.corpus = Corpus.from_table(data.domain, data)
self.load_features()
self.regenerate_docs()
self.commit()
def reset_widget(self):
# Corpus
self.corpus = None
self.corpus_docs = None
self.output_mask = []
# Widgets
self.search_listbox.clear()
self.display_listbox.clear()
self.filter_input.clear()
self.update_info()
# Models/vars
self.search_features.clear()
self.display_features.clear()
self.search_indices.clear()
self.display_indices.clear()
self.doc_list_model.clear()
# Warnings
self.Warning.clear()
# WebView
self.doc_webview.setHtml('')
def load_features(self):
self.search_indices = []
self.display_indices = []
if self.corpus is not None:
domain = self.corpus.domain
self.search_features = list(
filter_visible(chain(domain.variables, domain.metas)))
self.display_features = list(
filter_visible(chain(domain.variables, domain.metas)))
# FIXME: Select features based on ContextSetting
self.search_indices = list(range(len(self.search_features)))
self.display_indices = list(range(len(self.display_features)))
# Enable/disable tokens checkbox
if not self.corpus.has_tokens():
self.show_tokens_checkbox.setCheckState(False)
self.show_tokens_checkbox.setEnabled(self.corpus.has_tokens())
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 show_docs(self):
""" Show the selected documents in the right area """
HTML = '''
<!doctype html>
<html>
<head>
<meta charset='utf-8'>
<style>
table {{ border-collapse: collapse; }}
mark {{ background: #FFCD28; }}
tr > td {{
padding-bottom: 3px;
padding-top: 3px;
}}
body {{
font-family: Helvetica;
font-size: 10pt;
}}
.line {{ border-bottom: 1px solid #000; }}
.separator {{ height: 5px; }}
.variables {{
vertical-align: top;
padding-right: 10px;
}}
.token {{
padding: 3px;
border: 1px #B0B0B0 solid;
margin-right: 5px;
margin-bottom: 5px;
display: inline-block;
}}
img {{
max-width: 100%;
}}
</style>
</head>
<body>
{}
</body>
</html>
'''
if self.corpus is None:
return
self.Warning.no_feats_display.clear()
if len(self.display_indices) == 0:
self.Warning.no_feats_display()
if self.show_tokens:
tokens = list(self.corpus.ngrams_iterator(include_postags=True))
marked_search_features = [
f for i, f in enumerate(self.search_features)
if i in self.search_indices
]
html = '<table>'
for doc_count, index in enumerate(
self.doc_list.selectionModel().selectedRows()):
if doc_count > 0: # add split
html += '<tr class="line separator"><td/><td/></tr>' \
'<tr class="separator"><td/><td/></tr>'
row_ind = index.data(Qt.UserRole).row_index
for ind in self.display_indices:
feature = self.display_features[ind]
mark = 'class="mark-area"' if feature in marked_search_features else ''
value = str(index.data(Qt.UserRole)[feature.name])
is_image = feature.attributes.get('type', '') == 'image'
if is_image and value != '?':
value = '<img src="{}"></img>'.format(value)
html += '<tr><td class="variables"><strong>{}:</strong></td>' \
'<td {}>{}</td></tr>'.format(
feature.name, mark, value)
if self.show_tokens:
html += '<tr><td class="variables"><strong>Tokens & Tags:</strong></td>' \
'<td>{}</td></tr>'.format(''.join('<span class="token">{}</span>'.format(
token) for token in tokens[row_ind]))
html += '</table>'
# QUrl is a workaround to allow local resources
# https://bugreports.qt.io/browse/QTBUG-55902?focusedCommentId=335945
self.doc_webview.setHtml(HTML.format(html), QUrl("file://"))
self.load_js()
self.highlight_docs()
def load_js(self):
resources = os.path.join(os.path.dirname(__file__), 'resources')
for script in (
'jquery-3.1.1.min.js',
'jquery.mark.min.js',
'highlighter.js',
):
self.doc_webview.evalJS(
open(os.path.join(resources, script), encoding='utf-8').read())
def regenerate_docs(self):
self.corpus_docs = None
self.Warning.no_feats_search.clear()
if self.corpus is not None:
feats = [self.search_features[i] for i in self.search_indices]
if len(feats) == 0:
self.Warning.no_feats_search()
self.corpus_docs = self.corpus.documents_from_features(feats)
self.refresh_search()
def refresh_search(self):
if self.corpus is not None:
self.list_docs()
self.update_info()
def highlight_docs(self):
search_keyword = self.filter_input.text().\
strip('|').replace('\\', '\\\\') # escape one \ to two for mark.js
if search_keyword:
self.doc_webview.evalJS('mark("{}");'.format(search_keyword))
def update_info(self):
if self.corpus is not None:
self.n_documents = len(self.corpus)
self.n_matching = '{}/{}'.format(self.doc_list_model.rowCount(),
self.n_documents)
self.n_tokens = sum(
map(len,
self.corpus.tokens)) if self.corpus.has_tokens() else 'n/a'
self.n_types = len(
self.corpus.dictionary) if self.corpus.has_tokens() else 'n/a'
self.is_preprocessed = self.corpus.has_tokens()
self.is_pos_tagged = self.corpus.pos_tags is not None
self.ngram_range = '{}-{}'.format(*self.corpus.ngram_range)
else:
self.n_documents = ''
self.n_matching = ''
self.n_tokens = ''
self.n_types = ''
self.is_preprocessed = ''
self.is_pos_tagged = ''
self.ngram_range = ''
def commit(self):
if self.corpus is not None:
matched = self.corpus[self.output_mask]
output_mask = set(self.output_mask)
unmatched_mask = [
i for i in range(len(self.corpus)) if i not in output_mask
]
unmatched = self.corpus[unmatched_mask]
self.send(IO.MATCHED, matched)
self.send(IO.UNMATCHED, unmatched)
else:
self.send(IO.MATCHED, None)
self.send(IO.UNMATCHED, None)
class OWCorpusViewer(OWWidget):
name = "Corpus Viewer"
description = "Display corpus contents."
icon = "icons/CorpusViewer.svg"
priority = 70
inputs = [(IO.DATA, Table, 'set_data')]
outputs = [(IO.MATCHED, Corpus, widget.Default), (IO.UNMATCHED, Corpus)]
search_indices = ContextSetting([0]) # features included in search
display_indices = ContextSetting([0]) # features for display
show_tokens = Setting(False)
autocommit = Setting(True)
class Warning(OWWidget.Warning):
no_feats_search = Msg('No features included in search.')
no_feats_display = Msg('No features selected for display.')
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.corpus_docs = None # Documents generated from Corpus
self.output_mask = [] # Output corpus indices
self.doc_webview = None # WebView for showing content
self.search_features = [] # two copies are needed since Display allows drag & drop
self.display_features = []
# Info attributes
self.update_info()
info_box = gui.widgetBox(self.controlArea, 'Info')
gui.label(info_box, self, 'Documents: %(n_documents)s')
gui.label(info_box, self, 'Preprocessed: %(is_preprocessed)s')
gui.label(info_box, self, ' ◦ Tokens: %(n_tokens)s')
gui.label(info_box, self, ' ◦ Types: %(n_types)s')
gui.label(info_box, self, 'POS tagged: %(is_pos_tagged)s')
gui.label(info_box, self, 'N-grams range: %(ngram_range)s')
gui.label(info_box, self, 'Matching: %(n_matching)s')
# Search features
self.search_listbox = gui.listBox(
self.controlArea, self, 'search_indices', 'search_features',
selectionMode=QListView.ExtendedSelection,
box='Search features', callback=self.regenerate_docs,)
# Display features
display_box = gui.widgetBox(self.controlArea, 'Display features')
self.display_listbox = gui.listBox(
display_box, self, 'display_indices', 'display_features',
selectionMode=QListView.ExtendedSelection,
callback=self.show_docs, enableDragDrop=True)
self.show_tokens_checkbox = gui.checkBox(display_box, self, 'show_tokens',
'Show Tokens && Tags', callback=self.show_docs)
# Auto-commit box
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data', 'Auto send is on')
# Search
self.filter_input = gui.lineEdit(self.mainArea, self, '',
orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed),
label='RegExp Filter:')
self.filter_input.textChanged.connect(self.refresh_search)
# Main area
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
)
# Document list
self.doc_list = QTableView()
self.doc_list.setSelectionBehavior(QTableView.SelectRows)
self.doc_list.setSelectionMode(QTableView.ExtendedSelection)
self.doc_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.doc_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.doc_list.horizontalHeader().setVisible(False)
self.splitter.addWidget(self.doc_list)
self.doc_list_model = QStandardItemModel(self)
self.doc_list.setModel(self.doc_list_model)
self.doc_list.selectionModel().selectionChanged.connect(self.show_docs)
# Document contents
# For PyQt5 WebEngine's setHtml grabs the focus and makes typing hard
# More info: http://stackoverflow.com/questions/36609489
# To bypass the annoying behaviour disable the widget for WebEngine
self.doc_webview = gui.WebviewWidget(self.splitter, self,
debug=True, enabled=HAVE_WEBKIT)
self.mainArea.layout().addWidget(self.splitter)
def copy_to_clipboard(self):
text = self.doc_webview.selectedText()
QApplication.clipboard().setText(text)
def set_data(self, data=None):
self.reset_widget()
self.corpus = data
if data is not None:
if not isinstance(data, Corpus):
self.corpus = Corpus.from_table(data.domain, data)
self.load_features()
self.regenerate_docs()
self.commit()
def reset_widget(self):
# Corpus
self.corpus = None
self.corpus_docs = None
self.output_mask = []
# Widgets
self.search_listbox.clear()
self.display_listbox.clear()
self.filter_input.clear()
self.update_info()
# Models/vars
self.search_features.clear()
self.display_features.clear()
self.search_indices.clear()
self.display_indices.clear()
self.doc_list_model.clear()
# Warnings
self.Warning.clear()
# WebView
self.doc_webview.setHtml('')
def load_features(self):
self.search_indices = []
self.display_indices = []
if self.corpus is not None:
domain = self.corpus.domain
self.search_features = list(filter_visible(chain(domain.variables, domain.metas)))
self.display_features = list(filter_visible(chain(domain.variables, domain.metas)))
# FIXME: Select features based on ContextSetting
self.search_indices = list(range(len(self.search_features)))
self.display_indices = list(range(len(self.display_features)))
# Enable/disable tokens checkbox
if not self.corpus.has_tokens():
self.show_tokens_checkbox.setCheckState(False)
self.show_tokens_checkbox.setEnabled(self.corpus.has_tokens())
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 show_docs(self):
""" Show the selected documents in the right area """
HTML = '''
<!doctype html>
<html>
<head>
<meta charset='utf-8'>
<style>
table {{ border-collapse: collapse; }}
mark {{ background: #FFCD28; }}
tr > td {{
padding-bottom: 3px;
padding-top: 3px;
}}
body {{
font-family: Helvetica;
font-size: 10pt;
}}
.line {{ border-bottom: 1px solid #000; }}
.separator {{ height: 5px; }}
.variables {{
vertical-align: top;
padding-right: 10px;
}}
.token {{
padding: 3px;
border: 1px #B0B0B0 solid;
margin-right: 5px;
margin-bottom: 5px;
display: inline-block;
}}
</style>
</head>
<body>
{}
</body>
</html>
'''
if self.corpus is None:
return
self.Warning.no_feats_display.clear()
if len(self.display_indices) == 0:
self.Warning.no_feats_display()
if self.show_tokens:
tokens = list(self.corpus.ngrams_iterator(include_postags=True))
marked_search_features = [f for i, f in enumerate(self.search_features)
if i in self.search_indices]
html = '<table>'
for doc_count, index in enumerate(self.doc_list.selectionModel().selectedRows()):
if doc_count > 0: # add split
html += '<tr class="line separator"><td/><td/></tr>' \
'<tr class="separator"><td/><td/></tr>'
row_ind = index.data(Qt.UserRole).row_index
for ind in self.display_indices:
feature = self.display_features[ind]
mark = 'class="mark-area"' if feature in marked_search_features else ''
value = index.data(Qt.UserRole)[feature.name]
html += '<tr><td class="variables"><strong>{}:</strong></td>' \
'<td {}>{}</td></tr>'.format(
feature.name, mark, value)
if self.show_tokens:
html += '<tr><td class="variables"><strong>Tokens & Tags:</strong></td>' \
'<td>{}</td></tr>'.format(''.join('<span class="token">{}</span>'.format(
token) for token in tokens[row_ind]))
html += '</table>'
self.doc_webview.setHtml(HTML.format(html))
self.load_js()
self.highlight_docs()
def load_js(self):
resources = os.path.join(os.path.dirname(__file__), 'resources')
for script in ('jquery-3.1.1.min.js', 'jquery.mark.min.js', 'highlighter.js', ):
self.doc_webview.evalJS(open(os.path.join(resources, script), encoding='utf-8').read())
def regenerate_docs(self):
self.corpus_docs = None
self.Warning.no_feats_search.clear()
if self.corpus is not None:
feats = [self.search_features[i] for i in self.search_indices]
if len(feats) == 0:
self.Warning.no_feats_search()
self.corpus_docs = self.corpus.documents_from_features(feats)
self.refresh_search()
def refresh_search(self):
if self.corpus:
self.list_docs()
self.update_info()
def highlight_docs(self):
search_keyword = self.filter_input.text().\
strip('|').replace('\\', '\\\\') # escape one \ to two for mark.js
if search_keyword:
self.doc_webview.evalJS('mark("{}");'.format(search_keyword))
def update_info(self):
if self.corpus is not None:
self.n_documents = len(self.corpus)
self.n_matching = '{}/{}'.format(self.doc_list_model.rowCount(), self.n_documents)
self.n_tokens = sum(map(len, self.corpus.tokens)) if self.corpus.has_tokens() else 'n/a'
self.n_types = len(self.corpus.dictionary) if self.corpus.has_tokens() else 'n/a'
self.is_preprocessed = self.corpus.has_tokens()
self.is_pos_tagged = self.corpus.pos_tags is not None
self.ngram_range = '{}-{}'.format(*self.corpus.ngram_range)
else:
self.n_documents = ''
self.n_matching = ''
self.n_tokens = ''
self.n_types = ''
self.is_preprocessed = ''
self.is_pos_tagged = ''
self.ngram_range = ''
def commit(self):
if self.corpus is not None:
matched = self.corpus[self.output_mask]
output_mask = set(self.output_mask)
unmatched_mask = [i for i in range(len(self.corpus)) if i not in output_mask]
unmatched = self.corpus[unmatched_mask]
self.send(IO.MATCHED, matched)
self.send(IO.UNMATCHED, unmatched)
else:
self.send(IO.MATCHED, None)
self.send(IO.UNMATCHED, None)
class OWCorpusViewer(OWWidget):
name = "Corpus Viewer"
description = "Display corpus contents."
icon = "icons/CorpusViewer.svg"
priority = 500
class Inputs:
corpus = Input("Corpus", Corpus, replaces=["Data"])
class Outputs:
matching_docs = Output("Matching Docs", Corpus, default=True)
other_docs = Output("Other Docs", Corpus)
settingsHandler = PerfectDomainContextHandler(
match_values = PerfectDomainContextHandler.MATCH_VALUES_ALL
)
search_indices = ContextSetting([], exclude_metas=False) # features included in search
display_indices = ContextSetting([], exclude_metas=False) # features for display
display_features = ContextSetting([], exclude_metas=False)
regexp_filter = ContextSetting("")
selection = [0] # TODO: DataHashContextHandler
show_tokens = Setting(False)
autocommit = Setting(True)
class Warning(OWWidget.Warning):
no_feats_search = Msg('No features included in search.')
no_feats_display = Msg('No features selected for display.')
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.corpus_docs = None # Documents generated from Corpus
self.output_mask = [] # Output corpus indices
self.doc_webview = None # WebView for showing content
self.search_features = [] # two copies are needed since Display allows drag & drop
self.display_list_indices = [0]
# Info attributes
self.update_info()
info_box = gui.widgetBox(self.controlArea, 'Info')
gui.label(info_box, self, 'Documents: %(n_documents)s')
gui.label(info_box, self, 'Preprocessed: %(is_preprocessed)s')
gui.label(info_box, self, ' ◦ Tokens: %(n_tokens)s')
gui.label(info_box, self, ' ◦ Types: %(n_types)s')
gui.label(info_box, self, 'POS tagged: %(is_pos_tagged)s')
gui.label(info_box, self, 'N-grams range: %(ngram_range)s')
gui.label(info_box, self, 'Matching: %(n_matching)s')
# Search features
self.search_listbox = gui.listBox(
self.controlArea, self, 'search_indices', 'search_features',
selectionMode=QListView.ExtendedSelection,
box='Search features', callback=self.search_features_changed)
# Display features
display_box = gui.widgetBox(self.controlArea, 'Display features')
self.display_listbox = gui.listBox(
display_box, self, 'display_list_indices', 'display_features',
selectionMode=QListView.ExtendedSelection,
callback=self.show_docs, enableDragDrop=True)
self.show_tokens_checkbox = gui.checkBox(display_box, self, 'show_tokens',
'Show Tokens && Tags', callback=self.show_docs)
# Auto-commit box
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data', 'Auto send is on')
# Search
self.filter_input = gui.lineEdit(self.mainArea, self, 'regexp_filter',
orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed),
label='RegExp Filter:')
self.filter_input.textChanged.connect(self.refresh_search)
# Main area
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
)
# Document list
self.doc_list = QTableView()
self.doc_list.setSelectionBehavior(QTableView.SelectRows)
self.doc_list.setSelectionMode(QTableView.ExtendedSelection)
self.doc_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.doc_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.doc_list.horizontalHeader().setVisible(False)
self.splitter.addWidget(self.doc_list)
self.doc_list_model = QStandardItemModel(self)
self.doc_list.setModel(self.doc_list_model)
self.doc_list.selectionModel().selectionChanged.connect(self.show_docs)
# Document contents
self.doc_webview = gui.WebviewWidget(self.splitter, debug=False)
self.mainArea.layout().addWidget(self.splitter)
def copy_to_clipboard(self):
text = self.doc_webview.selectedText()
QApplication.clipboard().setText(text)
@Inputs.corpus
def set_data(self, corpus=None):
self.closeContext()
self.reset_widget()
self.corpus = corpus
self.search_features = []
if corpus is not None:
domain = self.corpus.domain
# Enable/disable tokens checkbox
if not self.corpus.has_tokens():
self.show_tokens_checkbox.setCheckState(False)
self.show_tokens_checkbox.setEnabled(self.corpus.has_tokens())
self.search_features = list(filter_visible(chain(domain.variables, domain.metas)))
self.display_features = list(filter_visible(chain(domain.variables, domain.metas)))
self.search_indices = list(range(len(self.search_features)))
self.display_indices = list(range(len(self.display_features)))
self.selection = [0]
self.openContext(self.corpus)
self.display_list_indices = self.display_indices
self.regenerate_docs()
self.list_docs()
self.update_info()
self.set_selection()
self.show_docs()
self.commit()
def reset_widget(self):
# Corpus
self.corpus = None
self.corpus_docs = None
self.output_mask = []
self.display_features = []
# Widgets
self.search_listbox.clear()
self.display_listbox.clear()
self.filter_input.clear()
self.update_info()
# Models/vars
self.search_features.clear()
self.search_indices.clear()
self.display_indices.clear()
self.doc_list_model.clear()
# Warnings
self.Warning.clear()
# WebView
self.doc_webview.setHtml('')
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 reset_selection(self):
if self.doc_list_model.rowCount() > 0:
self.doc_list.selectRow(0) # Select the first document
else:
self.doc_webview.setHtml('')
def set_selection(self):
view = self.doc_list
if len(self.selection):
selection = QItemSelection()
for row in self.selection:
selection.append(
QItemSelectionRange(
view.model().index(row, 0),
view.model().index(row, 0)
)
)
view.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def show_docs(self):
""" Show the selected documents in the right area """
HTML = '''
<!doctype html>
<html>
<head>
<script type="text/javascript" src="resources/jquery-3.1.1.min.js">
</script>
<script type="text/javascript" src="resources/jquery.mark.min.js">
</script>
<script type="text/javascript" src="resources/highlighter.js">
</script>
<meta charset='utf-8'>
<style>
table {{ border-collapse: collapse; }}
mark {{ background: #FFCD28; }}
tr > td {{
padding-bottom: 3px;
padding-top: 3px;
}}
body {{
font-family: Helvetica;
font-size: 10pt;
}}
.line {{ border-bottom: 1px solid #000; }}
.separator {{ height: 5px; }}
.variables {{
vertical-align: top;
padding-right: 10px;
}}
.content {{
/* Adopted from https://css-tricks.com/snippets/css/prevent-long-urls-from-breaking-out-of-container/ */
/* These are technically the same, but use both */
overflow-wrap: break-word;
word-wrap: break-word;
-ms-word-break: break-all;
/* This is the dangerous one in WebKit, as it breaks things wherever */
word-break: break-all;
/* Instead use this non-standard one: */
word-break: break-word;
/* Adds a hyphen where the word breaks, if supported (No Blink) */
-ms-hyphens: auto;
-moz-hyphens: auto;
-webkit-hyphens: auto;
hyphens: auto;
}}
.token {{
padding: 3px;
border: 1px #B0B0B0 solid;
margin-right: 5px;
margin-bottom: 5px;
display: inline-block;
}}
img {{
max-width: 100%;
}}
</style>
</head>
<body>
{}
</body>
</html>
'''
self.display_indices = self.display_list_indices
if self.corpus is None:
return
self.Warning.no_feats_display.clear()
if len(self.display_indices) == 0:
self.Warning.no_feats_display()
if self.show_tokens:
tokens = list(self.corpus.ngrams_iterator(include_postags=True))
marked_search_features = [f for i, f in enumerate(self.search_features)
if i in self.search_indices]
html = '<table>'
selection = [i.row() for i in self.doc_list.selectionModel().selectedRows()]
if selection != []:
self.selection = selection
for doc_count, index in enumerate(self.doc_list.selectionModel().selectedRows()):
if doc_count > 0: # add split
html += '<tr class="line separator"><td/><td/></tr>' \
'<tr class="separator"><td/><td/></tr>'
row_ind = index.data(Qt.UserRole).row_index
for ind in self.display_indices:
feature = self.display_features[ind]
value = str(index.data(Qt.UserRole)[feature.name])
if feature in marked_search_features:
value = self.__mark_text(value)
value = value.replace('\n', '<br/>')
is_image = feature.attributes.get('type', '') == 'image'
if is_image and value != '?':
value = '<img src="{}"></img>'.format(value)
html += '<tr><td class="variables"><strong>{}:</strong></td>' \
'<td class="content">{}</td></tr>'.format(
feature.name, value)
if self.show_tokens:
html += '<tr><td class="variables"><strong>Tokens & Tags:</strong></td>' \
'<td>{}</td></tr>'.format(''.join('<span class="token">{}</span>'.format(
token) for token in tokens[row_ind]))
html += '</table>'
base = QUrl.fromLocalFile(__file__)
self.doc_webview.setHtml(HTML.format(html), base)
def __mark_text(self, text):
search_keyword = self.regexp_filter.strip('|')
if not search_keyword:
return text
try:
reg = re.compile(search_keyword, re.IGNORECASE | re.MULTILINE)
except sre_constants.error:
return text
matches = list(reg.finditer(text))
if not matches:
return text
text = list(text)
for m in matches[::-1]:
text[m.start():m.end()] = list('<mark data-markjs="true">{}</mark>'\
.format("".join(text[m.start():m.end()])))
return "".join(text)
def search_features_changed(self):
self.regenerate_docs()
self.refresh_search()
def regenerate_docs(self):
self.corpus_docs = None
self.Warning.no_feats_search.clear()
if self.corpus is not None:
feats = [self.search_features[i] for i in self.search_indices]
if len(feats) == 0:
self.Warning.no_feats_search()
self.corpus_docs = self.corpus.documents_from_features(feats)
def refresh_search(self):
if self.corpus is not None:
self.list_docs()
self.reset_selection()
self.update_info()
self.commit()
def update_info(self):
if self.corpus is not None:
self.n_documents = len(self.corpus)
self.n_matching = '{}/{}'.format(self.doc_list_model.rowCount(), self.n_documents)
self.n_tokens = sum(map(len, self.corpus.tokens)) if self.corpus.has_tokens() else 'n/a'
self.n_types = len(self.corpus.dictionary) if self.corpus.has_tokens() else 'n/a'
self.is_preprocessed = self.corpus.has_tokens()
self.is_pos_tagged = self.corpus.pos_tags is not None
self.ngram_range = '{}-{}'.format(*self.corpus.ngram_range)
else:
self.n_documents = ''
self.n_matching = ''
self.n_tokens = ''
self.n_types = ''
self.is_preprocessed = ''
self.is_pos_tagged = ''
self.ngram_range = ''
def commit(self):
if self.corpus is not None:
matched = self.corpus[self.output_mask]
output_mask = set(self.output_mask)
unmatched_mask = [i for i in range(len(self.corpus)) if i not in output_mask]
unmatched = self.corpus[unmatched_mask]
self.Outputs.matching_docs.send(matched)
self.Outputs.other_docs.send(unmatched)
else:
self.Outputs.matching_docs.send(None)
self.Outputs.other_docs.send(None)
def send_report(self):
self.report_items((
("Query", self.regexp_filter),
("Matching documents", self.n_matching),
))
class ResolweDataWidget(QWidget):
def __init__(self, data_objects, descriptor_schema, *args, **kwargs):
super().__init__(*args, **kwargs)
self.ow = kwargs.get('parent', None)
self._data_objects = data_objects
self.descriptor_schema = descriptor_schema
self.header_schema = None
self.header = None
# set layout
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.view = QTreeView()
self.view.setSortingEnabled(False)
self.view.setAlternatingRowColors(True)
self.view.setEditTriggers(QTreeView.NoEditTriggers)
self.view.setSelectionMode(QTreeView.SingleSelection)
self.model = QStandardItemModel()
self.display_data_objects()
self.layout().addWidget(self.view)
def __set_header_values(self):
if self.header_schema:
labels = [val.get('label', '?') for val in self.header_schema]
self.model.setHorizontalHeaderLabels(labels)
def __create_row(self, obj):
row_items = []
tabular_data = obj.descriptor.get('tabular', None)
output_data = obj.output.get('table', None)
# TODO: refactor this. Use file_name and size from obj.output instead of desc. schema
for schema_value in self.header_schema:
item = QStandardItem()
schema_key = schema_value['name']
data_info = tabular_data.get(schema_key,
'?') if tabular_data else '?'
if schema_key == 'file_name' and data_info == '?':
data_info = output_data.get('file',
'?') if output_data else '?'
elif schema_key == 'file_size' and data_info == '?':
data_info = output_data.get('size',
'?') if output_data else '?'
item.setData(data_info, Qt.DisplayRole)
row_items.append(item)
return row_items
def __populate_data_model(self):
if self.model:
self.model.clear()
for data_object in self.data_objects:
self.model.appendRow(self.__create_row(data_object))
def __parse_description_schema(self):
self.header_schema = []
if self.descriptor_schema:
for schema_value in self.descriptor_schema.schema:
if schema_value['name'] == 'tabular':
[
self.header_schema.append(value)
for value in schema_value['group']
]
if self.header_schema:
keys = [val.get('name', '?') for val in self.header_schema]
header_index = namedtuple('header_index',
[label for label in keys])
self.header = header_index(
*[index for index, _ in enumerate(keys)])
@property
def data_objects(self):
return self._data_objects
@data_objects.setter
def data_objects(self, data_objects):
self._data_objects = data_objects
self.display_data_objects()
def display_data_objects(self):
self.__parse_description_schema()
self.__populate_data_model()
self.__set_header_values()
self.view.setModel(self.model)
def set_target_column(self, target_column):
# type: (int) -> None
for row in range(self.model.rowCount()):
item = self.model.item(row, target_column)
item_data = item.data(role=Qt.DisplayRole)
if item_data:
item.setIcon(variable_icon(item_data))
def selected_data_object(self):
# type: () -> Data
rows = self.view.selectionModel().selectedRows()
assert 0 <= len(rows) <= 1
sel_row_index = rows[0].row() if rows else None
obj_range = range(len(self._data_objects))
assert sel_row_index in obj_range
try:
return self._data_objects[sel_row_index]
except IndexError:
# can this happen? self._data_objects can't
# be empty if model is constructed
pass
class OWConfusionMatrix(widget.OWWidget):
"""Confusion matrix widget"""
name = "Confusion Matrix"
description = "Display a confusion matrix constructed from " \
"the results of classifier evaluations."
icon = "icons/ConfusionMatrix.svg"
priority = 1001
class Inputs:
evaluation_results = Input("Evaluation Results",
Orange.evaluation.Results)
class Outputs:
selected_data = Output("Selected Data",
Orange.data.Table,
default=True)
annotated_data = Output(ANNOTATED_DATA_SIGNAL_NAME, Orange.data.Table)
quantities = [
"Number of instances", "Proportion of predicted",
"Proportion of actual"
]
settings_version = 1
settingsHandler = settings.ClassValuesContextHandler()
selected_learner = settings.Setting([0], schema_only=True)
selection = settings.ContextSetting(set())
selected_quantity = settings.Setting(0)
append_predictions = settings.Setting(True)
append_probabilities = settings.Setting(False)
autocommit = settings.Setting(True)
UserAdviceMessages = [
widget.Message(
"Clicking on cells or in headers outputs the corresponding "
"data instances", "click_cell")
]
class Error(widget.OWWidget.Error):
no_regression = Msg("Confusion Matrix cannot show regression results.")
invalid_values = Msg(
"Evaluation Results input contains invalid values")
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
self.learners_box = gui.listBox(self.controlArea,
self,
"selected_learner",
"learners",
box=True,
callback=self._learner_changed)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box,
self,
"append_predictions",
"Predictions",
callback=self._invalidate)
gui.checkBox(box,
self,
"append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.outputbox,
self,
"autocommit",
"Send Selected",
"Send Automatically",
box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox,
self,
"selected_quantity",
items=self.quantities,
label="Show: ",
orientation=Qt.Horizontal,
callback=self._update)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
view.clicked.connect(self.cell_clicked)
box.layout().addWidget(view)
selbox = gui.hBox(box)
gui.button(selbox,
self,
"Select Correct",
callback=self.select_correct,
autoDefault=False)
gui.button(selbox,
self,
"Select Misclassified",
callback=self.select_wrong,
autoDefault=False)
gui.button(selbox,
self,
"Clear Selection",
callback=self.select_none,
autoDefault=False)
def sizeHint(self):
"""Initial size"""
return QSize(750, 340)
def _item(self, i, j):
return self.tablemodel.item(i, j) or QStandardItem()
def _set_item(self, i, j, item):
self.tablemodel.setItem(i, j, item)
def _init_table(self, nclasses):
item = self._item(0, 2)
item.setData("Predicted", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignCenter)
item.setFlags(Qt.NoItemFlags)
self._set_item(0, 2, item)
item = self._item(2, 0)
item.setData("Actual", Qt.DisplayRole)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignBottom)
item.setFlags(Qt.NoItemFlags)
self.tableview.setItemDelegateForColumn(0, gui.VerticalItemDelegate())
self._set_item(2, 0, item)
self.tableview.setSpan(0, 2, 1, nclasses)
self.tableview.setSpan(2, 0, nclasses, 1)
font = self.tablemodel.invisibleRootItem().font()
bold_font = QFont(font)
bold_font.setBold(True)
for i in (0, 1):
for j in (0, 1):
item = self._item(i, j)
item.setFlags(Qt.NoItemFlags)
self._set_item(i, j, item)
for p, label in enumerate(self.headers):
for i, j in ((1, p + 2), (p + 2, 1)):
item = self._item(i, j)
item.setData(label, Qt.DisplayRole)
item.setFont(bold_font)
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled)
if p < len(self.headers) - 1:
item.setData("br"[j == 1], BorderRole)
item.setData(QColor(192, 192, 192), BorderColorRole)
self._set_item(i, j, item)
hor_header = self.tableview.horizontalHeader()
if len(' '.join(self.headers)) < 120:
hor_header.setSectionResizeMode(QHeaderView.ResizeToContents)
else:
hor_header.setDefaultSectionSize(60)
self.tablemodel.setRowCount(nclasses + 3)
self.tablemodel.setColumnCount(nclasses + 3)
@Inputs.evaluation_results
def set_results(self, results):
"""Set the input results."""
prev_sel_learner = self.selected_learner.copy()
self.clear()
self.warning()
self.closeContext()
data = None
if results is not None and results.data is not None:
data = results.data[results.row_indices]
if data is not None and not data.domain.has_discrete_class:
self.Error.no_regression()
data = results = None
else:
self.Error.no_regression.clear()
nan_values = False
if results is not None:
assert isinstance(results, Orange.evaluation.Results)
if np.any(np.isnan(results.actual)) or \
np.any(np.isnan(results.predicted)):
# Error out here (could filter them out with a warning
# instead).
nan_values = True
results = data = None
if nan_values:
self.Error.invalid_values()
else:
self.Error.invalid_values.clear()
self.results = results
self.data = data
if data is not None:
class_values = data.domain.class_var.values
elif results is not None:
raise NotImplementedError
if results is None:
self.report_button.setDisabled(True)
else:
self.report_button.setDisabled(False)
nmodels = results.predicted.shape[0]
self.headers = class_values + \
[unicodedata.lookup("N-ARY SUMMATION")]
# NOTE: The 'learner_names' is set in 'Test Learners' widget.
if hasattr(results, "learner_names"):
self.learners = results.learner_names
else:
self.learners = [
"Learner #{}".format(i + 1) for i in range(nmodels)
]
self._init_table(len(class_values))
self.openContext(data.domain.class_var)
if not prev_sel_learner or prev_sel_learner[0] >= len(
self.learners):
if self.learners:
self.selected_learner[:] = [0]
else:
self.selected_learner[:] = prev_sel_learner
self._update()
self._set_selection()
self.unconditional_commit()
def clear(self):
"""Reset the widget, clear controls"""
self.results = None
self.data = None
self.tablemodel.clear()
self.headers = []
# Clear learners last. This action will invoke `_learner_changed`
self.learners = []
def select_correct(self):
"""Select the diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
index = self.tablemodel.index(i, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_wrong(self):
"""Select the off-diagonal elements of the matrix"""
selection = QItemSelection()
n = self.tablemodel.rowCount()
for i in range(2, n):
for j in range(i + 1, n):
index = self.tablemodel.index(i, j)
selection.select(index, index)
index = self.tablemodel.index(j, i)
selection.select(index, index)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def select_none(self):
"""Reset selection"""
self.tableview.selectionModel().clear()
def cell_clicked(self, model_index):
"""Handle cell click event"""
i, j = model_index.row(), model_index.column()
if not i or not j:
return
n = self.tablemodel.rowCount()
index = self.tablemodel.index
selection = None
if i == j == 1 or i == j == n - 1:
selection = QItemSelection(index(2, 2), index(n - 1, n - 1))
elif i in (1, n - 1):
selection = QItemSelection(index(2, j), index(n - 1, j))
elif j in (1, n - 1):
selection = QItemSelection(index(i, 2), index(i, n - 1))
if selection is not None:
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _prepare_data(self):
indices = self.tableview.selectedIndexes()
indices = {(ind.row() - 2, ind.column() - 2) for ind in indices}
actual = self.results.actual
learner_name = self.learners[self.selected_learner[0]]
predicted = self.results.predicted[self.selected_learner[0]]
selected = [
i for i, t in enumerate(zip(actual, predicted)) if t in indices
]
extra = []
class_var = self.data.domain.class_var
metas = self.data.domain.metas
if self.append_predictions:
extra.append(predicted.reshape(-1, 1))
var = Orange.data.DiscreteVariable(
"{}({})".format(class_var.name, learner_name),
class_var.values)
metas = metas + (var, )
if self.append_probabilities and \
self.results.probabilities is not None:
probs = self.results.probabilities[self.selected_learner[0]]
extra.append(np.array(probs, dtype=object))
pvars = [
Orange.data.ContinuousVariable("p({})".format(value))
for value in class_var.values
]
metas = metas + tuple(pvars)
domain = Orange.data.Domain(self.data.domain.attributes,
self.data.domain.class_vars, metas)
data = self.data.transform(domain)
if len(extra):
data.metas[:, len(self.data.domain.metas):] = \
np.hstack(tuple(extra))
data.name = learner_name
if selected:
annotated_data = create_annotated_table(data, selected)
data = data[selected]
else:
annotated_data = create_annotated_table(data, [])
data = None
return data, annotated_data
def commit(self):
"""Output data instances corresponding to selected cells"""
if self.results is not None and self.data is not None \
and self.selected_learner:
data, annotated_data = self._prepare_data()
else:
data = None
annotated_data = None
self.Outputs.selected_data.send(data)
self.Outputs.annotated_data.send(annotated_data)
def _invalidate(self):
indices = self.tableview.selectedIndexes()
self.selection = {(ind.row() - 2, ind.column() - 2) for ind in indices}
self.commit()
def _set_selection(self):
selection = QItemSelection()
index = self.tableview.model().index
for row, col in self.selection:
sel = index(row + 2, col + 2)
selection.select(sel, sel)
self.tableview.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect)
def _learner_changed(self):
self._update()
self._set_selection()
self.commit()
def _update(self):
def _isinvalid(x):
return isnan(x) or isinf(x)
# Update the displayed confusion matrix
if self.results is not None and self.selected_learner:
cmatrix = confusion_matrix(self.results, self.selected_learner[0])
colsum = cmatrix.sum(axis=0)
rowsum = cmatrix.sum(axis=1)
n = len(cmatrix)
diag = np.diag_indices(n)
colors = cmatrix.astype(np.double)
colors[diag] = 0
if self.selected_quantity == 0:
normalized = cmatrix.astype(np.int)
formatstr = "{}"
div = np.array([colors.max()])
else:
if self.selected_quantity == 1:
normalized = 100 * cmatrix / colsum
div = colors.max(axis=0)
else:
normalized = 100 * cmatrix / rowsum[:, np.newaxis]
div = colors.max(axis=1)[:, np.newaxis]
formatstr = "{:2.1f} %"
div[div == 0] = 1
colors /= div
colors[diag] = normalized[diag] / normalized[diag].max()
for i in range(n):
for j in range(n):
val = normalized[i, j]
col_val = colors[i, j]
item = self._item(i + 2, j + 2)
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)
item.setToolTip("actual: {}\npredicted: {}".format(
self.headers[i], self.headers[j]))
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._set_item(i + 2, j + 2, item)
bold_font = self.tablemodel.invisibleRootItem().font()
bold_font.setBold(True)
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
for i in range(n):
self._set_item(n + 2, i + 2, _sum_item(int(colsum[i]), "t"))
self._set_item(i + 2, n + 2, _sum_item(int(rowsum[i]), "l"))
self._set_item(n + 2, n + 2, _sum_item(int(rowsum.sum())))
def send_report(self):
"""Send report"""
if self.results is not None and self.selected_learner:
self.report_table(
"Confusion matrix for {} (showing {})".format(
self.learners[self.selected_learner[0]],
self.quantities[self.selected_quantity].lower()),
self.tableview)
@classmethod
def migrate_settings(cls, settings, version):
if not version:
# For some period of time the 'selected_learner' property was
# changed from List[int] -> int
# (commit 4e49bb3fd0e11262f3ebf4b1116a91a4b49cc982) and then back
# again (commit 8a492d79a2e17154a0881e24a05843406c8892c0)
if "selected_learner" in settings and \
isinstance(settings["selected_learner"], int):
settings["selected_learner"] = [settings["selected_learner"]]
class OWCorpusViewer(OWWidget):
name = "Corpus Viewer"
description = "Display corpus contents."
icon = "icons/CorpusViewer.svg"
priority = 500
class Inputs:
corpus = Input("Corpus", Corpus, replaces=["Data"])
class Outputs:
matching_docs = Output("Matching Docs", Corpus, default=True)
other_docs = Output("Other Docs", Corpus)
settingsHandler = PerfectDomainContextHandler(
match_values=PerfectDomainContextHandler.MATCH_VALUES_ALL)
search_indices = ContextSetting(
[], exclude_metas=False) # features included in search
display_indices = ContextSetting(
[], exclude_metas=False) # features for display
display_features = ContextSetting([], exclude_metas=False)
regexp_filter = ContextSetting("")
selection = [0] # TODO: DataHashContextHandler
show_tokens = Setting(False)
autocommit = Setting(True)
class Warning(OWWidget.Warning):
no_feats_search = Msg('No features included in search.')
no_feats_display = Msg('No features selected for display.')
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.corpus_docs = None # Documents generated from Corpus
self.output_mask = [] # Output corpus indices
self.doc_webview = None # WebView for showing content
self.search_features = [
] # two copies are needed since Display allows drag & drop
self.display_list_indices = [0]
# Info attributes
self.update_info()
info_box = gui.widgetBox(self.controlArea, 'Info')
gui.label(info_box, self, 'Documents: %(n_documents)s')
gui.label(info_box, self, 'Preprocessed: %(is_preprocessed)s')
gui.label(info_box, self, ' ◦ Tokens: %(n_tokens)s')
gui.label(info_box, self, ' ◦ Types: %(n_types)s')
gui.label(info_box, self, 'POS tagged: %(is_pos_tagged)s')
gui.label(info_box, self, 'N-grams range: %(ngram_range)s')
gui.label(info_box, self, 'Matching: %(n_matching)s')
# Search features
self.search_listbox = gui.listBox(
self.controlArea,
self,
'search_indices',
'search_features',
selectionMode=QListView.ExtendedSelection,
box='Search features',
callback=self.search_features_changed)
# Display features
display_box = gui.widgetBox(self.controlArea, 'Display features')
self.display_listbox = gui.listBox(
display_box,
self,
'display_list_indices',
'display_features',
selectionMode=QListView.ExtendedSelection,
callback=self.show_docs,
enableDragDrop=True)
self.show_tokens_checkbox = gui.checkBox(display_box,
self,
'show_tokens',
'Show Tokens && Tags',
callback=self.show_docs)
# Auto-commit box
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data',
'Auto send is on')
# Search
self.filter_input = gui.lineEdit(self.mainArea,
self,
'regexp_filter',
orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(
QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed),
label='RegExp Filter:')
self.filter_input.textChanged.connect(self.refresh_search)
# Main area
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
)
# Document list
self.doc_list = QTableView()
self.doc_list.setSelectionBehavior(QTableView.SelectRows)
self.doc_list.setSelectionMode(QTableView.ExtendedSelection)
self.doc_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.doc_list.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.doc_list.horizontalHeader().setVisible(False)
self.splitter.addWidget(self.doc_list)
self.doc_list_model = QStandardItemModel(self)
self.doc_list.setModel(self.doc_list_model)
self.doc_list.selectionModel().selectionChanged.connect(self.show_docs)
# Document contents
self.doc_webview = gui.WebviewWidget(self.splitter, debug=False)
self.doc_webview.loadFinished.connect(self.highlight_docs)
self.mainArea.layout().addWidget(self.splitter)
def copy_to_clipboard(self):
text = self.doc_webview.selectedText()
QApplication.clipboard().setText(text)
@Inputs.corpus
def set_data(self, corpus=None):
self.closeContext()
self.reset_widget()
self.corpus = corpus
self.search_features = []
if corpus is not None:
domain = self.corpus.domain
# Enable/disable tokens checkbox
if not self.corpus.has_tokens():
self.show_tokens_checkbox.setCheckState(False)
self.show_tokens_checkbox.setEnabled(self.corpus.has_tokens())
self.search_features = list(
filter_visible(chain(domain.variables, domain.metas)))
self.display_features = list(
filter_visible(chain(domain.variables, domain.metas)))
self.search_indices = list(range(len(self.search_features)))
self.display_indices = list(range(len(self.display_features)))
self.selection = [0]
self.openContext(self.corpus)
self.display_list_indices = self.display_indices
self.regenerate_docs()
self.list_docs()
self.update_info()
self.set_selection()
self.show_docs()
self.commit()
def reset_widget(self):
# Corpus
self.corpus = None
self.corpus_docs = None
self.output_mask = []
self.display_features = []
# Widgets
self.search_listbox.clear()
self.display_listbox.clear()
self.filter_input.clear()
self.update_info()
# Models/vars
self.search_features.clear()
self.search_indices.clear()
self.display_indices.clear()
self.doc_list_model.clear()
# Warnings
self.Warning.clear()
# WebView
self.doc_webview.setHtml('')
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 reset_selection(self):
if self.doc_list_model.rowCount() > 0:
self.doc_list.selectRow(0) # Select the first document
else:
self.doc_webview.setHtml('')
def set_selection(self):
view = self.doc_list
if len(self.selection):
selection = QItemSelection()
for row in self.selection:
selection.append(
QItemSelectionRange(view.model().index(row, 0),
view.model().index(row, 0)))
view.selectionModel().select(selection,
QItemSelectionModel.ClearAndSelect)
def show_docs(self):
""" Show the selected documents in the right area """
HTML = '''
<!doctype html>
<html>
<head>
<script type="text/javascript" src="resources/jquery-3.1.1.min.js">
</script>
<script type="text/javascript" src="resources/jquery.mark.min.js">
</script>
<script type="text/javascript" src="resources/highlighter.js">
</script>
<meta charset='utf-8'>
<style>
table {{ border-collapse: collapse; }}
mark {{ background: #FFCD28; }}
tr > td {{
padding-bottom: 3px;
padding-top: 3px;
}}
body {{
font-family: Helvetica;
font-size: 10pt;
}}
.line {{ border-bottom: 1px solid #000; }}
.separator {{ height: 5px; }}
.variables {{
vertical-align: top;
padding-right: 10px;
}}
.token {{
padding: 3px;
border: 1px #B0B0B0 solid;
margin-right: 5px;
margin-bottom: 5px;
display: inline-block;
}}
img {{
max-width: 100%;
}}
</style>
</head>
<body>
{}
</body>
</html>
'''
self.display_indices = self.display_list_indices
if self.corpus is None:
return
self.Warning.no_feats_display.clear()
if len(self.display_indices) == 0:
self.Warning.no_feats_display()
if self.show_tokens:
tokens = list(self.corpus.ngrams_iterator(include_postags=True))
marked_search_features = [
f for i, f in enumerate(self.search_features)
if i in self.search_indices
]
html = '<table>'
selection = [
i.row() for i in self.doc_list.selectionModel().selectedRows()
]
if selection != []:
self.selection = selection
for doc_count, index in enumerate(
self.doc_list.selectionModel().selectedRows()):
if doc_count > 0: # add split
html += '<tr class="line separator"><td/><td/></tr>' \
'<tr class="separator"><td/><td/></tr>'
row_ind = index.data(Qt.UserRole).row_index
for ind in self.display_indices:
feature = self.display_features[ind]
mark = 'class="mark-area"' if feature in marked_search_features else ''
value = str(index.data(Qt.UserRole)[feature.name])
is_image = feature.attributes.get('type', '') == 'image'
if is_image and value != '?':
value = '<img src="{}"></img>'.format(value)
html += '<tr><td class="variables"><strong>{}:</strong></td>' \
'<td {}>{}</td></tr>'.format(
feature.name, mark, value)
if self.show_tokens:
html += '<tr><td class="variables"><strong>Tokens & Tags:</strong></td>' \
'<td>{}</td></tr>'.format(''.join('<span class="token">{}</span>'.format(
token) for token in tokens[row_ind]))
html += '</table>'
base = QUrl.fromLocalFile(__file__)
self.doc_webview.setHtml(HTML.format(html), base)
def search_features_changed(self):
self.regenerate_docs()
self.refresh_search()
def regenerate_docs(self):
self.corpus_docs = None
self.Warning.no_feats_search.clear()
if self.corpus is not None:
feats = [self.search_features[i] for i in self.search_indices]
if len(feats) == 0:
self.Warning.no_feats_search()
self.corpus_docs = self.corpus.documents_from_features(feats)
def refresh_search(self):
if self.corpus is not None:
self.list_docs()
self.reset_selection()
self.update_info()
self.commit()
@Slot()
def highlight_docs(self):
search_keyword = self.regexp_filter.\
strip('|').replace('\\', '\\\\') # escape one \ to two for mark.js
if search_keyword:
# mark is undefined when clearing the view (`setHtml('')`). Maybe
# set and template html with all the scripts, ... but no contents?
self.doc_webview.runJavaScript('''
if (typeof mark !== "undefined") {{
mark("{}");
}}
'''.format(search_keyword))
def update_info(self):
if self.corpus is not None:
self.n_documents = len(self.corpus)
self.n_matching = '{}/{}'.format(self.doc_list_model.rowCount(),
self.n_documents)
self.n_tokens = sum(
map(len,
self.corpus.tokens)) if self.corpus.has_tokens() else 'n/a'
self.n_types = len(
self.corpus.dictionary) if self.corpus.has_tokens() else 'n/a'
self.is_preprocessed = self.corpus.has_tokens()
self.is_pos_tagged = self.corpus.pos_tags is not None
self.ngram_range = '{}-{}'.format(*self.corpus.ngram_range)
else:
self.n_documents = ''
self.n_matching = ''
self.n_tokens = ''
self.n_types = ''
self.is_preprocessed = ''
self.is_pos_tagged = ''
self.ngram_range = ''
def commit(self):
if self.corpus is not None:
matched = self.corpus[self.output_mask]
output_mask = set(self.output_mask)
unmatched_mask = [
i for i in range(len(self.corpus)) if i not in output_mask
]
unmatched = self.corpus[unmatched_mask]
self.Outputs.matching_docs.send(matched)
self.Outputs.other_docs.send(unmatched)
else:
self.Outputs.matching_docs.send(None)
self.Outputs.other_docs.send(None)
class OWCorpusViewer(OWWidget):
name = "Corpus Viewer"
description = "Display corpus contents."
icon = "icons/CorpusViewer.svg"
priority = 500
class Inputs:
corpus = Input("Corpus", Corpus, replaces=["Data"])
class Outputs:
matching_docs = Output("Matching Docs", Corpus, default=True)
other_docs = Output("Other Docs", Corpus)
corpus = Output("Corpus", Corpus)
settingsHandler = PerfectDomainContextHandler(
match_values = PerfectDomainContextHandler.MATCH_VALUES_ALL
)
search_indices = ContextSetting([], exclude_metas=False) # features included in search
display_indices = ContextSetting([], exclude_metas=False) # features for display
display_features = ContextSetting([], exclude_metas=False)
selected_documents = ContextSetting([])
regexp_filter = ContextSetting("")
show_tokens = Setting(False)
autocommit = Setting(True)
class Warning(OWWidget.Warning):
no_feats_search = Msg('No features included in search.')
no_feats_display = Msg('No features selected for display.')
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.corpus_docs = None # Documents generated from Corpus
self.doc_webview = None # WebView for showing content
self.search_features = [] # two copies are needed since Display allows drag & drop
self.display_list_indices = [0]
self.matches = 0 # Matches of the query
# Info attributes
self.update_info()
info_box = gui.widgetBox(self.controlArea, 'Info')
gui.label(info_box, self, 'Tokens: %(n_tokens)s')
gui.label(info_box, self, 'Types: %(n_types)s')
gui.label(info_box, self, 'Matching documents: %(n_matching)s')
gui.label(info_box, self, 'Matches: %(n_matches)s')
# Search features
self.search_listbox = gui.listBox(
self.controlArea, self, 'search_indices', 'search_features',
selectionMode=QListView.ExtendedSelection,
box='Search features', callback=self.search_features_changed)
# Display features
display_box = gui.widgetBox(self.controlArea, 'Display features')
self.display_listbox = gui.listBox(
display_box, self, 'display_list_indices', 'display_features',
selectionMode=QListView.ExtendedSelection,
callback=self.show_docs, enableDragDrop=True)
self.show_tokens_checkbox = gui.checkBox(display_box, self, 'show_tokens',
'Show Tokens && Tags', callback=self.show_docs)
# Auto-commit box
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data', 'Auto send is on')
# Search
self.filter_input = gui.lineEdit(self.mainArea, self, 'regexp_filter',
orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed),
label='RegExp Filter:',
callback=self.refresh_search)
# Main area
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
)
# Document list
self.doc_list = QTableView()
self.doc_list.setSelectionBehavior(QTableView.SelectRows)
self.doc_list.setSelectionMode(QTableView.ExtendedSelection)
self.doc_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.doc_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.doc_list.horizontalHeader().setVisible(False)
self.splitter.addWidget(self.doc_list)
self.doc_list_model = QStandardItemModel(self)
self.doc_list.setModel(self.doc_list_model)
self.doc_list.selectionModel().selectionChanged.connect(
self.selection_changed
)
# Document contents
self.doc_webview = gui.WebviewWidget(self.splitter, debug=False)
self.mainArea.layout().addWidget(self.splitter)
def copy_to_clipboard(self):
text = self.doc_webview.selectedText()
QApplication.clipboard().setText(text)
@Inputs.corpus
def set_data(self, corpus=None):
self.closeContext()
self.reset_widget()
self.corpus = corpus
self.search_features = []
if corpus is not None:
domain = self.corpus.domain
# Enable/disable tokens checkbox
if not self.corpus.has_tokens():
self.show_tokens_checkbox.setCheckState(False)
self.show_tokens_checkbox.setEnabled(self.corpus.has_tokens())
self.search_features = list(filter_visible(chain(domain.variables, domain.metas)))
self.display_features = list(filter_visible(chain(domain.variables, domain.metas)))
self.search_indices = list(range(len(self.search_features)))
self.display_indices = list(range(len(self.display_features)))
self.selected_documents = [corpus.titles[0]] if \
corpus.titles is not None and len(corpus.titles) else []
self.openContext(self.corpus)
self.display_list_indices = self.display_indices
self.regenerate_docs()
self.list_docs()
self.update_info()
self.set_selection()
self.show_docs()
self.commit()
def reset_widget(self):
# Corpus
self.corpus = None
self.corpus_docs = None
self.display_features = []
# Widgets
self.search_listbox.clear()
self.display_listbox.clear()
self.filter_input.clear()
self.update_info()
# Models/vars
self.search_features.clear()
self.search_indices.clear()
self.display_indices.clear()
self.doc_list_model.clear()
# Warnings
self.Warning.clear()
# WebView
self.doc_webview.setHtml('')
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 get_selected_documents_from_view(self) -> Set[str]:
"""
Returns
-------
Set with names of selected documents in the QTableView
"""
return {
i.data(Qt.DisplayRole)
for i in self.doc_list.selectionModel().selectedRows()
}
def set_selection(self) -> None:
"""
Select documents in selected_documents attribute in the view
"""
view = self.doc_list
model = view.model()
previously_selected = self.selected_documents.copy()
selection = QItemSelection()
for row in range(model.rowCount()):
document = model.data(model.index(row, 0), Qt.DisplayRole)
if document in self.selected_documents:
selection.append(QItemSelectionRange(
view.model().index(row, 0),
view.model().index(row, 0)
))
view.selectionModel().select(
selection, QItemSelectionModel.ClearAndSelect
)
if len(selection) == 0:
# in cases when selection is empty qt's selection_changed is not
# called and so we need to manually trigger show_docs
self.show_docs()
# select emmit selection change signal which causes calling
# selection_changed when filtering it means that documents which
# are currently filtered out get removed from self.selected_douments
# we still want to keep them to be still selected after user removes
# filter
self.selected_documents = previously_selected
def selection_changed(self) -> None:
"""
Function is called every time the selection changes - when user select
new range of documents
"""
self.selected_documents = self.get_selected_documents_from_view()
self.show_docs()
self.commit()
def show_docs(self):
""" Show the selected documents in the right area """
HTML = '''
<!doctype html>
<html>
<head>
<script type="text/javascript" src="resources/jquery-3.1.1.min.js">
</script>
<script type="text/javascript" src="resources/jquery.mark.min.js">
</script>
<script type="text/javascript" src="resources/highlighter.js">
</script>
<meta charset='utf-8'>
<style>
table {{ border-collapse: collapse; }}
mark {{ background: #FFCD28; }}
tr > td {{
padding-bottom: 3px;
padding-top: 3px;
}}
body {{
font-family: Helvetica;
font-size: 10pt;
}}
.line {{ border-bottom: 1px solid #000; }}
.separator {{ height: 5px; }}
.variables {{
vertical-align: top;
padding-right: 10px;
}}
.content {{
/* Adopted from https://css-tricks.com/snippets/css/prevent-long-urls-from-breaking-out-of-container/ */
/* These are technically the same, but use both */
overflow-wrap: break-word;
word-wrap: break-word;
-ms-word-break: break-all;
/* This is the dangerous one in WebKit, as it breaks things wherever */
word-break: break-all;
/* Instead use this non-standard one: */
word-break: break-word;
/* Adds a hyphen where the word breaks, if supported (No Blink) */
-ms-hyphens: auto;
-moz-hyphens: auto;
-webkit-hyphens: auto;
hyphens: auto;
}}
.token {{
padding: 3px;
border: 1px #B0B0B0 solid;
margin-right: 5px;
margin-bottom: 5px;
display: inline-block;
}}
img {{
max-width: 100%;
}}
</style>
</head>
<body>
{}
</body>
</html>
'''
self.display_indices = self.display_list_indices
if self.corpus is None:
return
self.Warning.no_feats_display.clear()
if len(self.display_indices) == 0:
self.Warning.no_feats_display()
if self.show_tokens:
tokens = list(self.corpus.ngrams_iterator(include_postags=True))
marked_search_features = [f for i, f in enumerate(self.search_features)
if i in self.search_indices]
html = '<table>'
for doc_count, index in enumerate(self.doc_list.selectionModel().selectedRows()):
if doc_count > 0: # add split
html += '<tr class="line separator"><td/><td/></tr>' \
'<tr class="separator"><td/><td/></tr>'
row_ind = index.data(Qt.UserRole).row_index
for ind in self.display_indices:
feature = self.display_features[ind]
value = str(index.data(Qt.UserRole)[feature.name])
if feature in marked_search_features:
value = self.__mark_text(value)
value = value.replace('\n', '<br/>')
is_image = feature.attributes.get('type', '') == 'image'
if is_image and value != '?':
value = '<img src="{}"></img>'.format(value)
html += '<tr><td class="variables"><strong>{}:</strong></td>' \
'<td class="content">{}</td></tr>'.format(
feature.name, value)
if self.show_tokens:
html += '<tr><td class="variables"><strong>Tokens & Tags:</strong></td>' \
'<td>{}</td></tr>'.format(''.join('<span class="token">{}</span>'.format(
token) for token in tokens[row_ind]))
html += '</table>'
base = QUrl.fromLocalFile(__file__)
self.doc_webview.setHtml(HTML.format(html), base)
def __mark_text(self, text):
search_keyword = self.regexp_filter.strip('|')
if not search_keyword:
return text
try:
reg = re.compile(search_keyword, re.IGNORECASE | re.MULTILINE)
except sre_constants.error:
return text
matches = list(reg.finditer(text))
if not matches:
return text
text = list(text)
for m in matches[::-1]:
text[m.start():m.end()] = list('<mark data-markjs="true">{}</mark>'\
.format("".join(text[m.start():m.end()])))
return "".join(text)
def search_features_changed(self):
self.regenerate_docs()
self.refresh_search()
def regenerate_docs(self):
self.corpus_docs = None
self.Warning.no_feats_search.clear()
if self.corpus is not None:
feats = [self.search_features[i] for i in self.search_indices]
if len(feats) == 0:
self.Warning.no_feats_search()
self.corpus_docs = self.corpus.documents_from_features(feats)
def refresh_search(self):
if self.corpus is not None:
self.list_docs()
self.set_selection()
self.update_info()
self.commit()
def update_info(self):
if self.corpus is not None:
self.n_matching = '{}/{}'.format(self.doc_list_model.rowCount(), len(self.corpus))
self.n_matches = self.matches if self.matches else 'n/a'
self.n_tokens = sum(map(len, self.corpus.tokens)) if self.corpus.has_tokens() else 'n/a'
self.n_types = len(self.corpus.dictionary) if self.corpus.has_tokens() else 'n/a'
else:
self.n_matching = ''
self.n_matches = ''
self.n_tokens = ''
self.n_types = ''
def commit(self):
matched = unmatched = annotated_corpus = None
corpus = self.corpus
if corpus is not None:
# it returns a set of selected documents which are in view
selected_docs = self.get_selected_documents_from_view()
titles = corpus.titles
matched_mask = [
i for i, t in enumerate(titles) if t in selected_docs
]
unmatched_mask = [
i for i, t in enumerate(titles) if t not in selected_docs
]
matched = corpus[matched_mask] if len(matched_mask) else None
unmatched = corpus[unmatched_mask] if len(unmatched_mask) else None
annotated_corpus = create_annotated_table(corpus, matched_mask)
self.Outputs.matching_docs.send(matched)
self.Outputs.other_docs.send(unmatched)
self.Outputs.corpus.send(annotated_corpus)
def send_report(self):
self.report_items((
("Query", self.regexp_filter),
("Matching documents", self.n_matching),
("Matches", self.n_matches)
))
def showEvent(self, event):
super().showEvent(event)
self.update_splitter()
def update_splitter(self):
"""
Update splitter that document list on the left never take more
than 1/3 of the space. It is only set on showEvent. If user
later changes sizes it stays as it is.
"""
w1, w2 = self.splitter.sizes()
ws = w1 + w2
if w2 < 2/3 * ws:
self.splitter.setSizes([ws * 1/3, ws * 2/3])
