def __init__(self):
super().__init__()
dbox = gui.widgetBox(self.controlArea, "Image values")
rbox = gui.radioButtons(
dbox, self, "value_type", callback=self._change_integration)
gui.appendRadioButton(rbox, "From spectra")
self.box_values_spectra = gui.indentedBox(rbox)
gui.comboBox(
self.box_values_spectra, self, "integration_method", valueType=int,
items=(a.name for a in self.integration_methods),
callback=self._change_integral_type)
gui.rubber(self.controlArea)
gui.appendRadioButton(rbox, "Use feature")
self.box_values_feature = gui.indentedBox(rbox)
self.feature_value_model = DomainModel(DomainModel.METAS | DomainModel.CLASSES,
valid_types=DomainModel.PRIMITIVE)
self.feature_value = gui.comboBox(
self.box_values_feature, self, "attr_value",
callback=self.update_feature_value, model=self.feature_value_model,
sendSelectedValue=True, valueType=str)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
self.imageplot = ImagePlot(self)
self.imageplot.selection_changed.connect(self.output_image_selection)
self.curveplot = CurvePlotHyper(self, select=SELECTONE)
self.curveplot.selection_changed.connect(self.redraw_data)
self.curveplot.plot.vb.x_padding = 0.005 # pad view so that lines are not hidden
splitter.addWidget(self.imageplot)
splitter.addWidget(self.curveplot)
self.mainArea.layout().addWidget(splitter)
self.line1 = MovableVline(position=self.lowlim, label="", report=self.curveplot)
self.line1.sigMoved.connect(lambda v: setattr(self, "lowlim", v))
self.line2 = MovableVline(position=self.highlim, label="", report=self.curveplot)
self.line2.sigMoved.connect(lambda v: setattr(self, "highlim", v))
self.line3 = MovableVline(position=self.choose, label="", report=self.curveplot)
self.line3.sigMoved.connect(lambda v: setattr(self, "choose", v))
for line in [self.line1, self.line2, self.line3]:
line.sigMoveFinished.connect(self.changed_integral_range)
self.curveplot.add_marking(line)
line.hide()
self.data = None
self.disable_integral_range = False
self.resize(900, 700)
self._update_integration_type()
# prepare interface according to the new context
self.contextAboutToBeOpened.connect(lambda x: self.init_interface_data(x[0]))
def __init__(self):
super().__init__()
self.data = None # type: Optional[Orange.data.Table]
self.predictors = {} # type: Dict[object, PredictorSlot]
self.class_values = [] # type: List[str]
self._delegates = []
self.left_width = 10
gui.listBox(self.controlArea,
self,
"selected_classes",
"class_values",
box="Show probabibilities for",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.ExtendedSelection,
addSpace=False,
sizePolicy=(QSizePolicy.Preferred, QSizePolicy.Preferred))
gui.rubber(self.controlArea)
self.reset_button = gui.button(
self.controlArea,
self,
"Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
table_opts = dict(horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus)
self.dataview = TableView(sortingEnabled=True,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
**table_opts)
self.predictionsview = TableView(
sortingEnabled=True,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
**table_opts)
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size: self.predictionsview.verticalHeader(
).resizeSection(index, size))
self.splitter = QSplitter(orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2)
self.splitter.splitterMoved.connect(self.splitter_resized)
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.score_table = ScoreTable(self)
self.vsplitter = gui.vBox(self.mainArea)
self.vsplitter.layout().addWidget(self.splitter)
self.vsplitter.layout().addWidget(self.score_table.view)
def __setupUi(self):
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.toolbox = WidgetToolBox()
self.help = QuickHelpWidget(objectName="quick-help")
self.__splitter = QSplitter()
self.__splitter.setOrientation(Qt.Vertical)
self.__splitter.addWidget(self.toolbox)
self.__splitter.addWidget(self.help)
self.toolbar = DynamicResizeToolBar()
self.toolbar.setMovable(False)
self.toolbar.setFloatable(False)
self.toolbar.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
layout.addWidget(self.__splitter, 10)
layout.addWidget(self.toolbar)
self.setLayout(layout)
self.__splitterResizer = SplitterResizer(self)
self.__splitterResizer.setSplitterAndWidget(self.__splitter, self.help)
def test_dock(self):
reg = registry_tests.small_testing_registry()
reg = QtWidgetRegistry(reg, parent=self.app)
toolbox = WidgetToolBox()
toolbox.setObjectName("widgets-toolbox")
toolbox.setModel(reg.model())
text = QTextEdit()
splitter = QSplitter()
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(toolbox)
splitter.addWidget(text)
dock = CollapsibleDockWidget()
dock.setExpandedWidget(splitter)
toolbar = QToolBar()
toolbar.addAction("1")
toolbar.setOrientation(Qt.Vertical)
toolbar.setMovable(False)
toolbar.setFloatable(False)
dock.setCollapsedWidget(toolbar)
dock.show()
self.qWait()
def __setupUi(self):
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.toolbox = WidgetToolBox()
self.help = QuickHelpWidget(objectName="quick-help")
self.__splitter = QSplitter()
self.__splitter.setOrientation(Qt.Vertical)
self.__splitter.addWidget(self.toolbox)
self.__splitter.addWidget(self.help)
self.toolbar = DynamicResizeToolBar()
self.toolbar.setMovable(False)
self.toolbar.setFloatable(False)
self.toolbar.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
layout.addWidget(self.__splitter, 10)
layout.addWidget(self.toolbar)
self.setLayout(layout)
self.__splitterResizer = SplitterResizer(self)
self.__splitterResizer.setSplitterAndWidget(self.__splitter, self.help)
def test_dock(self):
reg = global_registry()
reg = QtWidgetRegistry(reg, parent=self.app)
toolbox = WidgetToolBox()
toolbox.setObjectName("widgets-toolbox")
toolbox.setModel(reg.model())
text = QTextEdit()
splitter = QSplitter()
splitter.setOrientation(Qt.Vertical)
splitter.addWidget(toolbox)
splitter.addWidget(text)
dock = CollapsibleDockWidget()
dock.setExpandedWidget(splitter)
toolbar = QToolBar()
toolbar.addAction("1")
toolbar.setOrientation(Qt.Vertical)
toolbar.setMovable(False)
toolbar.setFloatable(False)
dock.setCollapsedWidget(toolbar)
dock.show()
self.app.exec_()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.ow = kwargs.get('parent', None)
# set layout
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
# set splitter
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Horizontal)
# data models
self.genes_model = None
self.info_model = None
# left side list view
self.genes_view = QTableView()
self.genes_view.horizontalHeader().hide()
self.genes_view.setItemDelegate(GeneItemDelegate())
self.genes_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
# right side list view
self.info_view = QTableView()
self.info_view.setItemDelegate(HTMLDelegate())
self.info_view.horizontalHeader().hide()
self.info_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.splitter.addWidget(self.genes_view)
self.splitter.addWidget(self.info_view)
# self.splitter.setStretchFactor(0, 60)
# self.splitter.setStretchFactor(1, 40)
self.layout().addWidget(self.splitter)
def __init__(self):
super().__init__()
dbox = gui.widgetBox(self.controlArea, "Image values")
rbox = gui.radioButtons(
dbox, self, "value_type", callback=self._change_integration)
gui.appendRadioButton(rbox, "From spectra")
self.box_values_spectra = gui.indentedBox(rbox)
gui.comboBox(
self.box_values_spectra, self, "integration_method", valueType=int,
items=(a.name for a in self.integration_methods),
callback=self._change_integral_type)
gui.rubber(self.controlArea)
gui.appendRadioButton(rbox, "Use feature")
self.box_values_feature = gui.indentedBox(rbox)
self.feature_value_model = DomainModel(DomainModel.METAS | DomainModel.CLASSES,
valid_types=DomainModel.PRIMITIVE)
self.feature_value = gui.comboBox(
self.box_values_feature, self, "attr_value",
callback=self.update_feature_value, model=self.feature_value_model,
sendSelectedValue=True, valueType=str)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
self.imageplot = ImagePlot(self)
self.imageplot.selection_changed.connect(self.output_image_selection)
self.curveplot = CurvePlotHyper(self, select=SELECTONE)
self.curveplot.selection_changed.connect(self.redraw_data)
self.curveplot.plot.vb.x_padding = 0.005 # pad view so that lines are not hidden
splitter.addWidget(self.imageplot)
splitter.addWidget(self.curveplot)
self.mainArea.layout().addWidget(splitter)
self.line1 = MovableVline(position=self.lowlim, label="", report=self.curveplot)
self.line1.sigMoved.connect(lambda v: setattr(self, "lowlim", v))
self.line2 = MovableVline(position=self.highlim, label="", report=self.curveplot)
self.line2.sigMoved.connect(lambda v: setattr(self, "highlim", v))
self.line3 = MovableVline(position=self.choose, label="", report=self.curveplot)
self.line3.sigMoved.connect(lambda v: setattr(self, "choose", v))
for line in [self.line1, self.line2, self.line3]:
line.sigMoveFinished.connect(self.changed_integral_range)
self.curveplot.add_marking(line)
line.hide()
self.data = None
self.disable_integral_range = False
self.resize(900, 700)
self._update_integration_type()
# prepare interface according to the new context
self.contextAboutToBeOpened.connect(lambda x: self.init_interface_data(x[0]))
class CanvasToolDock(QWidget):
"""Canvas dock widget with widget toolbox, quick help and
canvas actions.
"""
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.__setupUi()
def __setupUi(self):
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.toolbox = WidgetToolBox()
self.help = QuickHelpWidget(objectName="quick-help")
self.__splitter = QSplitter()
self.__splitter.setOrientation(Qt.Vertical)
self.__splitter.addWidget(self.toolbox)
self.__splitter.addWidget(self.help)
self.toolbar = DynamicResizeToolBar()
self.toolbar.setMovable(False)
self.toolbar.setFloatable(False)
self.toolbar.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
layout.addWidget(self.__splitter, 10)
layout.addWidget(self.toolbar)
self.setLayout(layout)
self.__splitterResizer = SplitterResizer(self)
self.__splitterResizer.setSplitterAndWidget(self.__splitter, self.help)
def setQuickHelpVisible(self, state):
"""Set the quick help box visibility status.
"""
self.__splitterResizer.setExpanded(state)
def quickHelpVisible(self):
return self.__splitterResizer.expanded()
def setQuickHelpAnimationEnabled(self, enabled):
"""Enable/disable the quick help animation.
"""
self.__splitterResizer.setAnimationEnabled(enabled)
def toogleQuickHelpAction(self):
"""Return a checkable QAction for help show/hide.
"""
return self.__splitterResizer.toogleExpandedAction()
def __init__(self):
super().__init__()
dbox = gui.widgetBox(self.controlArea, "Image values")
rbox = gui.radioButtons(
dbox, self, "value_type", callback=self._change_integration)
gui.appendRadioButton(rbox, "From spectra")
self.box_values_spectra = gui.indentedBox(rbox)
gui.comboBox(
self.box_values_spectra, self, "integration_method", valueType=int,
items=(a.name for a in self.integration_methods),
callback=self._change_integral_type)
gui.rubber(self.controlArea)
gui.appendRadioButton(rbox, "Use feature")
self.box_values_feature = gui.indentedBox(rbox)
self.feature_value_model = DomainModel(DomainModel.METAS | DomainModel.CLASSES,
valid_types=DomainModel.PRIMITIVE)
self.feature_value = gui.comboBox(
self.box_values_feature, self, "attr_value",
callback=self.update_feature_value, model=self.feature_value_model,
sendSelectedValue=True, valueType=str)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
self.imageplot = ImagePlot(self, self.image_selection_changed)
self.curveplot = CurvePlotHyper(self, select=SELECTONE)
self.curveplot.plot.vb.x_padding = 0.005 # pad view so that lines are not hidden
splitter.addWidget(self.imageplot)
splitter.addWidget(self.curveplot)
self.mainArea.layout().addWidget(splitter)
self.line1 = MovableVlineWD(position=self.lowlim, label="", setvalfn=self.set_lowlim,
confirmfn=self.edited, report=self.curveplot)
self.line2 = MovableVlineWD(position=self.highlim, label="", setvalfn=self.set_highlim,
confirmfn=self.edited, report=self.curveplot)
self.line3 = MovableVlineWD(position=self.choose, label="", setvalfn=self.set_choose,
confirmfn=self.edited, report=self.curveplot)
self.curveplot.add_marking(self.line1)
self.curveplot.add_marking(self.line2)
self.curveplot.add_marking(self.line3)
self.line1.hide()
self.line2.hide()
self.line3.hide()
self.data = None
self.resize(900, 700)
self.graph_name = "imageplot.plotview"
self._update_integration_type()
class CanvasToolDock(QWidget):
"""Canvas dock widget with widget toolbox, quick help and
canvas actions.
"""
def __init__(self, parent=None, **kwargs):
QWidget.__init__(self, parent, **kwargs)
self.__setupUi()
def __setupUi(self):
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.toolbox = WidgetToolBox()
self.help = QuickHelpWidget(objectName="quick-help")
self.__splitter = QSplitter()
self.__splitter.setOrientation(Qt.Vertical)
self.__splitter.addWidget(self.toolbox)
self.__splitter.addWidget(self.help)
self.toolbar = DynamicResizeToolBar()
self.toolbar.setMovable(False)
self.toolbar.setFloatable(False)
self.toolbar.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred)
layout.addWidget(self.__splitter, 10)
layout.addWidget(self.toolbar)
self.setLayout(layout)
self.__splitterResizer = SplitterResizer(self)
self.__splitterResizer.setSplitterAndWidget(self.__splitter, self.help)
def setQuickHelpVisible(self, state):
"""Set the quick help box visibility status.
"""
self.__splitterResizer.setExpanded(state)
def quickHelpVisible(self):
return self.__splitterResizer.expanded()
def setQuickHelpAnimationEnabled(self, enabled):
"""Enable/disable the quick help animation.
"""
self.__splitterResizer.setAnimationEnabled(enabled)
def toogleQuickHelpAction(self):
"""Return a checkable QAction for help show/hide.
"""
return self.__splitterResizer.toogleExpandedAction()
def test_splitter_resizer(self):
w = QSplitter(orientation=Qt.Vertical)
w.addWidget(QWidget())
text = QTextEdit()
w.addWidget(text)
resizer = SplitterResizer(w)
resizer.setSplitterAndWidget(w, text)
def toogle():
if resizer.size() == 0:
resizer.open()
else:
resizer.close()
self.singleShot(1000, toogle)
w.show()
self.singleShot(0, toogle)
self.app.exec_()
def test_splitter_resizer(self):
w = QSplitter(orientation=Qt.Vertical)
w.addWidget(QWidget())
text = QTextEdit()
w.addWidget(text)
resizer = SplitterResizer(parent=None)
resizer.setSplitterAndWidget(w, text)
def toogle():
if resizer.size() == 0:
resizer.open()
else:
resizer.close()
w.show()
timer = QTimer(resizer, interval=1000)
timer.timeout.connect(toogle)
timer.start()
self.app.exec_()
def test_splitter_resizer(self):
w = QSplitter(orientation=Qt.Vertical)
w.addWidget(QWidget())
text = QTextEdit()
w.addWidget(text)
resizer = SplitterResizer(parent=None)
resizer.setSplitterAndWidget(w, text)
def toogle():
if resizer.size() == 0:
resizer.open()
else:
resizer.close()
w.show()
timer = QTimer(resizer, interval=1000)
timer.timeout.connect(toogle)
timer.start()
self.app.exec_()
def __init__(self):
super().__init__()
dbox = gui.widgetBox(self.controlArea, "Integration")
rbox = gui.radioButtons(dbox,
self,
"integration_method",
callback=self._change_integration)
gui.appendRadioButton(rbox, "Integrate from 0")
gui.appendRadioButton(rbox, "Integrate from baseline")
gui.appendRadioButton(rbox, "Peak from 0")
gui.appendRadioButton(rbox, "Peak from baseline")
gui.rubber(self.controlArea)
splitter = QSplitter(self)
splitter.setOrientation(Qt.Vertical)
self.imageplot = ImagePlot(self)
self.curveplot = CurvePlot(self, select=SELECTONE)
splitter.addWidget(self.imageplot)
splitter.addWidget(self.curveplot)
self.mainArea.layout().addWidget(splitter)
self.line1 = MovableVlineWD(position=self.lowlim,
label="",
setvalfn=self.set_lowlim,
confirmfn=self.edited,
report=self.curveplot)
self.line2 = MovableVlineWD(position=self.highlim,
label="",
setvalfn=self.set_highlim,
confirmfn=self.edited,
report=self.curveplot)
self.curveplot.add_marking(self.line1)
self.curveplot.add_marking(self.line2)
self.resize(900, 700)
self.graph_name = "imageplot.plotview"
def _setup_gui(self):
# Control area
box = gui.hBox(self.controlArea, "Filtering")
gui.doubleSpin(box,
self,
"threshold",
0,
1,
0.01,
None,
label="Threshold: ",
orientation=Qt.Horizontal,
callback=self.__on_threshold_changed)
box = gui.hBox(self.controlArea, "Display")
gui.radioButtons(box,
self,
"display_index",
DisplayDocument.ITEMS,
callback=self.__on_display_changed)
gui.rubber(self.controlArea)
# Main area
model = PyTableModel(parent=self)
self._list_view = SemanticListView()
self._list_view.setModel(model)
self._list_view.selectionModel().selectionChanged.connect(
self.__on_selection_changed)
self._list_view.horizontalHeader().sectionClicked.connect(
self.__on_horizontal_header_clicked)
splitter = QSplitter()
splitter.addWidget(self._list_view)
self._web_view = gui.WebviewWidget(splitter, debug=False)
splitter.setSizes([200, 300])
self.mainArea.layout().addWidget(splitter)
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.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 OWGenes(OWWidget, ConcurrentWidgetMixin):
name = "Genes"
description = "Tool for working with genes"
icon = "../widgets/icons/OWGeneInfo.svg"
priority = 40
want_main_area = True
selected_organism: int = Setting(11)
search_pattern: str = Setting('')
exclude_unmatched = Setting(True)
replace_id_with_symbol = Setting(True)
auto_commit = Setting(True)
settingsHandler = DomainContextHandler()
selected_gene_col = ContextSetting(None)
use_attr_names = ContextSetting(True)
replaces = [
'orangecontrib.bioinformatics.widgets.OWGeneNameMatcher.OWGeneNameMatcher'
]
class Inputs:
data_table = Input("Data", Table)
class Outputs:
data_table = Output("Data", Table)
gene_matcher_results = Output("Genes", Table)
class Information(OWWidget.Information):
pass
def sizeHint(self):
return QSize(1280, 960)
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
# ATTRIBUTES #
self.target_database = ENTREZ_ID
# input data
self.input_data = None
self.input_genes = None
self.tax_id = None
self.column_candidates = []
# input options
self.organisms = []
# gene matcher
self.gene_matcher = None
# progress bar
self.progress_bar = None
self._timer = QTimer()
self._timer.timeout.connect(self._apply_filter)
self._timer.setSingleShot(True)
# GUI SECTION #
# Control area
self.info_box = widgetLabel(
widgetBox(self.controlArea, "Info", addSpace=True),
'No data on input.\n')
organism_box = vBox(self.controlArea, 'Organism')
self.organism_select_combobox = comboBox(
organism_box,
self,
'selected_organism',
callback=self.on_input_option_change)
self.get_available_organisms()
self.organism_select_combobox.setCurrentIndex(self.selected_organism)
box = widgetBox(self.controlArea, 'Gene IDs in the input data')
self.gene_columns_model = itemmodels.DomainModel(
valid_types=(StringVariable, DiscreteVariable))
self.gene_column_combobox = comboBox(
box,
self,
'selected_gene_col',
label='Stored in data column',
model=self.gene_columns_model,
sendSelectedValue=True,
callback=self.on_input_option_change,
)
self.attr_names_checkbox = checkBox(
box,
self,
'use_attr_names',
'Stored as feature (column) names',
disables=[(-1, self.gene_column_combobox)],
callback=self.on_input_option_change,
)
self.gene_column_combobox.setDisabled(bool(self.use_attr_names))
output_box = vBox(self.controlArea, 'Output')
# separator(output_box)
# output_box.layout().addWidget(horizontal_line())
# separator(output_box)
self.exclude_radio = checkBox(output_box,
self,
'exclude_unmatched',
'Exclude unmatched genes',
callback=self.commit)
self.replace_radio = checkBox(output_box,
self,
'replace_id_with_symbol',
'Replace feature IDs with gene names',
callback=self.commit)
auto_commit(self.controlArea,
self,
"auto_commit",
"&Commit",
box=False)
rubber(self.controlArea)
# Main area
self.filter = lineEdit(self.mainArea,
self,
'search_pattern',
'Filter:',
callbackOnType=True,
callback=self.handle_filter_callback)
# rubber(self.radio_group)
self.mainArea.layout().addWidget(self.filter)
# set splitter
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.table_model = GeneInfoModel()
self.table_view = QTableView()
self.table_view.setAlternatingRowColors(True)
self.table_view.viewport().setMouseTracking(True)
self.table_view.setSortingEnabled(True)
self.table_view.setShowGrid(False)
self.table_view.verticalHeader().hide()
# self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.unknown_model = UnknownGeneInfoModel()
self.unknown_view = QTableView()
self.unknown_view.setModel(self.unknown_model)
self.unknown_view.verticalHeader().hide()
self.unknown_view.setShowGrid(False)
self.unknown_view.setSelectionMode(QAbstractItemView.NoSelection)
self.unknown_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.splitter.addWidget(self.table_view)
self.splitter.addWidget(self.unknown_view)
self.splitter.setStretchFactor(0, 90)
self.splitter.setStretchFactor(1, 10)
self.mainArea.layout().addWidget(self.splitter)
def handle_filter_callback(self):
self._timer.stop()
self._timer.start(500)
def _apply_filter(self):
# filter only if input data is present and model is populated
if self.table_model.table is not None:
self.table_model.update_model(
filter_pattern=str(self.search_pattern))
self.commit()
def __reset_widget_state(self):
self.table_view.clearSpans()
self.table_view.setModel(None)
self.table_model.clear()
self.unknown_model.clear()
self._update_info_box()
def _update_info_box(self):
if self.input_genes and self.gene_matcher:
num_genes = len(self.gene_matcher.genes)
known_genes = len(self.gene_matcher.get_known_genes())
info_text = ('{} genes in input data\n'
'{} genes match Entrez database\n'
'{} genes with match conflicts\n'.format(
num_genes, known_genes, num_genes - known_genes))
else:
info_text = 'No data on input.'
self.info_box.setText(info_text)
def on_done(self, _):
# update info box
self._update_info_box()
# set output options
self.toggle_radio_options()
# set known genes
self.table_model.initialize(self.gene_matcher.genes)
self.table_view.setModel(self.table_model)
self.table_view.selectionModel().selectionChanged.connect(self.commit)
self.table_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table_view.setItemDelegateForColumn(
self.table_model.entrez_column_index,
LinkStyledItemDelegate(self.table_view))
v_header = self.table_view.verticalHeader()
option = self.table_view.viewOptions()
size = self.table_view.style().sizeFromContents(
QStyle.CT_ItemViewItem, option, QSize(20, 20), self.table_view)
v_header.setDefaultSectionSize(size.height() + 2)
v_header.setMinimumSectionSize(5)
self.table_view.horizontalHeader().setStretchLastSection(True)
# set unknown genes
self.unknown_model.initialize(self.gene_matcher.genes)
self.unknown_view.verticalHeader().setStretchLastSection(True)
self._apply_filter()
def get_available_organisms(self):
available_organism = sorted(((tax_id, taxonomy.name(tax_id))
for tax_id in taxonomy.common_taxids()),
key=lambda x: x[1])
self.organisms = [tax_id[0] for tax_id in available_organism]
self.organism_select_combobox.addItems(
[tax_id[1] for tax_id in available_organism])
def gene_names_from_table(self):
""" Extract and return gene names from `Orange.data.Table`.
"""
self.input_genes = []
if self.input_data:
if self.use_attr_names:
self.input_genes = [
str(attr.name).strip()
for attr in self.input_data.domain.attributes
]
else:
if self.selected_gene_col is None:
self.selected_gene_col = self.gene_column_identifier()
self.input_genes = [
str(e[self.selected_gene_col]) for e in self.input_data
if not np.isnan(e[self.selected_gene_col])
]
def _update_gene_matcher(self):
self.gene_names_from_table()
self.gene_matcher = GeneMatcher(self.get_selected_organism(),
auto_start=False)
self.gene_matcher.genes = self.input_genes
# self.gene_matcher.organism = self.get_selected_organism()
def get_selected_organism(self):
return self.organisms[self.selected_organism]
def _run(self):
if self.gene_matcher is not None:
self.start(run_gene_matcher, self.gene_matcher)
def on_input_option_change(self):
self.__reset_widget_state()
self._update_gene_matcher()
self._run()
def gene_column_identifier(self):
"""
Get most suitable column that stores genes. If there are
several suitable columns, select the one with most unique
values. Take the best one.
"""
# candidates -> (variable, num of unique values)
candidates = ((col,
np.unique(self.input_data.get_column_view(col)[0]).size)
for col in self.gene_columns_model
if isinstance(col, DiscreteVariable)
or isinstance(col, StringVariable))
best_candidate, _ = sorted(candidates, key=lambda x: x[1])[-1]
return best_candidate
def find_genes_location(self):
""" Try locate the genes in the input data when we first load the data.
Proposed rules:
- when no suitable feature names are present, check the columns.
- find the most suitable column, that is, the one with most unique values.
"""
domain = self.input_data.domain
if not domain.attributes:
if self.selected_gene_col is None:
self.selected_gene_col = self.gene_column_identifier()
self.use_attr_names = False
@Inputs.data_table
def handle_input(self, data):
self.closeContext()
self.input_data = None
self.input_genes = None
self.__reset_widget_state()
self.gene_columns_model.set_domain(None)
self.selected_gene_col = None
if data:
self.input_data = data
self.gene_columns_model.set_domain(self.input_data.domain)
# check if input table has tax_id, human is used if tax_id is not found
self.tax_id = str(self.input_data.attributes.get(TAX_ID, '9606'))
# check for gene location. Default is that genes are attributes in the input table.
self.use_attr_names = self.input_data.attributes.get(
GENE_AS_ATTRIBUTE_NAME, self.use_attr_names)
if self.tax_id in self.organisms and not self.selected_organism:
self.selected_organism = self.organisms.index(self.tax_id)
self.openContext(self.input_data.domain)
self.find_genes_location()
self.on_input_option_change()
def commit(self):
selection = self.table_view.selectionModel().selectedRows(
self.table_model.entrez_column_index)
selected_genes = [row.data() for row in selection]
if not len(selected_genes):
selected_genes = self.table_model.get_filtered_genes()
gene_ids = self.get_target_ids()
known_genes = [gid for gid in gene_ids if gid != '?']
table = None
gm_table = None
if known_genes:
# Genes are in rows (we have a column with genes).
if not self.use_attr_names:
if self.target_database in self.input_data.domain:
gene_var = self.input_data.domain[self.target_database]
metas = self.input_data.domain.metas
else:
gene_var = StringVariable(self.target_database)
metas = self.input_data.domain.metas + (gene_var, )
domain = Domain(self.input_data.domain.attributes,
self.input_data.domain.class_vars, metas)
table = self.input_data.transform(domain)
col, _ = table.get_column_view(gene_var)
col[:] = gene_ids
# filter selected rows
selected_genes_set = set(selected_genes)
selected_rows = [
row_index for row_index, row in enumerate(table)
if str(row[gene_var]) in selected_genes_set
]
# handle table attributes
table.attributes[TAX_ID] = self.get_selected_organism()
table.attributes[GENE_AS_ATTRIBUTE_NAME] = False
table.attributes[GENE_ID_COLUMN] = self.target_database
table = table[selected_rows] if selected_rows else table
if self.exclude_unmatched:
# create filter from selected column for genes
only_known = table_filter.FilterStringList(
gene_var, known_genes)
# apply filter to the data
table = table_filter.Values([only_known])(table)
self.Outputs.data_table.send(table)
# genes are are in columns (genes are features).
else:
domain = self.input_data.domain.copy()
table = self.input_data.transform(domain)
for gene in self.gene_matcher.genes:
if gene.input_identifier in table.domain:
table.domain[gene.input_identifier].attributes[
self.target_database] = (str(gene.gene_id)
if gene.gene_id else '?')
if self.replace_id_with_symbol:
try:
table.domain[gene.input_identifier].name = str(
gene.symbol)
except AttributeError:
# TODO: missing gene symbol, need to handle this?
pass
# filter selected columns
selected_genes_set = set(selected_genes)
selected = [
column for column in table.domain.attributes
if self.target_database in column.attributes
and str(column.attributes[
self.target_database]) in selected_genes_set
]
output_attrs = table.domain.attributes
if selected:
output_attrs = selected
if self.exclude_unmatched:
known_genes_set = set(known_genes)
output_attrs = [
col for col in output_attrs if col.attributes[
self.target_database] in known_genes_set
]
domain = Domain(output_attrs, table.domain.class_vars,
table.domain.metas)
table = table.from_table(domain, table)
# handle table attributes
table.attributes[TAX_ID] = self.get_selected_organism()
table.attributes[GENE_AS_ATTRIBUTE_NAME] = True
table.attributes[GENE_ID_ATTRIBUTE] = self.target_database
gm_table = self.gene_matcher.to_data_table(
selected_genes=selected_genes if selected_genes else None)
self.Outputs.data_table.send(table)
self.Outputs.gene_matcher_results.send(gm_table)
def toggle_radio_options(self):
self.replace_radio.setEnabled(bool(self.use_attr_names))
if self.gene_matcher.genes:
# enable checkbox if unknown genes are detected
self.exclude_radio.setEnabled(
len(self.gene_matcher.genes) != len(
self.gene_matcher.get_known_genes()))
self.exclude_unmatched = len(self.gene_matcher.genes) != len(
self.gene_matcher.get_known_genes())
def get_target_ids(self):
return [
str(gene.gene_id) if gene.gene_id else '?'
for gene in self.gene_matcher.genes
]
class OWPythonScript(widget.OWWidget):
name = "Python Script"
description = "Write a Python script and run it on input data or models."
icon = "icons/PythonScript.svg"
priority = 3150
keywords = ["file", "program"]
class Inputs:
data = Input("Data", Table, replaces=["in_data"],
default=True, multiple=True)
learner = Input("Learner", Learner, replaces=["in_learner"],
default=True, multiple=True)
classifier = Input("Classifier", Model, replaces=["in_classifier"],
default=True, multiple=True)
object = Input("Object", object, replaces=["in_object"],
default=False, multiple=True)
class Outputs:
data = Output("Data", Table, replaces=["out_data"])
learner = Output("Learner", Learner, replaces=["out_learner"])
classifier = Output("Classifier", Model, replaces=["out_classifier"])
object = Output("Object", object, replaces=["out_object"])
signal_names = ("data", "learner", "classifier", "object")
settingsHandler = PrepareSavingSettingsHandler()
libraryListSource = \
Setting([Script("Hello world", "print('Hello world')\n")])
currentScriptIndex = Setting(0)
scriptText = Setting(None, schema_only=True)
splitterState = Setting(None)
class Error(OWWidget.Error):
pass
def __init__(self):
super().__init__()
for name in self.signal_names:
setattr(self, name, {})
for s in self.libraryListSource:
s.flags = 0
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " +
"<li>".join(map("in_{0}, in_{0}s".format, self.signal_names)) +
"</ul></p><p>Output variables:<ul><li>" +
"<li>".join(map("out_{0}".format, self.signal_names)) +
"</ul></p>"
)
self.libraryList = itemmodels.PyListModel(
[], self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked |
QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
)
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged
)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Script from File", self)
save_to_file = QAction("Save Selected Script to File", self)
restore_saved = QAction("Undo Changes to Selected Script", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
restore_saved.triggered.connect(self.restoreSaved)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
menu.addAction(restore_saved)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
self.execute_button = gui.button(self.controlArea, self, 'Run', callback=self.commit)
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python Script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
select_row(self.libraryView, self.currentScriptIndex)
self.restoreScriptText()
self.splitCanvas.setSizes([2, 1])
if self.splitterState is not None:
self.splitCanvas.restoreState(QByteArray(self.splitterState))
self.splitCanvas.splitterMoved[int, int].connect(self.onSpliterMoved)
self.controlArea.layout().addStretch(1)
self.resize(800, 600)
def storeSpecificSettings(self):
self.saveScriptText()
def restoreScriptText(self):
if self.scriptText is not None:
current = self.text.toPlainText()
# do not mark scripts as modified
if self.scriptText != current:
self.text.document().setPlainText(self.scriptText)
def saveScriptText(self):
self.scriptText = self.text.toPlainText()
def handle_input(self, obj, id, signal):
id = id[0]
dic = getattr(self, signal)
if obj is None:
if id in dic.keys():
del dic[id]
else:
dic[id] = obj
@Inputs.data
def set_data(self, data, id):
self.handle_input(data, id, "data")
@Inputs.learner
def set_learner(self, data, id):
self.handle_input(data, id, "learner")
@Inputs.classifier
def set_classifier(self, data, id):
self.handle_input(data, id, "classifier")
@Inputs.object
def set_object(self, data, id):
self.handle_input(data, id, "object")
def handleNewSignals(self):
self.commit()
def selectedScriptIndex(self):
rows = self.libraryView.selectionModel().selectedRows()
if rows:
return [i.row() for i in rows][0]
else:
return None
def setSelectedScript(self, index):
select_row(self.libraryView, index)
def onAddScript(self, *args):
self.libraryList.append(Script("New script", self.text.toPlainText(), 0))
self.setSelectedScript(len(self.libraryList) - 1)
def onAddScriptFromFile(self, *args):
filename, _ = QFileDialog.getOpenFileName(
self, 'Open Python Script',
os.path.expanduser("~/"),
'Python files (*.py)\nAll files(*.*)'
)
if filename:
name = os.path.basename(filename)
# TODO: use `tokenize.detect_encoding`
with open(filename, encoding="utf-8") as f:
contents = f.read()
self.libraryList.append(Script(name, contents, 0, filename))
self.setSelectedScript(len(self.libraryList) - 1)
def onRemoveScript(self, *args):
index = self.selectedScriptIndex()
if index is not None:
del self.libraryList[index]
select_row(self.libraryView, max(index - 1, 0))
def onSaveScriptToFile(self, *args):
index = self.selectedScriptIndex()
if index is not None:
self.saveScript()
def onSelectedScriptChanged(self, selected, deselected):
index = [i.row() for i in selected.indexes()]
if index:
current = index[0]
if current >= len(self.libraryList):
self.addNewScriptAction.trigger()
return
self.text.setDocument(self.documentForScript(current))
self.currentScriptIndex = current
def documentForScript(self, script=0):
if type(script) != Script:
script = self.libraryList[script]
if script not in self._cachedDocuments:
doc = QTextDocument(self)
doc.setDocumentLayout(QPlainTextDocumentLayout(doc))
doc.setPlainText(script.script)
doc.setDefaultFont(QFont(self.defaultFont))
doc.highlighter = PythonSyntaxHighlighter(doc)
doc.modificationChanged[bool].connect(self.onModificationChanged)
doc.setModified(False)
self._cachedDocuments[script] = doc
return self._cachedDocuments[script]
def commitChangesToLibrary(self, *args):
index = self.selectedScriptIndex()
if index is not None:
self.libraryList[index].script = self.text.toPlainText()
self.text.document().setModified(False)
self.libraryList.emitDataChanged(index)
def onModificationChanged(self, modified):
index = self.selectedScriptIndex()
if index is not None:
self.libraryList[index].flags = Script.Modified if modified else 0
self.libraryList.emitDataChanged(index)
def onSpliterMoved(self, pos, ind):
self.splitterState = bytes(self.splitCanvas.saveState())
def restoreSaved(self):
index = self.selectedScriptIndex()
if index is not None:
self.text.document().setPlainText(self.libraryList[index].script)
self.text.document().setModified(False)
def saveScript(self):
index = self.selectedScriptIndex()
if index is not None:
script = self.libraryList[index]
filename = script.filename
else:
filename = os.path.expanduser("~/")
filename, _ = QFileDialog.getSaveFileName(
self, 'Save Python Script',
filename,
'Python files (*.py)\nAll files(*.*)'
)
if filename:
fn = ""
head, tail = os.path.splitext(filename)
if not tail:
fn = head + ".py"
else:
fn = filename
f = open(fn, 'w')
f.write(self.text.toPlainText())
f.close()
def initial_locals_state(self):
d = {}
for name in self.signal_names:
value = getattr(self, name)
all_values = list(value.values())
one_value = all_values[0] if len(all_values) == 1 else None
d["in_" + name + "s"] = all_values
d["in_" + name] = one_value
return d
def commit(self):
self.Error.clear()
self._script = str(self.text.toPlainText())
lcls = self.initial_locals_state()
lcls["_script"] = str(self.text.toPlainText())
self.console.updateLocals(lcls)
self.console.write("\nRunning script:\n")
self.console.push("exec(_script)")
self.console.new_prompt(sys.ps1)
for signal in self.signal_names:
out_var = self.console.locals.get("out_" + signal)
signal_type = getattr(self.Outputs, signal).type
if not isinstance(out_var, signal_type) and out_var is not None:
self.Error.add_message(signal,
"'{}' has to be an instance of '{}'.".
format(signal, signal_type.__name__))
getattr(self.Error, signal)()
out_var = None
getattr(self.Outputs, signal).send(out_var)
class OWDataSets(widget.OWWidget):
name = "Data Sets"
description = "Load a data set from an online repository"
icon = "icons/DataSets.svg"
priority = 20
replaces = ["orangecontrib.prototypes.widgets.owdatasets.OWDataSets"]
# The following constants can be overridden in a subclass
# to reuse this widget for a different repository
# Take care when refactoring! (used in e.g. single-cell)
INDEX_URL = "http://datasets.orange.biolab.si/"
DATASET_DIR = "datasets"
class Error(widget.OWWidget.Error):
no_remote_datasets = Msg("Could not fetch data set list")
class Warning(widget.OWWidget.Warning):
only_local_datasets = Msg("Could not fetch data sets list, only local "
"cached data sets are shown")
class Outputs:
data = Output("Data", Orange.data.Table)
#: Selected data set id
selected_id = settings.Setting(None) # type: Optional[str]
auto_commit = settings.Setting(False) # type: bool
#: main area splitter state
splitter_state = settings.Setting(b'') # type: bytes
header_state = settings.Setting(b'') # type: bytes
def __init__(self):
super().__init__()
self.local_cache_path = os.path.join(data_dir(), self.DATASET_DIR)
self.__awaiting_state = None # type: Optional[_FetchState]
box = gui.widgetBox(self.controlArea, "Info")
self.infolabel = QLabel(text="Initializing...\n\n")
box.layout().addWidget(self.infolabel)
gui.widgetLabel(self.mainArea, "Filter")
self.filterLineEdit = QLineEdit(
textChanged=self.filter
)
self.mainArea.layout().addWidget(self.filterLineEdit)
self.splitter = QSplitter(orientation=Qt.Vertical)
self.view = QTreeView(
sortingEnabled=True,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True,
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
)
box = gui.widgetBox(self.splitter, "Description", addToLayout=False)
self.descriptionlabel = QLabel(
wordWrap=True,
textFormat=Qt.RichText,
)
self.descriptionlabel = QTextBrowser(
openExternalLinks=True,
textInteractionFlags=(Qt.TextSelectableByMouse |
Qt.LinksAccessibleByMouse)
)
self.descriptionlabel.setFrameStyle(QTextBrowser.NoFrame)
# no (white) text background
self.descriptionlabel.viewport().setAutoFillBackground(False)
box.layout().addWidget(self.descriptionlabel)
self.splitter.addWidget(self.view)
self.splitter.addWidget(box)
self.splitter.setSizes([300, 200])
self.splitter.splitterMoved.connect(
lambda:
setattr(self, "splitter_state", bytes(self.splitter.saveState()))
)
self.mainArea.layout().addWidget(self.splitter)
self.controlArea.layout().addStretch(10)
gui.auto_commit(self.controlArea, self, "auto_commit", "Send Data")
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(HEADER)
proxy = QSortFilterProxyModel()
proxy.setSourceModel(model)
proxy.setFilterKeyColumn(-1)
proxy.setFilterCaseSensitivity(False)
self.view.setModel(proxy)
if self.splitter_state:
self.splitter.restoreState(self.splitter_state)
self.view.setItemDelegateForColumn(
Header.Size, SizeDelegate(self))
self.view.setItemDelegateForColumn(
Header.Local, gui.IndicatorItemDelegate(self, role=Qt.DisplayRole))
self.view.setItemDelegateForColumn(
Header.Instances, NumericalDelegate(self))
self.view.setItemDelegateForColumn(
Header.Variables, NumericalDelegate(self))
self.view.resizeColumnToContents(Header.Local)
if self.header_state:
self.view.header().restoreState(self.header_state)
self.setBlocking(True)
self.setStatusMessage("Initializing")
self._executor = ThreadPoolExecutor(max_workers=1)
f = self._executor.submit(self.list_remote)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__set_index)
@Slot(object)
def __set_index(self, f):
# type: (Future) -> None
# set results from `list_remote` query.
assert QThread.currentThread() is self.thread()
assert f.done()
self.setBlocking(False)
self.setStatusMessage("")
allinfolocal = self.list_local()
try:
res = f.result()
except Exception:
log.exception("Error while fetching updated index")
if not allinfolocal:
self.Error.no_remote_datasets()
else:
self.Warning.only_local_datasets()
res = {}
allinforemote = res # type: Dict[Tuple[str, str], dict]
allkeys = set(allinfolocal)
if allinforemote is not None:
allkeys = allkeys | set(allinforemote)
allkeys = sorted(allkeys)
def info(file_path):
if file_path in allinforemote:
info = allinforemote[file_path]
else:
info = allinfolocal[file_path]
islocal = file_path in allinfolocal
isremote = file_path in allinforemote
outdated = islocal and isremote and (
allinforemote[file_path].get('version', '') !=
allinfolocal[file_path].get('version', ''))
islocal &= not outdated
prefix = os.path.join('', *file_path[:-1])
filename = file_path[-1]
return namespace(
prefix=prefix, filename=filename,
title=info.get("title", filename),
datetime=info.get("datetime", None),
description=info.get("description", None),
references=info.get("references", []),
seealso=info.get("seealso", []),
source=info.get("source", None),
year=info.get("year", None),
instances=info.get("instances", None),
variables=info.get("variables", None),
target=info.get("target", None),
missing=info.get("missing", None),
tags=info.get("tags", []),
size=info.get("size", None),
islocal=islocal,
outdated=outdated
)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(HEADER)
current_index = -1
for i, file_path in enumerate(allkeys):
datainfo = info(file_path)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
if datainfo.target:
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags) if datainfo.tags else "",
Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
hs = self.view.header().saveState()
model_ = self.view.model().sourceModel()
self.view.model().setSourceModel(model)
self.view.header().restoreState(hs)
model_.deleteLater()
model_.setParent(None)
self.view.selectionModel().selectionChanged.connect(
self.__on_selection
)
# Update the info text
self.infolabel.setText(format_info(model.rowCount(), len(allinfolocal)))
if current_index != -1:
selmodel = self.view.selectionModel()
selmodel.select(
self.view.model().mapFromSource(model.index(current_index, 0)),
QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
def __update_cached_state(self):
model = self.view.model().sourceModel()
localinfo = self.list_local()
assert isinstance(model, QStandardItemModel)
allinfo = []
for i in range(model.rowCount()):
item = model.item(i, 0)
info = item.data(Qt.UserRole)
info.islocal = (info.prefix, info.filename) in localinfo
item.setData(" " if info.islocal else "", Qt.DisplayRole)
allinfo.append(info)
self.infolabel.setText(format_info(
model.rowCount(), sum(info.islocal for info in allinfo)))
def selected_dataset(self):
"""
Return the current selected data set info or None if not selected
Returns
-------
info : Optional[namespace]
"""
rows = self.view.selectionModel().selectedRows(0)
assert 0 <= len(rows) <= 1
current = rows[0] if rows else None # type: Optional[QModelIndex]
if current is not None:
info = current.data(Qt.UserRole)
assert isinstance(info, namespace)
else:
info = None
return info
def filter(self):
filter_string = self.filterLineEdit.text().strip()
proxyModel = self.view.model()
if proxyModel:
proxyModel.setFilterFixedString(filter_string)
def __on_selection(self):
# Main data sets view selection has changed
rows = self.view.selectionModel().selectedRows(0)
assert 0 <= len(rows) <= 1
current = rows[0] if rows else None # type: Optional[QModelIndex]
if current is not None:
current = self.view.model().mapToSource(current)
di = current.data(Qt.UserRole)
text = description_html(di)
self.descriptionlabel.setText(text)
self.selected_id = os.path.join(di.prefix, di.filename)
else:
self.descriptionlabel.setText("")
self.selected_id = None
self.commit()
def commit(self):
"""
Commit a dataset to the output immediately (if available locally) or
schedule download background and an eventual send.
During the download the widget is in blocking state
(OWWidget.isBlocking)
"""
di = self.selected_dataset()
if di is not None:
self.Error.clear()
if self.__awaiting_state is not None:
# disconnect from the __commit_complete
self.__awaiting_state.watcher.done.disconnect(
self.__commit_complete)
# .. and connect to update_cached_state
# self.__awaiting_state.watcher.done.connect(
# self.__update_cached_state)
# TODO: There are possible pending __progress_advance queued
self.__awaiting_state.pb.advance.disconnect(
self.__progress_advance)
self.progressBarFinished(processEvents=None)
self.__awaiting_state = None
if not di.islocal:
pr = progress()
callback = lambda pr=pr: pr.advance.emit()
pr.advance.connect(self.__progress_advance, Qt.QueuedConnection)
self.progressBarInit(processEvents=None)
self.setStatusMessage("Fetching...")
self.setBlocking(True)
f = self._executor.submit(
ensure_local, self.INDEX_URL, di.prefix, di.filename,
self.local_cache_path, force=di.outdated,
progress_advance=callback)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__commit_complete)
self.__awaiting_state = _FetchState(f, w, pr)
else:
self.setStatusMessage("")
self.setBlocking(False)
self.commit_cached(di.prefix, di.filename)
else:
self.Outputs.data.send(None)
@Slot(object)
def __commit_complete(self, f):
# complete the commit operation after the required file has been
# downloaded
assert QThread.currentThread() is self.thread()
assert self.__awaiting_state is not None
assert self.__awaiting_state.future is f
if self.isBlocking():
self.progressBarFinished(processEvents=None)
self.setBlocking(False)
self.setStatusMessage("")
self.__awaiting_state = None
try:
path = f.result()
except Exception as ex:
log.exception("Error:")
self.error(format_exception(ex))
path = None
self.__update_cached_state()
if path is not None:
data = Orange.data.Table(path)
else:
data = None
self.Outputs.data.send(data)
def commit_cached(self, prefix, filename):
path = LocalFiles(self.local_cache_path).localpath(prefix, filename)
self.Outputs.data.send(Orange.data.Table(path))
@Slot()
def __progress_advance(self):
assert QThread.currentThread() is self.thread()
self.progressBarAdvance(1, processEvents=None)
def onDeleteWidget(self):
super().onDeleteWidget()
if self.__awaiting_state is not None:
self.__awaiting_state.watcher.done.disconnect(self.__commit_complete)
self.__awaiting_state.pb.advance.disconnect(self.__progress_advance)
self.__awaiting_state = None
def sizeHint(self):
return QSize(900, 600)
def closeEvent(self, event):
self.splitter_state = bytes(self.splitter.saveState())
self.header_state = bytes(self.view.header().saveState())
super().closeEvent(event)
def list_remote(self):
# type: () -> Dict[Tuple[str, str], dict]
client = ServerFiles(server=self.INDEX_URL)
return client.allinfo()
def list_local(self):
# type: () -> Dict[Tuple[str, str], dict]
return LocalFiles(self.local_cache_path).allinfo()
def __init__(self):
super().__init__()
self.allinfo_local = {}
self.allinfo_remote = {}
self.local_cache_path = os.path.join(data_dir(), self.DATASET_DIR)
# current_output does not equal selected_id when, for instance, the
# data is still downloading
self.current_output = None
self._header_labels = [
header['label'] for _, header in self.HEADER_SCHEMA]
self._header_index = namedtuple(
'_header_index', [info_tag for info_tag, _ in self.HEADER_SCHEMA])
self.Header = self._header_index(
*[index for index, _ in enumerate(self._header_labels)])
self.__awaiting_state = None # type: Optional[_FetchState]
self.filterLineEdit = QLineEdit(
textChanged=self.filter, placeholderText="Search for data set ..."
)
self.mainArea.layout().addWidget(self.filterLineEdit)
self.splitter = QSplitter(orientation=Qt.Vertical)
self.view = TreeViewWithReturn(
sortingEnabled=True,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True,
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
uniformRowHeights=True,
toolTip="Press Return or double-click to send"
)
# the method doesn't exists yet, pylint: disable=unnecessary-lambda
self.view.doubleClicked.connect(self.commit)
self.view.returnPressed.connect(self.commit)
box = gui.widgetBox(self.splitter, "说明", addToLayout=False)
self.descriptionlabel = QLabel(
wordWrap=True,
textFormat=Qt.RichText,
)
self.descriptionlabel = QTextBrowser(
openExternalLinks=True,
textInteractionFlags=(Qt.TextSelectableByMouse |
Qt.LinksAccessibleByMouse)
)
self.descriptionlabel.setFrameStyle(QTextBrowser.NoFrame)
# no (white) text background
self.descriptionlabel.viewport().setAutoFillBackground(False)
box.layout().addWidget(self.descriptionlabel)
self.splitter.addWidget(self.view)
self.splitter.addWidget(box)
self.splitter.setSizes([300, 200])
self.splitter.splitterMoved.connect(
lambda:
setattr(self, "splitter_state", bytes(self.splitter.saveState()))
)
self.mainArea.layout().addWidget(self.splitter)
proxy = QSortFilterProxyModel()
proxy.setFilterKeyColumn(-1)
proxy.setFilterCaseSensitivity(False)
self.view.setModel(proxy)
if self.splitter_state:
self.splitter.restoreState(self.splitter_state)
self.assign_delegates()
self.setBlocking(True)
self.setStatusMessage("Initializing")
self._executor = ThreadPoolExecutor(max_workers=1)
f = self._executor.submit(self.list_remote)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__set_index)
class OWPythonScript(OWWidget):
name = "Python Script"
description = "Write a Python script and run it on input data or models."
icon = "icons/PythonScript.svg"
priority = 3150
keywords = ["file", "program"]
class Inputs:
data = Input("Data",
Table,
replaces=["in_data"],
default=True,
multiple=True)
learner = Input("Learner",
Learner,
replaces=["in_learner"],
default=True,
multiple=True)
classifier = Input("Classifier",
Model,
replaces=["in_classifier"],
default=True,
multiple=True)
object = Input("Object",
object,
replaces=["in_object"],
default=False,
multiple=True)
class Outputs:
data = Output("Data", Table, replaces=["out_data"])
learner = Output("Learner", Learner, replaces=["out_learner"])
classifier = Output("Classifier", Model, replaces=["out_classifier"])
object = Output("Object", object, replaces=["out_object"])
signal_names = ("data", "learner", "classifier", "object")
settings_version = 2
scriptLibrary: 'List[_ScriptData]' = Setting([{
"name": "Hello world",
"script": "print('Hello world')\n",
"filename": None
}])
currentScriptIndex = Setting(0)
scriptText: Optional[str] = Setting(None, schema_only=True)
splitterState: Optional[bytes] = Setting(None)
# Widgets in the same schema share namespace through a dictionary whose
# key is self.signalManager. ales-erjavec expressed concern (and I fully
# agree!) about widget being aware of the outside world. I am leaving this
# anyway. If this causes any problems in the future, replace this with
# shared_namespaces = {} and thus use a common namespace for all instances
# of # PythonScript even if they are in different schemata.
shared_namespaces = weakref.WeakKeyDictionary()
class Error(OWWidget.Error):
pass
def __init__(self):
super().__init__()
self.libraryListSource = []
for name in self.signal_names:
setattr(self, name, {})
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " +
"<li>".join(map("in_{0}, in_{0}s".format, self.signal_names)) +
"</ul></p><p>Output variables:<ul><li>" +
"<li>".join(map("out_{0}".format, self.signal_names)) +
"</ul></p>")
self.libraryList = itemmodels.PyListModel(
[],
self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked | QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred))
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Script from File", self)
save_to_file = QAction("Save Selected Script to File", self)
restore_saved = QAction("Undo Changes to Selected Script", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
restore_saved.triggered.connect(self.restoreSaved)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
menu.addAction(restore_saved)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
self.execute_button = gui.button(self.controlArea,
self,
'Run',
callback=self.commit)
run = QAction("Run script",
self,
triggered=self.commit,
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_R))
self.addAction(run)
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python Script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
self.splitCanvas.setSizes([2, 1])
self.setAcceptDrops(True)
self.controlArea.layout().addStretch(10)
self._restoreState()
self.settingsAboutToBePacked.connect(self._saveState)
def sizeHint(self) -> QSize:
return super().sizeHint().expandedTo(QSize(800, 600))
def _restoreState(self):
self.libraryListSource = [
Script.fromdict(s) for s in self.scriptLibrary
]
self.libraryList.wrap(self.libraryListSource)
select_row(self.libraryView, self.currentScriptIndex)
if self.scriptText is not None:
current = self.text.toPlainText()
# do not mark scripts as modified
if self.scriptText != current:
self.text.document().setPlainText(self.scriptText)
if self.splitterState is not None:
self.splitCanvas.restoreState(QByteArray(self.splitterState))
def _saveState(self):
self.scriptLibrary = [s.asdict() for s in self.libraryListSource]
self.scriptText = self.text.toPlainText()
self.splitterState = bytes(self.splitCanvas.saveState())
def handle_input(self, obj, sig_id, signal):
dic = getattr(self, signal)
if obj is None:
if sig_id in dic.keys():
del dic[sig_id]
else:
dic[sig_id] = obj
@Inputs.data
def set_data(self, data, sig_id):
self.handle_input(data, sig_id, "data")
@Inputs.learner
def set_learner(self, data, sig_id):
self.handle_input(data, sig_id, "learner")
@Inputs.classifier
def set_classifier(self, data, sig_id):
self.handle_input(data, sig_id, "classifier")
@Inputs.object
def set_object(self, data, sig_id):
self.handle_input(data, sig_id, "object")
def handleNewSignals(self):
self.commit()
def selectedScriptIndex(self):
rows = self.libraryView.selectionModel().selectedRows()
if rows:
return [i.row() for i in rows][0]
else:
return None
def setSelectedScript(self, index):
select_row(self.libraryView, index)
def onAddScript(self, *_):
self.libraryList.append(
Script("New script", self.text.toPlainText(), 0))
self.setSelectedScript(len(self.libraryList) - 1)
def onAddScriptFromFile(self, *_):
filename, _ = QFileDialog.getOpenFileName(
self, 'Open Python Script', os.path.expanduser("~/"),
'Python files (*.py)\nAll files(*.*)')
if filename:
name = os.path.basename(filename)
# TODO: use `tokenize.detect_encoding`
with open(filename, encoding="utf-8") as f:
contents = f.read()
self.libraryList.append(Script(name, contents, 0, filename))
self.setSelectedScript(len(self.libraryList) - 1)
def onRemoveScript(self, *_):
index = self.selectedScriptIndex()
if index is not None:
del self.libraryList[index]
select_row(self.libraryView, max(index - 1, 0))
def onSaveScriptToFile(self, *_):
index = self.selectedScriptIndex()
if index is not None:
self.saveScript()
def onSelectedScriptChanged(self, selected, _deselected):
index = [i.row() for i in selected.indexes()]
if index:
current = index[0]
if current >= len(self.libraryList):
self.addNewScriptAction.trigger()
return
self.text.setDocument(self.documentForScript(current))
self.currentScriptIndex = current
def documentForScript(self, script=0):
if not isinstance(script, Script):
script = self.libraryList[script]
if script not in self._cachedDocuments:
doc = QTextDocument(self)
doc.setDocumentLayout(QPlainTextDocumentLayout(doc))
doc.setPlainText(script.script)
doc.setDefaultFont(QFont(self.defaultFont))
doc.highlighter = PythonSyntaxHighlighter(doc)
doc.modificationChanged[bool].connect(self.onModificationChanged)
doc.setModified(False)
self._cachedDocuments[script] = doc
return self._cachedDocuments[script]
def commitChangesToLibrary(self, *_):
index = self.selectedScriptIndex()
if index is not None:
self.libraryList[index].script = self.text.toPlainText()
self.text.document().setModified(False)
self.libraryList.emitDataChanged(index)
def onModificationChanged(self, modified):
index = self.selectedScriptIndex()
if index is not None:
self.libraryList[index].flags = Script.Modified if modified else 0
self.libraryList.emitDataChanged(index)
def restoreSaved(self):
index = self.selectedScriptIndex()
if index is not None:
self.text.document().setPlainText(self.libraryList[index].script)
self.text.document().setModified(False)
def saveScript(self):
index = self.selectedScriptIndex()
if index is not None:
script = self.libraryList[index]
filename = script.filename
else:
filename = os.path.expanduser("~/")
filename, _ = QFileDialog.getSaveFileName(
self, 'Save Python Script', filename,
'Python files (*.py)\nAll files(*.*)')
if filename:
fn = ""
head, tail = os.path.splitext(filename)
if not tail:
fn = head + ".py"
else:
fn = filename
f = open(fn, 'w')
f.write(self.text.toPlainText())
f.close()
def initial_locals_state(self):
d = self.shared_namespaces.setdefault(self.signalManager, {}).copy()
for name in self.signal_names:
value = getattr(self, name)
all_values = list(value.values())
one_value = all_values[0] if len(all_values) == 1 else None
d["in_" + name + "s"] = all_values
d["in_" + name] = one_value
return d
def update_namespace(self, namespace):
not_saved = reduce(set.union,
({f"in_{name}s", f"in_{name}", f"out_{name}"}
for name in self.signal_names))
self.shared_namespaces.setdefault(self.signalManager, {}).update({
name: value
for name, value in namespace.items() if name not in not_saved
})
def commit(self):
self.Error.clear()
lcls = self.initial_locals_state()
lcls["_script"] = str(self.text.toPlainText())
self.console.updateLocals(lcls)
self.console.write("\nRunning script:\n")
self.console.push("exec(_script)")
self.console.new_prompt(sys.ps1)
self.update_namespace(self.console.locals)
for signal in self.signal_names:
out_var = self.console.locals.get("out_" + signal)
signal_type = getattr(self.Outputs, signal).type
if not isinstance(out_var, signal_type) and out_var is not None:
self.Error.add_message(
signal, "'{}' has to be an instance of '{}'.".format(
signal, signal_type.__name__))
getattr(self.Error, signal)()
out_var = None
getattr(self.Outputs, signal).send(out_var)
def dragEnterEvent(self, event): # pylint: disable=no-self-use
urls = event.mimeData().urls()
if urls:
# try reading the file as text
c = read_file_content(urls[0].toLocalFile(), limit=1000)
if c is not None:
event.acceptProposedAction()
def dropEvent(self, event):
"""Handle file drops"""
urls = event.mimeData().urls()
if urls:
self.text.pasteFile(urls[0])
@classmethod
def migrate_settings(cls, settings, version):
if version is not None and version < 2:
scripts = settings.pop("libraryListSource") # type: List[Script]
library = [
dict(name=s.name, script=s.script, filename=s.filename)
for s in scripts
] # type: List[_ScriptData]
settings["scriptLibrary"] = library
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 __init__(self, parent=None):
super().__init__(parent)
self.organismCodes = []
self._changedFlag = False
self.__invalidated = False
self.__runstate = OWKEGGPathwayBrowser.Initializing
self.__in_setProgress = False
self.controlArea.setMaximumWidth(250)
box = gui.widgetBox(self.controlArea, "Info")
self.infoLabel = gui.widgetLabel(box, "No data on input\n")
# Organism selection.
box = gui.widgetBox(self.controlArea, "Organism")
self.organismComboBox = gui.comboBox(
box,
self,
"organismIndex",
items=[],
callback=self.Update,
addSpace=True,
tooltip="Select the organism of the input genes",
)
# Selection of genes attribute
box = gui.widgetBox(self.controlArea, "Gene attribute")
self.geneAttrCandidates = itemmodels.VariableListModel(parent=self)
self.geneAttrCombo = gui.comboBox(box, self, "geneAttrIndex", callback=self.Update)
self.geneAttrCombo.setModel(self.geneAttrCandidates)
gui.checkBox(
box, self, "useAttrNames", "Use variable names", disables=[(-1, self.geneAttrCombo)], callback=self.Update
)
self.geneAttrCombo.setDisabled(bool(self.useAttrNames))
gui.separator(self.controlArea)
gui.checkBox(self.controlArea, self, "useReference", "From signal", box="Reference", callback=self.Update)
gui.separator(self.controlArea)
gui.checkBox(
self.controlArea,
self,
"showOrthology",
"Show pathways in full orthology",
box="Orthology",
callback=self.UpdateListView,
)
gui.checkBox(
self.controlArea, self, "autoResize", "Resize to fit", box="Image", callback=self.UpdatePathwayViewTransform
)
box = gui.widgetBox(self.controlArea, "Cache Control")
gui.button(
box,
self,
"Clear cache",
callback=self.ClearCache,
tooltip="Clear all locally cached KEGG data.",
default=False,
autoDefault=False,
)
gui.separator(self.controlArea)
gui.auto_commit(self.controlArea, self, "autoCommit", "Commit")
gui.rubber(self.controlArea)
spliter = QSplitter(Qt.Vertical, self.mainArea)
self.pathwayView = PathwayView(self, spliter)
self.pathwayView.scene().selectionChanged.connect(self._onSelectionChanged)
self.mainArea.layout().addWidget(spliter)
self.listView = QTreeWidget(
allColumnsShowFocus=True, selectionMode=QTreeWidget.SingleSelection, sortingEnabled=True, maximumHeight=200
)
spliter.addWidget(self.listView)
self.listView.setColumnCount(4)
self.listView.setHeaderLabels(["Pathway", "P value", "Genes", "Reference"])
self.listView.itemSelectionChanged.connect(self.UpdatePathwayView)
select = QAction("Select All", self, shortcut=QKeySequence.SelectAll)
select.triggered.connect(self.selectAll)
self.addAction(select)
self.data = None
self.refData = None
self._executor = concurrent.ThreadExecutor()
self.setEnabled(False)
self.setBlocking(True)
progress = concurrent.methodinvoke(self, "setProgress", (float,))
def get_genome():
"""Return a KEGGGenome with the common org entries precached."""
genome = kegg.KEGGGenome()
essential = genome.essential_organisms()
common = genome.common_organisms()
# Remove duplicates of essential from common.
# (essential + common list as defined here will be used in the
# GUI.)
common = [c for c in common if c not in essential]
# TODO: Add option to specify additional organisms not
# in the common list.
keys = list(map(genome.org_code_to_entry_key, essential + common))
genome.pre_cache(keys, progress_callback=progress)
return (keys, genome)
self._genomeTask = task = concurrent.Task(function=get_genome)
task.finished.connect(self.__initialize_finish)
self.progressBarInit()
self.infoLabel.setText("Fetching organism definitions\n")
self._executor.submit(task)
def __init__(self, parent=None):
super().__init__(self, parent)
self.input_data = None
self.ref_data = None
self.ontology = None
self.annotations = None
self.loaded_annotation_code = None
self.treeStructRootKey = None
self.probFunctions = [statistics.Binomial(), statistics.Hypergeometric()]
self.selectedTerms = []
self.selectionChanging = 0
self.__state = State.Ready
self.__scheduletimer = QTimer(self, singleShot=True)
self.__scheduletimer.timeout.connect(self.__update)
#############
# GUI
#############
self.tabs = gui.tabWidget(self.controlArea)
# Input tab
self.inputTab = gui.createTabPage(self.tabs, "Input")
box = gui.widgetBox(self.inputTab, "Info")
self.infoLabel = gui.widgetLabel(box, "No data on input\n")
gui.button(box, self, "Ontology/Annotation Info",
callback=self.ShowInfo,
tooltip="Show information on loaded ontology and annotations")
self.referenceRadioBox = gui.radioButtonsInBox(
self.inputTab, self, "useReferenceDataset",
["Entire genome", "Reference set (input)"],
tooltips=["Use entire genome for reference",
"Use genes from Referece Examples input signal as reference"],
box="Reference", callback=self.__invalidate)
self.referenceRadioBox.buttons[1].setDisabled(True)
gui.radioButtonsInBox(
self.inputTab, self, "aspectIndex",
["Biological process", "Cellular component", "Molecular function"],
box="Aspect", callback=self.__invalidate)
# Filter tab
self.filterTab = gui.createTabPage(self.tabs, "Filter")
box = gui.widgetBox(self.filterTab, "Filter GO Term Nodes")
gui.checkBox(box, self, "filterByNumOfInstances", "Genes",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by number of input genes mapped to a term")
ibox = gui.indentedBox(box)
gui.spin(ibox, self, 'minNumOfInstances', 1, 100,
step=1, label='#:', labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Min. number of input genes mapped to a term")
gui.checkBox(box, self, "filterByPValue_nofdr", "p-value",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by term p-value")
gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue_nofdr', 1e-8, 1,
step=1e-8, label='p:', labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Max term p-value")
# use filterByPValue for FDR, as it was the default in prior versions
gui.checkBox(box, self, "filterByPValue", "FDR",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by term FDR")
gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue', 1e-8, 1,
step=1e-8, label='p:', labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Max term p-value")
box = gui.widgetBox(box, "Significance test")
gui.radioButtonsInBox(box, self, "probFunc", ["Binomial", "Hypergeometric"],
tooltips=["Use binomial distribution test",
"Use hypergeometric distribution test"],
callback=self.__invalidate) # TODO: only update the p values
box = gui.widgetBox(self.filterTab, "Evidence codes in annotation",
addSpace=True)
self.evidenceCheckBoxDict = {}
for etype in go.evidenceTypesOrdered:
ecb = QCheckBox(
etype, toolTip=go.evidenceTypes[etype],
checked=self.useEvidenceType[etype])
ecb.toggled.connect(self.__on_evidenceChanged)
box.layout().addWidget(ecb)
self.evidenceCheckBoxDict[etype] = ecb
# Select tab
self.selectTab = gui.createTabPage(self.tabs, "Select")
box = gui.radioButtonsInBox(
self.selectTab, self, "selectionDirectAnnotation",
["Directly or Indirectly", "Directly"],
box="Annotated genes",
callback=self.ExampleSelection)
box = gui.widgetBox(self.selectTab, "Output", addSpace=True)
gui.radioButtonsInBox(
box, self, "selectionDisjoint",
btnLabels=["All selected genes",
"Term-specific genes",
"Common term genes"],
tooltips=["Outputs genes annotated to all selected GO terms",
"Outputs genes that appear in only one of selected GO terms",
"Outputs genes common to all selected GO terms"],
callback=self.ExampleSelection)
# ListView for DAG, and table for significant GOIDs
self.DAGcolumns = ['GO term', 'Cluster', 'Reference', 'p-value',
'FDR', 'Genes', 'Enrichment']
self.splitter = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitter)
# list view
self.listView = GOTreeWidget(self.splitter)
self.listView.setSelectionMode(QTreeView.ExtendedSelection)
self.listView.setAllColumnsShowFocus(1)
self.listView.setColumnCount(len(self.DAGcolumns))
self.listView.setHeaderLabels(self.DAGcolumns)
self.listView.header().setSectionsClickable(True)
self.listView.header().setSortIndicatorShown(True)
self.listView.header().setSortIndicator(self.DAGcolumns.index('p-value'), Qt.AscendingOrder)
self.listView.setSortingEnabled(True)
self.listView.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.listView.setRootIsDecorated(True)
self.listView.itemSelectionChanged.connect(self.ViewSelectionChanged)
# table of significant GO terms
self.sigTerms = QTreeWidget(self.splitter)
self.sigTerms.setColumnCount(len(self.DAGcolumns))
self.sigTerms.setHeaderLabels(self.DAGcolumns)
self.sigTerms.setSortingEnabled(True)
self.sigTerms.setSelectionMode(QTreeView.ExtendedSelection)
self.sigTerms.header().setSortIndicator(self.DAGcolumns.index('p-value'), Qt.AscendingOrder)
self.sigTerms.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.sigTerms.itemSelectionChanged.connect(self.TableSelectionChanged)
self.sigTableTermsSorted = []
self.graph = {}
self.originalGraph = None
self.inputTab.layout().addStretch(1)
self.filterTab.layout().addStretch(1)
self.selectTab.layout().addStretch(1)
class AnnotationSlot(SimpleNamespace):
taxid = ... # type: str
name = ... # type: str
filename = ... # type:str
@staticmethod
def parse_tax_id(f_name):
return f_name.split('.')[1]
try:
remote_files = serverfiles.ServerFiles().listfiles(DOMAIN)
except (ConnectTimeout, RequestException, ConnectionError):
# TODO: Warn user about failed connection to the remote server
remote_files = []
self.available_annotations = [
AnnotationSlot(
taxid=AnnotationSlot.parse_tax_id(annotation_file),
name=taxonomy.common_taxid_to_name(AnnotationSlot.parse_tax_id(annotation_file)),
filename=FILENAME_ANNOTATION.format(AnnotationSlot.parse_tax_id(annotation_file))
)
for _, annotation_file in set(remote_files + serverfiles.listfiles(DOMAIN))
if annotation_file != FILENAME_ONTOLOGY
]
self._executor = ThreadExecutor()
def __init__(self):
super().__init__()
for name in self.signal_names:
setattr(self, name, {})
for s in self.libraryListSource:
s.flags = 0
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, '信息')
gui.label(
self.infoBox, self, "<p>执行Python脚本。</p><p>输入变量:<ul><li> " +
"<li>".join(map("in_{0}, in_{0}s".format, self.signal_names)) +
"</ul></p><p>输出变量:<ul><li>" +
"<li>".join(map("out_{0}".format, self.signal_names)) +
"</ul></p>")
self.libraryList = itemmodels.PyListModel(
[],
self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, '脚本库')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked | QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred))
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("向库中添加新脚本")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("从库中删除脚本")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("保存", self)
action.setToolTip("将编辑器中的更改的脚本保存到库中")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("更多", self, toolTip="更多操作")
new_from_file = QAction("从文件导入脚本", self)
save_to_file = QAction("将所选脚本保存到文件", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
auto = gui.auto_commit(self.controlArea,
self,
"auto_execute",
"运行",
checkbox_label="对新数据自动运行")
self.execute_button, self.autobox = auto.button, auto.checkbox
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python脚本')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, '控制台')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
select_row(self.libraryView, self.currentScriptIndex)
self.splitCanvas.setSizes([2, 1])
if self.splitterState is not None:
self.splitCanvas.restoreState(QByteArray(self.splitterState))
self.splitCanvas.splitterMoved[int, int].connect(self.onSpliterMoved)
self.controlArea.layout().addStretch(1)
self.resize(800, 600)
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])
def __init__(self):
super().__init__()
self.local_cache_path = os.path.join(data_dir(), self.DATASET_DIR)
self._header_labels = [header['label'] for _, header in self.HEADER_SCHEMA]
self._header_index = namedtuple('_header_index', [info_tag for info_tag, _ in self.HEADER_SCHEMA])
self.Header = self._header_index(*[index for index, _ in enumerate(self._header_labels)])
self.__awaiting_state = None # type: Optional[_FetchState]
box = gui.widgetBox(self.controlArea, "Info")
self.infolabel = QLabel(text="Initializing...\n\n")
box.layout().addWidget(self.infolabel)
gui.widgetLabel(self.mainArea, "Filter")
self.filterLineEdit = QLineEdit(
textChanged=self.filter
)
self.mainArea.layout().addWidget(self.filterLineEdit)
self.splitter = QSplitter(orientation=Qt.Vertical)
self.view = QTreeView(
sortingEnabled=True,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True,
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
uniformRowHeights=True,
)
box = gui.widgetBox(self.splitter, "Description", addToLayout=False)
self.descriptionlabel = QLabel(
wordWrap=True,
textFormat=Qt.RichText,
)
self.descriptionlabel = QTextBrowser(
openExternalLinks=True,
textInteractionFlags=(Qt.TextSelectableByMouse |
Qt.LinksAccessibleByMouse)
)
self.descriptionlabel.setFrameStyle(QTextBrowser.NoFrame)
# no (white) text background
self.descriptionlabel.viewport().setAutoFillBackground(False)
box.layout().addWidget(self.descriptionlabel)
self.splitter.addWidget(self.view)
self.splitter.addWidget(box)
self.splitter.setSizes([300, 200])
self.splitter.splitterMoved.connect(
lambda:
setattr(self, "splitter_state", bytes(self.splitter.saveState()))
)
self.mainArea.layout().addWidget(self.splitter)
self.controlArea.layout().addStretch(10)
gui.auto_commit(self.controlArea, self, "auto_commit", "Send Data")
proxy = QSortFilterProxyModel()
proxy.setFilterKeyColumn(-1)
proxy.setFilterCaseSensitivity(False)
self.view.setModel(proxy)
if self.splitter_state:
self.splitter.restoreState(self.splitter_state)
self.assign_delegates()
self.setBlocking(True)
self.setStatusMessage("Initializing")
self._executor = ThreadPoolExecutor(max_workers=1)
f = self._executor.submit(self.list_remote)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__set_index)
def generate_panel(self, formset):
"""
Generate a panel for the module form with all the controls
formset format example: [('_video', '_arenas', '_run'), {"Player":['_threshold', "_player", "=", "_results", "_query"], "Background image":[(' ', '_selectBackground', '_paintBackground'), '_image']}, "_progress"]
tuple: will display the controls in the same horizontal line
list: will display the controls in the same vertical line
dict: will display the controls in a tab widget
'||': will plit the controls in a horizontal line
'=': will plit the controls in a vertical line
@param formset: Form configuration
@type formset: list
"""
control = None
if '=' in formset or isinstance(formset, hsplitter):
control = QSplitter(QtCore.Qt.Vertical)
index = list(formset).index('=')
first_panel = self.generate_panel(formset[0:index])
second_panel = self.generate_panel(formset[index + 1:])
control.addWidget(first_panel)
control.addWidget(second_panel)
self._splitters.append(control)
return control
elif '||' in formset or isinstance(formset, vsplitter):
control = QSplitter(QtCore.Qt.Horizontal)
index = list(formset).index('||')
first_panel = self.generate_panel(formset[0:index])
second_panel = self.generate_panel(formset[index + 1:])
control.addWidget(first_panel)
control.addWidget(second_panel)
if isinstance(formset, vsplitter):
sizes = [formset.left_width, formset.right_width]
control.setSizes(sizes)
self._splitters.append(control)
return control
control = QFrame(self)
layout = None
if type(formset) is tuple:
layout = QHBoxLayout()
for row in formset:
if isinstance(row, (list, tuple, vsplitter, hsplitter)):
panel = self.generate_panel(row)
layout.addWidget(panel)
elif row == " ":
spacer = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
layout.addItem(spacer)
elif type(row) is dict:
c = self.generate_tabs(row)
layout.addWidget(c)
self._tabs.append(c)
else:
param = self.controls.get(row, None)
if param is None:
label = QLabel()
label.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Maximum)
# layout.addWidget( label )
if row.startswith('info:'):
label.setText(row[5:])
font = QFont()
font.setPointSize(10)
label.setFont(font)
label.setAccessibleName('info')
elif row.startswith('h1:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(17)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h1')
elif row.startswith('h2:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(16)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h2')
elif row.startswith('h3:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(15)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h3')
elif row.startswith('h4:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(14)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h4')
elif row.startswith('h5:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(12)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h5')
else:
label.setText(row)
font = QFont()
font.setPointSize(10)
label.setFont(font)
label.setAccessibleName('msg')
label.setToolTip(label.text())
layout.addWidget(label)
else:
param.parent = self
param.name = row
layout.addWidget(param.form)
elif type(formset) is list:
layout = QVBoxLayout()
for row in formset:
if isinstance(row, (list, tuple, vsplitter, hsplitter)):
panel = self.generate_panel(row)
layout.addWidget(panel)
elif row == " ":
spacer = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
layout.addItem(spacer)
elif type(row) is dict:
c = self.generate_tabs(row)
layout.addWidget(c)
self._tabs.append(c)
else:
param = self.controls.get(row, None)
if param is None:
label = QLabel()
label.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Maximum)
label.resize(30, 30)
# layout.addWidget( label )
if row.startswith('info:'):
label.setText(row[5:])
font = QFont()
font.setPointSize(10)
label.setFont(font)
label.setAccessibleName('info')
elif row.startswith('h1:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(17)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h1')
elif row.startswith('h2:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(16)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h2')
elif row.startswith('h3:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(15)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h3')
elif row.startswith('h4:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(14)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h4')
elif row.startswith('h5:'):
label.setText(row[3:])
font = QFont()
font.setPointSize(12)
font.setBold(True)
label.setFont(font)
label.setAccessibleName('h5')
else:
label.setText(row)
font = QFont()
font.setPointSize(10)
label.setFont(font)
label.setAccessibleName('msg')
label.setToolTip(label.text())
layout.addWidget(label)
else:
param.parent = self
param.name = row
layout.addWidget(param.form)
if _api.USED_API == _api.QT_API_PYQT5:
layout.setContentsMargins(0, 0, 0, 0)
elif _api.USED_API == _api.QT_API_PYQT4:
layout.setMargin(0)
control.setLayout(layout)
return control
class OWDataSets(OWWidget):
name = "数据集(Datasets)"
description = "从联机存储库加载数据集"
icon = "icons/DataSets.svg"
priority = 20
replaces = ["orangecontrib.prototypes.widgets.owdatasets.OWDataSets"]
keywords = ["online"]
want_control_area = False
# The following constants can be overridden in a subclass
# to reuse this widget for a different repository
# Take care when refactoring! (used in e.g. single-cell)
INDEX_URL = "https://datasets.biolab.si/"
DATASET_DIR = "datasets"
# override HEADER_SCHEMA to define new columns
# if schema is changed override methods: self.assign_delegates and
# self.create_model
HEADER_SCHEMA = [
['islocal', {'label': ''}],
['title', {'label': '标题'}],
['size', {'label': '大小'}],
['instances', {'label': '样本数目'}],
['variables', {'label': '变量数目'}],
['target', {'label': '目标'}],
['tags', {'label': '标签'}]
] # type: List[str, dict]
IndicatorBrushes = (QBrush(Qt.darkGray), QBrush(QColor(0, 192, 0)))
class Error(OWWidget.Error):
no_remote_datasets = Msg("Could not fetch dataset list")
class Warning(OWWidget.Warning):
only_local_datasets = Msg("Could not fetch datasets list, only local "
"cached datasets are shown")
class Outputs:
data = Output("数据(Data)", Orange.data.Table, replaces=['Data'])
#: Selected dataset id
selected_id = settings.Setting(None) # type: Optional[str]
#: main area splitter state
splitter_state = settings.Setting(b'') # type: bytes
header_state = settings.Setting(b'') # type: bytes
def __init__(self):
super().__init__()
self.allinfo_local = {}
self.allinfo_remote = {}
self.local_cache_path = os.path.join(data_dir(), self.DATASET_DIR)
# current_output does not equal selected_id when, for instance, the
# data is still downloading
self.current_output = None
self._header_labels = [
header['label'] for _, header in self.HEADER_SCHEMA]
self._header_index = namedtuple(
'_header_index', [info_tag for info_tag, _ in self.HEADER_SCHEMA])
self.Header = self._header_index(
*[index for index, _ in enumerate(self._header_labels)])
self.__awaiting_state = None # type: Optional[_FetchState]
self.filterLineEdit = QLineEdit(
textChanged=self.filter, placeholderText="Search for data set ..."
)
self.mainArea.layout().addWidget(self.filterLineEdit)
self.splitter = QSplitter(orientation=Qt.Vertical)
self.view = TreeViewWithReturn(
sortingEnabled=True,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True,
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
uniformRowHeights=True,
toolTip="Press Return or double-click to send"
)
# the method doesn't exists yet, pylint: disable=unnecessary-lambda
self.view.doubleClicked.connect(self.commit)
self.view.returnPressed.connect(self.commit)
box = gui.widgetBox(self.splitter, "说明", addToLayout=False)
self.descriptionlabel = QLabel(
wordWrap=True,
textFormat=Qt.RichText,
)
self.descriptionlabel = QTextBrowser(
openExternalLinks=True,
textInteractionFlags=(Qt.TextSelectableByMouse |
Qt.LinksAccessibleByMouse)
)
self.descriptionlabel.setFrameStyle(QTextBrowser.NoFrame)
# no (white) text background
self.descriptionlabel.viewport().setAutoFillBackground(False)
box.layout().addWidget(self.descriptionlabel)
self.splitter.addWidget(self.view)
self.splitter.addWidget(box)
self.splitter.setSizes([300, 200])
self.splitter.splitterMoved.connect(
lambda:
setattr(self, "splitter_state", bytes(self.splitter.saveState()))
)
self.mainArea.layout().addWidget(self.splitter)
proxy = QSortFilterProxyModel()
proxy.setFilterKeyColumn(-1)
proxy.setFilterCaseSensitivity(False)
self.view.setModel(proxy)
if self.splitter_state:
self.splitter.restoreState(self.splitter_state)
self.assign_delegates()
self.setBlocking(True)
self.setStatusMessage("Initializing")
self._executor = ThreadPoolExecutor(max_workers=1)
f = self._executor.submit(self.list_remote)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__set_index)
def assign_delegates(self):
# NOTE: All columns must have size hinting delegates.
# QTreeView queries only the columns displayed in the viewport so
# the layout would be different depending in the horizontal scroll
# position
self.view.setItemDelegate(UniformHeightDelegate(self))
self.view.setItemDelegateForColumn(
self.Header.islocal,
UniformHeightIndicatorDelegate(self, role=Qt.DisplayRole, indicatorSize=4)
)
self.view.setItemDelegateForColumn(
self.Header.size,
SizeDelegate(self)
)
self.view.setItemDelegateForColumn(
self.Header.instances,
NumericalDelegate(self)
)
self.view.setItemDelegateForColumn(
self.Header.variables,
NumericalDelegate(self)
)
self.view.resizeColumnToContents(self.Header.islocal)
def _parse_info(self, file_path):
if file_path in self.allinfo_remote:
info = self.allinfo_remote[file_path]
else:
info = self.allinfo_local[file_path]
islocal = file_path in self.allinfo_local
isremote = file_path in self.allinfo_remote
outdated = islocal and isremote and (
self.allinfo_remote[file_path].get('version', '')
!= self.allinfo_local[file_path].get('version', '')
)
islocal &= not outdated
prefix = os.path.join('', *file_path[:-1])
filename = file_path[-1]
return Namespace(file_path=file_path, prefix=prefix, filename=filename,
islocal=islocal, outdated=outdated, **info)
def create_model(self):
allkeys = set(self.allinfo_local) | set(self.allinfo_remote)
allkeys = sorted(allkeys)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(self._header_labels)
current_index = -1
for i, file_path in enumerate(allkeys):
datainfo = self._parse_info(file_path)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(self.IndicatorBrushes[0], Qt.ForegroundRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
if datainfo.target:
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags) if datainfo.tags else "",
Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
return model, current_index
@Slot(object)
def __set_index(self, f):
# type: (Future) -> None
# set results from `list_remote` query.
assert QThread.currentThread() is self.thread()
assert f.done()
self.setBlocking(False)
self.setStatusMessage("")
self.allinfo_local = self.list_local()
try:
self.allinfo_remote = f.result()
except Exception: # anytying can happen, pylint: disable=broad-except
log.exception("Error while fetching updated index")
if not self.allinfo_local:
self.Error.no_remote_datasets()
else:
self.Warning.only_local_datasets()
self.allinfo_remote = {}
model, current_index = self.create_model()
self.view.model().setSourceModel(model)
self.view.selectionModel().selectionChanged.connect(
self.__on_selection
)
self.view.resizeColumnToContents(0)
self.view.setColumnWidth(
1, min(self.view.sizeHintForColumn(1),
self.view.fontMetrics().width("X" * 37)))
header = self.view.header()
header.restoreState(self.header_state)
if current_index != -1:
selmodel = self.view.selectionModel()
selmodel.select(
self.view.model().mapFromSource(model.index(current_index, 0)),
QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
self.commit()
def __update_cached_state(self):
model = self.view.model().sourceModel()
localinfo = self.list_local()
assert isinstance(model, QStandardItemModel)
allinfo = []
for i in range(model.rowCount()):
item = model.item(i, 0)
info = item.data(Qt.UserRole)
is_local = info.file_path in localinfo
is_current = (is_local and
os.path.join(self.local_cache_path, *info.file_path)
== self.current_output)
item.setData(" " * (is_local + is_current), Qt.DisplayRole)
item.setData(self.IndicatorBrushes[is_current], Qt.ForegroundRole)
allinfo.append(info)
def selected_dataset(self):
"""
Return the current selected dataset info or None if not selected
Returns
-------
info : Optional[Namespace]
"""
rows = self.view.selectionModel().selectedRows(0)
assert 0 <= len(rows) <= 1
current = rows[0] if rows else None # type: Optional[QModelIndex]
if current is not None:
info = current.data(Qt.UserRole)
assert isinstance(info, Namespace)
else:
info = None
return info
def filter(self):
filter_string = self.filterLineEdit.text().strip()
proxyModel = self.view.model()
if proxyModel:
proxyModel.setFilterFixedString(filter_string)
def __on_selection(self):
# Main datasets view selection has changed
rows = self.view.selectionModel().selectedRows(0)
assert 0 <= len(rows) <= 1
current = rows[0] if rows else None # type: Optional[QModelIndex]
if current is not None:
current = self.view.model().mapToSource(current)
di = current.data(Qt.UserRole)
text = description_html(di)
self.descriptionlabel.setText(text)
self.selected_id = os.path.join(di.prefix, di.filename)
else:
self.descriptionlabel.setText("")
self.selected_id = None
def commit(self):
"""
Commit a dataset to the output immediately (if available locally) or
schedule download background and an eventual send.
During the download the widget is in blocking state
(OWWidget.isBlocking)
"""
di = self.selected_dataset()
if di is not None:
self.Error.clear()
if self.__awaiting_state is not None:
# disconnect from the __commit_complete
self.__awaiting_state.watcher.done.disconnect(
self.__commit_complete)
# .. and connect to update_cached_state
# self.__awaiting_state.watcher.done.connect(
# self.__update_cached_state)
# TODO: There are possible pending __progress_advance queued
self.__awaiting_state.pb.advance.disconnect(
self.__progress_advance)
self.progressBarFinished()
self.__awaiting_state = None
if not di.islocal:
pr = progress()
callback = lambda pr=pr: pr.advance.emit()
pr.advance.connect(self.__progress_advance, Qt.QueuedConnection)
self.progressBarInit()
self.setStatusMessage("Fetching...")
self.setBlocking(True)
f = self._executor.submit(
ensure_local, self.INDEX_URL, di.file_path,
self.local_cache_path, force=di.outdated,
progress_advance=callback)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__commit_complete)
self.__awaiting_state = _FetchState(f, w, pr)
else:
self.setStatusMessage("")
self.setBlocking(False)
self.commit_cached(di.file_path)
else:
self.load_and_output(None)
@Slot(object)
def __commit_complete(self, f):
# complete the commit operation after the required file has been
# downloaded
assert QThread.currentThread() is self.thread()
assert self.__awaiting_state is not None
assert self.__awaiting_state.future is f
if self.isBlocking():
self.progressBarFinished()
self.setBlocking(False)
self.setStatusMessage("")
self.__awaiting_state = None
try:
path = f.result()
# anything can happen here, pylint: disable=broad-except
except Exception as ex:
log.exception("Error:")
self.error(format_exception(ex))
path = None
self.load_and_output(path)
def commit_cached(self, file_path):
path = LocalFiles(self.local_cache_path).localpath(*file_path)
self.load_and_output(path)
@Slot()
def __progress_advance(self):
assert QThread.currentThread() is self.thread()
self.progressBarAdvance(1)
def onDeleteWidget(self):
super().onDeleteWidget()
if self.__awaiting_state is not None:
self.__awaiting_state.watcher.done.disconnect(self.__commit_complete)
self.__awaiting_state.pb.advance.disconnect(self.__progress_advance)
self.__awaiting_state = None
@staticmethod
def sizeHint():
return QSize(1100, 500)
def closeEvent(self, event):
self.splitter_state = bytes(self.splitter.saveState())
self.header_state = bytes(self.view.header().saveState())
super().closeEvent(event)
def load_and_output(self, path):
if path is None:
self.Outputs.data.send(None)
else:
data = self.load_data(path)
self.Outputs.data.send(data)
self.current_output = path
self.__update_cached_state()
@staticmethod
def load_data(path):
return Orange.data.Table(path)
def list_remote(self):
# type: () -> Dict[Tuple[str, ...], dict]
client = ServerFiles(server=self.INDEX_URL)
return client.allinfo()
def list_local(self):
# type: () -> Dict[Tuple[str, ...], dict]
return LocalFiles(self.local_cache_path).allinfo()
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),
))
def __init__(self):
super().__init__()
self.local_cache_path = os.path.join(data_dir(), self.DATASET_DIR)
self.__awaiting_state = None # type: Optional[_FetchState]
box = gui.widgetBox(self.controlArea, "Info")
self.infolabel = QLabel(text="Initializing...\n\n")
box.layout().addWidget(self.infolabel)
gui.widgetLabel(self.mainArea, "Filter")
self.filterLineEdit = QLineEdit(
textChanged=self.filter
)
self.mainArea.layout().addWidget(self.filterLineEdit)
self.splitter = QSplitter(orientation=Qt.Vertical)
self.view = QTreeView(
sortingEnabled=True,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True,
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
)
box = gui.widgetBox(self.splitter, "Description", addToLayout=False)
self.descriptionlabel = QLabel(
wordWrap=True,
textFormat=Qt.RichText,
)
self.descriptionlabel = QTextBrowser(
openExternalLinks=True,
textInteractionFlags=(Qt.TextSelectableByMouse |
Qt.LinksAccessibleByMouse)
)
self.descriptionlabel.setFrameStyle(QTextBrowser.NoFrame)
# no (white) text background
self.descriptionlabel.viewport().setAutoFillBackground(False)
box.layout().addWidget(self.descriptionlabel)
self.splitter.addWidget(self.view)
self.splitter.addWidget(box)
self.splitter.setSizes([300, 200])
self.splitter.splitterMoved.connect(
lambda:
setattr(self, "splitter_state", bytes(self.splitter.saveState()))
)
self.mainArea.layout().addWidget(self.splitter)
self.controlArea.layout().addStretch(10)
gui.auto_commit(self.controlArea, self, "auto_commit", "Send Data")
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(HEADER)
proxy = QSortFilterProxyModel()
proxy.setSourceModel(model)
proxy.setFilterKeyColumn(-1)
proxy.setFilterCaseSensitivity(False)
self.view.setModel(proxy)
if self.splitter_state:
self.splitter.restoreState(self.splitter_state)
self.view.setItemDelegateForColumn(
Header.Size, SizeDelegate(self))
self.view.setItemDelegateForColumn(
Header.Local, gui.IndicatorItemDelegate(self, role=Qt.DisplayRole))
self.view.setItemDelegateForColumn(
Header.Instances, NumericalDelegate(self))
self.view.setItemDelegateForColumn(
Header.Variables, NumericalDelegate(self))
self.view.resizeColumnToContents(Header.Local)
if self.header_state:
self.view.header().restoreState(self.header_state)
self.setBlocking(True)
self.setStatusMessage("Initializing")
self._executor = ThreadPoolExecutor(max_workers=1)
f = self._executor.submit(self.list_remote)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__set_index)
class OWPythonScript(widget.OWWidget):
name = "Python Script"
description = "Write a Python script and run it on input data or models."
icon = "icons/PythonScript.svg"
priority = 3150
inputs = [("in_data", Orange.data.Table, "setExampleTable",
widget.Default),
# ("in_distance", Orange.misc.SymMatrix, "setDistanceMatrix",
# widget.Default),
("in_learner", Learner, "setLearner",
widget.Default),
("in_classifier", Model, "setClassifier",
widget.Default),
("in_object", object, "setObject")]
outputs = [("out_data", Orange.data.Table, ),
# ("out_distance", Orange.misc.SymMatrix, ),
("out_learner", Learner, ),
("out_classifier", Model, widget.Dynamic),
("out_object", object, widget.Dynamic)]
libraryListSource = \
Setting([Script("Hello world", "print('Hello world')\n")])
currentScriptIndex = Setting(0)
splitterState = Setting(None)
auto_execute = Setting(False)
def __init__(self):
super().__init__()
self.in_data = None
self.in_distance = None
self.in_learner = None
self.in_classifier = None
self.in_object = None
self.auto_execute = False
for s in self.libraryListSource:
s.flags = 0
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " + \
"<li>".join(t.name for t in self.inputs) + \
"</ul></p><p>Output variables:<ul><li>" + \
"<li>".join(t.name for t in self.outputs) + \
"</ul></p>"
)
self.libraryList = itemmodels.PyListModel(
[], self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked |
QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
)
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged
)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Script from File", self)
save_to_file = QAction("Save Selected Script to File", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
self.execute_button = gui.auto_commit(
self.controlArea, self, "auto_execute", "Execute",
auto_label="Auto Execute")
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python Script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
select_row(self.libraryView, self.currentScriptIndex)
self.splitCanvas.setSizes([2, 1])
if self.splitterState is not None:
self.splitCanvas.restoreState(QByteArray(self.splitterState))
self.splitCanvas.splitterMoved[int, int].connect(self.onSpliterMoved)
self.controlArea.layout().addStretch(1)
self.resize(800, 600)
def setExampleTable(self, et):
self.in_data = et
def setDistanceMatrix(self, dm):
self.in_distance = dm
def setLearner(self, learner):
self.in_learner = learner
def setClassifier(self, classifier):
self.in_classifier = classifier
def setObject(self, obj):
self.in_object = obj
def handleNewSignals(self):
self.unconditional_commit()
def selectedScriptIndex(self):
rows = self.libraryView.selectionModel().selectedRows()
if rows:
return [i.row() for i in rows][0]
else:
return None
def setSelectedScript(self, index):
select_row(self.libraryView, index)
def onAddScript(self, *args):
self.libraryList.append(Script("New script", "", 0))
self.setSelectedScript(len(self.libraryList) - 1)
def onAddScriptFromFile(self, *args):
filename, _ = QFileDialog.getOpenFileName(
self, 'Open Python Script',
os.path.expanduser("~/"),
'Python files (*.py)\nAll files(*.*)'
)
if filename:
name = os.path.basename(filename)
# TODO: use `tokenize.detect_encoding`
with open(filename, encoding="utf-8") as f:
contents = f.read()
self.libraryList.append(Script(name, contents, 0, filename))
self.setSelectedScript(len(self.libraryList) - 1)
def onRemoveScript(self, *args):
index = self.selectedScriptIndex()
if index is not None:
del self.libraryList[index]
select_row(self.libraryView, max(index - 1, 0))
def onSaveScriptToFile(self, *args):
index = self.selectedScriptIndex()
if index is not None:
self.saveScript()
def onSelectedScriptChanged(self, selected, deselected):
index = [i.row() for i in selected.indexes()]
if index:
current = index[0]
if current >= len(self.libraryList):
self.addNewScriptAction.trigger()
return
self.text.setDocument(self.documentForScript(current))
self.currentScriptIndex = current
def documentForScript(self, script=0):
if type(script) != Script:
script = self.libraryList[script]
if script not in self._cachedDocuments:
doc = QTextDocument(self)
doc.setDocumentLayout(QPlainTextDocumentLayout(doc))
doc.setPlainText(script.script)
doc.setDefaultFont(QFont(self.defaultFont))
doc.highlighter = PythonSyntaxHighlighter(doc)
doc.modificationChanged[bool].connect(self.onModificationChanged)
doc.setModified(False)
self._cachedDocuments[script] = doc
return self._cachedDocuments[script]
def commitChangesToLibrary(self, *args):
index = self.selectedScriptIndex()
if index is not None:
self.libraryList[index].script = self.text.toPlainText()
self.text.document().setModified(False)
self.libraryList.emitDataChanged(index)
def onModificationChanged(self, modified):
index = self.selectedScriptIndex()
if index is not None:
self.libraryList[index].flags = Script.Modified if modified else 0
self.libraryList.emitDataChanged(index)
def onSpliterMoved(self, pos, ind):
self.splitterState = bytes(self.splitCanvas.saveState())
def updateSelecetdScriptState(self):
index = self.selectedScriptIndex()
if index is not None:
script = self.libraryList[index]
self.libraryList[index] = Script(script.name,
self.text.toPlainText(),
0)
def saveScript(self):
index = self.selectedScriptIndex()
if index is not None:
script = self.libraryList[index]
filename = script.filename
else:
filename = os.path.expanduser("~/")
filename, _ = QFileDialog.getSaveFileName(
self, 'Save Python Script',
filename,
'Python files (*.py)\nAll files(*.*)'
)
if filename:
fn = ""
head, tail = os.path.splitext(filename)
if not tail:
fn = head + ".py"
else:
fn = filename
f = open(fn, 'w')
f.write(self.text.toPlainText())
f.close()
def initial_locals_state(self):
d = dict([(i.name, getattr(self, i.name, None)) for i in self.inputs])
d.update(dict([(o.name, None) for o in self.outputs]))
return d
def commit(self):
self._script = str(self.text.toPlainText())
lcls = self.initial_locals_state()
lcls["_script"] = str(self.text.toPlainText())
self.console.updateLocals(lcls)
self.console.write("\nRunning script:\n")
self.console.push("exec(_script)")
self.console.new_prompt(sys.ps1)
for out in self.outputs:
signal = out.name
self.send(signal, self.console.locals.get(signal, None))
def __init__(self):
super().__init__()
# widget attributes
self.input_data = None
self.store_input_domain = None
self.input_genes_names = []
self.input_genes_ids = []
self.tax_id = None
self.use_attr_names = None
self.gene_id_attribute = None
# custom gene set input
self.feature_model = itemmodels.DomainModel(
valid_types=(DiscreteVariable, StringVariable))
self.custom_data = None
self.custom_tax_id = None
self.custom_use_attr_names = None
self.custom_gene_id_attribute = None
self.custom_gene_id_column = None
self.num_of_custom_sets = None
self.rows_by_cluster = None
self.rows_by_batch = None
self.clusters = []
self.new_cluster_profile = []
# data model
self.cluster_info_model = None
# Info
info_box = vBox(self.controlArea, 'Info')
self.input_info = widgetLabel(info_box)
# Cluster selection
self.cluster_indicator_model = itemmodels.DomainModel(
valid_types=(DiscreteVariable, ), separators=False)
self.cluster_indicator_box = widgetBox(self.controlArea,
'Cluster Indicator')
self.cluster_indicator_view = listView(
self.cluster_indicator_box,
self,
'cluster_indicators',
model=self.cluster_indicator_model,
selectionMode=QListWidget.MultiSelection,
callback=self.invalidate,
sizeHint=QSize(256, 70))
# Batch selection
self.batch_indicator_model = itemmodels.DomainModel(
valid_types=(DiscreteVariable, ), separators=False, placeholder="")
box = widgetBox(self.controlArea, 'Batch Indicator')
self.batch_indicator_combobox = comboBox(
box,
self,
'batch_indicator',
model=self.batch_indicator_model,
sendSelectedValue=True,
callback=self.batch_indicator_changed)
# Gene scoring
box = widgetBox(self.controlArea, 'Gene Scoring')
self.gene_scoring = GeneScoringWidget(box, self)
self.gene_scoring.set_method_selection_area('scoring_method_selection')
self.gene_scoring.set_method_design_area('scoring_method_design')
self.gene_scoring.set_test_type('scoring_test_type')
# Gene Sets widget
gene_sets_box = widgetBox(self.controlArea, "Gene Sets")
self.gs_widget = GeneSetsSelection(gene_sets_box, self,
'stored_gene_sets_selection')
self.gs_widget.hierarchy_tree_widget.itemClicked.connect(
self.__gene_sets_enrichment)
# custom gene sets area
box = vBox(self.controlArea, "Custom Gene Sets")
if self.custom_gene_set_indicator not in self.feature_model:
self.custom_gene_set_indicator = None
self.gs_label_combobox = comboBox(
box,
self,
"custom_gene_set_indicator",
sendSelectedValue=True,
model=self.feature_model,
callback=self.handle_custom_gene_sets)
self.gs_label_combobox.setDisabled(True)
# main area
splitter = QSplitter(Qt.Horizontal, self.mainArea)
self.mainArea.layout().addWidget(splitter)
genes_filter = widgetBox(splitter,
'Filter Genes',
orientation=QHBoxLayout())
spin(genes_filter,
self,
'max_gene_count',
0,
10000,
label='Count',
tooltip='Minimum genes count',
checked='use_gene_count_filter',
callback=self.filter_genes,
callbackOnReturn=True,
checkCallback=self.filter_genes)
doubleSpin(genes_filter,
self,
'max_gene_p_value',
0.0,
1.0,
0.0001,
label='p-value',
tooltip='Maximum p-value of the enrichment score',
checked='use_gene_pval_filter',
callback=self.filter_genes,
callbackOnReturn=True,
checkCallback=self.filter_genes)
doubleSpin(genes_filter,
self,
'max_gene_fdr',
0.0,
1.0,
0.0001,
label='FDR',
tooltip='Maximum false discovery rate',
checked='use_gene_fdr_filter',
callback=self.filter_genes,
callbackOnReturn=True,
checkCallback=self.filter_genes)
gene_sets_filter = widgetBox(splitter,
'Filter Gene Sets',
orientation=QHBoxLayout())
spin(gene_sets_filter,
self,
'min_gs_count',
0,
DISPLAY_GENE_SETS_COUNT,
label='Count',
tooltip='Minimum genes count',
checked='use_gs_count_filter',
callback=self.filter_gene_sets,
callbackOnReturn=True,
checkCallback=self.filter_gene_sets)
doubleSpin(gene_sets_filter,
self,
'max_gs_p_value',
0.0,
1.0,
0.0001,
label='p-value',
tooltip='Maximum p-value of the enrichment score',
checked='use_gs_pval_filter',
callback=self.filter_gene_sets,
callbackOnReturn=True,
checkCallback=self.filter_gene_sets)
doubleSpin(gene_sets_filter,
self,
'max_gs_fdr',
0.0,
1.0,
0.0001,
label='FDR',
tooltip='Maximum false discovery rate',
checked='use_gs_max_fdr',
callback=self.filter_gene_sets,
callbackOnReturn=True,
checkCallback=self.filter_gene_sets)
self.cluster_info_view = QTableView()
self.cluster_info_view.verticalHeader().setVisible(False)
self.cluster_info_view.setItemDelegate(HTMLDelegate())
self.cluster_info_view.horizontalHeader().hide()
self.cluster_info_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
auto_commit(self.controlArea,
self,
"auto_commit",
"&Commit",
box=False)
self.mainArea.layout().addWidget(self.cluster_info_view)
class OWPredictions(OWWidget):
name = "Predictions"
icon = "icons/Predictions.svg"
priority = 200
description = "Display predictions of models for an input dataset."
keywords = []
class Inputs:
data = Input("Data", Orange.data.Table)
predictors = Input("Predictors", Model, multiple=True)
class Outputs:
predictions = Output("Predictions", Orange.data.Table)
evaluation_results = Output("Evaluation Results", Results)
class Warning(OWWidget.Warning):
empty_data = Msg("Empty dataset")
wrong_targets = Msg(
"Some model(s) predict a different target (see more ...)\n{}")
class Error(OWWidget.Error):
predictor_failed = Msg("Some predictor(s) failed (see more ...)\n{}")
scorer_failed = Msg("Some scorer(s) failed (see more ...)\n{}")
settingsHandler = settings.ClassValuesContextHandler()
score_table = settings.SettingProvider(ScoreTable)
#: List of selected class value indices in the `class_values` list
selected_classes = settings.ContextSetting([])
selection = settings.Setting([], schema_only=True)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Orange.data.Table]
self.predictors = {} # type: Dict[object, PredictorSlot]
self.class_values = [] # type: List[str]
self._delegates = []
self.left_width = 10
self.selection_store = None
self.__pending_selection = self.selection
self._set_input_summary()
self._set_output_summary(None)
gui.listBox(self.controlArea,
self,
"selected_classes",
"class_values",
box="Show probabibilities for",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.ExtendedSelection,
addSpace=False,
sizePolicy=(QSizePolicy.Preferred, QSizePolicy.Preferred))
gui.rubber(self.controlArea)
self.reset_button = gui.button(
self.controlArea,
self,
"Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
table_opts = dict(horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.ExtendedSelection,
focusPolicy=Qt.StrongFocus)
self.dataview = TableView(sortingEnabled=True,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
**table_opts)
self.predictionsview = TableView(
sortingEnabled=True,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
**table_opts)
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size: self.predictionsview.verticalHeader(
).resizeSection(index, size))
self.dataview.setItemDelegate(DataItemDelegate(self.dataview))
self.splitter = QSplitter(orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2)
self.splitter.splitterMoved.connect(self.splitter_resized)
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.score_table = ScoreTable(self)
self.vsplitter = gui.vBox(self.mainArea)
self.vsplitter.layout().addWidget(self.splitter)
self.vsplitter.layout().addWidget(self.score_table.view)
def get_selection_store(self, proxy):
# Both proxies map the same, so it doesn't matter which one is used
# to initialize SharedSelectionStore
if self.selection_store is None:
self.selection_store = SharedSelectionStore(proxy)
return self.selection_store
@Inputs.data
@check_sql_input
def set_data(self, data):
self.Warning.empty_data(shown=data is not None and not data)
self.data = data
self.selection_store = None
if not data:
self.dataview.setModel(None)
self.predictionsview.setModel(None)
else:
# force full reset of the view's HeaderView state
self.dataview.setModel(None)
model = TableModel(data, parent=None)
modelproxy = SortProxyModel()
modelproxy.setSourceModel(model)
self.dataview.setModel(modelproxy)
sel_model = SharedSelectionModel(
self.get_selection_store(modelproxy), modelproxy,
self.dataview)
self.dataview.setSelectionModel(sel_model)
if self.__pending_selection is not None:
self.selection = self.__pending_selection
self.__pending_selection = None
self.selection_store.select_rows(
set(self.selection), QItemSelectionModel.ClearAndSelect)
sel_model.selectionChanged.connect(self.commit)
sel_model.selectionChanged.connect(self._store_selection)
self.dataview.model().list_sorted.connect(
partial(self._update_data_sort_order, self.dataview,
self.predictionsview))
self._invalidate_predictions()
def _store_selection(self):
self.selection = list(self.selection_store.rows)
@property
def class_var(self):
return self.data and self.data.domain.class_var
# pylint: disable=redefined-builtin
@Inputs.predictors
def set_predictor(self, predictor=None, id=None):
if id in self.predictors:
if predictor is not None:
self.predictors[id] = self.predictors[id]._replace(
predictor=predictor, name=predictor.name, results=None)
else:
del self.predictors[id]
elif predictor is not None:
self.predictors[id] = PredictorSlot(predictor, predictor.name,
None)
def _set_class_values(self):
class_values = []
for slot in self.predictors.values():
class_var = slot.predictor.domain.class_var
if class_var and class_var.is_discrete:
for value in class_var.values:
if value not in class_values:
class_values.append(value)
if self.class_var and self.class_var.is_discrete:
values = self.class_var.values
self.class_values = sorted(class_values,
key=lambda val: val not in values)
self.selected_classes = [
i for i, name in enumerate(class_values) if name in values
]
else:
self.class_values = class_values # This assignment updates listview
self.selected_classes = []
def handleNewSignals(self):
self._set_class_values()
self._call_predictors()
self._update_scores()
self._update_predictions_model()
self._update_prediction_delegate()
self._set_errors()
self._set_input_summary()
self.commit()
def _call_predictors(self):
if not self.data:
return
if self.class_var:
domain = self.data.domain
classless_data = self.data.transform(
Domain(domain.attributes, None, domain.metas))
else:
classless_data = self.data
for inputid, slot in self.predictors.items():
if isinstance(slot.results, Results):
continue
predictor = slot.predictor
try:
if predictor.domain.class_var.is_discrete:
pred, prob = predictor(classless_data, Model.ValueProbs)
else:
pred = predictor(classless_data, Model.Value)
prob = numpy.zeros((len(pred), 0))
except (ValueError, DomainTransformationError) as err:
self.predictors[inputid] = \
slot._replace(results=f"{predictor.name}: {err}")
continue
results = Results()
results.data = self.data
results.domain = self.data.domain
results.row_indices = numpy.arange(len(self.data))
results.folds = (Ellipsis, )
results.actual = self.data.Y
results.unmapped_probabilities = prob
results.unmapped_predicted = pred
results.probabilities = results.predicted = None
self.predictors[inputid] = slot._replace(results=results)
target = predictor.domain.class_var
if target != self.class_var:
continue
if target is not self.class_var and target.is_discrete:
backmappers, n_values = predictor.get_backmappers(self.data)
prob = predictor.backmap_probs(prob, n_values, backmappers)
pred = predictor.backmap_value(pred, prob, n_values,
backmappers)
results.predicted = pred.reshape((1, len(self.data)))
results.probabilities = prob.reshape((1, ) + prob.shape)
def _update_scores(self):
model = self.score_table.model
model.clear()
scorers = usable_scorers(self.class_var) if self.class_var else []
self.score_table.update_header(scorers)
errors = []
for inputid, pred in self.predictors.items():
results = self.predictors[inputid].results
if not isinstance(results, Results) or results.predicted is None:
continue
row = [
QStandardItem(learner_name(pred.predictor)),
QStandardItem("N/A"),
QStandardItem("N/A")
]
for scorer in scorers:
item = QStandardItem()
try:
score = scorer_caller(scorer, results)()[0]
item.setText(f"{score:.3f}")
except Exception as exc: # pylint: disable=broad-except
item.setToolTip(str(exc))
if scorer.name in self.score_table.shown_scores:
errors.append(str(exc))
row.append(item)
self.score_table.model.appendRow(row)
view = self.score_table.view
if model.rowCount():
view.setVisible(True)
view.ensurePolished()
view.setFixedHeight(5 + view.horizontalHeader().height() +
view.verticalHeader().sectionSize(0) *
model.rowCount())
else:
view.setVisible(False)
self.Error.scorer_failed("\n".join(errors), shown=bool(errors))
def _set_errors(self):
# Not all predictors are run every time, so errors can't be collected
# in _call_predictors
errors = "\n".join(f"- {p.predictor.name}: {p.results}"
for p in self.predictors.values()
if isinstance(p.results, str) and p.results)
self.Error.predictor_failed(errors, shown=bool(errors))
if self.class_var:
inv_targets = "\n".join(
f"- {pred.name} predicts '{pred.domain.class_var.name}'"
for pred in (p.predictor for p in self.predictors.values()
if isinstance(p.results, Results)
and p.results.probabilities is None))
self.Warning.wrong_targets(inv_targets, shown=bool(inv_targets))
else:
self.Warning.wrong_targets.clear()
def _set_input_summary(self):
if not self.data and not self.predictors:
self.info.set_input_summary(self.info.NoInput)
return
summary = len(self.data) if self.data else 0
details = self._get_details()
self.info.set_input_summary(summary, details, format=Qt.RichText)
def _get_details(self):
details = "Data:<br>"
details += format_summary_details(self.data).replace('\n', '<br>') if \
self.data else "No data on input."
details += "<hr>"
pred_names = [v.name for v in self.predictors.values()]
n_predictors = len(self.predictors)
if n_predictors:
n_valid = len(self._non_errored_predictors())
details += plural("Model: {number} model{s}", n_predictors)
if n_valid != n_predictors:
details += f" ({n_predictors - n_valid} failed)"
details += "<ul>"
for name in pred_names:
details += f"<li>{name}</li>"
details += "</ul>"
else:
details += "Model:<br>No model on input."
return details
def _set_output_summary(self, output):
summary = len(output) if output else self.info.NoOutput
details = format_summary_details(output) if output else ""
self.info.set_output_summary(summary, details)
def _invalidate_predictions(self):
for inputid, pred in list(self.predictors.items()):
self.predictors[inputid] = pred._replace(results=None)
def _non_errored_predictors(self):
return [
p for p in self.predictors.values()
if isinstance(p.results, Results)
]
def _reordered_probabilities(self, prediction):
cur_values = prediction.predictor.domain.class_var.values
new_ind = [self.class_values.index(x) for x in cur_values]
probs = prediction.results.unmapped_probabilities
new_probs = numpy.full((probs.shape[0], len(self.class_values)),
numpy.nan)
new_probs[:, new_ind] = probs
return new_probs
def _update_predictions_model(self):
results = []
headers = []
for p in self._non_errored_predictors():
values = p.results.unmapped_predicted
target = p.predictor.domain.class_var
if target.is_discrete:
# order probabilities in order from Show prob. for
prob = self._reordered_probabilities(p)
values = [Value(target, v) for v in values]
else:
prob = numpy.zeros((len(values), 0))
results.append((values, prob))
headers.append(p.predictor.name)
if results:
results = list(zip(*(zip(*res) for res in results)))
model = PredictionsModel(results, headers)
else:
model = None
if self.selection_store is not None:
self.selection_store.unregister(
self.predictionsview.selectionModel())
predmodel = PredictionsSortProxyModel()
predmodel.setSourceModel(model)
predmodel.setDynamicSortFilter(True)
self.predictionsview.setModel(predmodel)
self.predictionsview.setSelectionModel(
SharedSelectionModel(self.get_selection_store(predmodel),
predmodel, self.predictionsview))
hheader = self.predictionsview.horizontalHeader()
hheader.setSortIndicatorShown(False)
# SortFilterProxyModel is slow due to large abstraction overhead
# (every comparison triggers multiple `model.index(...)`,
# model.rowCount(...), `model.parent`, ... calls)
hheader.setSectionsClickable(predmodel.rowCount() < 20000)
self.predictionsview.model().list_sorted.connect(
partial(self._update_data_sort_order, self.predictionsview,
self.dataview))
self.predictionsview.resizeColumnsToContents()
def _update_data_sort_order(self, sort_source_view, sort_dest_view):
sort_dest = sort_dest_view.model()
sort_source = sort_source_view.model()
sortindicatorshown = False
if sort_dest is not None:
assert isinstance(sort_dest, QSortFilterProxyModel)
n = sort_dest.rowCount()
if sort_source is not None and sort_source.sortColumn() >= 0:
sortind = numpy.argsort([
sort_source.mapToSource(sort_source.index(i, 0)).row()
for i in range(n)
])
sortind = numpy.array(sortind, numpy.int)
sortindicatorshown = True
else:
sortind = None
sort_dest.setSortIndices(sortind)
sort_dest_view.horizontalHeader().setSortIndicatorShown(False)
sort_source_view.horizontalHeader().setSortIndicatorShown(
sortindicatorshown)
self.commit()
def _reset_order(self):
datamodel = self.dataview.model()
predmodel = self.predictionsview.model()
if datamodel is not None:
datamodel.setSortIndices(None)
datamodel.sort(-1)
if predmodel is not None:
predmodel.setSortIndices(None)
predmodel.sort(-1)
self.predictionsview.horizontalHeader().setSortIndicatorShown(False)
self.dataview.horizontalHeader().setSortIndicatorShown(False)
def _all_color_values(self):
"""
Return list of colors together with their values from all predictors
classes. Colors and values are sorted according to the values order
for simpler comparison.
"""
predictors = self._non_errored_predictors()
color_values = [
list(
zip(*sorted(zip(p.predictor.domain.class_var.colors,
p.predictor.domain.class_var.values),
key=itemgetter(1)))) for p in predictors
if p.predictor.domain.class_var.is_discrete
]
return color_values if color_values else [([], [])]
@staticmethod
def _colors_match(colors1, values1, color2, values2):
"""
Test whether colors for values match. Colors matches when all
values match for shorter list and colors match for shorter list.
It is assumed that values will be sorted together with their colors.
"""
shorter_length = min(len(colors1), len(color2))
return (values1[:shorter_length] == values2[:shorter_length]
and (numpy.array(colors1[:shorter_length]) == numpy.array(
color2[:shorter_length])).all())
def _get_colors(self):
"""
Defines colors for values. If colors match in all models use the union
otherwise use standard colors.
"""
all_colors_values = self._all_color_values()
base_color, base_values = all_colors_values[0]
for c, v in all_colors_values[1:]:
if not self._colors_match(base_color, base_values, c, v):
base_color = []
break
# replace base_color if longer
if len(v) > len(base_color):
base_color = c
base_values = v
if len(base_color) != len(self.class_values):
return LimitedDiscretePalette(len(self.class_values)).palette
# reorder colors to widgets order
colors = [None] * len(self.class_values)
for c, v in zip(base_color, base_values):
colors[self.class_values.index(v)] = c
return colors
def _update_prediction_delegate(self):
self._delegates.clear()
colors = self._get_colors()
for col, slot in enumerate(self.predictors.values()):
target = slot.predictor.domain.class_var
shown_probs = (() if target.is_continuous else [
val if self.class_values[val] in target.values else None
for val in self.selected_classes
])
delegate = PredictionsItemDelegate(
None if target.is_continuous else self.class_values,
colors,
shown_probs,
target.format_str if target.is_continuous else None,
parent=self.predictionsview)
# QAbstractItemView does not take ownership of delegates, so we must
self._delegates.append(delegate)
self.predictionsview.setItemDelegateForColumn(col, delegate)
self.predictionsview.setColumnHidden(col, False)
self.predictionsview.resizeColumnsToContents()
self._recompute_splitter_sizes()
if self.predictionsview.model() is not None:
self.predictionsview.model().setProbInd(self.selected_classes)
def _recompute_splitter_sizes(self):
if not self.data:
return
view = self.predictionsview
self.left_width = \
view.horizontalHeader().length() + view.verticalHeader().width()
self._update_splitter()
def _update_splitter(self):
w1, w2 = self.splitter.sizes()
self.splitter.setSizes([self.left_width, w1 + w2 - self.left_width])
def splitter_resized(self):
self.left_width = self.splitter.sizes()[0]
def commit(self):
self._commit_predictions()
self._commit_evaluation_results()
def _commit_evaluation_results(self):
slots = [
p for p in self._non_errored_predictors()
if p.results.predicted is not None
]
if not slots:
self.Outputs.evaluation_results.send(None)
return
nanmask = numpy.isnan(self.data.get_column_view(self.class_var)[0])
data = self.data[~nanmask]
results = Results(data, store_data=True)
results.folds = None
results.row_indices = numpy.arange(len(data))
results.actual = data.Y.ravel()
results.predicted = numpy.vstack(
tuple(p.results.predicted[0][~nanmask] for p in slots))
if self.class_var and self.class_var.is_discrete:
results.probabilities = numpy.array(
[p.results.probabilities[0][~nanmask] for p in slots])
results.learner_names = [p.name for p in slots]
self.Outputs.evaluation_results.send(results)
def _commit_predictions(self):
if not self.data:
self._set_output_summary(None)
self.Outputs.predictions.send(None)
return
newmetas = []
newcolumns = []
for slot in self._non_errored_predictors():
if slot.predictor.domain.class_var.is_discrete:
self._add_classification_out_columns(slot, newmetas,
newcolumns)
else:
self._add_regression_out_columns(slot, newmetas, newcolumns)
attrs = list(self.data.domain.attributes)
metas = list(self.data.domain.metas)
names = [
var.name
for var in chain(attrs, self.data.domain.class_vars, metas) if var
]
uniq_newmetas = []
for new_ in newmetas:
uniq = get_unique_names(names, new_.name)
if uniq != new_.name:
new_ = new_.copy(name=uniq)
uniq_newmetas.append(new_)
names.append(uniq)
metas += uniq_newmetas
domain = Orange.data.Domain(attrs, self.class_var, metas=metas)
predictions = self.data.transform(domain)
if newcolumns:
newcolumns = numpy.hstack(
[numpy.atleast_2d(cols) for cols in newcolumns])
predictions.metas[:, -newcolumns.shape[1]:] = newcolumns
index = self.dataview.model().index
map_to = self.dataview.model().mapToSource
assert self.selection_store is not None
rows = None
if self.selection_store.rows:
rows = [
ind.row()
for ind in self.dataview.selectionModel().selectedRows(0)
]
rows.sort()
elif self.dataview.model().isSorted() \
or self.predictionsview.model().isSorted():
rows = list(range(len(self.data)))
if rows:
source_rows = [map_to(index(row, 0)).row() for row in rows]
predictions = predictions[source_rows]
self.Outputs.predictions.send(predictions)
self._set_output_summary(predictions)
@staticmethod
def _add_classification_out_columns(slot, newmetas, newcolumns):
# Mapped or unmapped predictions?!
# Or provide a checkbox so the user decides?
pred = slot.predictor
name = pred.name
values = pred.domain.class_var.values
newmetas.append(DiscreteVariable(name=name, values=values))
newcolumns.append(slot.results.unmapped_predicted.reshape(-1, 1))
newmetas += [
ContinuousVariable(name=f"{name} ({value})") for value in values
]
newcolumns.append(slot.results.unmapped_probabilities)
@staticmethod
def _add_regression_out_columns(slot, newmetas, newcolumns):
newmetas.append(ContinuousVariable(name=slot.predictor.name))
newcolumns.append(slot.results.unmapped_predicted.reshape((-1, 1)))
def send_report(self):
def merge_data_with_predictions():
data_model = self.dataview.model()
predictions_view = self.predictionsview
predictions_model = predictions_view.model()
# use ItemDelegate to style prediction values
delegates = [
predictions_view.itemDelegateForColumn(i)
for i in range(predictions_model.columnCount())
]
# iterate only over visible columns of data's QTableView
iter_data_cols = list(
filter(lambda x: not self.dataview.isColumnHidden(x),
range(data_model.columnCount())))
# print header
yield [''] + \
[predictions_model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
for col in range(predictions_model.columnCount())] + \
[data_model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
for col in iter_data_cols]
# print data & predictions
for i in range(data_model.rowCount()):
yield [data_model.headerData(i, Qt.Vertical, Qt.DisplayRole)] + \
[delegate.displayText(
predictions_model.data(predictions_model.index(i, j)),
QLocale())
for j, delegate in enumerate(delegates)] + \
[data_model.data(data_model.index(i, j))
for j in iter_data_cols]
if self.data:
text = self._get_details().replace('\n', '<br>')
if self.selected_classes:
text += '<br>Showing probabilities for: '
text += ', '.join(
[self.class_values[i] for i in self.selected_classes])
self.report_paragraph('Info', text)
self.report_table("Data & Predictions",
merge_data_with_predictions(),
header_rows=1,
header_columns=1)
self.report_table("Scores", self.score_table.view)
def resizeEvent(self, event):
super().resizeEvent(event)
self._update_splitter()
def showEvent(self, event):
super().showEvent(event)
QTimer.singleShot(0, self._update_splitter)
def __init__(self):
super().__init__()
for name in self.signal_names:
setattr(self, name, {})
for s in self.libraryListSource:
s.flags = 0
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " +
"<li>".join(map("in_{0}, in_{0}s".format, self.signal_names)) +
"</ul></p><p>Output variables:<ul><li>" +
"<li>".join(map("out_{0}".format, self.signal_names)) +
"</ul></p>"
)
self.libraryList = itemmodels.PyListModel(
[], self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked |
QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Preferred)
)
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged
)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Script from File", self)
save_to_file = QAction("Save Selected Script to File", self)
restore_saved = QAction("Undo Changes to Selected Script", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
restore_saved.triggered.connect(self.restoreSaved)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
menu.addAction(restore_saved)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
self.execute_button = gui.button(self.controlArea, self, 'Run', callback=self.commit)
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python Script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
select_row(self.libraryView, self.currentScriptIndex)
self.restoreScriptText()
self.splitCanvas.setSizes([2, 1])
if self.splitterState is not None:
self.splitCanvas.restoreState(QByteArray(self.splitterState))
self.splitCanvas.splitterMoved[int, int].connect(self.onSpliterMoved)
self.controlArea.layout().addStretch(1)
self.resize(800, 600)
def __init__(self, parent=None):
super().__init__(self, parent)
self.clusterDataset = None
self.referenceDataset = None
self.ontology = None
self.annotations = None
self.loadedAnnotationCode = "---"
self.treeStructRootKey = None
self.probFunctions = [stats.Binomial(), stats.Hypergeometric()]
self.selectedTerms = []
self.selectionChanging = 0
self.__state = OWGOEnrichmentAnalysis.Initializing
self.annotationCodes = []
#############
## GUI
#############
self.tabs = gui.tabWidget(self.controlArea)
## Input tab
self.inputTab = gui.createTabPage(self.tabs, "Input")
box = gui.widgetBox(self.inputTab, "Info")
self.infoLabel = gui.widgetLabel(box, "No data on input\n")
gui.button(
box,
self,
"Ontology/Annotation Info",
callback=self.ShowInfo,
tooltip="Show information on loaded ontology and annotations")
box = gui.widgetBox(self.inputTab, "Organism")
self.annotationComboBox = gui.comboBox(box,
self,
"annotationIndex",
items=self.annotationCodes,
callback=self._updateEnrichment,
tooltip="Select organism")
genebox = gui.widgetBox(self.inputTab, "Gene Names")
self.geneAttrIndexCombo = gui.comboBox(
genebox,
self,
"geneAttrIndex",
callback=self._updateEnrichment,
tooltip="Use this attribute to extract gene names from input data")
self.geneAttrIndexCombo.setDisabled(self.useAttrNames)
cb = gui.checkBox(genebox,
self,
"useAttrNames",
"Use column names",
tooltip="Use column names for gene names",
callback=self._updateEnrichment)
cb.toggled[bool].connect(self.geneAttrIndexCombo.setDisabled)
gui.button(genebox,
self,
"Gene matcher settings",
callback=self.UpdateGeneMatcher,
tooltip="Open gene matching settings dialog")
self.referenceRadioBox = gui.radioButtonsInBox(
self.inputTab,
self,
"useReferenceDataset", ["Entire genome", "Reference set (input)"],
tooltips=[
"Use entire genome for reference",
"Use genes from Referece Examples input signal as reference"
],
box="Reference",
callback=self._updateEnrichment)
self.referenceRadioBox.buttons[1].setDisabled(True)
gui.radioButtonsInBox(
self.inputTab,
self,
"aspectIndex",
["Biological process", "Cellular component", "Molecular function"],
box="Aspect",
callback=self._updateEnrichment)
## Filter tab
self.filterTab = gui.createTabPage(self.tabs, "Filter")
box = gui.widgetBox(self.filterTab, "Filter GO Term Nodes")
gui.checkBox(
box,
self,
"filterByNumOfInstances",
"Genes",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by number of input genes mapped to a term")
ibox = gui.indentedBox(box)
gui.spin(ibox,
self,
'minNumOfInstances',
1,
100,
step=1,
label='#:',
labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Min. number of input genes mapped to a term")
gui.checkBox(box,
self,
"filterByPValue_nofdr",
"p-value",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by term p-value")
gui.doubleSpin(gui.indentedBox(box),
self,
'maxPValue_nofdr',
1e-8,
1,
step=1e-8,
label='p:',
labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Max term p-value")
#use filterByPValue for FDR, as it was the default in prior versions
gui.checkBox(box,
self,
"filterByPValue",
"FDR",
callback=self.FilterAndDisplayGraph,
tooltip="Filter by term FDR")
gui.doubleSpin(gui.indentedBox(box),
self,
'maxPValue',
1e-8,
1,
step=1e-8,
label='p:',
labelWidth=15,
callback=self.FilterAndDisplayGraph,
callbackOnReturn=True,
tooltip="Max term p-value")
box = gui.widgetBox(box, "Significance test")
gui.radioButtonsInBox(box,
self,
"probFunc", ["Binomial", "Hypergeometric"],
tooltips=[
"Use binomial distribution test",
"Use hypergeometric distribution test"
],
callback=self._updateEnrichment)
box = gui.widgetBox(self.filterTab,
"Evidence codes in annotation",
addSpace=True)
self.evidenceCheckBoxDict = {}
for etype in go.evidenceTypesOrdered:
ecb = QCheckBox(etype,
toolTip=go.evidenceTypes[etype],
checked=self.useEvidenceType[etype])
ecb.toggled.connect(self.__on_evidenceChanged)
box.layout().addWidget(ecb)
self.evidenceCheckBoxDict[etype] = ecb
## Select tab
self.selectTab = gui.createTabPage(self.tabs, "Select")
box = gui.radioButtonsInBox(self.selectTab,
self,
"selectionDirectAnnotation",
["Directly or Indirectly", "Directly"],
box="Annotated genes",
callback=self.ExampleSelection)
box = gui.widgetBox(self.selectTab, "Output", addSpace=True)
gui.radioButtonsInBox(
box,
self,
"selectionDisjoint",
btnLabels=[
"All selected genes", "Term-specific genes",
"Common term genes"
],
tooltips=[
"Outputs genes annotated to all selected GO terms",
"Outputs genes that appear in only one of selected GO terms",
"Outputs genes common to all selected GO terms"
],
callback=[self.ExampleSelection, self.UpdateAddClassButton])
self.addClassCB = gui.checkBox(box,
self,
"selectionAddTermAsClass",
"Add GO Term as class",
callback=self.ExampleSelection)
# ListView for DAG, and table for significant GOIDs
self.DAGcolumns = [
'GO term', 'Cluster', 'Reference', 'p-value', 'FDR', 'Genes',
'Enrichment'
]
self.splitter = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitter)
# list view
self.listView = GOTreeWidget(self.splitter)
self.listView.setSelectionMode(QTreeView.ExtendedSelection)
self.listView.setAllColumnsShowFocus(1)
self.listView.setColumnCount(len(self.DAGcolumns))
self.listView.setHeaderLabels(self.DAGcolumns)
self.listView.header().setSectionsClickable(True)
self.listView.header().setSortIndicatorShown(True)
self.listView.setSortingEnabled(True)
self.listView.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.listView.setRootIsDecorated(True)
self.listView.itemSelectionChanged.connect(self.ViewSelectionChanged)
# table of significant GO terms
self.sigTerms = QTreeWidget(self.splitter)
self.sigTerms.setColumnCount(len(self.DAGcolumns))
self.sigTerms.setHeaderLabels(self.DAGcolumns)
self.sigTerms.setSortingEnabled(True)
self.sigTerms.setSelectionMode(QTreeView.ExtendedSelection)
self.sigTerms.setItemDelegateForColumn(
6, EnrichmentColumnItemDelegate(self))
self.sigTerms.itemSelectionChanged.connect(self.TableSelectionChanged)
self.sigTableTermsSorted = []
self.graph = {}
self.inputTab.layout().addStretch(1)
self.filterTab.layout().addStretch(1)
self.selectTab.layout().addStretch(1)
self.setBlocking(True)
self._executor = ThreadExecutor()
self._init = EnsureDownloaded([(taxonomy.Taxonomy.DOMAIN,
taxonomy.Taxonomy.FILENAME),
("GO", "taxonomy.pickle")])
self._init.finished.connect(self.__initialize_finish)
self._executor.submit(self._init)
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
# ATTRIBUTES #
self.target_database = ENTREZ_ID
# input data
self.input_data = None
self.input_genes = None
self.tax_id = None
self.column_candidates = []
# input options
self.organisms = []
# gene matcher
self.gene_matcher = None
# progress bar
self.progress_bar = None
self._timer = QTimer()
self._timer.timeout.connect(self._apply_filter)
self._timer.setSingleShot(True)
# GUI SECTION #
# Control area
self.info_box = widgetLabel(
widgetBox(self.controlArea, "Info", addSpace=True),
'No data on input.\n')
organism_box = vBox(self.controlArea, 'Organism')
self.organism_select_combobox = comboBox(
organism_box,
self,
'selected_organism',
callback=self.on_input_option_change)
self.get_available_organisms()
self.organism_select_combobox.setCurrentIndex(self.selected_organism)
box = widgetBox(self.controlArea, 'Gene IDs in the input data')
self.gene_columns_model = itemmodels.DomainModel(
valid_types=(StringVariable, DiscreteVariable))
self.gene_column_combobox = comboBox(
box,
self,
'selected_gene_col',
label='Stored in data column',
model=self.gene_columns_model,
sendSelectedValue=True,
callback=self.on_input_option_change,
)
self.attr_names_checkbox = checkBox(
box,
self,
'use_attr_names',
'Stored as feature (column) names',
disables=[(-1, self.gene_column_combobox)],
callback=self.on_input_option_change,
)
self.gene_column_combobox.setDisabled(bool(self.use_attr_names))
output_box = vBox(self.controlArea, 'Output')
# separator(output_box)
# output_box.layout().addWidget(horizontal_line())
# separator(output_box)
self.exclude_radio = checkBox(output_box,
self,
'exclude_unmatched',
'Exclude unmatched genes',
callback=self.commit)
self.replace_radio = checkBox(output_box,
self,
'replace_id_with_symbol',
'Replace feature IDs with gene names',
callback=self.commit)
auto_commit(self.controlArea,
self,
"auto_commit",
"&Commit",
box=False)
rubber(self.controlArea)
# Main area
self.filter = lineEdit(self.mainArea,
self,
'search_pattern',
'Filter:',
callbackOnType=True,
callback=self.handle_filter_callback)
# rubber(self.radio_group)
self.mainArea.layout().addWidget(self.filter)
# set splitter
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.table_model = GeneInfoModel()
self.table_view = QTableView()
self.table_view.setAlternatingRowColors(True)
self.table_view.viewport().setMouseTracking(True)
self.table_view.setSortingEnabled(True)
self.table_view.setShowGrid(False)
self.table_view.verticalHeader().hide()
# self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.unknown_model = UnknownGeneInfoModel()
self.unknown_view = QTableView()
self.unknown_view.setModel(self.unknown_model)
self.unknown_view.verticalHeader().hide()
self.unknown_view.setShowGrid(False)
self.unknown_view.setSelectionMode(QAbstractItemView.NoSelection)
self.unknown_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.splitter.addWidget(self.table_view)
self.splitter.addWidget(self.unknown_view)
self.splitter.setStretchFactor(0, 90)
self.splitter.setStretchFactor(1, 10)
self.mainArea.layout().addWidget(self.splitter)
def __init__(self, parent=None, signalManager=None, name=" GEO Data Sets"):
OWWidget.__init__(self, parent, signalManager, name)
self.selectionChanged = False
self.filterString = ""
self.datasetName = ""
## GUI
box = gui.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoBox = gui.widgetLabel(box, "Initializing\n\n")
box = gui.widgetBox(self.controlArea, "Output", addSpace=True)
gui.radioButtonsInBox(box,
self,
"outputRows",
["Genes in rows", "Samples in rows"],
"Rows",
callback=self.commitIf)
gui.checkBox(box,
self,
"mergeSpots",
"Merge spots of same gene",
callback=self.commitIf)
gui.separator(box)
self.nameEdit = gui.lineEdit(
box,
self,
"datasetName",
"Data set name",
tooltip="Override the default output data set name",
callback=self.onNameEdited)
self.nameEdit.setPlaceholderText("")
if sys.version_info < (3, ):
box = gui.widgetBox(self.controlArea, "Commit", addSpace=True)
self.commitButton = gui.button(box,
self,
"Commit",
callback=self.commit)
cb = gui.checkBox(box, self, "autoCommit", "Commit on any change")
gui.setStopper(self, self.commitButton, cb, "selectionChanged",
self.commit)
else:
gui.auto_commit(self.controlArea,
self,
"autoCommit",
"Commit",
box="Commit")
self.commitIf = self.commit
gui.rubber(self.controlArea)
gui.widgetLabel(self.mainArea, "Filter")
self.filterLineEdit = QLineEdit(textChanged=self.filter)
self.completer = TokenListCompleter(self,
caseSensitivity=Qt.CaseInsensitive)
self.filterLineEdit.setCompleter(self.completer)
self.mainArea.layout().addWidget(self.filterLineEdit)
splitter = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(splitter)
self.treeWidget = QTreeView(splitter)
self.treeWidget.setSelectionMode(QTreeView.SingleSelection)
self.treeWidget.setRootIsDecorated(False)
self.treeWidget.setSortingEnabled(True)
self.treeWidget.setAlternatingRowColors(True)
self.treeWidget.setUniformRowHeights(True)
self.treeWidget.setEditTriggers(QTreeView.NoEditTriggers)
linkdelegate = LinkStyledItemDelegate(self.treeWidget)
self.treeWidget.setItemDelegateForColumn(1, linkdelegate)
self.treeWidget.setItemDelegateForColumn(8, linkdelegate)
self.treeWidget.setItemDelegateForColumn(
0, gui.IndicatorItemDelegate(self.treeWidget, role=Qt.DisplayRole))
proxyModel = MySortFilterProxyModel(self.treeWidget)
self.treeWidget.setModel(proxyModel)
self.treeWidget.selectionModel().selectionChanged.connect(
self.updateSelection)
self.treeWidget.viewport().setMouseTracking(True)
splitterH = QSplitter(Qt.Horizontal, splitter)
box = gui.widgetBox(splitterH, "Description")
self.infoGDS = gui.widgetLabel(box, "")
self.infoGDS.setWordWrap(True)
gui.rubber(box)
box = gui.widgetBox(splitterH, "Sample Annotations")
self.annotationsTree = QTreeWidget(box)
self.annotationsTree.setHeaderLabels(
["Type (Sample annotations)", "Sample count"])
self.annotationsTree.setRootIsDecorated(True)
box.layout().addWidget(self.annotationsTree)
self.annotationsTree.itemChanged.connect(
self.annotationSelectionChanged)
self._annotationsUpdating = False
self.splitters = splitter, splitterH
for sp, setting in zip(self.splitters, self.splitterSettings):
sp.splitterMoved.connect(self.splitterMoved)
sp.restoreState(setting)
self.searchKeys = [
"dataset_id", "title", "platform_organism", "description"
]
self.gds = []
self.gds_info = None
self.resize(1000, 600)
self.setBlocking(True)
self.setEnabled(False)
self.progressBarInit()
self._executor = ThreadExecutor()
func = partial(get_gds_model,
methodinvoke(self, "_setProgress", (float, )))
self._inittask = Task(function=func)
self._inittask.finished.connect(self._initializemodel)
self._executor.submit(self._inittask)
self._datatask = None
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)
class OWDataSets(OWWidget):
name = "Datasets"
description = "Load a dataset from an online repository"
icon = "icons/DataSets.svg"
priority = 20
replaces = ["orangecontrib.prototypes.widgets.owdatasets.OWDataSets"]
keywords = ["online"]
# The following constants can be overridden in a subclass
# to reuse this widget for a different repository
# Take care when refactoring! (used in e.g. single-cell)
INDEX_URL = "https://datasets.biolab.si/"
DATASET_DIR = "datasets"
# override HEADER_SCHEMA to define new columns
# if schema is changed override methods: self.assign_delegates and
# self.create_model
HEADER_SCHEMA = [
['islocal', {'label': ''}],
['title', {'label': 'Title'}],
['size', {'label': 'Size'}],
['instances', {'label': 'Instances'}],
['variables', {'label': 'Variables'}],
['target', {'label': 'Target'}],
['tags', {'label': 'Tags'}]
] # type: List[str, dict]
class Error(OWWidget.Error):
no_remote_datasets = Msg("Could not fetch dataset list")
class Warning(OWWidget.Warning):
only_local_datasets = Msg("Could not fetch datasets list, only local "
"cached datasets are shown")
class Outputs:
data = Output("Data", Orange.data.Table)
#: Selected dataset id
selected_id = settings.Setting(None) # type: Optional[str]
auto_commit = settings.Setting(False) # type: bool
#: main area splitter state
splitter_state = settings.Setting(b'') # type: bytes
header_state = settings.Setting(b'') # type: bytes
def __init__(self):
super().__init__()
self.allinfo_local = {}
self.allinfo_remote = {}
self.local_cache_path = os.path.join(data_dir(), self.DATASET_DIR)
self._header_labels = [
header['label'] for _, header in self.HEADER_SCHEMA]
self._header_index = namedtuple(
'_header_index', [info_tag for info_tag, _ in self.HEADER_SCHEMA])
self.Header = self._header_index(
*[index for index, _ in enumerate(self._header_labels)])
self.__awaiting_state = None # type: Optional[_FetchState]
box = gui.widgetBox(self.controlArea, "Info")
self.infolabel = QLabel(text="Initializing...\n\n")
box.layout().addWidget(self.infolabel)
gui.widgetLabel(self.mainArea, "Filter")
self.filterLineEdit = QLineEdit(
textChanged=self.filter
)
self.mainArea.layout().addWidget(self.filterLineEdit)
self.splitter = QSplitter(orientation=Qt.Vertical)
self.view = QTreeView(
sortingEnabled=True,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True,
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
uniformRowHeights=True,
)
# the method doesn't exists yet, pylint: disable=unnecessary-lambda
self.view.doubleClicked.connect(lambda: self.unconditional_commit())
box = gui.widgetBox(self.splitter, "Description", addToLayout=False)
self.descriptionlabel = QLabel(
wordWrap=True,
textFormat=Qt.RichText,
)
self.descriptionlabel = QTextBrowser(
openExternalLinks=True,
textInteractionFlags=(Qt.TextSelectableByMouse |
Qt.LinksAccessibleByMouse)
)
self.descriptionlabel.setFrameStyle(QTextBrowser.NoFrame)
# no (white) text background
self.descriptionlabel.viewport().setAutoFillBackground(False)
box.layout().addWidget(self.descriptionlabel)
self.splitter.addWidget(self.view)
self.splitter.addWidget(box)
self.splitter.setSizes([300, 200])
self.splitter.splitterMoved.connect(
lambda:
setattr(self, "splitter_state", bytes(self.splitter.saveState()))
)
self.mainArea.layout().addWidget(self.splitter)
self.controlArea.layout().addStretch(10)
gui.auto_commit(self.controlArea, self, "auto_commit", "Send Data")
proxy = QSortFilterProxyModel()
proxy.setFilterKeyColumn(-1)
proxy.setFilterCaseSensitivity(False)
self.view.setModel(proxy)
if self.splitter_state:
self.splitter.restoreState(self.splitter_state)
self.assign_delegates()
self.setBlocking(True)
self.setStatusMessage("Initializing")
self._executor = ThreadPoolExecutor(max_workers=1)
f = self._executor.submit(self.list_remote)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__set_index)
def assign_delegates(self):
# NOTE: All columns must have size hinting delegates.
# QTreeView queries only the columns displayed in the viewport so
# the layout would be different depending in the horizontal scroll
# position
self.view.setItemDelegate(UniformHeightDelegate(self))
self.view.setItemDelegateForColumn(
self.Header.islocal,
UniformHeightIndicatorDelegate(self, role=Qt.DisplayRole)
)
self.view.setItemDelegateForColumn(
self.Header.size,
SizeDelegate(self)
)
self.view.setItemDelegateForColumn(
self.Header.instances,
NumericalDelegate(self)
)
self.view.setItemDelegateForColumn(
self.Header.variables,
NumericalDelegate(self)
)
self.view.resizeColumnToContents(self.Header.islocal)
def _parse_info(self, file_path):
if file_path in self.allinfo_remote:
info = self.allinfo_remote[file_path]
else:
info = self.allinfo_local[file_path]
islocal = file_path in self.allinfo_local
isremote = file_path in self.allinfo_remote
outdated = islocal and isremote and (
self.allinfo_remote[file_path].get('version', '')
!= self.allinfo_local[file_path].get('version', '')
)
islocal &= not outdated
prefix = os.path.join('', *file_path[:-1])
filename = file_path[-1]
return Namespace(file_path=file_path, prefix=prefix, filename=filename,
islocal=islocal, outdated=outdated, **info)
def create_model(self):
allkeys = set(self.allinfo_local) | set(self.allinfo_remote)
allkeys = sorted(allkeys)
model = QStandardItemModel(self)
model.setHorizontalHeaderLabels(self._header_labels)
current_index = -1
for i, file_path in enumerate(allkeys):
datainfo = self._parse_info(file_path)
item1 = QStandardItem()
item1.setData(" " if datainfo.islocal else "", Qt.DisplayRole)
item1.setData(datainfo, Qt.UserRole)
item2 = QStandardItem(datainfo.title)
item3 = QStandardItem()
item3.setData(datainfo.size, Qt.DisplayRole)
item4 = QStandardItem()
item4.setData(datainfo.instances, Qt.DisplayRole)
item5 = QStandardItem()
item5.setData(datainfo.variables, Qt.DisplayRole)
item6 = QStandardItem()
item6.setData(datainfo.target, Qt.DisplayRole)
if datainfo.target:
item6.setIcon(variable_icon(datainfo.target))
item7 = QStandardItem()
item7.setData(", ".join(datainfo.tags) if datainfo.tags else "",
Qt.DisplayRole)
row = [item1, item2, item3, item4, item5, item6, item7]
model.appendRow(row)
if os.path.join(*file_path) == self.selected_id:
current_index = i
return model, current_index
@Slot(object)
def __set_index(self, f):
# type: (Future) -> None
# set results from `list_remote` query.
assert QThread.currentThread() is self.thread()
assert f.done()
self.setBlocking(False)
self.setStatusMessage("")
self.allinfo_local = self.list_local()
try:
self.allinfo_remote = f.result()
except Exception: # anytying can happen, pylint: disable=broad-except
log.exception("Error while fetching updated index")
if not self.allinfo_local:
self.Error.no_remote_datasets()
else:
self.Warning.only_local_datasets()
self.allinfo_remote = {}
model, current_index = self.create_model()
self.view.model().setSourceModel(model)
self.view.selectionModel().selectionChanged.connect(
self.__on_selection
)
self.view.resizeColumnToContents(0)
self.view.setColumnWidth(
1, min(self.view.sizeHintForColumn(1),
self.view.fontMetrics().width("X" * 24)))
header = self.view.header()
header.restoreState(self.header_state)
# Update the info text
self.infolabel.setText(
format_info(model.rowCount(), len(self.allinfo_local)))
if current_index != -1:
selmodel = self.view.selectionModel()
selmodel.select(
self.view.model().mapFromSource(model.index(current_index, 0)),
QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
def __update_cached_state(self):
model = self.view.model().sourceModel()
localinfo = self.list_local()
assert isinstance(model, QStandardItemModel)
allinfo = []
for i in range(model.rowCount()):
item = model.item(i, 0)
info = item.data(Qt.UserRole)
info.islocal = info.file_path in localinfo
item.setData(" " if info.islocal else "", Qt.DisplayRole)
allinfo.append(info)
self.infolabel.setText(format_info(
model.rowCount(), sum(info.islocal for info in allinfo)))
def selected_dataset(self):
"""
Return the current selected dataset info or None if not selected
Returns
-------
info : Optional[Namespace]
"""
rows = self.view.selectionModel().selectedRows(0)
assert 0 <= len(rows) <= 1
current = rows[0] if rows else None # type: Optional[QModelIndex]
if current is not None:
info = current.data(Qt.UserRole)
assert isinstance(info, Namespace)
else:
info = None
return info
def filter(self):
filter_string = self.filterLineEdit.text().strip()
proxyModel = self.view.model()
if proxyModel:
proxyModel.setFilterFixedString(filter_string)
def __on_selection(self):
# Main datasets view selection has changed
rows = self.view.selectionModel().selectedRows(0)
assert 0 <= len(rows) <= 1
current = rows[0] if rows else None # type: Optional[QModelIndex]
if current is not None:
current = self.view.model().mapToSource(current)
di = current.data(Qt.UserRole)
text = description_html(di)
self.descriptionlabel.setText(text)
self.selected_id = os.path.join(di.prefix, di.filename)
else:
self.descriptionlabel.setText("")
self.selected_id = None
self.commit()
def commit(self):
"""
Commit a dataset to the output immediately (if available locally) or
schedule download background and an eventual send.
During the download the widget is in blocking state
(OWWidget.isBlocking)
"""
di = self.selected_dataset()
if di is not None:
self.Error.clear()
if self.__awaiting_state is not None:
# disconnect from the __commit_complete
self.__awaiting_state.watcher.done.disconnect(
self.__commit_complete)
# .. and connect to update_cached_state
# self.__awaiting_state.watcher.done.connect(
# self.__update_cached_state)
# TODO: There are possible pending __progress_advance queued
self.__awaiting_state.pb.advance.disconnect(
self.__progress_advance)
self.progressBarFinished(processEvents=None)
self.__awaiting_state = None
if not di.islocal:
pr = progress()
callback = lambda pr=pr: pr.advance.emit()
pr.advance.connect(self.__progress_advance, Qt.QueuedConnection)
self.progressBarInit(processEvents=None)
self.setStatusMessage("Fetching...")
self.setBlocking(True)
f = self._executor.submit(
ensure_local, self.INDEX_URL, di.file_path,
self.local_cache_path, force=di.outdated,
progress_advance=callback)
w = FutureWatcher(f, parent=self)
w.done.connect(self.__commit_complete)
self.__awaiting_state = _FetchState(f, w, pr)
else:
self.setStatusMessage("")
self.setBlocking(False)
self.commit_cached(di.file_path)
else:
self.Outputs.data.send(None)
@Slot(object)
def __commit_complete(self, f):
# complete the commit operation after the required file has been
# downloaded
assert QThread.currentThread() is self.thread()
assert self.__awaiting_state is not None
assert self.__awaiting_state.future is f
if self.isBlocking():
self.progressBarFinished(processEvents=None)
self.setBlocking(False)
self.setStatusMessage("")
self.__awaiting_state = None
try:
path = f.result()
# anything can happen here, pylint: disable=broad-except
except Exception as ex:
log.exception("Error:")
self.error(format_exception(ex))
path = None
self.__update_cached_state()
if path is not None:
data = self.load_data(path)
else:
data = None
self.Outputs.data.send(data)
def commit_cached(self, file_path):
path = LocalFiles(self.local_cache_path).localpath(*file_path)
self.Outputs.data.send(self.load_data(path))
@Slot()
def __progress_advance(self):
assert QThread.currentThread() is self.thread()
self.progressBarAdvance(1, processEvents=None)
def onDeleteWidget(self):
super().onDeleteWidget()
if self.__awaiting_state is not None:
self.__awaiting_state.watcher.done.disconnect(self.__commit_complete)
self.__awaiting_state.pb.advance.disconnect(self.__progress_advance)
self.__awaiting_state = None
@staticmethod
def sizeHint():
return QSize(900, 600)
def closeEvent(self, event):
self.splitter_state = bytes(self.splitter.saveState())
self.header_state = bytes(self.view.header().saveState())
super().closeEvent(event)
def load_data(self, path): # pylint: disable=no-self-use
return Orange.data.Table(path)
def list_remote(self):
# type: () -> Dict[Tuple[str, ...], dict]
client = ServerFiles(server=self.INDEX_URL)
return client.allinfo()
def list_local(self):
# type: () -> Dict[Tuple[str, ...], dict]
return LocalFiles(self.local_cache_path).allinfo()
class OWPredictions(widget.OWWidget):
name = "Predictions"
icon = "icons/Predictions.svg"
priority = 200
description = "Display the predictions of models for an input data set."
inputs = [("Data", Orange.data.Table, "set_data"),
("Predictors", Model,
"set_predictor", widget.Multiple)]
outputs = [("Predictions", Orange.data.Table),
("Evaluation Results", Orange.evaluation.Results)]
settingsHandler = settings.ClassValuesContextHandler()
#: Display the full input dataset or only the target variable columns (if
#: available)
show_attrs = settings.Setting(True)
#: Show predicted values (for discrete target variable)
show_predictions = settings.Setting(True)
#: Show predictions probabilities (for discrete target variable)
show_probabilities = settings.Setting(True)
#: List of selected class value indices in the "Show probabilities" list
selected_classes = settings.ContextSetting([])
#: Draw colored distribution bars
draw_dist = settings.Setting(True)
output_attrs = settings.Setting(True)
output_predictions = settings.Setting(True)
output_probabilities = settings.Setting(True)
def __init__(self):
super().__init__()
#: Input data table
self.data = None # type: Optional[Orange.data.Table]
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict() # type: Dict[object, PredictorSlot]
#: A class variable (prediction target)
self.class_var = None # type: Optional[Orange.data.Variable]
#: List of (discrete) class variable's values
self.class_values = [] # type: List[str]
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input.\nPredictors: 0\nTask: N/A")
self.infolabel.setMinimumWidth(150)
gui.button(box, self, "Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
self.classification_options = box = gui.vBox(
self.controlArea, "Options (classification)", spacing=-1,
addSpace=False)
gui.checkBox(box, self, "show_predictions", "Show predicted class",
callback=self._update_prediction_delegate)
b = gui.checkBox(box, self, "show_probabilities",
"Show predicted probabilities",
callback=self._update_prediction_delegate)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(b),
addSpace=False)
gui.listBox(ibox, self, "selected_classes", "class_values",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.MultiSelection,
addSpace=False)
gui.checkBox(box, self, "draw_dist", "Draw distribution bars",
callback=self._update_prediction_delegate)
box = gui.vBox(self.controlArea, "Data View")
gui.checkBox(box, self, "show_attrs", "Show full data set",
callback=self._update_column_visibility)
box = gui.vBox(self.controlArea, "Output", spacing=-1)
self.checkbox_class = gui.checkBox(
box, self, "output_attrs", "Original data",
callback=self.commit)
self.checkbox_class = gui.checkBox(
box, self, "output_predictions", "Predictions",
callback=self.commit)
self.checkbox_prob = gui.checkBox(
box, self, "output_probabilities", "Probabilities",
callback=self.commit)
gui.rubber(self.controlArea)
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2,
)
self.dataview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus
)
self.predictionsview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus,
sortingEnabled=True,
)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size:
self.predictionsview.verticalHeader()
.resizeSection(index, size)
)
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.mainArea.layout().addWidget(self.splitter)
@check_sql_input
def set_data(self, data):
"""Set the input data set"""
self.data = data
if data is None:
self.dataview.setModel(None)
self.predictionsview.setModel(None)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
else:
# force full reset of the view's HeaderView state
self.dataview.setModel(None)
model = TableModel(data, parent=None)
modelproxy = TableSortProxyModel()
modelproxy.setSourceModel(model)
self.dataview.setModel(modelproxy)
self._update_column_visibility()
self.invalidate_predictions()
def set_predictor(self, predictor=None, id=None):
if id in self.predictors:
if predictor is not None:
self.predictors[id] = self.predictors[id]._replace(
predictor=predictor, name=predictor.name, results=None)
else:
del self.predictors[id]
elif predictor is not None:
self.predictors[id] = \
PredictorSlot(predictor, predictor.name, None)
if predictor is not None:
self.class_var = predictor.domain.class_var
def handleNewSignals(self):
self.clear_messages()
if self.data is not None:
for inputid, pred in list(self.predictors.items()):
if pred.results is None or numpy.isnan(pred.results[0]).all():
try:
results = self.predict(pred.predictor, self.data)
except ValueError as err:
err_msg = '{}:\n'.format(pred.predictor.name) + \
str(err)
self.error(err_msg)
n, m = len(self.data), 1
if self.data.domain.has_discrete_class:
m = len(self.data.domain.class_var.values)
probabilities = numpy.full((n, m), numpy.nan)
results = (numpy.full(n, numpy.nan), probabilities)
self.predictors[inputid] = pred._replace(results=results)
if not self.predictors:
self.class_var = None
self.classification_options.setVisible(
self.class_var is not None and self.class_var.is_discrete)
self.closeContext()
if self.class_var is not None and self.class_var.is_discrete:
self.class_values = list(self.class_var.values)
self.selected_classes = list(range(len(self.class_values)))
self.openContext(self.class_var)
else:
self.class_values = []
self.selected_classes = []
self._update_predictions_model()
self._update_prediction_delegate()
# Check for prediction target consistency
target_vars = set([p.predictor.domain.class_var
for p in self.predictors.values()])
self.warning("Mismatching class variables", shown=len(target_vars) > 1)
# Update the Info box text.
info = []
if self.data is not None:
info.append("Data: {} instances.".format(len(self.data)))
else:
info.append("Data: N/A")
if self.predictors:
info.append("Predictors: {}".format(len(self.predictors)))
else:
info.append("Predictors: N/A")
if self.class_var is not None:
if self.class_var.is_discrete:
info.append("Task: Classification")
self.checkbox_class.setEnabled(True)
self.checkbox_prob.setEnabled(True)
else:
info.append("Task: Regression")
self.checkbox_class.setEnabled(False)
self.checkbox_prob.setEnabled(False)
else:
info.append("Task: N/A")
self.infolabel.setText("\n".join(info))
self.commit()
def invalidate_predictions(self):
for inputid, pred in list(self.predictors.items()):
self.predictors[inputid] = pred._replace(results=None)
def _update_predictions_model(self):
"""Update the prediction view model."""
if self.data is not None:
slots = self.predictors.values()
results = []
for p in slots:
values, prob = p.results
if p.predictor.domain.class_var.is_discrete:
values = [
Orange.data.Value(p.predictor.domain.class_var, v)
for v in values
]
results.append((values, prob))
results = list(zip(*(zip(*res) for res in results)))
headers = [p.name for p in slots]
model = PredictionsModel(results, headers)
else:
model = None
predmodel = PredictionsSortProxyModel()
predmodel.setSourceModel(model)
predmodel.setDynamicSortFilter(True)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.predictionsview.setModel(predmodel)
hheader = self.predictionsview.horizontalHeader()
hheader.setSortIndicatorShown(False)
# SortFilterProxyModel is slow due to large abstraction overhead
# (every comparison triggers multiple `model.index(...)`,
# model.rowCount(...), `model.parent`, ... calls)
hheader.setSectionsClickable(predmodel.rowCount() < 20000)
predmodel.layoutChanged.connect(self._update_data_sort_order)
self._update_data_sort_order()
self.predictionsview.resizeColumnsToContents()
def _update_column_visibility(self):
"""Update data column visibility."""
if self.data is not None:
domain = self.data.domain
first_attr = len(domain.class_vars) + len(domain.metas)
for i in range(first_attr, first_attr + len(domain.attributes)):
self.dataview.setColumnHidden(i, not self.show_attrs)
if domain.class_var:
self.dataview.setColumnHidden(0, False)
def _update_data_sort_order(self):
"""Update data row order to match the current predictions view order"""
datamodel = self.dataview.model() # data model proxy
predmodel = self.predictionsview.model() # predictions model proxy
sortindicatorshown = False
if datamodel is not None:
assert isinstance(datamodel, TableSortProxyModel)
n = datamodel.rowCount()
if predmodel is not None and predmodel.sortColumn() >= 0:
sortind = numpy.argsort(
[predmodel.mapToSource(predmodel.index(i, 0)).row()
for i in range(n)])
sortind = numpy.array(sortind, numpy.int)
sortindicatorshown = True
else:
sortind = None
datamodel.setSortIndices(sortind)
self.predictionsview.horizontalHeader() \
.setSortIndicatorShown(sortindicatorshown)
def _reset_order(self):
"""Reset the row sorting to original input order."""
datamodel = self.dataview.model()
predmodel = self.predictionsview.model()
if datamodel is not None:
datamodel.sort(-1)
if predmodel is not None:
predmodel.sort(-1)
self.predictionsview.horizontalHeader().setSortIndicatorShown(False)
def _update_prediction_delegate(self):
"""Update the predicted probability visibility state"""
delegate = PredictionsItemDelegate()
colors = None
if self.class_var is not None:
if self.class_var.is_discrete:
colors = [QtGui.QColor(*rgb) for rgb in self.class_var.colors]
dist_fmt = ""
pred_fmt = ""
if self.show_probabilities:
decimals = 2
float_fmt = "{{dist[{}]:.{}f}}"
dist_fmt = " : ".join(
float_fmt.format(i, decimals)
for i in range(len(self.class_var.values))
if i in self.selected_classes
)
if self.show_predictions:
pred_fmt = "{value!s}"
if pred_fmt and dist_fmt:
fmt = dist_fmt + " \N{RIGHTWARDS ARROW} " + pred_fmt
else:
fmt = dist_fmt or pred_fmt
else:
assert isinstance(self.class_var, ContinuousVariable)
fmt = "{{value:.{}f}}".format(
self.class_var.number_of_decimals)
delegate.setFormat(fmt)
if self.draw_dist and colors is not None:
delegate.setColors(colors)
self.predictionsview.setItemDelegate(delegate)
self.predictionsview.resizeColumnsToContents()
if self.class_var is not None and self.class_var.is_discrete:
proxy = self.predictionsview.model()
if proxy is not None:
proxy.setProbInd(numpy.array(self.selected_classes, dtype=int))
self._update_spliter()
def _update_spliter(self):
if self.data is None:
return
def width(view):
h_header = view.horizontalHeader()
v_header = view.verticalHeader()
return h_header.length() + v_header.width()
w = width(self.predictionsview) + 4
w1, w2 = self.splitter.sizes()
self.splitter.setSizes([w, w1 + w2 - w])
def commit(self):
if self.data is None or not self.predictors:
self.send("Predictions", None)
self.send("Evaluation Results", None)
return
predictor = next(iter(self.predictors.values())).predictor
class_var = predictor.domain.class_var
classification = class_var and class_var.is_discrete
newmetas = []
newcolumns = []
slots = list(self.predictors.values())
if classification:
if self.output_predictions:
mc = [DiscreteVariable(name=p.name, values=class_var.values)
for p in slots]
newmetas.extend(mc)
newcolumns.extend(p.results[0].reshape((-1, 1))
for p in slots)
if self.output_probabilities:
for p in slots:
m = [ContinuousVariable(name="%s(%s)" % (p.name, value))
for value in class_var.values]
newmetas.extend(m)
newcolumns.extend(p.results[1] for p in slots)
else:
# regression
mc = [ContinuousVariable(name=p.name)
for p in self.predictors.values()]
newmetas.extend(mc)
newcolumns.extend(p.results[0].reshape((-1, 1))
for p in slots)
if self.output_attrs:
attrs = list(self.data.domain.attributes)
else:
attrs = []
metas = list(self.data.domain.metas) + newmetas
domain = Orange.data.Domain(attrs, self.data.domain.class_var,
metas=metas)
predictions = self.data.from_table(domain, self.data)
if newcolumns:
newcolumns = numpy.hstack(
[numpy.atleast_2d(cols) for cols in newcolumns]
)
predictions.metas[:, -newcolumns.shape[1]:] = newcolumns
results = None
if self.data.domain.class_var == class_var:
N = len(self.data)
results = Orange.evaluation.Results(self.data, store_data=True)
results.folds = None
results.row_indices = numpy.arange(N)
results.actual = self.data.Y.ravel()
results.predicted = numpy.vstack(
tuple(p.results[0] for p in slots))
if classification:
results.probabilities = numpy.array(
[p.results[1] for p in slots])
results.learner_names = [p.name for p in slots]
self.send("Predictions", predictions)
self.send("Evaluation Results", results)
def send_report(self):
def merge_data_with_predictions():
data_model = self.dataview.model()
predictions_model = self.predictionsview.model()
# use ItemDelegate to style prediction values
style = lambda x: self.predictionsview.itemDelegate().displayText(x, QLocale())
# iterate only over visible columns of data's QTableView
iter_data_cols = list(filter(lambda x: not self.dataview.isColumnHidden(x),
range(data_model.columnCount())))
# print header
yield [''] + \
[predictions_model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
for col in range(predictions_model.columnCount())] + \
[data_model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
for col in iter_data_cols]
# print data & predictions
for i in range(data_model.rowCount()):
yield [data_model.headerData(i, Qt.Vertical, Qt.DisplayRole)] + \
[style(predictions_model.data(predictions_model.index(i, j)))
for j in range(predictions_model.columnCount())] + \
[data_model.data(data_model.index(i, j))
for j in iter_data_cols]
if self.data is not None:
text = self.infolabel.text().replace('\n', '<br>')
if self.show_probabilities and self.selected_classes:
text += '<br>Showing probabilities for: '
text += ', '. join([self.data.domain.class_var.values[i]
for i in self.selected_classes])
self.report_paragraph('Info', text)
self.report_table("Data & Predictions", merge_data_with_predictions(),
header_rows=1, header_columns=1)
@classmethod
def predict(cls, predictor, data):
class_var = predictor.domain.class_var
if class_var:
if class_var.is_discrete:
return cls.predict_discrete(predictor, data)
elif class_var.is_continuous:
return cls.predict_continuous(predictor, data)
@staticmethod
def predict_discrete(predictor, data):
return predictor(data, Model.ValueProbs)
@staticmethod
def predict_continuous(predictor, data):
values = predictor(data, Model.Value)
return values, [None] * len(data)
def __init__(self):
super().__init__()
#: Input data table
self.data = None # type: Optional[Orange.data.Table]
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict() # type: Dict[object, PredictorSlot]
#: A class variable (prediction target)
self.class_var = None # type: Optional[Orange.data.Variable]
#: List of (discrete) class variable's values
self.class_values = [] # type: List[str]
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input.\nPredictors: 0\nTask: N/A")
self.infolabel.setMinimumWidth(150)
gui.button(box, self, "Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
self.classification_options = box = gui.vBox(
self.controlArea, "Options (classification)", spacing=-1,
addSpace=False)
gui.checkBox(box, self, "show_predictions", "Show predicted class",
callback=self._update_prediction_delegate)
b = gui.checkBox(box, self, "show_probabilities",
"Show predicted probabilities",
callback=self._update_prediction_delegate)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(b),
addSpace=False)
gui.listBox(ibox, self, "selected_classes", "class_values",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.MultiSelection,
addSpace=False)
gui.checkBox(box, self, "draw_dist", "Draw distribution bars",
callback=self._update_prediction_delegate)
box = gui.vBox(self.controlArea, "Data View")
gui.checkBox(box, self, "show_attrs", "Show full data set",
callback=self._update_column_visibility)
box = gui.vBox(self.controlArea, "Output", spacing=-1)
self.checkbox_class = gui.checkBox(
box, self, "output_attrs", "Original data",
callback=self.commit)
self.checkbox_class = gui.checkBox(
box, self, "output_predictions", "Predictions",
callback=self.commit)
self.checkbox_prob = gui.checkBox(
box, self, "output_probabilities", "Probabilities",
callback=self.commit)
gui.rubber(self.controlArea)
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2,
)
self.dataview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus
)
self.predictionsview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus,
sortingEnabled=True,
)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size:
self.predictionsview.verticalHeader()
.resizeSection(index, size)
)
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.mainArea.layout().addWidget(self.splitter)
def __init__(self):
super().__init__()
self.libraryListSource = []
for name in self.signal_names:
setattr(self, name, {})
self._cachedDocuments = {}
self.infoBox = gui.vBox(self.controlArea, 'Info')
gui.label(
self.infoBox, self,
"<p>Execute python script.</p><p>Input variables:<ul><li> " +
"<li>".join(map("in_{0}, in_{0}s".format, self.signal_names)) +
"</ul></p><p>Output variables:<ul><li>" +
"<li>".join(map("out_{0}".format, self.signal_names)) +
"</ul></p>")
self.libraryList = itemmodels.PyListModel(
[],
self,
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.libraryList.wrap(self.libraryListSource)
self.controlBox = gui.vBox(self.controlArea, 'Library')
self.controlBox.layout().setSpacing(1)
self.libraryView = QListView(
editTriggers=QListView.DoubleClicked | QListView.EditKeyPressed,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Preferred))
self.libraryView.setItemDelegate(ScriptItemDelegate(self))
self.libraryView.setModel(self.libraryList)
self.libraryView.selectionModel().selectionChanged.connect(
self.onSelectedScriptChanged)
self.controlBox.layout().addWidget(self.libraryView)
w = itemmodels.ModelActionsWidget()
self.addNewScriptAction = action = QAction("+", self)
action.setToolTip("Add a new script to the library")
action.triggered.connect(self.onAddScript)
w.addAction(action)
action = QAction(unicodedata.lookup("MINUS SIGN"), self)
action.setToolTip("Remove script from library")
action.triggered.connect(self.onRemoveScript)
w.addAction(action)
action = QAction("Update", self)
action.setToolTip("Save changes in the editor to library")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.triggered.connect(self.commitChangesToLibrary)
w.addAction(action)
action = QAction("More", self, toolTip="More actions")
new_from_file = QAction("Import Script from File", self)
save_to_file = QAction("Save Selected Script to File", self)
restore_saved = QAction("Undo Changes to Selected Script", self)
save_to_file.setShortcut(QKeySequence(QKeySequence.SaveAs))
new_from_file.triggered.connect(self.onAddScriptFromFile)
save_to_file.triggered.connect(self.saveScript)
restore_saved.triggered.connect(self.restoreSaved)
menu = QMenu(w)
menu.addAction(new_from_file)
menu.addAction(save_to_file)
menu.addAction(restore_saved)
action.setMenu(menu)
button = w.addAction(action)
button.setPopupMode(QToolButton.InstantPopup)
w.layout().setSpacing(1)
self.controlBox.layout().addWidget(w)
self.execute_button = gui.button(self.controlArea,
self,
'Run',
callback=self.commit)
run = QAction("Run script",
self,
triggered=self.commit,
shortcut=QKeySequence(Qt.ControlModifier | Qt.Key_R))
self.addAction(run)
self.splitCanvas = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(self.splitCanvas)
self.defaultFont = defaultFont = \
"Monaco" if sys.platform == "darwin" else "Courier"
self.textBox = gui.vBox(self, 'Python Script')
self.splitCanvas.addWidget(self.textBox)
self.text = PythonScriptEditor(self)
self.textBox.layout().addWidget(self.text)
self.textBox.setAlignment(Qt.AlignVCenter)
self.text.setTabStopWidth(4)
self.text.modificationChanged[bool].connect(self.onModificationChanged)
self.saveAction = action = QAction("&Save", self.text)
action.setToolTip("Save script to file")
action.setShortcut(QKeySequence(QKeySequence.Save))
action.setShortcutContext(Qt.WidgetWithChildrenShortcut)
action.triggered.connect(self.saveScript)
self.consoleBox = gui.vBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole({}, self)
self.consoleBox.layout().addWidget(self.console)
self.console.document().setDefaultFont(QFont(defaultFont))
self.consoleBox.setAlignment(Qt.AlignBottom)
self.console.setTabStopWidth(4)
self.splitCanvas.setSizes([2, 1])
self.setAcceptDrops(True)
self.controlArea.layout().addStretch(10)
self._restoreState()
self.settingsAboutToBePacked.connect(self._saveState)
class OWPredictions(OWWidget):
name = "Predictions"
icon = "icons/Predictions.svg"
priority = 200
description = "Display the predictions of models for an input dataset."
keywords = []
class Inputs:
data = Input("Data", Orange.data.Table)
predictors = Input("Predictors", Model, multiple=True)
class Outputs:
predictions = Output("Predictions", Orange.data.Table)
evaluation_results = Output("Evaluation Results",
Orange.evaluation.Results,
dynamic=False)
class Warning(OWWidget.Warning):
empty_data = Msg("Empty dataset")
class Error(OWWidget.Error):
predictor_failed = \
Msg("One or more predictors failed (see more...)\n{}")
predictors_target_mismatch = \
Msg("Predictors do not have the same target.")
data_target_mismatch = \
Msg("Data does not have the same target as predictors.")
settingsHandler = settings.ClassValuesContextHandler()
#: Display the full input dataset or only the target variable columns (if
#: available)
show_attrs = settings.Setting(True)
#: Show predicted values (for discrete target variable)
show_predictions = settings.Setting(True)
#: Show predictions probabilities (for discrete target variable)
show_probabilities = settings.Setting(True)
#: List of selected class value indices in the "Show probabilities" list
selected_classes = settings.ContextSetting([])
#: Draw colored distribution bars
draw_dist = settings.Setting(True)
output_attrs = settings.Setting(True)
output_predictions = settings.Setting(True)
output_probabilities = settings.Setting(True)
def __init__(self):
super().__init__()
#: Input data table
self.data = None # type: Optional[Orange.data.Table]
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict() # type: Dict[object, PredictorSlot]
#: A class variable (prediction target)
self.class_var = None # type: Optional[Orange.data.Variable]
#: List of (discrete) class variable's values
self.class_values = [] # type: List[str]
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input.\nPredictors: 0\nTask: N/A")
self.infolabel.setMinimumWidth(150)
gui.button(box, self, "Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
self.classification_options = box = gui.vBox(
self.controlArea, "Show", spacing=-1, addSpace=False)
gui.checkBox(box, self, "show_predictions", "Predicted class",
callback=self._update_prediction_delegate)
b = gui.checkBox(box, self, "show_probabilities",
"Predicted probabilities for:",
callback=self._update_prediction_delegate)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(b),
addSpace=False)
gui.listBox(ibox, self, "selected_classes", "class_values",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.MultiSelection,
addSpace=False)
gui.checkBox(box, self, "draw_dist", "Draw distribution bars",
callback=self._update_prediction_delegate)
box = gui.vBox(self.controlArea, "Data View")
gui.checkBox(box, self, "show_attrs", "Show full dataset",
callback=self._update_column_visibility)
box = gui.vBox(self.controlArea, "Output", spacing=-1)
self.checkbox_class = gui.checkBox(
box, self, "output_attrs", "Original data",
callback=self.commit)
self.checkbox_class = gui.checkBox(
box, self, "output_predictions", "Predictions",
callback=self.commit)
self.checkbox_prob = gui.checkBox(
box, self, "output_probabilities", "Probabilities",
callback=self.commit)
gui.rubber(self.controlArea)
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2,
)
self.dataview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus
)
self.predictionsview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus,
sortingEnabled=True,
)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size:
self.predictionsview.verticalHeader().resizeSection(index, size)
)
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.mainArea.layout().addWidget(self.splitter)
@Inputs.data
@check_sql_input
def set_data(self, data):
"""Set the input dataset"""
if data is not None and not len(data):
data = None
self.Warning.empty_data()
else:
self.Warning.empty_data.clear()
self.data = data
if data is None:
self.dataview.setModel(None)
self.predictionsview.setModel(None)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
else:
# force full reset of the view's HeaderView state
self.dataview.setModel(None)
model = TableModel(data, parent=None)
modelproxy = TableSortProxyModel()
modelproxy.setSourceModel(model)
self.dataview.setModel(modelproxy)
self._update_column_visibility()
self._invalidate_predictions()
@Inputs.predictors
def set_predictor(self, predictor=None, id=None):
if id in self.predictors:
if predictor is not None:
self.predictors[id] = self.predictors[id]._replace(
predictor=predictor, name=predictor.name, results=None)
else:
del self.predictors[id]
elif predictor is not None:
self.predictors[id] = \
PredictorSlot(predictor, predictor.name, None)
def set_class_var(self):
pred_classes = set(pred.predictor.domain.class_var
for pred in self.predictors.values())
self.Error.predictors_target_mismatch.clear()
self.Error.data_target_mismatch.clear()
self.class_var = None
if len(pred_classes) > 1:
self.Error.predictors_target_mismatch()
if len(pred_classes) == 1:
self.class_var = pred_classes.pop()
if self.data is not None and \
self.data.domain.class_var is not None and \
self.class_var != self.data.domain.class_var:
self.Error.data_target_mismatch()
self.class_var = None
discrete_class = self.class_var is not None \
and self.class_var.is_discrete
self.classification_options.setVisible(discrete_class)
self.closeContext()
if discrete_class:
self.class_values = list(self.class_var.values)
self.selected_classes = list(range(len(self.class_values)))
self.openContext(self.class_var)
else:
self.class_values = []
self.selected_classes = []
def handleNewSignals(self):
self.set_class_var()
if self.data is not None:
self._call_predictors()
self._update_predictions_model()
self._update_prediction_delegate()
self._set_errors()
self._update_info()
self.commit()
def _call_predictors(self):
for inputid, pred in self.predictors.items():
if pred.results is None \
or isinstance(pred.results, str) \
or numpy.isnan(pred.results[0]).all():
try:
results = self.predict(pred.predictor, self.data)
except (ValueError, DomainTransformationError) as err:
results = "{}: {}".format(pred.predictor.name, err)
self.predictors[inputid] = pred._replace(results=results)
def _set_errors(self):
errors = "\n".join(p.results for p in self.predictors.values()
if isinstance(p.results, str))
if errors:
self.Error.predictor_failed(errors)
else:
self.Error.predictor_failed.clear()
def _update_info(self):
info = []
if self.data is not None:
info.append("Data: {} instances.".format(len(self.data)))
else:
info.append("Data: N/A")
n_predictors = len(self.predictors)
n_valid = len(self._valid_predictors())
if n_valid != n_predictors:
info.append("Predictors: {} (+ {} failed)".format(
n_valid, n_predictors - n_valid))
else:
info.append("Predictors: {}".format(n_predictors or "N/A"))
if self.class_var is None:
info.append("Task: N/A")
elif self.class_var.is_discrete:
info.append("Task: Classification")
self.checkbox_class.setEnabled(True)
self.checkbox_prob.setEnabled(True)
else:
info.append("Task: Regression")
self.checkbox_class.setEnabled(False)
self.checkbox_prob.setEnabled(False)
self.infolabel.setText("\n".join(info))
def _invalidate_predictions(self):
for inputid, pred in list(self.predictors.items()):
self.predictors[inputid] = pred._replace(results=None)
def _valid_predictors(self):
if self.class_var is not None and \
self.data is not None:
return [p for p in self.predictors.values()
if p.results is not None and not isinstance(p.results, str)]
else:
return []
def _update_predictions_model(self):
"""Update the prediction view model."""
if self.data is not None and self.class_var is not None:
slots = self._valid_predictors()
results = []
class_var = self.class_var
for p in slots:
values, prob = p.results
if self.class_var.is_discrete:
# if values were added to class_var between building the
# model and predicting, add zeros for new class values,
# which are always at the end
prob = numpy.c_[
prob,
numpy.zeros((prob.shape[0], len(class_var.values) - prob.shape[1]))]
values = [Value(class_var, v) for v in values]
results.append((values, prob))
results = list(zip(*(zip(*res) for res in results)))
headers = [p.name for p in slots]
model = PredictionsModel(results, headers)
else:
model = None
predmodel = PredictionsSortProxyModel()
predmodel.setSourceModel(model)
predmodel.setDynamicSortFilter(True)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.predictionsview.setModel(predmodel)
hheader = self.predictionsview.horizontalHeader()
hheader.setSortIndicatorShown(False)
# SortFilterProxyModel is slow due to large abstraction overhead
# (every comparison triggers multiple `model.index(...)`,
# model.rowCount(...), `model.parent`, ... calls)
hheader.setSectionsClickable(predmodel.rowCount() < 20000)
predmodel.layoutChanged.connect(self._update_data_sort_order)
self._update_data_sort_order()
self.predictionsview.resizeColumnsToContents()
def _update_column_visibility(self):
"""Update data column visibility."""
if self.data is not None and self.class_var is not None:
domain = self.data.domain
first_attr = len(domain.class_vars) + len(domain.metas)
for i in range(first_attr, first_attr + len(domain.attributes)):
self.dataview.setColumnHidden(i, not self.show_attrs)
if domain.class_var:
self.dataview.setColumnHidden(0, False)
def _update_data_sort_order(self):
"""Update data row order to match the current predictions view order"""
datamodel = self.dataview.model() # data model proxy
predmodel = self.predictionsview.model() # predictions model proxy
sortindicatorshown = False
if datamodel is not None:
assert isinstance(datamodel, TableSortProxyModel)
n = datamodel.rowCount()
if predmodel is not None and predmodel.sortColumn() >= 0:
sortind = numpy.argsort(
[predmodel.mapToSource(predmodel.index(i, 0)).row()
for i in range(n)])
sortind = numpy.array(sortind, numpy.int)
sortindicatorshown = True
else:
sortind = None
datamodel.setSortIndices(sortind)
self.predictionsview.horizontalHeader() \
.setSortIndicatorShown(sortindicatorshown)
def _reset_order(self):
"""Reset the row sorting to original input order."""
datamodel = self.dataview.model()
predmodel = self.predictionsview.model()
if datamodel is not None:
datamodel.sort(-1)
if predmodel is not None:
predmodel.sort(-1)
self.predictionsview.horizontalHeader().setSortIndicatorShown(False)
def _update_prediction_delegate(self):
"""Update the predicted probability visibility state"""
if self.class_var is not None:
delegate = PredictionsItemDelegate()
if self.class_var.is_continuous:
self._setup_delegate_continuous(delegate)
else:
self._setup_delegate_discrete(delegate)
proxy = self.predictionsview.model()
if proxy is not None:
proxy.setProbInd(
numpy.array(self.selected_classes, dtype=int))
self.predictionsview.setItemDelegate(delegate)
self.predictionsview.resizeColumnsToContents()
self._update_spliter()
def _setup_delegate_discrete(self, delegate):
colors = [QtGui.QColor(*rgb) for rgb in self.class_var.colors]
fmt = []
if self.show_probabilities:
fmt.append(" : ".join("{{dist[{}]:.2f}}".format(i)
for i in sorted(self.selected_classes)))
if self.show_predictions:
fmt.append("{value!s}")
delegate.setFormat(" \N{RIGHTWARDS ARROW} ".join(fmt))
if self.draw_dist and colors is not None:
delegate.setColors(colors)
return delegate
def _setup_delegate_continuous(self, delegate):
delegate.setFormat("{{value:{}}}".format(self.class_var.format_str[1:]))
def _update_spliter(self):
if self.data is None:
return
def width(view):
h_header = view.horizontalHeader()
v_header = view.verticalHeader()
return h_header.length() + v_header.width()
w = width(self.predictionsview) + 4
w1, w2 = self.splitter.sizes()
self.splitter.setSizes([w, w1 + w2 - w])
def commit(self):
self._commit_predictions()
self._commit_evaluation_results()
def _commit_evaluation_results(self):
slots = self._valid_predictors()
if not slots or self.data.domain.class_var is None:
self.Outputs.evaluation_results.send(None)
return
class_var = self.class_var
nanmask = numpy.isnan(self.data.get_column_view(class_var)[0])
data = self.data[~nanmask]
N = len(data)
results = Orange.evaluation.Results(data, store_data=True)
results.folds = None
results.row_indices = numpy.arange(N)
results.actual = data.Y.ravel()
results.predicted = numpy.vstack(
tuple(p.results[0][~nanmask] for p in slots))
if class_var and class_var.is_discrete:
results.probabilities = numpy.array(
[p.results[1][~nanmask] for p in slots])
results.learner_names = [p.name for p in slots]
self.Outputs.evaluation_results.send(results)
def _commit_predictions(self):
slots = self._valid_predictors()
if not slots:
self.Outputs.predictions.send(None)
return
if self.class_var and self.class_var.is_discrete:
newmetas, newcolumns = self._classification_output_columns()
else:
newmetas, newcolumns = self._regression_output_columns()
attrs = list(self.data.domain.attributes) if self.output_attrs else []
metas = list(self.data.domain.metas) + newmetas
domain = \
Orange.data.Domain(attrs, self.data.domain.class_var, metas=metas)
predictions = self.data.transform(domain)
if newcolumns:
newcolumns = numpy.hstack(
[numpy.atleast_2d(cols) for cols in newcolumns])
predictions.metas[:, -newcolumns.shape[1]:] = newcolumns
self.Outputs.predictions.send(predictions)
def _classification_output_columns(self):
newmetas = []
newcolumns = []
slots = self._valid_predictors()
if self.output_predictions:
newmetas += [DiscreteVariable(name=p.name, values=self.class_values)
for p in slots]
newcolumns += [p.results[0].reshape((-1, 1)) for p in slots]
if self.output_probabilities:
newmetas += [ContinuousVariable(name="%s (%s)" % (p.name, value))
for p in slots for value in self.class_values]
newcolumns += [p.results[1] for p in slots]
return newmetas, newcolumns
def _regression_output_columns(self):
slots = self._valid_predictors()
newmetas = [ContinuousVariable(name=p.name) for p in slots]
newcolumns = [p.results[0].reshape((-1, 1)) for p in slots]
return newmetas, newcolumns
def send_report(self):
def merge_data_with_predictions():
data_model = self.dataview.model()
predictions_model = self.predictionsview.model()
# use ItemDelegate to style prediction values
style = lambda x: self.predictionsview.itemDelegate().displayText(x, QLocale())
# iterate only over visible columns of data's QTableView
iter_data_cols = list(filter(lambda x: not self.dataview.isColumnHidden(x),
range(data_model.columnCount())))
# print header
yield [''] + \
[predictions_model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
for col in range(predictions_model.columnCount())] + \
[data_model.headerData(col, Qt.Horizontal, Qt.DisplayRole)
for col in iter_data_cols]
# print data & predictions
for i in range(data_model.rowCount()):
yield [data_model.headerData(i, Qt.Vertical, Qt.DisplayRole)] + \
[style(predictions_model.data(predictions_model.index(i, j)))
for j in range(predictions_model.columnCount())] + \
[data_model.data(data_model.index(i, j))
for j in iter_data_cols]
if self.data is not None and self.class_var is not None:
text = self.infolabel.text().replace('\n', '<br>')
if self.show_probabilities and self.selected_classes:
text += '<br>Showing probabilities for: '
text += ', '. join([self.class_values[i]
for i in self.selected_classes])
self.report_paragraph('Info', text)
self.report_table("Data & Predictions", merge_data_with_predictions(),
header_rows=1, header_columns=1)
@classmethod
def predict(cls, predictor, data):
class_var = predictor.domain.class_var
if class_var:
if class_var.is_discrete:
return cls.predict_discrete(predictor, data)
elif class_var.is_continuous:
return cls.predict_continuous(predictor, data)
@staticmethod
def predict_discrete(predictor, data):
return predictor(data, Model.ValueProbs)
@staticmethod
def predict_continuous(predictor, data):
values = predictor(data, Model.Value)
return values, [None] * len(data)
