def setFilterFixedString(self, string):
"""Should this raise an error? It is not being used.
"""
QSortFilterProxyModel.setFilterFixedString(self, string)
class OWCreateInstance(OWWidget):
name = "Create Instance"
description = "Interactively create a data instance from sample dataset."
icon = "icons/CreateInstance.svg"
category = "Data"
keywords = ["simulator"]
priority = 4000
class Inputs:
data = Input("Data", Table)
reference = Input("Reference", Table)
class Outputs:
data = Output("Data", Table)
class Information(OWWidget.Information):
nans_removed = Msg("Variables with only missing values were "
"removed from the list.")
want_main_area = False
ACTIONS = ["median", "mean", "random", "input"]
HEADER = [["name", "Variable"], ["variable", "Value"]]
Header = namedtuple("header",
[tag for tag, _ in HEADER])(*range(len(HEADER)))
values: Dict[str, Union[float, str]] = Setting({}, schema_only=True)
append_to_data = Setting(True)
auto_commit = Setting(True)
def __init__(self):
super().__init__()
self.data: Optional[Table] = None
self.reference: Optional[Table] = None
self.filter_edit = QLineEdit(textChanged=self.__filter_edit_changed,
placeholderText="Filter...")
self.view = QTableView(sortingEnabled=True,
contextMenuPolicy=Qt.CustomContextMenu,
selectionMode=QTableView.NoSelection)
self.view.customContextMenuRequested.connect(self.__menu_requested)
self.view.setItemDelegateForColumn(self.Header.variable,
VariableDelegate(self))
self.view.verticalHeader().hide()
self.view.horizontalHeader().setStretchLastSection(True)
self.view.horizontalHeader().setMaximumSectionSize(350)
self.model = VariableItemModel(self)
self.model.setHorizontalHeaderLabels([x for _, x in self.HEADER])
self.model.dataChanged.connect(self.__table_data_changed)
self.model.dataHasNanColumn.connect(self.Information.nans_removed)
self.proxy_model = QSortFilterProxyModel()
self.proxy_model.setFilterKeyColumn(-1)
self.proxy_model.setFilterCaseSensitivity(False)
self.proxy_model.setSourceModel(self.model)
self.view.setModel(self.proxy_model)
vbox = gui.vBox(self.controlArea, box=True)
vbox.layout().addWidget(self.filter_edit)
vbox.layout().addWidget(self.view)
box = gui.hBox(vbox)
gui.rubber(box)
for name in self.ACTIONS:
gui.button(box,
self,
name.capitalize(),
lambda *args, fun=name: self._initialize_values(fun),
autoDefault=False)
gui.rubber(box)
box = gui.auto_apply(self.controlArea, self, "auto_commit")
box.button.setFixedWidth(180)
box.layout().insertStretch(0)
# pylint: disable=unnecessary-lambda
append = gui.checkBox(None,
self,
"append_to_data",
"Append this instance to input data",
callback=lambda: self.commit())
box.layout().insertWidget(0, append)
self._set_input_summary()
self._set_output_summary()
self.settingsAboutToBePacked.connect(self.pack_settings)
def __filter_edit_changed(self):
self.proxy_model.setFilterFixedString(self.filter_edit.text().strip())
def __table_data_changed(self):
self.commit()
def __menu_requested(self, point: QPoint):
index = self.view.indexAt(point)
model: QSortFilterProxyModel = index.model()
source_index = model.mapToSource(index)
menu = QMenu(self)
for action in self._create_actions(source_index):
menu.addAction(action)
menu.popup(self.view.viewport().mapToGlobal(point))
def _create_actions(self, index: QModelIndex) -> List[QAction]:
actions = []
for name in self.ACTIONS:
action = QAction(name.capitalize(), self)
action.triggered.connect(
lambda *args, fun=name: self._initialize_values(fun, [index]))
actions.append(action)
return actions
def _initialize_values(self, fun: str, indices: List[QModelIndex] = None):
cont_fun = {
"median": np.nanmedian,
"mean": np.nanmean,
"random": cont_random,
"input": np.nanmean
}.get(fun, NotImplemented)
disc_fun = {
"median": majority,
"mean": majority,
"random": disc_random,
"input": majority
}.get(fun, NotImplemented)
if not self.data or fun == "input" and not self.reference:
return
self.model.dataChanged.disconnect(self.__table_data_changed)
rows = range(self.proxy_model.rowCount()) if indices is None else \
[index.row() for index in indices]
for row in rows:
index = self.model.index(row, self.Header.variable)
variable = self.model.data(index, VariableRole)
if fun == "input":
if variable not in self.reference.domain:
continue
values = self.reference.get_column_view(variable)[0]
if variable.is_primitive():
values = values.astype(float)
if all(np.isnan(values)):
continue
else:
values = self.model.data(index, ValuesRole)
if variable.is_continuous:
value = cont_fun(values)
value = round(value, variable.number_of_decimals)
elif variable.is_discrete:
value = disc_fun(values)
elif variable.is_string:
value = ""
else:
raise NotImplementedError
self.model.setData(index, value, ValueRole)
self.model.dataChanged.connect(self.__table_data_changed)
self.commit()
@Inputs.data
def set_data(self, data: Table):
self.data = data
self._set_input_summary()
self._set_model_data()
self.unconditional_commit()
def _set_model_data(self):
self.Information.nans_removed.clear()
self.model.removeRows(0, self.model.rowCount())
if not self.data:
return
self.model.set_data(self.data, self.values)
self.values = {}
self.view.horizontalHeader().setStretchLastSection(False)
self.view.resizeColumnsToContents()
self.view.resizeRowsToContents()
self.view.horizontalHeader().setStretchLastSection(True)
@Inputs.reference
def set_reference(self, data: Table):
self.reference = data
self._set_input_summary()
def _set_input_summary(self):
n_data = len(self.data) if self.data else 0
n_refs = len(self.reference) if self.reference else 0
summary, details, kwargs = self.info.NoInput, "", {}
if self.data or self.reference:
summary = f"{self.info.format_number(n_data)}, " \
f"{self.info.format_number(n_refs)}"
data_list = [("Data", self.data), ("Reference", self.reference)]
details = format_multiple_summaries(data_list)
kwargs = {"format": Qt.RichText}
self.info.set_input_summary(summary, details, **kwargs)
def _set_output_summary(self, data: Optional[Table] = None):
if data:
summary, details = len(data), format_summary_details(data)
else:
summary, details = self.info.NoOutput, ""
self.info.set_output_summary(summary, details)
def commit(self):
output_data = None
if self.data:
output_data = self._create_data_from_values()
if self.append_to_data:
output_data = self._append_to_data(output_data)
self._set_output_summary(output_data)
self.Outputs.data.send(output_data)
def _create_data_from_values(self) -> Table:
data = Table.from_domain(self.data.domain, 1)
data.name = "created"
data.X[:] = np.nan
data.Y[:] = np.nan
for i, m in enumerate(self.data.domain.metas):
data.metas[:, i] = "" if m.is_string else np.nan
values = self._get_values()
for var_name, value in values.items():
data[:, var_name] = value
return data
def _append_to_data(self, data: Table) -> Table:
assert self.data
assert len(data) == 1
var = DiscreteVariable("Source ID", values=(self.data.name, data.name))
data = Table.concatenate([self.data, data], axis=0)
domain = Domain(data.domain.attributes, data.domain.class_vars,
data.domain.metas + (var, ))
data = data.transform(domain)
data.metas[:len(self.data), -1] = 0
data.metas[len(self.data):, -1] = 1
return data
def _get_values(self) -> Dict[str, Union[str, float]]:
values = {}
for row in range(self.model.rowCount()):
index = self.model.index(row, self.Header.variable)
values[self.model.data(index, VariableRole).name] = \
self.model.data(index, ValueRole)
return values
def send_report(self):
if not self.data:
return
self.report_domain("Input", self.data.domain)
self.report_domain("Output", self.data.domain)
items = []
values: Dict = self._get_values()
for var in self.data.domain.variables + self.data.domain.metas:
val = values.get(var.name, np.nan)
if var.is_primitive():
val = var.repr_val(val)
items.append([f"{var.name}:", val])
self.report_table("Values", items)
@staticmethod
def sizeHint():
return QSize(600, 500)
def pack_settings(self):
self.values: Dict[str, Union[str, float]] = self._get_values()
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 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
def setFilterFixedString(self, string):
"""Should this raise an error? It is not being used.
"""
QSortFilterProxyModel.setFilterFixedString(self, string)
class ListViewSearch(QListView):
"""
An QListView with an implicit and transparent row filtering.
"""
def __init__(self, *a, preferred_size=None, **ak):
super().__init__(*a, **ak)
self.__search = QLineEdit(self, placeholderText="Filter...")
self.__search.textEdited.connect(self.__setFilterString)
# Use an QSortFilterProxyModel for filtering. Note that this is
# never set on the view, only its rows insertes/removed signals are
# connected to observe an update row hidden state.
self.__pmodel = QSortFilterProxyModel(
self, filterCaseSensitivity=Qt.CaseInsensitive)
self.__pmodel.rowsAboutToBeRemoved.connect(
self.__filter_rowsAboutToBeRemoved)
self.__pmodel.rowsInserted.connect(self.__filter_rowsInserted)
self.__layout()
self.preferred_size = preferred_size
self.setMinimumHeight(100)
def setFilterPlaceholderText(self, text: str):
self.__search.setPlaceholderText(text)
def filterPlaceholderText(self) -> str:
return self.__search.placeholderText()
def setFilterProxyModel(self, proxy: QSortFilterProxyModel) -> None:
"""
Set an instance of QSortFilterProxyModel that will be used for filtering
the model. The `proxy` must be a filtering proxy only; it MUST not sort
the row of the model.
The FilterListView takes ownership of the proxy.
"""
self.__pmodel.rowsAboutToBeRemoved.disconnect(
self.__filter_rowsAboutToBeRemoved)
self.__pmodel.rowsInserted.disconnect(self.__filter_rowsInserted)
self.__pmodel = proxy
proxy.setParent(self)
self.__pmodel.rowsAboutToBeRemoved.connect(
self.__filter_rowsAboutToBeRemoved)
self.__pmodel.rowsInserted.connect(self.__filter_rowsInserted)
self.__pmodel.setSourceModel(self.model())
self.__filter_reset()
def filterProxyModel(self) -> QSortFilterProxyModel:
return self.__pmodel
def setModel(self, model: QAbstractItemModel) -> None:
super().setModel(model)
self.__pmodel.setSourceModel(model)
self.__filter_reset()
self.model().rowsInserted.connect(self.__model_rowInserted)
def setRootIndex(self, index: QModelIndex) -> None:
super().setRootIndex(index)
self.__filter_reset()
def __filter_reset(self):
root = self.rootIndex()
self.__filter(range(self.__pmodel.rowCount(root)))
def __setFilterString(self, string: str):
self.__pmodel.setFilterFixedString(string)
def setFilterString(self, string: str):
"""Set the filter string."""
self.__search.setText(string)
self.__pmodel.setFilterFixedString(string)
def filterString(self):
"""Return the filter string."""
return self.__search.text()
def __filter(self, rows: Iterable[int]) -> None:
"""Set hidden state for rows based on filter string"""
root = self.rootIndex()
pm = self.__pmodel
for r in rows:
self.setRowHidden(r, not pm.filterAcceptsRow(r, root))
def __filter_set(self, rows: Iterable[int], state: bool):
for r in rows:
self.setRowHidden(r, state)
def __filter_rowsAboutToBeRemoved(self, parent: QModelIndex, start: int,
end: int) -> None:
fmodel = self.__pmodel
mrange = QItemSelection(fmodel.index(start, 0, parent),
fmodel.index(end, 0, parent))
mranges = fmodel.mapSelectionToSource(mrange)
for mrange in mranges:
self.__filter_set(range(mrange.top(), mrange.bottom() + 1), True)
def __filter_rowsInserted(self, parent: QModelIndex, start: int,
end: int) -> None:
fmodel = self.__pmodel
mrange = QItemSelection(fmodel.index(start, 0, parent),
fmodel.index(end, 0, parent))
mranges = fmodel.mapSelectionToSource(mrange)
for mrange in mranges:
self.__filter_set(range(mrange.top(), mrange.bottom() + 1), False)
def __model_rowInserted(self, _, start: int, end: int) -> None:
"""
Filter elements when inserted in list - proxy model's rowsAboutToBeRemoved
is not called on elements that are hidden when inserting
"""
self.__filter(range(start, end + 1))
def resizeEvent(self, event: QResizeEvent) -> None:
super().resizeEvent(event)
def updateGeometries(self) -> None:
super().updateGeometries()
self.__layout()
def __layout(self):
margins = self.viewportMargins()
search = self.__search
sh = search.sizeHint()
size = self.size()
margins.setTop(sh.height())
vscroll = self.verticalScrollBar()
style = self.style()
transient = style.styleHint(QStyle.SH_ScrollBar_Transient, None,
vscroll)
w = size.width()
if vscroll.isVisibleTo(self) and not transient:
w = w - vscroll.width() - 1
search.setGeometry(0, 0, w, sh.height())
self.setViewportMargins(margins)
def sizeHint(self):
return (self.preferred_size
if self.preferred_size is not None else super().sizeHint())
