def _create_layout(self):
info = gui.widgetBox(self.controlArea, 'Info')
gui.label(info, self, '%(n_object_types)d object types')
gui.label(info, self, '%(n_relations)d relations')
# Table view of relation details
info = gui.widgetBox(self.controlArea, 'Relations')
def send_relation(item):
data = item.data(QtCore.Qt.UserRole)
self.send(Output.RELATION, Relation(data))
self.table = SimpleTableWidget(info, callback=send_relation)
self.controlArea.layout().addStretch(1)
gui.lineEdit(self.controlArea,
self, 'pref_algo_name', 'Fuser name',
callback=self.checkcommit, enterPlaceholder=True)
gui.radioButtons(self.controlArea,
self, 'pref_algorithm', [i[0] for i in DECOMPOSITION_ALGO],
box='Decomposition algorithm',
callback=self.checkcommit)
gui.radioButtons(self.controlArea,
self, 'pref_initialization', INITIALIZATION_ALGO,
box='Initialization algorithm',
callback=self.checkcommit)
gui.hSlider(self.controlArea, self, 'pref_n_iterations',
'Maximum number of iterations',
minValue=10, maxValue=500, createLabel=True,
callback=self.checkcommit)
self.slider_rank = gui.hSlider(self.controlArea, self, 'pref_rank',
'Factorization rank',
minValue=1, maxValue=100, createLabel=True,
labelFormat=" %d%%",
callback=self.checkcommit)
gui.auto_commit(self.controlArea, self, "autorun", "Run",
checkbox_label="Run after any change ")
def __init__(self):
super().__init__()
self.corpus = None
self.learning_thread = None
# Commit button
gui.auto_commit(self.buttonsArea, self, 'autocommit', 'Commit', box=False)
button_group = QButtonGroup(self, exclusive=True)
button_group.buttonClicked[int].connect(self.change_method)
self.widgets = []
method_layout = QVBoxLayout()
self.controlArea.layout().addLayout(method_layout)
for i, (method, attr_name) in enumerate(self.methods):
widget = method(self, title='Options')
widget.setFixedWidth(self.control_area_width)
widget.valueChanged.connect(self.commit)
self.widgets.append(widget)
setattr(self, attr_name, widget)
rb = QRadioButton(text=widget.Model.name)
button_group.addButton(rb, i)
method_layout.addWidget(rb)
method_layout.addWidget(widget)
button_group.button(self.method_index).setChecked(True)
self.toggle_widgets()
method_layout.addStretch()
# Topics description
self.topic_desc = TopicViewer()
self.topic_desc.topicSelected.connect(self.send_topic_by_id)
self.mainArea.layout().addWidget(self.topic_desc)
self.topic_desc.setFocus()
def __init__(self):
super().__init__()
self.data_points_interpolate = None
dbox = gui.widgetBox(self.controlArea, "Interpolation")
rbox = gui.radioButtons(
dbox, self, "input_radio", callback=self._change_input)
gui.appendRadioButton(rbox, "Enable automatic interpolation")
gui.appendRadioButton(rbox, "Linear interval")
ibox = gui.indentedBox(rbox)
form = QWidget()
formlayout = QFormLayout()
form.setLayout(formlayout)
ibox.layout().addWidget(form)
self.xmin_edit = lineEditFloatOrNone(ibox, self, "xmin", callback=self.commit)
formlayout.addRow("Min", self.xmin_edit)
self.xmax_edit = lineEditFloatOrNone(ibox, self, "xmax", callback=self.commit)
formlayout.addRow("Max", self.xmax_edit)
self.dx_edit = lineEditFloatOrNone(ibox, self, "dx", callback=self.commit)
formlayout.addRow("Δ", self.dx_edit)
gui.appendRadioButton(rbox, "Reference data")
self.data = None
gui.auto_commit(self.controlArea, self, "autocommit", "Interpolate")
self._change_input()
def __init__(self):
super().__init__()
self.data = None
self.input_vars = ()
self._invalidated = False
box = gui.vBox(self.controlArea, "Domain Features")
self.domain_model = itemmodels.VariableListModel()
self.domain_view = QListView(
selectionMode=QListView.SingleSelection
)
self.domain_view.setModel(self.domain_model)
self.domain_view.selectionModel().selectionChanged.connect(
self._on_selection_changed)
box.layout().addWidget(self.domain_view)
box = gui.hBox(self.controlArea)
gui.button(box, self, "Reset Selected", callback=self.reset_selected)
gui.button(box, self, "Reset All", callback=self.reset_all)
gui.auto_commit(self.controlArea, self, "autocommit", "Apply")
box = gui.vBox(self.mainArea, "Edit")
self.editor_stack = QStackedWidget()
self.editor_stack.addWidget(DiscreteVariableEditor())
self.editor_stack.addWidget(ContinuousVariableEditor())
self.editor_stack.addWidget(VariableEditor())
box.layout().addWidget(self.editor_stack)
def __init__(self):
super().__init__()
self.net = None
self.method = 0
self.iterationHistory = 0
self.autoApply = 0
self.iterations = 1000
self.hop_attenuation = 0.1
commit = lambda: self.commit()
gui.spin(self.controlArea, self, "iterations", 1,
100000, 1, label="Iterations: ",
callback=commit)
ribg = gui.radioButtonsInBox(
self.controlArea, self, "method",
btnLabels=["Label propagation clustering (Raghavan et al., 2007)",
"Label propagation clustering (Leung et al., 2009)"],
label="Method", callback=commit)
gui.doubleSpin(gui.indentedBox(ribg), self, "hop_attenuation",
0, 1, 0.01, label="Hop attenuation (delta): ")
self.info = gui.widgetLabel(self.controlArea, ' ')
gui.checkBox(self.controlArea, self, "iterationHistory",
"Append clustering data on each iteration",
callback=commit)
gui.auto_commit(self.controlArea, self, "autoApply", 'Commit',
checkbox_label='Auto-commit')
commit()
def __init__(self):
super().__init__()
self.corpus = None
# Info box.
info_box = gui.widgetBox(
self.controlArea,
'Info',
)
bow_info = 'No info available.'
self.info_label = gui.label(info_box, self, bow_info)
# TF-IDF.
tfidf_box = gui.widgetBox(
self.controlArea,
'Settings',
)
self.tfidf_checkbox = gui.checkBox(
tfidf_box,
self,
'use_tfidf',
'Use TF-IDF'
)
self.tfidf_checkbox.stateChanged.connect(self.tfidf_changed)
gui.auto_commit(
self.controlArea,
self,
'autocommit',
'Commit',
box=False
)
def __init__(self):
super().__init__()
self.data = None
self.db = None
box = gui.widgetBox(self.controlArea, "Parameters")
gui.spin(box, self, "min_samples", 1, 100, 1, callback=self._invalidate,
label="Core point neighbors")
gui.doubleSpin(box, self, "eps", 0.1, 0.9, 0.1,
callback=self._invalidate,
label="Neighborhood distance")
box = gui.widgetBox(self.controlArea, self.tr("Distance Metric"))
gui.comboBox(box, self, "metric_idx",
items=list(zip(*self.METRICS))[0],
callback=self._invalidate)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box, self, "place_cluster_ids",
label="Append cluster id as ", orientation="horizontal",
callback=self.send_data, items=self.OUTPUT_METHODS)
gui.lineEdit(box, self, "output_name",
label="Name: ", orientation="horizontal",
callback=self.send_data)
gui.auto_commit(self.controlArea, self, "auto_run", "Run",
checkbox_label="Run after any change ",
orientation="horizontal")
gui.rubber(self.controlArea)
self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width())
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self):
hbox = gui.hBox(self.controlArea)
_properties = dict(alternatingRowColors=True,
defaultDropAction=Qt.MoveAction,
dragDropMode=QListView.DragDrop,
dragEnabled=True,
selectionMode=QListView.ExtendedSelection,
selectionBehavior=QListView.SelectRows,
showDropIndicator=True,
acceptDrops=True)
listview_avail = DnDListView(lambda: self.commit(), self, **_properties)
self.model_avail = model = VariableListModel(parent=self, enable_dnd=True)
listview_avail.setModel(model)
listview_key = DnDListView(lambda: self.commit(), self, **_properties)
self.model_key = model = VariableListModel(parent=self, enable_dnd=True)
listview_key.setModel(model)
box = gui.vBox(hbox, 'Available Variables')
box.layout().addWidget(listview_avail)
box = gui.vBox(hbox, 'Group-By Key')
box.layout().addWidget(listview_key)
gui.comboBox(self.controlArea, self, 'tiebreaker',
label='Which instance to select in each group:',
items=tuple(self.TIEBREAKERS.keys()),
callback=lambda: self.commit(),
sendSelectedValue=True)
gui.auto_commit(self.controlArea, self, 'autocommit', 'Commit',
orientation=Qt.Horizontal)
def __init__(self):
super().__init__()
box = gui.vBox(self.controlArea, "Multinomial Attributes")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Continuous Attributes")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.vBox(self.controlArea, "Discrete Class Attribute")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.vBox(self.controlArea, "Value Range")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_commit(self.buttonsArea, self, "autosend", "Apply", box=False)
self.data = None
def __init__(self):
self.data = None
box = gui.vBox(self.controlArea, 'Differencing')
self.order_spin = gui.spin(
box, self, 'diff_order', 1, 2,
label='Differencing order:',
callback=self.on_changed,
tooltip='The value corresponds to n-th order numerical '
'derivative of the series. \nThe order is fixed to 1 '
'if the shift period is other than 1.')
gui.spin(box, self, 'shift_period', 1, 100,
label='Shift:',
callback=self.on_changed,
tooltip='Set this to other than 1 if you don\'t want to '
'compute differences for subsequent values but for '
'values shifted number of spaces apart. \n'
'If this value is different from 1, differencing '
'order is fixed to 1.')
gui.checkBox(box, self, 'invert_direction',
label='Invert differencing direction',
callback=self.on_changed,
tooltip='Influences where the series is padded with nan '
'values — at the beginning or at the end.')
self.view = view = QListView(self,
selectionMode=QListView.ExtendedSelection)
self.model = model = VariableListModel(parent=self)
view.setModel(model)
view.selectionModel().selectionChanged.connect(self.on_changed)
box.layout().addWidget(view)
gui.auto_commit(box, self, 'autocommit', '&Apply')
def __init__(self):
super().__init__()
self.data = None
self.set_data(self.data) # show warning
gui.auto_commit(self.controlArea, self, "autocommit", "Apply")
def _add_controls(self):
infobox = gui.widgetBox(self.controlArea, "Info")
self.infoLabel = gui.widgetLabel(infobox, "No data on input.")
displaybox = gui.widgetBox(self.controlArea, "Display")
gui.checkBox(displaybox, self, "show_profiles", "Lines",
callback=self.__show_profiles_changed,
tooltip="Plot lines")
gui.checkBox(displaybox, self, "show_range", "Range",
callback=self.__show_range_changed,
tooltip="Plot range between 10th and 90th percentile")
gui.checkBox(displaybox, self, "show_mean", "Mean",
callback=self.__show_mean_changed,
tooltip="Plot mean curve")
gui.checkBox(displaybox, self, "show_error", "Error bars",
callback=self.__show_error_changed,
tooltip="Show standard deviation")
self.group_vars = DomainModel(
placeholder="None", separators=False, valid_types=DiscreteVariable)
self.group_view = gui.listView(
self.controlArea, self, "group_var", box="Group by",
model=self.group_vars, callback=self.__group_var_changed)
self.group_view.setEnabled(False)
self.group_view.setMinimumSize(QSize(30, 100))
self.group_view.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Ignored)
plot_gui = OWPlotGUI(self)
plot_gui.box_zoom_select(self.controlArea)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selection", "Send Automatically")
def _create_layout(self):
self.mainArea.layout().addWidget(self.graphview)
info = gui.widgetBox(self.controlArea, 'Info')
gui.label(info, self, '%(n_object_types)d object types')
gui.label(info, self, '%(n_relations)d relations')
# Table view of relation details
info = gui.widgetBox(self.controlArea, 'Relations')
class TableView(gui.TableView):
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self._parent = parent
self.bold_font = self.BoldFontDelegate(self) # member because PyQt sometimes unrefs too early
self.setItemDelegateForColumn(2, self.bold_font)
self.setItemDelegateForColumn(4, self.bold_font)
self.horizontalHeader().setVisible(False)
def selectionChanged(self, selected, deselected):
super().selectionChanged(selected, deselected)
if not selected:
assert len(deselected) > 0
relation = None
else:
assert len(selected) == 1
data = self._parent.tablemodel[selected[0].top()][0]
relation = Relation(data)
self._parent.send(Output.RELATION, relation)
model = self.tablemodel = PyTableModel(parent=self)
table = self.table = TableView(self,
selectionMode=TableView.SingleSelection)
table.setModel(model)
info.layout().addWidget(self.table)
gui.lineEdit(self.controlArea,
self, 'pref_algo_name', 'Fuser name:',
orientation='horizontal',
callback=self.checkcommit, enterPlaceholder=True)
gui.radioButtons(self.controlArea,
self, 'pref_algorithm', [i[0] for i in DECOMPOSITION_ALGO],
box='Decomposition algorithm',
callback=self.checkcommit)
gui.radioButtons(self.controlArea,
self, 'pref_initialization', INITIALIZATION_ALGO,
box='Initialization algorithm',
callback=self.checkcommit)
slider = gui.hSlider(
self.controlArea, self, 'pref_n_iterations',
'Maximum number of iterations',
minValue=10, maxValue=500, createLabel=True,
callback=self.checkcommit)
slider.setTracking(False)
self.slider_rank = gui.hSlider(self.controlArea, self, 'pref_rank',
'Factorization rank',
minValue=1, maxValue=100, createLabel=True,
labelFormat=" %d%%",
callback=self.checkcommit)
self.slider_rank.setTracking(False)
gui.auto_commit(self.controlArea, self, "autorun", "Run",
checkbox_label="Run after any change ")
def __init__(self):
super().__init__()
self.data = None
gui.radioButtons(self.controlArea, self, "axis", ["Rows", "Columns"],
box="Distances between", callback=self._invalidate
)
box = gui.widgetBox(self.controlArea, "Distance Metric")
self.metrics_combo = gui.comboBox(
box, self, "metric_idx",
items=[m[0] for m in METRICS],
callback=self._metric_changed
)
self.normalization_check = gui.checkBox(
box, self, "normalized_dist", "Normalized",
callback=self._invalidate,
tooltip=("All dimensions are (implicitly) scaled to a common"
"scale to normalize the influence across the domain.")
)
_, metric = METRICS[self.metric_idx]
self.normalization_check.setEnabled(metric.supports_normalization)
gui.auto_commit(self.controlArea, self, "autocommit", "Apply")
self.layout().setSizeConstraint(self.layout().SetFixedSize)
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
box = gui.widgetBox(self.controlArea, "Multinomial attributes")
gui.radioButtonsInBox(
box, self, "multinomial_treatment",
btnLabels=[x[0] for x in self.multinomial_treats],
callback=self.settings_changed)
box = gui.widgetBox(self.controlArea, "Continuous attributes")
gui.radioButtonsInBox(
box, self, "continuous_treatment",
btnLabels=[x[0] for x in self.continuous_treats],
callback=self.settings_changed)
box = gui.widgetBox(self.controlArea, "Discrete class attribute")
gui.radioButtonsInBox(
box, self, "class_treatment",
btnLabels=[t[0] for t in self.class_treats],
callback=self.settings_changed)
zbbox = gui.widgetBox(self.controlArea, "Value range")
gui.radioButtonsInBox(
zbbox, self, "zero_based",
btnLabels=self.value_ranges,
callback=self.settings_changed)
gui.auto_commit(self.controlArea, self, "autosend", "Apply")
self.data = None
self.resize(150, 300)
def __init__(self):
super().__init__()
self.data = None
self._effective_data = None
self._matrix = None
self._silhouette = None
self._labels = None
self._silplot = None
gui.comboBox(
self.controlArea, self, "distance_idx", box="Distance",
items=[name for name, _ in OWSilhouettePlot.Distances],
orientation=Qt.Horizontal, callback=self._invalidate_distances)
box = gui.vBox(self.controlArea, "Cluster Label")
self.cluster_var_cb = gui.comboBox(
box, self, "cluster_var_idx", addSpace=4,
callback=self._invalidate_scores)
gui.checkBox(
box, self, "group_by_cluster", "Group by cluster",
callback=self._replot)
self.cluster_var_model = itemmodels.VariableListModel(parent=self)
self.cluster_var_cb.setModel(self.cluster_var_model)
box = gui.vBox(self.controlArea, "Bars")
gui.widgetLabel(box, "Bar width:")
gui.hSlider(
box, self, "bar_size", minValue=1, maxValue=10, step=1,
callback=self._update_bar_size, addSpace=6)
gui.widgetLabel(box, "Annotations:")
self.annotation_cb = gui.comboBox(
box, self, "annotation_var_idx", callback=self._update_annotations)
self.annotation_var_model = itemmodels.VariableListModel(parent=self)
self.annotation_var_model[:] = ["None"]
self.annotation_cb.setModel(self.annotation_var_model)
ibox = gui.indentedBox(box, 5)
self.ann_hidden_warning = warning = gui.widgetLabel(
ibox, "(increase the width to show)")
ibox.setFixedWidth(ibox.sizeHint().width())
warning.setVisible(False)
gui.rubber(self.controlArea)
gui.separator(self.buttonsArea)
box = gui.vBox(self.buttonsArea, "Output")
# Thunk the call to commit to call conditional commit
gui.checkBox(box, self, "add_scores", "Add silhouette scores",
callback=lambda: self.commit())
gui.auto_commit(
box, self, "auto_commit", "Commit",
auto_label="Auto commit", box=False)
# Ensure that the controlArea is not narrower than buttonsArea
self.controlArea.layout().addWidget(self.buttonsArea)
self.scene = QtGui.QGraphicsScene()
self.view = QtGui.QGraphicsView(self.scene)
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.view.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.mainArea.layout().addWidget(self.view)
def __init__(self):
super().__init__()
self.data = None
self.removedAttrs = "-"
self.reducedAttrs = "-"
self.resortedAttrs = "-"
self.removedClasses = "-"
self.reducedClasses = "-"
self.resortedClasses = "-"
boxAt = gui.vBox(self.controlArea, "Features")
for not_first, (value, label) in enumerate(self.feature_options):
if not_first:
gui.separator(boxAt, 2)
gui.checkBox(boxAt, self, value, label,
callback=self.optionsChanged)
boxAt = gui.vBox(self.controlArea, "Classes", addSpace=True)
for not_first, (value, label) in enumerate(self.class_options):
if not_first:
gui.separator(boxAt, 2)
gui.checkBox(boxAt, self, value, label,
callback=self.optionsChanged)
box3 = gui.vBox(self.controlArea, 'Statistics', addSpace=True)
for label, value in self.stat_labels:
gui.label(box3, self, "{}: %({})s".format(label, value))
gui.auto_commit(self.buttonsArea, self, "autoSend", "Send Data",
checkbox_label="Send automatically",
orientation=Qt.Horizontal)
gui.rubber(self.controlArea)
def __init__(self):
super().__init__()
self.net = None
commit = lambda: self.commit()
gui.spin(self.controlArea, self, "iterations", 1, 100000, 1, label="Max. iterations:", callback=commit)
ribg = gui.radioButtonsInBox(
self.controlArea,
self,
"method",
btnLabels=[
"Label propagation clustering (Raghavan et al., 2007)",
"Label propagation clustering (Leung et al., 2009)",
],
box="Clustering method",
callback=commit,
)
gui.doubleSpin(gui.indentedBox(ribg), self, "hop_attenuation", 0, 1, 0.01, label="Hop attenuation (delta): ")
self.info = gui.widgetLabel(self.controlArea, " ")
gui.auto_commit(self.controlArea, self, "autoApply", "Commit", checkbox_label="Auto-commit")
commit()
def __init__(self):
super().__init__()
self.data = None
self.preprocessors = None
box = gui.widgetBox(self.controlArea, "Learner/Predictor Name")
gui.lineEdit(box, self, "learner_name")
box = gui.widgetBox(self.controlArea, "Regularization")
box = gui.radioButtons(
box, self, "reg_type",
btnLabels=["No regularization", "Ridge regression",
"Lasso regression"],
callback=self._reg_type_changed)
gui.separator(box)
self.alpha_box = box2 = gui.widgetBox(box, margin=0)
gui.widgetLabel(box2, "Regularization strength")
self.alpha_slider = gui.hSlider(
box2, self, "alpha_index",
minValue=0, maxValue=len(self.alphas) - 1,
callback=self._alpha_changed, createLabel=False)
box3 = gui.widgetBox(box, orientation="horizontal")
box3.layout().setAlignment(Qt.AlignCenter)
self.alpha_label = gui.widgetLabel(box3, "")
self._set_alpha_label()
gui.auto_commit(self.controlArea, self, "autosend", "Apply",
checkbox_label="Apply on every change")
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.alpha_slider.setEnabled(self.reg_type != self.OLS)
self.commit()
def __init__(self, parent=None):
super().__init__(parent)
# GUI
box = gui.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoBox = gui.widgetLabel(box, "No data on input.")
box = gui.widgetBox(self.controlArea, "Split by", addSpace=True)
self.groupCombo = gui.comboBox(
box, self, "selectedGroup", callback=self.onGroupSelection)
gui.comboBox(self.controlArea, self, "selectedCenterMethod",
box="Center Fold-change Using",
items=[name for name, _ in self.CENTER_METHODS],
callback=self.onCenterMethodChange,
addSpace=True)
gui.comboBox(self.controlArea, self, "selectedMergeMethod",
box="Merge Replicates",
items=[name for name, _ in self.MERGE_METHODS],
tooltip="Select the method for replicate merging",
callback=self.onMergeMethodChange,
addSpace=True)
box = gui.doubleSpin(self.controlArea, self, "zCutoff", 0.0, 3.0, 0.01,
box="Z-Score Cutoff",
callback=[self.replotMA, self.commitIf])
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Ouput")
gui.checkBox(box, self, "appendZScore", "Append Z-Scores",
tooltip="Append calculated Z-Scores to output",
callback=self.commitIf)
gui.checkBox(box, self, "appendRIValues",
"Append Log Ratio and Intensity values",
tooltip="Append calculated Log Ratio and Intensity "
"values to output data",
callback=self.commitIf)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "autoCommit", "Commit")
self.graph = pg.PlotWidget(background="w")
self.graph.getAxis("bottom").setLabel("Intensity: log<sub>10</sub>(R*G)")
self.graph.getAxis("left").setLabel("Log ratio: log<sub>2</sub>(R/G)")
self.mainArea.layout().addWidget(self.graph)
self.groups = []
self.split_data = None, None
self.merged_splits = None, None
self.centered = None, None
self.changedFlag = False
self.data = None
self._executor = concurrent.ThreadExecutor(
threadPool=QThreadPool(maxThreadCount=1))
def __init__(self, parent=None):
super().__init__(parent)
self.inputs = OrderedDict()
self.dist_color = QtGui.QColor(*self.dist_color_RGB)
info_box = gui.widgetBox(self.controlArea, "Info")
self.info_ex = gui.widgetLabel(info_box, 'No data on input.', )
self.info_ex.setWordWrap(True)
self.info_attr = gui.widgetLabel(info_box, ' ')
self.info_attr.setWordWrap(True)
self.info_class = gui.widgetLabel(info_box, ' ')
self.info_class.setWordWrap(True)
self.info_meta = gui.widgetLabel(info_box, ' ')
self.info_meta.setWordWrap(True)
gui.separator(info_box)
gui.button(info_box, self, "Restore Original Order",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Variables")
self.c_show_attribute_labels = gui.checkBox(
box, self, "show_attribute_labels",
"Show variable labels (if present)",
callback=self._on_show_variable_labels_changed)
gui.checkBox(box, self, "show_distributions",
'Visualize continuous values',
callback=self._on_distribution_color_changed)
gui.checkBox(box, self, "color_by_class", 'Color by instance classes',
callback=self._on_distribution_color_changed)
gui.button(box, self, "Set colors", self.set_colors, autoDefault=False,
tooltip="Set the background color and color palette")
box = gui.widgetBox(self.controlArea, "Selection")
gui.checkBox(box, self, "select_rows", "Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selected Rows", "Auto send is on")
dlg = self.create_color_dialog()
self.discPalette = dlg.getDiscretePalette("discPalette")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
copy = QtGui.QAction("Copy", self, shortcut=QtGui.QKeySequence.Copy,
triggered=self.copy)
self.addAction(copy)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.preRemoveValues = 1
self.preRemoveClasses = 1
self.removedAttrs = "-"
self.reducedAttrs = "-"
self.resortedAttrs = "-"
self.classAttr = "-"
boxAt = gui.widgetBox(self.controlArea, "Attributes")
gui.checkBox(boxAt, self, 'sortValues', 'Sort attribute values',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
rua = gui.checkBox(
boxAt, self, "removeAttributes",
"Remove attributes with less than two values",
callback=self.removeAttributesChanged)
ruv = gui.checkBox(
gui.indentedBox(boxAt, sep=gui.checkButtonOffsetHint(rua)),
self,
"removeValues",
"Remove unused attribute values",
callback=self.optionsChanged
)
rua.disables = [ruv]
rua.makeConsistent()
boxAt = gui.widgetBox(self.controlArea, "Classes", addSpace=True)
gui.checkBox(boxAt, self, 'sortClasses', 'Sort classes',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
rua = gui.checkBox(
boxAt, self, "removeClassAttribute",
"Remove class attribute if there are less than two classes",
callback=self.removeClassesChanged
)
ruv = gui.checkBox(
gui.indentedBox(boxAt, sep=gui.checkButtonOffsetHint(rua)),
self,
"removeClasses",
"Remove unused class values",
callback=self.optionsChanged
)
rua.disables = [ruv]
rua.makeConsistent()
box3 = gui.widgetBox(self.controlArea, 'Statistics', addSpace=True)
gui.label(box3, self, "Removed attributes: %(removedAttrs)s")
gui.label(box3, self, "Reduced attributes: %(reducedAttrs)s")
gui.label(box3, self, "Resorted attributes: %(resortedAttrs)s")
gui.label(box3, self, "Class attribute: %(classAttr)s")
gui.auto_commit(self.controlArea, self, "autoSend", "Send Data",
checkbox_label="Send automatically",
orientation="horizontal")
gui.rubber(self.controlArea)
def __init__(self):
super().__init__()
self.data = None
self.allAttrs = []
self.stringAttrs = []
self.selectedIndices = []
#: List of _ImageItems
self.items = []
self._errcount = 0
self._successcount = 0
self.info = gui.widgetLabel(
gui.vBox(self.controlArea, "Info"),
"Waiting for input.\n"
)
self.imageAttrCB = gui.comboBox(
self.controlArea, self, "imageAttr",
box="Image Filename Attribute",
tooltip="Attribute with image filenames",
callback=[self.clearScene, self.setupScene],
contentsLength=12,
addSpace=True,
)
self.titleAttrCB = gui.comboBox(
self.controlArea, self, "titleAttr",
box="Title Attribute",
tooltip="Attribute with image title",
callback=self.updateTitles,
contentsLength=12,
addSpace=True
)
self.titleAttrCB.setStyleSheet("combobox-popup: 0;")
gui.hSlider(
self.controlArea, self, "imageSize",
box="Image Size", minValue=32, maxValue=1024, step=16,
callback=self.updateSize,
createLabel=False
)
gui.rubber(self.controlArea)
gui.auto_commit(self.buttonsArea, self, "autoCommit", "Send", box=False)
self.thumbnailView = ThumbnailView(
alignment=Qt.AlignTop | Qt.AlignLeft, # scene alignment,
focusPolicy=Qt.StrongFocus,
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn
)
self.mainArea.layout().addWidget(self.thumbnailView)
self.scene = self.thumbnailView.scene()
self.scene.selectionChanged.connect(self.onSelectionChanged)
self.loader = ImageLoader(self)
def __init__(self):
self.data = None
self.indices = []
gui.comboBox(self.controlArea, self, 'agg_interval',
label='Aggregate by:',
items=tuple(self.AGG_TIME.keys()),
sendSelectedValue=True,
orientation=Qt.Horizontal,
callback=self.on_changed,)
self.model = model = PyTableModel(parent=self, editable=[False, True])
model.setHorizontalHeaderLabels(['Attribute', 'Aggregation function'])
class TableView(gui.TableView):
def __init__(self, parent):
super().__init__(parent,
editTriggers=(self.SelectedClicked |
self.CurrentChanged |
self.DoubleClicked |
self.EditKeyPressed),
)
self.horizontalHeader().setStretchLastSection(False)
self.setItemDelegateForColumn(1, self.ComboDelegate(self))
class _ItemDelegate(QStyledItemDelegate):
def updateEditorGeometry(self, widget, option, _index):
widget.setGeometry(option.rect)
class ComboDelegate(_ItemDelegate):
def __init__(self, parent):
super().__init__(parent)
self._parent = parent
self._combo_continuous_model = ListModel(AGG_FUNCTIONS, parent=self)
self._combo_discrete_model = ListModel([Mode], parent=self)
self._combo_string_model = ListModel([Concatenate], parent=self)
def createEditor(self, parent, _QStyleOptionViewItem, index):
combo = QComboBox(parent)
attr = index.model()[index.row()][0]
combo.setModel(self._combo_continuous_model if attr.is_continuous else
self._combo_discrete_model if attr.is_discrete else
self._combo_string_model)
return combo
def setEditorData(self, combo, index):
var = index.model().data(index, Qt.EditRole)
combo.setCurrentIndex(combo.model().indexOf(var))
def setModelData(self, combo, model, index):
func = combo.model()[combo.currentIndex()]
model.setData(index, func, Qt.EditRole)
view = TableView(self)
view.setModel(model)
model.dataChanged.connect(self.on_changed)
self.controlArea.layout().addWidget(view)
gui.auto_commit(self.controlArea, self, 'autocommit', '&Apply')
def _add_controls(self):
self._point_box = self.graph.gui.point_properties_box(self.controlArea)
self._effects_box = self.graph.gui.effects_box(self.controlArea)
self._plot_box = self.graph.gui.plot_properties_box(self.controlArea)
self.control_area_stretch = gui.widgetBox(self.controlArea)
self.control_area_stretch.layout().addStretch(100)
self.graph.box_zoom_select(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selection", "Send Automatically")
def add_bottom_buttons(self):
box = gui.vBox(self.controlArea, 'Forecast')
gui.spin(box, self, 'forecast_steps', 1, 100,
label='Forecast steps ahead:',
callback=self.apply)
gui.hSlider(box, self, 'forecast_confint',
None, 1, 99, label='Confidence intervals:',
callback=self.apply)
gui.auto_commit(self.controlArea, self, 'autocommit', "&Apply")
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
self.data = None
self.data_desc = self.match_desc = self.nonmatch_desc = None
box = gui.widgetBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QtGui.QTableWidget(box)
box.layout().addWidget(self.cond_list)
self.cond_list.setShowGrid(False)
self.cond_list.setSelectionMode(QtGui.QTableWidget.NoSelection)
self.cond_list.setColumnCount(3)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
self.cond_list.resizeColumnToContents(0)
self.cond_list.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.cond_list.viewport().setBackgroundRole(QtGui.QPalette.Window)
box2 = gui.widgetBox(box, orientation="horizontal")
self.add_button = gui.button(box2, self, "Add condition",
callback=self.add_row)
self.add_all_button = gui.button(box2, self, "Add all variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2, self, "Remove all",
callback=self.remove_all)
gui.rubber(box2)
info = gui.widgetBox(self.controlArea, '', orientation="horizontal")
box_data_in = gui.widgetBox(info, 'Data In')
# self.data_in_rows = gui.widgetLabel(box_data_in, " ")
self.data_in_variables = gui.widgetLabel(box_data_in, " ")
gui.rubber(box_data_in)
box_data_out = gui.widgetBox(info, 'Data Out')
self.data_out_rows = gui.widgetLabel(box_data_out, " ")
# self.dataOutAttributesLabel = gui.widgetLabel(box_data_out, " ")
gui.rubber(box_data_out)
box = gui.widgetBox(self.controlArea, orientation="horizontal")
box_setting = gui.widgetBox(box, 'Purging')
self.cb_pa = gui.checkBox(
box_setting, self, "purge_attributes", "Remove unused features",
callback=self.conditions_changed)
gui.separator(box_setting, height=1)
self.cb_pc = gui.checkBox(
box_setting, self, "purge_classes", "Remove unused classes",
callback=self.conditions_changed)
gui.auto_commit(box, self, "auto_commit", label="Commit",
checkbox_label="Commit on change")
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
self.learners_box = gui.listBox(
self.controlArea, self, "selected_learner", "learners", box=True,
callback=self._learner_changed
)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.outputbox, self, "autocommit",
"Send Selected", "Send Automatically", box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox, self, "selected_quantity",
items=self.quantities, label="Show: ",
orientation=Qt.Horizontal, callback=self._update)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
view.clicked.connect(self.cell_clicked)
box.layout().addWidget(view)
selbox = gui.hBox(box)
gui.button(selbox, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(selbox, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(selbox, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
def __init__(self):
self.tree = QTreeWidget(self.mainArea,
columnCount=2,
allColumnsShowFocus=True,
alternatingRowColors=True,
selectionMode=QTreeWidget.ExtendedSelection,
uniformRowHeights=True)
self.tree.setHeaderLabels(["Itemsets", "Support", "%"])
self.tree.header().setStretchLastSection(True)
self.tree.itemSelectionChanged.connect(self.selectionChanged)
self.mainArea.layout().addWidget(self.tree)
box = gui.widgetBox(self.controlArea, "Info")
self.nItemsets = self.nSelectedExamples = self.nSelectedItemsets = ''
gui.label(box, self, "Number of itemsets: %(nItemsets)s")
gui.label(box, self, "Selected itemsets: %(nSelectedItemsets)s")
gui.label(box, self, "Selected examples: %(nSelectedExamples)s")
hbox = gui.widgetBox(box, orientation='horizontal')
gui.button(hbox, self, "Expand all", callback=self.tree.expandAll)
gui.button(hbox, self, "Collapse all", callback=self.tree.collapseAll)
box = gui.widgetBox(self.controlArea, 'Find itemsets')
gui.hSlider(box, self, 'minSupport', minValue=1, maxValue=100,
label='Minimal support:', labelFormat="%d%%",
callback=lambda: self.find_itemsets())
gui.hSlider(box, self, 'maxItemsets', minValue=10000, maxValue=100000, step=10000,
label='Max. number of itemsets:', labelFormat="%d",
callback=lambda: self.find_itemsets())
gui.checkBox(box, self, 'filterSearch',
label='Apply below filters in search',
tooltip='If checked, the itemsets are filtered according '
'to below filter conditions already in the search '
'phase. \nIf unchecked, the only filters applied '
'during search are the ones above, '
'and the itemsets are \nfiltered afterwards only for '
'display, i.e. only the matching itemsets are shown.')
self.button = gui.auto_commit(
box, self, 'autoFind', 'Find itemsets', commit=self.find_itemsets)
box = gui.widgetBox(self.controlArea, 'Filter itemsets')
gui.lineEdit(box, self, 'filterKeywords', 'Contains:',
callback=self.filter_change, orientation='horizontal',
tooltip='A comma or space-separated list of regular '
'expressions.')
hbox = gui.widgetBox(box, orientation='horizontal')
gui.spin(hbox, self, 'filterMinItems', 1, 998, label='Min. items:',
callback=self.filter_change)
gui.spin(hbox, self, 'filterMaxItems', 2, 999, label='Max. items:',
callback=self.filter_change)
gui.rubber(hbox)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, 'autoSend', 'Send selection')
self.filter_change()
def __init__(self):
super().__init__()
if isinstance(self.selected_learner, list):
self.selected_learner = (self.selected_learner + [0])[0]
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Selected", "Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def __init__(self, parent=None):
super().__init__(parent)
# Diagram update is in progress
self._updating = False
# Input update is in progress
self._inputUpdate = False
# All input tables have the same domain.
self.samedomain = True
# Input datasets in the order they were 'connected'.
self.data = OrderedDict()
# Extracted input item sets in the order they were 'connected'
self.itemsets = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, "No data on input\n")
self.identifiersBox = gui.radioButtonsInBox(
self.controlArea, self, "useidentifiers", [],
box="Data Instance Identifiers",
callback=self._on_useidentifiersChanged
)
self.useequalityButton = gui.appendRadioButton(
self.identifiersBox, "Use instance equality"
)
rb = gui.appendRadioButton(
self.identifiersBox, "Use identifiers"
)
self.inputsBox = gui.indentedBox(
self.identifiersBox, sep=gui.checkButtonOffsetHint(rb)
)
self.inputsBox.setEnabled(bool(self.useidentifiers))
for i in range(5):
box = gui.widgetBox(self.inputsBox, "Data set #%i" % (i + 1),
addSpace=False)
box.setFlat(True)
model = itemmodels.VariableListModel(parent=self)
cb = QComboBox()
cb.setModel(model)
cb.activated[int].connect(self._on_inputAttrActivated)
box.setEnabled(False)
# Store the combo in the box for later use.
box.combo_box = cb
box.layout().addWidget(cb)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "autocommit",
"Commit", "Auto commit")
# Main area view
self.scene = QGraphicsScene()
self.view = QGraphicsView(self.scene)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.setBackgroundRole(QPalette.Window)
self.view.setFrameStyle(QGraphicsView.StyledPanel)
self.mainArea.layout().addWidget(self.view)
self.vennwidget = VennDiagram()
self.vennwidget.resize(400, 400)
self.vennwidget.itemTextEdited.connect(self._on_itemTextEdited)
self.scene.selectionChanged.connect(self._on_selectionChanged)
self.scene.addItem(self.vennwidget)
self.resize(self.controlArea.sizeHint().width() + 550,
max(self.controlArea.sizeHint().height(), 550))
self._queue = []
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,
)
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()
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)
def __init__(self):
super().__init__()
self.data = None
self.removedAttrs = "-"
self.reducedAttrs = "-"
self.resortedAttrs = "-"
self.removedClasses = "-"
self.reducedClasses = "-"
self.resortedClasses = "-"
boxAt = gui.widgetBox(self.controlArea, "Features")
gui.checkBox(boxAt,
self,
'sortValues',
'Sort discrete feature values',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeValues",
"Remove unused feature values",
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeAttributes",
"Remove constant features",
callback=self.optionsChanged)
boxAt = gui.widgetBox(self.controlArea, "Classes", addSpace=True)
gui.checkBox(boxAt,
self,
'sortClasses',
'Sort discrete class variable values',
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeClasses",
"Remove unused class variable values",
callback=self.optionsChanged)
gui.separator(boxAt, 2)
gui.checkBox(boxAt,
self,
"removeClassAttribute",
"Remove constant class variables",
callback=self.optionsChanged)
box3 = gui.widgetBox(self.controlArea, 'Statistics', addSpace=True)
gui.label(box3, self, "Removed features: %(removedAttrs)s")
gui.label(box3, self, "Reduced features: %(reducedAttrs)s")
gui.label(box3, self, "Resorted features: %(resortedAttrs)s")
gui.label(box3, self, "Removed classes: %(removedClasses)s")
gui.label(box3, self, "Reduced classes: %(reducedClasses)s")
gui.label(box3, self, "Resorted classes: %(resortedClasses)s")
gui.auto_commit(self.controlArea,
self,
"autoSend",
"Send Data",
checkbox_label="Send automatically ",
orientation="horizontal")
gui.rubber(self.controlArea)
def __init__(self):
super().__init__()
self.data = None
self.source_id = None
self._mas = None
self._Ws = None
self._transformed = None
self._components = None
self._use_genes = None
self._shared_correlations = None
self._transformed_table = None
self._line = False
self._feature_model = DomainModel(valid_types=DiscreteVariable, separators=False)
self._feature_model.set_domain(None)
self._init_mas()
self._legend = None
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
# Data source indicator
box = gui.vBox(self.controlArea, "Data source indicator")
gui.comboBox(
box, self, "source_id", sendSelectedValue=True,
callback=self._update_combo_source_id,
model=self._feature_model,
)
# Canonical correlation analysis
box = gui.vBox(self.controlArea, "Canonical correlation analysis")
gui.spin(
box, self, "ncomponents", 1, MAX_COMPONENTS,
callback=self._update_selection_component_spin,
keyboardTracking=False,
label="Num. of components"
)
# Shared genes
box = gui.vBox(self.controlArea, "Shared genes")
gui.spin(
box, self, "ngenes", 1, MAX_GENES,
callback=self._update_ngenes_spin,
keyboardTracking=False,
)
form.addRow(
"Num. of genes",
self.controls.ngenes
)
gui.comboBox(
box, self, "scoring",
callback=self._update_scoring_combo,
items=list(SCORINGS.keys()), sendSelectedValue=True,
editable=False,
)
form.addRow(
"Scoring:",
self.controls.scoring
)
box.layout().addLayout(form)
# Post-processing
box = gui.vBox(self.controlArea, "Post-processing")
gui.doubleSpin(
box, self, "quantile_normalization_perc", minv=0, maxv=49, step=5e-1,
callback=self._update_quantile_normalization,
checkCallback=self._update_quantile_normalization,
controlWidth=80, alignment=Qt.AlignRight,
label="Quantile normalization", checked="quantile_normalization",
)
self.controls.quantile_normalization_perc.setSuffix("%")
gui.checkBox(
box, self, "dynamic_time_warping",
callback=self._update_dynamic_time_warping,
label="Dynamic time warping"
)
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "auto_commit", "Apply",
callback=self._invalidate_selection(),
checkbox_label="Apply automatically")
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Correlation components")
axis = self.plot.getAxis("left")
axis.setLabel("Correlation strength")
self.plot_horlabels = []
self.plot_horlines = []
self.plot.getViewBox().setMenuEnabled(False)
self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(box,
self,
"selected_learner",
"learners",
callback=self._learner_changed)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box,
self,
"selected_quantity",
items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box,
self,
"Select Correct",
callback=self.select_correct,
autoDefault=False)
gui.button(box,
self,
"Select Misclassified",
callback=self.select_wrong,
autoDefault=False)
gui.button(box,
self,
"Clear Selection",
callback=self.select_none,
autoDefault=False)
self.outputbox = box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box,
self,
"append_predictions",
"Predictions",
callback=self._invalidate)
gui.checkBox(box,
self,
"append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit", "Send Selected",
"Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
self.data = None
self.data_desc = self.match_desc = self.nonmatch_desc = None
box = gui.vBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QtGui.QTableWidget(
box, showGrid=False, selectionMode=QtGui.QTableWidget.NoSelection)
box.layout().addWidget(self.cond_list)
self.cond_list.setColumnCount(3)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
self.cond_list.resizeColumnToContents(0)
self.cond_list.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.cond_list.viewport().setBackgroundRole(QtGui.QPalette.Window)
box2 = gui.hBox(box)
gui.rubber(box2)
self.add_button = gui.button(box2,
self,
"Add Condition",
callback=self.add_row)
self.add_all_button = gui.button(box2,
self,
"Add All Variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2,
self,
"Remove All",
callback=self.remove_all)
gui.rubber(box2)
boxes = gui.widgetBox(self.controlArea,
orientation=QtGui.QGridLayout())
layout = boxes.layout()
layout.setColumnStretch(0, 1)
layout.setColumnStretch(1, 1)
box_data = gui.vBox(boxes, 'Data', addToLayout=False)
self.data_in_variables = gui.widgetLabel(box_data, " ")
self.data_out_rows = gui.widgetLabel(box_data, " ")
layout.addWidget(box_data, 0, 0)
box_setting = gui.vBox(boxes, 'Purging', addToLayout=False)
self.cb_pa = gui.checkBox(box_setting,
self,
"purge_attributes",
"Remove unused features",
callback=self.conditions_changed)
gui.separator(box_setting, height=1)
self.cb_pc = gui.checkBox(box_setting,
self,
"purge_classes",
"Remove unused classes",
callback=self.conditions_changed)
layout.addWidget(box_setting, 0, 1)
self.report_button.setFixedWidth(120)
gui.rubber(self.buttonsArea.layout())
layout.addWidget(self.buttonsArea, 1, 0)
acbox = gui.auto_commit(None,
self,
"auto_commit",
label="Send",
orientation=Qt.Horizontal,
checkbox_label="Send automatically")
layout.addWidget(acbox, 1, 1)
self.set_data(None)
self.resize(600, 400)
def __init__(
self,
parent=None,
):
super().__init__(self, parent)
self.selectionChangedFlag = False
self.__initialized = False
self.initfuture = None
self.itemsfuture = None
self.map_input_to_ensembl = None
self.infoLabel = gui.widgetLabel(
gui.widgetBox(self.controlArea, "Info", addSpace=True),
"Initializing\n")
self.organisms = None
self.organismBox = gui.widgetBox(self.controlArea,
"Organism",
addSpace=True)
self.organismComboBox = gui.comboBox(
self.organismBox,
self,
"organism_index",
callback=self._onSelectedOrganismChanged)
box = gui.widgetBox(self.controlArea, "Gene names", addSpace=True)
self.geneAttrComboBox = gui.comboBox(box,
self,
"gene_attr",
"Gene attribute",
callback=self.updateInfoItems)
self.geneAttrComboBox.setEnabled(not self.useAttr)
self.geneAttrCheckbox = gui.checkBox(box,
self,
"useAttr",
"Use column names",
callback=self.updateInfoItems)
self.geneAttrCheckbox.toggled[bool].connect(
self.geneAttrComboBox.setDisabled)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
gui.rubber(self.controlArea)
gui.lineEdit(self.mainArea,
self,
"search_string",
"Filter",
callbackOnType=True,
callback=self.searchUpdate)
self.treeWidget = QTreeView(self.mainArea)
self.treeWidget.setAlternatingRowColors(True)
self.treeWidget.setSortingEnabled(True)
self.treeWidget.setSelectionMode(QTreeView.ExtendedSelection)
self.treeWidget.setUniformRowHeights(True)
self.treeWidget.setRootIsDecorated(False)
self.treeWidget.setItemDelegateForColumn(
HEADER_SCHEMA['NCBI ID'],
gui.LinkStyledItemDelegate(self.treeWidget))
self.treeWidget.setItemDelegateForColumn(
HEADER_SCHEMA['Ensembl ID'],
gui.LinkStyledItemDelegate(self.treeWidget))
self.treeWidget.viewport().setMouseTracking(True)
self.mainArea.layout().addWidget(self.treeWidget)
box = gui.widgetBox(self.mainArea, "", orientation="horizontal")
gui.button(box, self, "Select Filtered", callback=self.selectFiltered)
gui.button(box,
self,
"Clear Selection",
callback=self.treeWidget.clearSelection)
self.geneinfo = []
self.cells = []
self.row2geneinfo = {}
self.data = None
# : (# input genes, # matches genes)
self.matchedInfo = 0, 0
self.setBlocking(True)
self.executor = ThreadExecutor(self)
self.progressBarInit()
task = Task(
function=partial(taxonomy.ensure_downloaded,
callback=methodinvoke(self, "advance", ())))
task.resultReady.connect(self.initialize)
task.exceptionReady.connect(self._onInitializeError)
self.initfuture = self.executor.submit(task)
def __init__(self):
super().__init__()
self.data = None
self._invalidated = False
# List of available preprocessors (DescriptionRole : Description)
self.preprocessors = QStandardItemModel()
def mimeData(indexlist):
assert len(indexlist) == 1
index = indexlist[0]
qname = index.data(DescriptionRole).qualname
m = QMimeData()
m.setData("application/x-qwidget-ref", qname.encode("utf-8"))
return m
# TODO: Fix this (subclass even if just to pass a function
# for mimeData delegate)
self.preprocessors.mimeData = mimeData
box = gui.vBox(self.controlArea, "预处理程序")
self.preprocessorsView = view = QListView(
selectionMode=QListView.SingleSelection,
dragEnabled=True,
dragDropMode=QListView.DragOnly
)
view.setModel(self.preprocessors)
view.activated.connect(self.__activated)
box.layout().addWidget(view)
####
self._qname2ppdef = {ppdef.qualname: ppdef for
ppdef in self.PREPROCESSORS}
# List of 'selected' preprocessors and their parameters.
self.preprocessormodel = None
self.flow_view = SequenceFlow()
self.controler = self.CONTROLLER(self.flow_view, parent=self)
self.overlay = OverlayWidget(self)
self.overlay.setAttribute(Qt.WA_TransparentForMouseEvents)
self.overlay.setWidget(self.flow_view)
self.overlay.setLayout(QVBoxLayout())
self.overlay.layout().addWidget(
QLabel("从左侧列表中拖动项目", wordWrap=True))
self.scroll_area = QScrollArea(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn
)
self.scroll_area.viewport().setAcceptDrops(True)
self.scroll_area.setWidget(self.flow_view)
self.scroll_area.setWidgetResizable(True)
self.mainArea.layout().addWidget(self.scroll_area)
self.flow_view.installEventFilter(self)
box = gui.vBox(self.controlArea, "输出")
gui.auto_commit(box, self, "autocommit", "发送", box=False)
self._initialize()
def __init__(self, parent=None):
widget.OWWidget.__init__(self, parent)
self.min_value, self.max_value = \
self.thresholds.get(self.Scores[self.score_index][0], (1, 0))
#: Input data set
self.data = None
#: Current target group selection
self.targets = []
#: The computed scores
self.scores = None
#: The computed scores from label permutations
self.nulldist = None
self.__scores_future = self.__scores_state = None
self.__in_progress = False
self.test_f = {
OWFeatureSelection.LowTail: test_low,
OWFeatureSelection.HighTail: test_high,
OWFeatureSelection.TwoTail: test_two_tail,
}
self.histogram = Histogram(enableMouse=False,
enableMenu=False,
background="w")
self.histogram.enableAutoRange(enable=False)
self.histogram.getPlotItem().hideButtons() # hide auto range button
self.histogram.getViewBox().setMouseEnabled(False, False)
self.histogram.selectionChanged.connect(
self.__on_histogram_plot_selection_changed)
self.histogram.selectionEdited.connect(self._invalidate_selection)
self.mainArea.layout().addWidget(self.histogram)
box = gui.widgetBox(self.controlArea, "Info")
self.dataInfoLabel = gui.widgetLabel(box, "No data on input.\n")
self.dataInfoLabel.setWordWrap(True)
self.selectedInfoLabel = gui.widgetLabel(box, "\n")
box1 = gui.widgetBox(self.controlArea, "Scoring Method")
gui.comboBox(
box1,
self,
"score_index",
items=[sm[0] for sm in self.Scores],
callback=[self.on_scoring_method_changed, self.update_scores])
box = gui.widgetBox(self.controlArea, "Target Labels")
self.label_selection_widget = guiutils.LabelSelectionWidget(self)
self.label_selection_widget.setMaximumHeight(150)
box.layout().addWidget(self.label_selection_widget)
self.label_selection_widget.groupChanged.connect(
self.on_label_activated)
self.label_selection_widget.groupSelectionChanged.connect(
self.on_target_changed)
box = gui.widgetBox(self.controlArea, "Selection")
box.layout().setSpacing(0)
self.max_value_spin = gui.doubleSpin(box,
self,
"max_value",
minv=-1e6,
maxv=1e6,
step=1e-6,
label="Upper threshold:",
callback=self.update_boundary,
callbackOnReturn=True)
self.low_value_spin = gui.doubleSpin(box,
self,
"min_value",
minv=-1e6,
maxv=1e6,
step=1e-6,
label="Lower threshold:",
callback=self.update_boundary,
callbackOnReturn=True)
check = gui.checkBox(box,
self,
"compute_null",
"Compute null distribution",
callback=self.update_scores)
perm_spin = gui.spin(box,
self,
"permutations_count",
minv=1,
maxv=50,
label="Permutations:",
callback=self.update_scores,
callbackOnReturn=True)
check.disables.append(perm_spin)
box1 = gui.widgetBox(box, orientation='horizontal')
pval_spin = gui.doubleSpin(box1,
self,
"alpha_value",
minv=2e-7,
maxv=1.0,
step=1e-7,
label="α-value:")
pval_select = gui.button(box1,
self,
"Select",
callback=self.select_p_best,
autoDefault=False)
check.disables.append(pval_spin)
check.disables.append(pval_select)
check.makeConsistent()
box1 = gui.widgetBox(box, orientation='horizontal')
gui.spin(box1, self, "n_best", 0, 10000, step=1, label="Best Ranked:")
gui.button(box1,
self,
"Select",
callback=self.select_n_best,
autoDefault=False)
box = gui.widgetBox(self.controlArea, "Output")
acbox = gui.auto_commit(box, self, "auto_commit", "Commit", box=None)
acbox.button.setDefault(True)
gui.checkBox(box,
self,
"add_scores_to_output",
"Add gene scores to output",
callback=self._invalidate_selection)
gui.rubber(self.controlArea)
self.on_scoring_method_changed()
self._executor = concurrent.ThreadExecutor()
def __init__(self):
super().__init__()
self.data = None
self.km = None
self.optimization_runs = []
box = gui.widgetBox(self.controlArea, "Number of Clusters")
layout = QGridLayout()
bg = gui.radioButtonsInBox(box,
self,
"optimize_k", [],
orientation=layout,
callback=self.update)
layout.addWidget(gui.appendRadioButton(bg, "Fixed", addToLayout=False),
1, 1)
sb = gui.widgetBox(None, margin=0, orientation="horizontal")
self.fixedSpinBox = gui.spin(sb,
self,
"k",
minv=2,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_k)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(
gui.appendRadioButton(bg, "Optimized", addToLayout=False), 2, 1)
ftobox = gui.widgetBox(None, orientation="horizontal")
ftobox.layout().setMargin(0)
layout.addWidget(ftobox)
gui.spin(ftobox,
self,
"k_from",
minv=2,
maxv=29,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_from)
gui.widgetLabel(ftobox, " To: ")
self.fixedSpinBox = gui.spin(ftobox,
self,
"k_to",
minv=3,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_to)
gui.rubber(ftobox)
layout.addWidget(gui.widgetLabel(None, "Scoring: "), 5, 1,
Qt.AlignRight)
layout.addWidget(
gui.comboBox(None,
self,
"scoring",
label="Scoring",
items=list(zip(*self.SCORING_METHODS))[0],
callback=self.update), 5, 2)
box = gui.widgetBox(self.controlArea, "Initialization")
gui.comboBox(box,
self,
"smart_init",
items=self.INIT_METHODS,
callback=self.update)
layout = QGridLayout()
box2 = gui.widgetBox(box, orientation=layout)
box2.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "), 0, 0,
Qt.AlignLeft)
sb = gui.widgetBox(None, margin=0, orientation="horizontal")
layout.addWidget(sb, 0, 1)
gui.lineEdit(sb,
self,
"n_init",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.update)
layout.addWidget(gui.widgetLabel(None, "Maximal iterations: "), 1, 0,
Qt.AlignLeft)
sb = gui.widgetBox(None, margin=0, orientation="horizontal")
layout.addWidget(sb, 1, 1)
gui.lineEdit(sb,
self,
"max_iterations",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.update)
box = gui.widgetBox(self.controlArea, "Output")
gui.comboBox(box,
self,
"place_cluster_ids",
label="Append cluster id as ",
orientation="horizontal",
callback=self.send_data,
items=self.OUTPUT_METHODS)
gui.lineEdit(box,
self,
"output_name",
label="Name ",
orientation="horizontal",
callback=self.send_data)
gui.auto_commit(self.controlArea,
self,
"auto_run",
"Run",
checkbox_label="Run after any change ",
orientation="horizontal")
gui.rubber(self.controlArea)
self.table_model = QStandardItemModel()
self.table_model.setHorizontalHeaderLabels(["k", "Score"])
self.table_model.setColumnCount(2)
self.table_box = gui.widgetBox(self.mainArea,
"Optimization Report",
addSpace=0)
table = self.table_view = QTableView(self.table_box)
table.setHorizontalScrollMode(QTableView.ScrollPerPixel)
table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.verticalHeader().hide()
table.setItemDelegateForColumn(1, gui.TableBarItem(self))
table.setModel(self.table_model)
table.selectionModel().selectionChanged.connect(
self.table_item_selected)
table.setColumnWidth(0, 40)
table.setColumnWidth(1, 120)
table.horizontalHeader().setStretchLastSection(True)
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.mainArea.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Preferred)
self.table_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
self.table_view.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.MinimumExpanding)
self.table_box.layout().addWidget(self.table_view)
self.hide_show_opt_results()
def __init__(self):
super().__init__()
self.measure_scores = None
self.update_scores = True
self.usefulAttributes = []
self.learners = {}
self.labels = []
self.out_domain_desc = None
self.all_measures = SCORES
self.selectedMeasures = dict([(m.name, True)
for m in self.all_measures])
# Discrete (0) or continuous (1) class mode
self.rankMode = 0
self.data = None
self.discMeasures = [
m for m in self.all_measures
if issubclass(DiscreteVariable, m.score.class_type)
]
self.contMeasures = [
m for m in self.all_measures
if issubclass(ContinuousVariable, m.score.class_type)
]
self.score_checks = []
self.cls_scoring_box = gui.vBox(None, "Scoring for Classification")
self.reg_scoring_box = gui.vBox(None, "Scoring for Regression")
boxes = [self.cls_scoring_box] * 7 + [self.reg_scoring_box] * 2
for _score, var, box in zip(SCORES, self._score_vars, boxes):
check = gui.checkBox(
box,
self,
var,
label=_score.name,
callback=lambda val=_score: self.measuresSelectionChanged(val))
self.score_checks.append(check)
self.score_stack = QStackedWidget(self)
self.score_stack.addWidget(self.cls_scoring_box)
self.score_stack.addWidget(self.reg_scoring_box)
self.score_stack.addWidget(QWidget())
self.controlArea.layout().addWidget(self.score_stack)
gui.rubber(self.controlArea)
selMethBox = gui.vBox(self.controlArea,
"Select Attributes",
addSpace=True)
grid = QGridLayout()
grid.setContentsMargins(6, 0, 6, 0)
self.selectButtons = QButtonGroup()
self.selectButtons.buttonClicked[int].connect(self.setSelectMethod)
def button(text, buttonid, toolTip=None):
b = QRadioButton(text)
self.selectButtons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr("None"), OWRank.SelectNone)
b2 = button(self.tr("All"), OWRank.SelectAll)
b3 = button(self.tr("Manual"), OWRank.SelectManual)
b4 = button(self.tr("Best ranked:"), OWRank.SelectNBest)
s = gui.spin(selMethBox,
self,
"nSelected",
1,
100,
callback=self.nSelectedChanged)
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(b4, 3, 0)
grid.addWidget(s, 3, 1)
self.selectButtons.button(self.selectMethod).setChecked(True)
selMethBox.layout().addLayout(grid)
gui.auto_commit(selMethBox, self, "auto_apply", "Send", box=False)
# Discrete, continuous and no_class table views are stacked
self.ranksViewStack = QStackedLayout()
self.mainArea.layout().addLayout(self.ranksViewStack)
self.discRanksView = QTableView()
self.ranksViewStack.addWidget(self.discRanksView)
self.discRanksView.setSelectionBehavior(QTableView.SelectRows)
self.discRanksView.setSelectionMode(QTableView.MultiSelection)
self.discRanksView.setSortingEnabled(True)
self.discRanksLabels = ["#"] + [m.shortname for m in self.discMeasures]
self.discRanksModel = QStandardItemModel(self)
self.discRanksModel.setHorizontalHeaderLabels(self.discRanksLabels)
self.discRanksProxyModel = MySortProxyModel(self)
self.discRanksProxyModel.setSourceModel(self.discRanksModel)
self.discRanksView.setModel(self.discRanksProxyModel)
self.discRanksView.setColumnWidth(0, 20)
self.discRanksView.selectionModel().selectionChanged.connect(
self.commit)
self.discRanksView.pressed.connect(self.onSelectItem)
self.discRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick)
self.discRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem)
if self.headerState[0] is not None:
self.discRanksView.horizontalHeader().restoreState(
self.headerState[0])
self.contRanksView = QTableView()
self.ranksViewStack.addWidget(self.contRanksView)
self.contRanksView.setSelectionBehavior(QTableView.SelectRows)
self.contRanksView.setSelectionMode(QTableView.MultiSelection)
self.contRanksView.setSortingEnabled(True)
self.contRanksLabels = ["#"] + [m.shortname for m in self.contMeasures]
self.contRanksModel = QStandardItemModel(self)
self.contRanksModel.setHorizontalHeaderLabels(self.contRanksLabels)
self.contRanksProxyModel = MySortProxyModel(self)
self.contRanksProxyModel.setSourceModel(self.contRanksModel)
self.contRanksView.setModel(self.contRanksProxyModel)
self.contRanksView.setColumnWidth(0, 20)
self.contRanksView.selectionModel().selectionChanged.connect(
self.commit)
self.contRanksView.pressed.connect(self.onSelectItem)
self.contRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick)
self.contRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem)
if self.headerState[1] is not None:
self.contRanksView.horizontalHeader().restoreState(
self.headerState[1])
self.noClassRanksView = QTableView()
self.ranksViewStack.addWidget(self.noClassRanksView)
self.noClassRanksView.setSelectionBehavior(QTableView.SelectRows)
self.noClassRanksView.setSelectionMode(QTableView.MultiSelection)
self.noClassRanksView.setSortingEnabled(True)
self.noClassRanksLabels = ["#"]
self.noClassRanksModel = QStandardItemModel(self)
self.noClassRanksModel.setHorizontalHeaderLabels(
self.noClassRanksLabels)
self.noClassRanksProxyModel = MySortProxyModel(self)
self.noClassRanksProxyModel.setSourceModel(self.noClassRanksModel)
self.noClassRanksView.setModel(self.noClassRanksProxyModel)
self.noClassRanksView.setColumnWidth(0, 20)
self.noClassRanksView.selectionModel().selectionChanged.connect(
self.commit)
self.noClassRanksView.pressed.connect(self.onSelectItem)
self.noClassRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick)
self.noClassRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem)
if self.headerState[2] is not None:
self.noClassRanksView.horizontalHeader().restoreState(
self.headerState[2])
# Switch the current view to Discrete
self.switchRanksMode(0)
self.resetInternals()
self.updateDelegates()
self.updateVisibleScoreColumns()
self.resize(690, 500)
self.measure_scores = table((len(self.measures), 0), None)
def __init__(self):
super().__init__()
self.data = None
self.filename = ""
self.basename = ""
self.type_ext = ""
self.compress_ext = ""
self.writer = None
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
rowWrapPolicy=QFormLayout.WrapLongRows,
verticalSpacing=10,
)
box = gui.vBox(self.controlArea, "Format")
gui.comboBox(
box,
self,
"filetype",
callback=self._update_text,
items=[item for item, _, _ in FILE_TYPES],
sendSelectedValue=True,
)
form.addRow(
"File type",
self.controls.filetype,
)
gui.comboBox(
box,
self,
"compression",
callback=self._update_text,
items=[item for item, _ in COMPRESSIONS],
sendSelectedValue=True,
)
gui.checkBox(
box,
self,
"compress",
label="Use compression",
callback=self._update_text,
)
form.addRow(self.controls.compress, self.controls.compression)
box.layout().addLayout(form)
self.save = gui.auto_commit(self.controlArea,
self,
"auto_save",
"Save",
box=False,
commit=self.save_file,
callback=self.adjust_label,
disabled=True,
addSpace=True)
self.save_as = gui.button(self.controlArea,
self,
"Save As...",
callback=self.save_file_as,
disabled=True)
self.save_as.setMinimumWidth(220)
self.adjustSize()
def __init__(self, parent=None, ):
super().__init__(self, parent)
self.selectionChangedFlag = False
self.__initialized = False
self.initfuture = None
self.itemsfuture = None
self.infoLabel = gui.widgetLabel(
gui.widgetBox(self.controlArea, "Info", addSpace=True),
"Initializing\n"
)
self.organisms = None
self.organismBox = gui.widgetBox(
self.controlArea, "Organism", addSpace=True)
self.organismComboBox = gui.comboBox(
self.organismBox, self, "organism_index",
callback=self._onSelectedOrganismChanged)
# For now only support one alt source, with a checkbox
# In the future this can be extended to multiple selections
self.altSourceCheck = gui.checkBox(
self.organismBox, self, "useAltSource",
"Show information from dictyBase",
callback=self.onAltSourceChange)
self.altSourceCheck.hide()
box = gui.widgetBox(self.controlArea, "Gene names", addSpace=True)
self.geneAttrComboBox = gui.comboBox(
box, self, "gene_attr",
"Gene attribute", callback=self.updateInfoItems
)
self.geneAttrComboBox.setEnabled(not self.useAttr)
cb = gui.checkBox(box, self, "useAttr", "Use attribute names",
callback=self.updateInfoItems)
cb.toggled[bool].connect(self.geneAttrComboBox.setDisabled)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
# A label for dictyExpress link (Why oh god why???)
self.dictyExpressBox = gui.widgetBox(
self.controlArea, "Dicty Express")
self.linkLabel = gui.widgetLabel(self.dictyExpressBox, "")
self.linkLabel.setOpenExternalLinks(False)
self.linkLabel.linkActivated.connect(self.onDictyExpressLink)
self.dictyExpressBox.hide()
gui.rubber(self.controlArea)
gui.lineEdit(self.mainArea, self, "search_string", "Filter",
callbackOnType=True, callback=self.searchUpdate)
self.treeWidget = QTreeView(
self.mainArea,
selectionMode=QTreeView.ExtendedSelection,
rootIsDecorated=False,
uniformRowHeights=True,
sortingEnabled=True)
self.treeWidget.setItemDelegate(
gui.LinkStyledItemDelegate(self.treeWidget))
self.treeWidget.viewport().setMouseTracking(True)
self.mainArea.layout().addWidget(self.treeWidget)
box = gui.widgetBox(self.mainArea, "", orientation="horizontal")
gui.button(box, self, "Select Filtered", callback=self.selectFiltered)
gui.button(box, self, "Clear Selection",
callback=self.treeWidget.clearSelection)
self.geneinfo = []
self.cells = []
self.row2geneinfo = {}
self.data = None
# : (# input genes, # matches genes)
self.matchedInfo = 0, 0
self.setBlocking(True)
self.executor = ThreadExecutor(self)
self.progressBarInit()
task = Task(
function=partial(
taxonomy.ensure_downloaded,
callback=methodinvoke(self, "advance", ())
)
)
task.resultReady.connect(self.initialize)
task.exceptionReady.connect(self._onInitializeError)
self.initfuture = self.executor.submit(task)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self._pca = None
self._transformed = None
self._variance_ratio = None
self._cumulative = None
self._line = False
box = gui.widgetBox(self.controlArea, "Components Selection")
form = QFormLayout()
box.layout().addLayout(form)
self.components_spin = gui.spin(
box,
self,
"ncomponents",
0,
1000,
callback=self._update_selection_component_spin,
keyboardTracking=False)
self.components_spin.setSpecialValueText("All")
self.variance_spin = gui.spin(
box,
self,
"variance_covered",
1,
100,
callback=self._update_selection_variance_spin,
keyboardTracking=False)
self.variance_spin.setSuffix("%")
form.addRow("Components", self.components_spin)
form.addRow("Variance covered", self.variance_spin)
self.sampling_box = gui.widgetBox(self.controlArea,
"Incremental learning")
self.addresstext = QLineEdit(box)
self.addresstext.setPlaceholderText('Remote server')
if self.address:
self.addresstext.setText(self.address)
self.sampling_box.layout().addWidget(self.addresstext)
form = QFormLayout()
self.sampling_box.layout().addLayout(form)
self.batch_spin = gui.spin(self.sampling_box,
self,
"batch_size",
50,
100000,
step=50,
keyboardTracking=False)
form.addRow("Batch size ~ ", self.batch_spin)
self.start_button = gui.button(
self.sampling_box,
self,
"Start remote computation",
callback=self.start,
autoDefault=False,
tooltip="Start/abort computation on the server")
self.start_button.setEnabled(False)
gui.checkBox(self.sampling_box,
self,
"auto_update",
"Periodically fetch model",
callback=self.update_model)
self.__timer = QTimer(self, interval=2000)
self.__timer.timeout.connect(self.get_model)
self.sampling_box.setVisible(remotely)
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea,
self,
"auto_commit",
"Send data",
checkbox_label="Auto send on change")
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Principal Components")
axis = self.plot.getAxis("left")
axis.setLabel("Proportion of variance")
self.plot.getViewBox().setMenuEnabled(False)
self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
def __init__(self):
super().__init__()
self.all_measures = SCORES
self.selectedMeasures = dict(
[(name, True) for name in _DEFAULT_SELECTED] +
[(m.name, False)
for m in self.all_measures[len(_DEFAULT_SELECTED):]]
)
# Discrete (0) or continuous (1) class mode
self.rankMode = 0
self.data = None
self.discMeasures = [m for m in self.all_measures
if issubclass(DiscreteVariable, m.score.class_type)]
self.contMeasures = [m for m in self.all_measures
if issubclass(ContinuousVariable, m.score.class_type)]
selMethBox = gui.widgetBox(
self.controlArea, "Select attributes", addSpace=True)
grid = QtGui.QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
self.selectButtons = QtGui.QButtonGroup()
self.selectButtons.buttonClicked[int].connect(self.setSelectMethod)
def button(text, buttonid, toolTip=None):
b = QtGui.QRadioButton(text)
self.selectButtons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr("None"), OWRank.SelectNone)
b2 = button(self.tr("All"), OWRank.SelectAll)
b3 = button(self.tr("Manual"), OWRank.SelectManual)
b4 = button(self.tr("Best ranked"), OWRank.SelectNBest)
s = gui.spin(selMethBox, self, "nSelected", 1, 100,
callback=self.nSelectedChanged)
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(b4, 3, 0)
grid.addWidget(s, 3, 1)
self.selectButtons.button(self.selectMethod).setChecked(True)
selMethBox.layout().addLayout(grid)
gui.auto_commit(self.controlArea, self, "auto_apply", "Commit",
checkbox_label="Commit on any change")
gui.rubber(self.controlArea)
# Discrete and continuous table views are stacked
self.ranksViewStack = QtGui.QStackedLayout()
self.mainArea.layout().addLayout(self.ranksViewStack)
self.discRanksView = QtGui.QTableView()
self.ranksViewStack.addWidget(self.discRanksView)
self.discRanksView.setSelectionBehavior(QtGui.QTableView.SelectRows)
self.discRanksView.setSelectionMode(QtGui.QTableView.MultiSelection)
self.discRanksView.setSortingEnabled(True)
self.discRanksModel = QtGui.QStandardItemModel(self)
self.discRanksModel.setHorizontalHeaderLabels(
["#"] + [m.shortname for m in self.discMeasures]
)
self.discRanksProxyModel = MySortProxyModel(self)
self.discRanksProxyModel.setSourceModel(self.discRanksModel)
self.discRanksView.setModel(self.discRanksProxyModel)
self.discRanksView.setColumnWidth(0, 20)
self.discRanksView.sortByColumn(1, Qt.DescendingOrder)
self.discRanksView.selectionModel().selectionChanged.connect(
self.commit
)
self.discRanksView.pressed.connect(self.onSelectItem)
self.discRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick
)
if self.headerState[0] is not None:
self.discRanksView.horizontalHeader().restoreState(
self.headerState[0]
)
self.contRanksView = QtGui.QTableView()
self.ranksViewStack.addWidget(self.contRanksView)
self.contRanksView.setSelectionBehavior(QtGui.QTableView.SelectRows)
self.contRanksView.setSelectionMode(QtGui.QTableView.MultiSelection)
self.contRanksView.setSortingEnabled(True)
self.contRanksModel = QtGui.QStandardItemModel(self)
self.contRanksModel.setHorizontalHeaderLabels(
["#"] + [m.shortname for m in self.contMeasures]
)
self.contRanksProxyModel = MySortProxyModel(self)
self.contRanksProxyModel.setSourceModel(self.contRanksModel)
self.contRanksView.setModel(self.contRanksProxyModel)
self.discRanksView.setColumnWidth(0, 20)
self.contRanksView.sortByColumn(1, Qt.DescendingOrder)
self.contRanksView.selectionModel().selectionChanged.connect(
self.commit
)
self.contRanksView.pressed.connect(self.onSelectItem)
self.contRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick
)
if self.headerState[1] is not None:
self.contRanksView.horizontalHeader().restoreState(
self.headerState[1]
)
# Switch the current view to Discrete
self.switchRanksMode(0)
self.resetInternals()
self.updateDelegates()
self.updateVisibleScoreColumns()
self.resize(690, 500)
self.measure_scores = table((len(self.measures), 0), None)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.clusterings = {}
self.__executor = ThreadExecutor(parent=self)
self.__task = None # type: Optional[Task]
layout = QGridLayout()
bg = gui.radioButtonsInBox(
self.controlArea,
self,
"optimize_k",
orientation=layout,
box="Number of Clusters",
callback=self.update_method,
)
layout.addWidget(
gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1)
sb = gui.hBox(None, margin=0)
gui.spin(
sb,
self,
"k",
minv=2,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_k,
)
gui.rubber(sb)
layout.addWidget(sb, 1, 2)
layout.addWidget(gui.appendRadioButton(bg, "From", addToLayout=False),
2, 1)
ftobox = gui.hBox(None)
ftobox.layout().setContentsMargins(0, 0, 0, 0)
layout.addWidget(ftobox, 2, 2)
gui.spin(
ftobox,
self,
"k_from",
minv=2,
maxv=29,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_from,
)
gui.widgetLabel(ftobox, "to")
gui.spin(
ftobox,
self,
"k_to",
minv=3,
maxv=30,
controlWidth=60,
alignment=Qt.AlignRight,
callback=self.update_to,
)
gui.rubber(ftobox)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(box,
self,
"smart_init",
items=self.INIT_METHODS,
callback=self.invalidate)
layout = QGridLayout()
gui.widgetBox(box, orientation=layout)
layout.addWidget(gui.widgetLabel(None, "Re-runs: "), 0, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 0, 1)
gui.lineEdit(
sb,
self,
"n_init",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate,
)
layout.addWidget(gui.widgetLabel(None, "Maximum iterations: "), 1, 0,
Qt.AlignLeft)
sb = gui.hBox(None, margin=0)
layout.addWidget(sb, 1, 1)
gui.lineEdit(
sb,
self,
"max_iterations",
controlWidth=60,
valueType=int,
validator=QIntValidator(),
callback=self.invalidate,
)
self.apply_button = gui.auto_commit(self.buttonsArea,
self,
"auto_commit",
"Apply",
box=None,
commit=self.commit)
gui.rubber(self.controlArea)
box = gui.vBox(self.mainArea, box="Silhouette Scores")
self.mainArea.setVisible(self.optimize_k)
self.table_model = ClusterTableModel(self)
table = self.table_view = QTableView(self.mainArea)
table.setModel(self.table_model)
table.setSelectionMode(QTableView.SingleSelection)
table.setSelectionBehavior(QTableView.SelectRows)
table.setItemDelegate(gui.ColoredBarItemDelegate(self, color=Qt.cyan))
table.selectionModel().selectionChanged.connect(self.select_row)
table.setMaximumWidth(200)
table.horizontalHeader().setStretchLastSection(True)
table.horizontalHeader().hide()
table.setShowGrid(False)
box.layout().addWidget(table)
def __init__(self):
super().__init__()
#: Input dissimilarity matrix
self.matrix = None # type: Optional[Orange.misc.DistMatrix]
#: Effective data used for plot styling/annotations. Can be from the
#: input signal (`self.signal_data`) or the input matrix
#: (`self.matrix.data`)
self.data = None # type: Optional[Orange.data.Table]
#: Input subset data table
self.subset_data = None # type: Optional[Orange.data.Table]
#: Data table from the `self.matrix.row_items` (if present)
self.matrix_data = None # type: Optional[Orange.data.Table]
#: Input data table
self.signal_data = None
self._similar_pairs = None
self._subset_mask = None # type: Optional[np.ndarray]
self._invalidated = False
self.effective_matrix = None
self._curve = None
self.variable_x = ContinuousVariable("mds-x")
self.variable_y = ContinuousVariable("mds-y")
self.__update_loop = None
# timer for scheduling updates
self.__timer = QTimer(self, singleShot=True, interval=0)
self.__timer.timeout.connect(self.__next_step)
self.__state = OWMDS.Waiting
self.__in_next_step = False
self.__draw_similar_pairs = False
box = gui.vBox(self.controlArea, "MDS Optimization")
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow,
verticalSpacing=10
)
form.addRow(
"Max iterations:",
gui.spin(box, self, "max_iter", 10, 10 ** 4, step=1))
form.addRow(
"Initialization:",
gui.radioButtons(box, self, "initialization", btnLabels=("PCA (Torgerson)", "Random"),
callback=self.__invalidate_embedding))
box.layout().addLayout(form)
form.addRow(
"Refresh:",
gui.comboBox(box, self, "refresh_rate", items=[t for t, _ in OWMDS.RefreshRate],
callback=self.__invalidate_refresh))
gui.separator(box, 10)
self.runbutton = gui.button(box, self, "Run", callback=self._toggle_run)
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = OWMDSGraph(self, box, "MDSGraph", view_box=MDSInteractiveViewBox)
box.layout().addWidget(self.graph.plot_widget)
self.plot = self.graph.plot_widget
g = self.graph.gui
box = g.point_properties_box(self.controlArea)
self.models = g.points_models
self.size_model = self.models[2]
self.label_model = self.models[3]
self.size_model.order = \
self.size_model.order[:1] + ("Stress", ) + self.models[2].order[1:]
gui.hSlider(box, self, "connected_pairs", label="Show similar pairs:", minValue=0,
maxValue=20, createLabel=False, callback=self._on_connected_changed)
g.add_widgets(ids=[g.JitterSizeSlider], widget=box)
box = gui.vBox(self.controlArea, "Plot Properties")
g.add_widgets([g.ShowLegend,
g.ToolTipShowsAll,
g.ClassDensity,
g.LabelOnlySelected], box)
self.controlArea.layout().addStretch(100)
self.icons = gui.attributeIconDict
palette = self.graph.plot_widget.palette()
self.graph.set_palette(palette)
gui.rubber(self.controlArea)
self.graph.box_zoom_select(self.controlArea)
gui.auto_commit(box, self, "auto_commit", "Send Selected",
checkbox_label="Send selected automatically",
box=None)
self.plot.getPlotItem().hideButtons()
self.plot.setRenderHint(QPainter.Antialiasing)
self.graph.jitter_continuous = True
self._initialize()
def __init__(self):
super().__init__()
self.data = None
self._pca = None
self._transformed = None
self._variance_ratio = None
self._cumulative = None
self._line = False
# max_components limit allows scikit-learn to select a faster method for big data
self._pca_projector = PCA(max_components=MAX_COMPONENTS)
self._pca_projector.component = self.ncomponents
self._pca_preprocessors = PCA.preprocessors
# Components Selection
box = gui.vBox(self.controlArea, "Components Selection")
form = QFormLayout()
box.layout().addLayout(form)
self.components_spin = gui.spin(
box,
self,
"ncomponents",
1,
MAX_COMPONENTS,
callback=self._update_selection_component_spin,
keyboardTracking=False)
self.components_spin.setSpecialValueText("All")
self.variance_spin = gui.spin(
box,
self,
"variance_covered",
1,
100,
callback=self._update_selection_variance_spin,
keyboardTracking=False)
self.variance_spin.setSuffix("%")
form.addRow("Components:", self.components_spin)
form.addRow("Variance covered:", self.variance_spin)
# Incremental learning
self.sampling_box = gui.vBox(self.controlArea, "Incremental learning")
self.addresstext = QLineEdit(box)
self.addresstext.setPlaceholderText('Remote server')
if self.address:
self.addresstext.setText(self.address)
self.sampling_box.layout().addWidget(self.addresstext)
form = QFormLayout()
self.sampling_box.layout().addLayout(form)
self.batch_spin = gui.spin(self.sampling_box,
self,
"batch_size",
50,
100000,
step=50,
keyboardTracking=False)
form.addRow("Batch size ~ ", self.batch_spin)
self.start_button = gui.button(
self.sampling_box,
self,
"Start remote computation",
callback=self.start,
autoDefault=False,
tooltip="Start/abort computation on the server")
self.start_button.setEnabled(False)
gui.checkBox(self.sampling_box,
self,
"auto_update",
"Periodically fetch model",
callback=self.update_model)
self.__timer = QTimer(self, interval=2000)
self.__timer.timeout.connect(self.get_model)
self.sampling_box.setVisible(remotely)
# Options
self.options_box = gui.vBox(self.controlArea, "Options")
gui.checkBox(self.options_box,
self,
"normalize",
"Normalize data",
callback=self._update_normalize)
self.maxp_spin = gui.spin(self.options_box,
self,
"maxp",
1,
MAX_COMPONENTS,
label="Show only first",
callback=self._setup_plot,
keyboardTracking=False)
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea,
self,
"auto_commit",
"Apply",
checkbox_label="Apply automatically")
self.plot = pg.PlotWidget(background="w")
axis = self.plot.getAxis("bottom")
axis.setLabel("Principal Components")
axis = self.plot.getAxis("left")
axis.setLabel("Proportion of variance")
self.plot_horlabels = []
self.plot_horlines = []
self.plot.getViewBox().setMenuEnabled(False)
self.plot.getViewBox().setMouseEnabled(False, False)
self.plot.showGrid(True, True, alpha=0.5)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.mainArea.layout().addWidget(self.plot)
self._update_normalize()
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.widgetBox(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.widgetBox(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 a script from a file", self)
save_to_file = QAction("Save selected script to a 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)
gui.auto_commit(self.controlArea, self, "auto_execute", "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.widgetBox(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.widgetBox(self, 'Console')
self.splitCanvas.addWidget(self.consoleBox)
self.console = PythonConsole(self.__dict__, 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 __init__(self):
super().__init__()
self.inputs = OrderedDict()
self.dist_color = QtGui.QColor(*self.dist_color_RGB)
info_box = gui.widgetBox(self.controlArea, "Info")
self.info_ex = gui.widgetLabel(
info_box,
'No data on input.',
)
self.info_ex.setWordWrap(True)
self.info_attr = gui.widgetLabel(info_box, ' ')
self.info_attr.setWordWrap(True)
self.info_class = gui.widgetLabel(info_box, ' ')
self.info_class.setWordWrap(True)
self.info_meta = gui.widgetLabel(info_box, ' ')
self.info_meta.setWordWrap(True)
gui.separator(info_box)
gui.button(info_box,
self,
"Restore Original Order",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Variables")
self.c_show_attribute_labels = gui.checkBox(
box,
self,
"show_attribute_labels",
"Show variable labels (if present)",
callback=self._on_show_variable_labels_changed)
gui.checkBox(box,
self,
"show_distributions",
'Visualize continuous values',
callback=self._on_distribution_color_changed)
gui.checkBox(box,
self,
"color_by_class",
'Color by instance classes',
callback=self._on_distribution_color_changed)
box = gui.widgetBox(self.controlArea, "Selection")
gui.checkBox(box,
self,
"select_rows",
"Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit",
"Send Selected Rows", "Auto send is on")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
copy = QtGui.QAction("Copy",
self,
shortcut=QtGui.QKeySequence.Copy,
triggered=self.copy)
self.addAction(copy)
def __init__(self):
super().__init__()
# copy METHODS (some are modified by the widget)
self.methods = copy.deepcopy(OWImpute.METHODS)
main_layout = QVBoxLayout()
main_layout.setContentsMargins(10, 10, 10, 10)
self.controlArea.layout().addLayout(main_layout)
box = QGroupBox(title=self.tr("Default Method"), flat=False)
box_layout = QVBoxLayout(box)
main_layout.addWidget(box)
button_group = QButtonGroup()
button_group.buttonClicked[int].connect(self.set_default_method)
for i, method in enumerate(self.methods):
if not method.columns_only:
button = QRadioButton(method.name)
button.setChecked(i == self.default_method_index)
button_group.addButton(button, i)
box_layout.addWidget(button)
self.default_button_group = button_group
box = QGroupBox(title=self.tr("Individual Attribute Settings"),
flat=False)
main_layout.addWidget(box)
horizontal_layout = QHBoxLayout(box)
main_layout.addWidget(box)
self.varview = QListView(selectionMode=QListView.ExtendedSelection)
self.varview.setItemDelegate(DisplayFormatDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._on_var_selection_changed)
self.selection = self.varview.selectionModel()
horizontal_layout.addWidget(self.varview)
method_layout = QVBoxLayout()
horizontal_layout.addLayout(method_layout)
button_group = QButtonGroup()
for i, method in enumerate(self.methods):
button = QRadioButton(text=method.name)
button_group.addButton(button, i)
method_layout.addWidget(button)
self.value_combo = QComboBox(
minimumContentsLength=8,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength,
activated=self._on_value_selected)
self.value_double = QDoubleSpinBox(
editingFinished=self._on_value_selected,
minimum=-1000.,
maximum=1000.,
singleStep=.1,
decimals=3,
)
self.value_stack = value_stack = QStackedWidget()
value_stack.addWidget(self.value_combo)
value_stack.addWidget(self.value_double)
method_layout.addWidget(value_stack)
button_group.buttonClicked[int].connect(
self.set_method_for_current_selection)
method_layout.addStretch(2)
reset_button = QPushButton("Restore All to Default",
checked=False,
checkable=False,
clicked=self.reset_variable_methods,
default=False,
autoDefault=False)
method_layout.addWidget(reset_button)
self.variable_button_group = button_group
box = gui.auto_commit(self.controlArea,
self,
"autocommit",
"Apply",
orientation=Qt.Horizontal,
checkbox_label="Apply automatically")
box.layout().insertSpacing(0, 80)
box.layout().insertWidget(0, self.report_button)
self.data = None
self.learner = None
self.modified = False
self.default_method = self.methods[self.default_method_index]
self.executor = qconcurrent.ThreadExecutor(self)
self.__task = None
def __init__(self):
super().__init__()
self.data = None
self.spectra = None
self.spectra_table = None
self.wavenumbers = None
self.sweeps = None
if self.dx_HeNe is True:
self.dx = 1.0 / self.laser_wavenumber / 2.0
# GUI
# An info box
infoBox = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(infoBox, "No data on input.")
self.infob = gui.widgetLabel(infoBox, "")
# Input Data control area
self.dataBox = gui.widgetBox(self.controlArea, "Input Data")
gui.widgetLabel(self.dataBox, "Datapoint spacing (Δx):")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
self.dx_edit = gui.lineEdit(self.dataBox,
self,
"dx",
callback=self.setting_changed,
valueType=float,
controlWidth=100,
disabled=self.dx_HeNe)
cb = gui.checkBox(
self.dataBox,
self,
"dx_HeNe",
label="HeNe laser",
callback=self.dx_changed,
)
lb = gui.widgetLabel(self.dataBox, "cm")
grid.addWidget(cb, 0, 0)
grid.addWidget(self.dx_edit, 0, 1)
grid.addWidget(lb, 0, 2)
self.dataBox.layout().addLayout(grid)
# FFT Options control area
self.optionsBox = gui.widgetBox(self.controlArea, "FFT Options")
box = gui.comboBox(self.optionsBox,
self,
"apod_func",
label="Apodization function:",
items=self.apod_opts,
callback=self.setting_changed)
box = gui.comboBox(self.optionsBox,
self,
"zff",
label="Zero Filling Factor:",
items=(2**n for n in range(10)),
callback=self.setting_changed)
box = gui.comboBox(self.optionsBox,
self,
"phase_corr",
label="Phase Correction:",
items=self.phase_opts,
callback=self.setting_changed)
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
le1 = gui.lineEdit(self.optionsBox,
self,
"phase_resolution",
callback=self.setting_changed,
valueType=int,
controlWidth=30)
cb1 = gui.checkBox(self.optionsBox,
self,
"phase_res_limit",
label="Limit phase resolution to ",
callback=self.setting_changed,
disables=le1)
lb1 = gui.widgetLabel(self.optionsBox, "cm<sup>-1<sup>")
grid.addWidget(cb1, 0, 0)
grid.addWidget(le1, 0, 1)
grid.addWidget(lb1, 0, 2)
self.optionsBox.layout().addLayout(grid)
# Output Data control area
self.outputBox = gui.widgetBox(self.controlArea, "Output")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
le2 = gui.lineEdit(self.outputBox,
self,
"out_limit1",
callback=self.out_limit_changed,
valueType=float,
controlWidth=50)
le3 = gui.lineEdit(self.outputBox,
self,
"out_limit2",
callback=self.out_limit_changed,
valueType=float,
controlWidth=50)
cb2 = gui.checkBox(self.outputBox,
self,
"limit_output",
label="Limit spectral region:",
callback=self.setting_changed,
disables=[le2, le3])
lb2 = gui.widgetLabel(self.outputBox, "-")
lb3 = gui.widgetLabel(self.outputBox, "cm<sup>-1</sup>")
grid.addWidget(cb2, 0, 0, 1, 6)
grid.addWidget(le2, 1, 1)
grid.addWidget(lb2, 1, 2)
grid.addWidget(le3, 1, 3)
grid.addWidget(lb3, 1, 4)
self.outputBox.layout().addLayout(grid)
gui.auto_commit(self.outputBox,
self,
"autocommit",
"Calculate",
box=False)
# Disable the controls initially (no data)
self.dataBox.setDisabled(True)
self.optionsBox.setDisabled(True)
def __init__(self):
super().__init__()
self.data = None
self.features = None
# Schedule interface updates (enabled buttons) using a coalescing
# single shot timer (complex interactions on selection and filtering
# updates in the 'available_attrs_view')
self.__interface_update_timer = QTimer(self,
interval=0,
singleShot=True)
self.__interface_update_timer.timeout.connect(
self.__update_interface_state)
# The last view that has the selection for move operation's source
self.__last_active_view = None # type: Optional[QListView]
def update_on_change(view):
# Schedule interface state update on selection change in `view`
self.__last_active_view = view
self.__interface_update_timer.start()
self.controlArea = QWidget(self.controlArea)
self.layout().addWidget(self.controlArea)
layout = QGridLayout()
self.controlArea.setLayout(layout)
layout.setContentsMargins(4, 4, 4, 4)
box = gui.vBox(self.controlArea, "可用变量", addToLayout=False)
self.available_attrs = VariablesListItemModel()
filter_edit, self.available_attrs_view = variables_filter(
parent=self, model=self.available_attrs)
box.layout().addWidget(filter_edit)
def dropcompleted(action):
if action == Qt.MoveAction:
self.commit()
self.available_attrs_view.selectionModel().selectionChanged.connect(
partial(update_on_change, self.available_attrs_view))
self.available_attrs_view.dragDropActionDidComplete.connect(
dropcompleted)
box.layout().addWidget(self.available_attrs_view)
layout.addWidget(box, 0, 0, 3, 1)
box = gui.vBox(self.controlArea, "特征", addToLayout=False)
self.used_attrs = VariablesListItemModel()
filter_edit, self.used_attrs_view = variables_filter(
parent=self,
model=self.used_attrs,
accepted_type=(Orange.data.DiscreteVariable,
Orange.data.ContinuousVariable))
self.used_attrs.rowsInserted.connect(self.__used_attrs_changed)
self.used_attrs.rowsRemoved.connect(self.__used_attrs_changed)
self.used_attrs_view.selectionModel().selectionChanged.connect(
partial(update_on_change, self.used_attrs_view))
self.used_attrs_view.dragDropActionDidComplete.connect(dropcompleted)
self.use_features_box = gui.auto_commit(
self.controlArea,
self,
"use_input_features",
"Use input features",
"Always use input features",
box=False,
commit=self.__use_features_clicked,
callback=self.__use_features_changed,
addToLayout=False)
self.enable_use_features_box()
box.layout().addWidget(self.use_features_box)
box.layout().addWidget(filter_edit)
box.layout().addWidget(self.used_attrs_view)
layout.addWidget(box, 0, 2, 1, 1)
box = gui.vBox(self.controlArea, "目标变量", addToLayout=False)
self.class_attrs = VariablesListItemModel()
self.class_attrs_view = VariablesListItemView(
acceptedType=(Orange.data.DiscreteVariable,
Orange.data.ContinuousVariable))
self.class_attrs_view.setModel(self.class_attrs)
self.class_attrs_view.selectionModel().selectionChanged.connect(
partial(update_on_change, self.class_attrs_view))
self.class_attrs_view.dragDropActionDidComplete.connect(dropcompleted)
self.class_attrs_view.setMaximumHeight(72)
box.layout().addWidget(self.class_attrs_view)
layout.addWidget(box, 1, 2, 1, 1)
box = gui.vBox(self.controlArea, "元属性", addToLayout=False)
self.meta_attrs = VariablesListItemModel()
self.meta_attrs_view = VariablesListItemView(
acceptedType=Orange.data.Variable)
self.meta_attrs_view.setModel(self.meta_attrs)
self.meta_attrs_view.selectionModel().selectionChanged.connect(
partial(update_on_change, self.meta_attrs_view))
self.meta_attrs_view.dragDropActionDidComplete.connect(dropcompleted)
box.layout().addWidget(self.meta_attrs_view)
layout.addWidget(box, 2, 2, 1, 1)
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 0, 1, 1, 1)
self.up_attr_button = gui.button(bbox,
self,
"向上",
callback=partial(
self.move_up,
self.used_attrs_view))
self.move_attr_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.used_attrs_view))
self.down_attr_button = gui.button(bbox,
self,
"向下",
callback=partial(
self.move_down,
self.used_attrs_view))
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 1, 1, 1, 1)
self.up_class_button = gui.button(bbox,
self,
"向上",
callback=partial(
self.move_up,
self.class_attrs_view))
self.move_class_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.class_attrs_view,
exclusive=False))
self.down_class_button = gui.button(bbox,
self,
"向下",
callback=partial(
self.move_down,
self.class_attrs_view))
bbox = gui.vBox(self.controlArea, addToLayout=False, margin=0)
layout.addWidget(bbox, 2, 1, 1, 1)
self.up_meta_button = gui.button(bbox,
self,
"向上",
callback=partial(
self.move_up,
self.meta_attrs_view))
self.move_meta_button = gui.button(bbox,
self,
">",
callback=partial(
self.move_selected,
self.meta_attrs_view))
self.down_meta_button = gui.button(bbox,
self,
"向下",
callback=partial(
self.move_down,
self.meta_attrs_view))
autobox = gui.auto_commit(None, self, "auto_commit", "发送")
layout.addWidget(autobox, 3, 0, 1, 3)
reset = gui.button(None, self, "重置", callback=self.reset, width=120)
autobox.layout().insertWidget(0, reset)
autobox.layout().insertStretch(1, 20)
layout.setRowStretch(0, 4)
layout.setRowStretch(1, 0)
layout.setRowStretch(2, 2)
layout.setHorizontalSpacing(0)
self.controlArea.setLayout(layout)
self.output_data = None
self.original_completer_items = []
self.resize(600, 600)
def __init__(self):
super().__init__()
box = gui.vBox(self.mainArea, True, margin=0)
self.graph = OWScatterPlotGraph(self, box, "ScatterPlot")
box.layout().addWidget(self.graph.plot_widget)
plot = self.graph.plot_widget
axispen = QPen(self.palette().color(QPalette.Text))
axis = plot.getAxis("bottom")
axis.setPen(axispen)
axis = plot.getAxis("left")
axis.setPen(axispen)
self.data = None # Orange.data.Table
self.subset_data = None # Orange.data.Table
self.data_metas_X = None # self.data, where primitive metas are moved to X
self.sql_data = None # Orange.data.sql.table.SqlTable
self.attribute_selection_list = None # list of Orange.data.Variable
self.__timer = QTimer(self, interval=1200)
self.__timer.timeout.connect(self.add_data)
common_options = dict(labelWidth=50,
orientation=Qt.Horizontal,
sendSelectedValue=True,
valueType=str)
box = gui.vBox(self.controlArea, "Axis Data")
dmod = DomainModel
self.xy_model = DomainModel(dmod.MIXED, valid_types=dmod.PRIMITIVE)
self.cb_attr_x = gui.comboBox(box,
self,
"attr_x",
label="Axis x:",
callback=self.update_attr,
model=self.xy_model,
**common_options)
self.cb_attr_y = gui.comboBox(box,
self,
"attr_y",
label="Axis y:",
callback=self.update_attr,
model=self.xy_model,
**common_options)
vizrank_box = gui.hBox(box)
gui.separator(vizrank_box, width=common_options["labelWidth"])
self.vizrank, self.vizrank_button = ScatterPlotVizRank.add_vizrank(
vizrank_box, self, "Find Informative Projections", self.set_attr)
gui.separator(box)
gui.valueSlider(box,
self,
value='graph.jitter_size',
label='Jittering: ',
values=self.jitter_sizes,
callback=self.reset_graph_data,
labelFormat=lambda x: "None"
if x == 0 else ("%.1f %%" if x < 1 else "%d %%") % x)
gui.checkBox(gui.indentedBox(box),
self,
'graph.jitter_continuous',
'Jitter continuous values',
callback=self.reset_graph_data)
self.sampling = gui.auto_commit(self.controlArea,
self,
"auto_sample",
"Sample",
box="Sampling",
callback=self.switch_sampling,
commit=lambda: self.add_data(1))
self.sampling.setVisible(False)
g = self.graph.gui
g.point_properties_box(self.controlArea)
self.models = [self.xy_model] + g.points_models
box = gui.vBox(self.controlArea, "Plot Properties")
g.add_widgets([g.ShowLegend, g.ShowGridLines], box)
gui.checkBox(box,
self,
value='graph.tooltip_shows_all',
label='Show all data on mouse hover')
self.cb_class_density = gui.checkBox(box,
self,
value='graph.class_density',
label='Show class density',
callback=self.update_density)
self.cb_reg_line = gui.checkBox(box,
self,
value='graph.show_reg_line',
label='Show regression line',
callback=self.update_regression_line)
gui.checkBox(box,
self,
'graph.label_only_selected',
'Label only selected points',
callback=self.graph.update_labels)
self.zoom_select_toolbar = g.zoom_select_toolbar(
gui.vBox(self.controlArea, "Zoom/Select"),
nomargin=True,
buttons=[
g.StateButtonsBegin, g.SimpleSelect, g.Pan, g.Zoom,
g.StateButtonsEnd, g.ZoomReset
])
buttons = self.zoom_select_toolbar.buttons
buttons[g.Zoom].clicked.connect(self.graph.zoom_button_clicked)
buttons[g.Pan].clicked.connect(self.graph.pan_button_clicked)
buttons[g.SimpleSelect].clicked.connect(
self.graph.select_button_clicked)
buttons[g.ZoomReset].clicked.connect(self.graph.reset_button_clicked)
self.controlArea.layout().addStretch(100)
self.icons = gui.attributeIconDict
p = self.graph.plot_widget.palette()
self.graph.set_palette(p)
gui.auto_commit(self.controlArea, self, "auto_send_selection",
"Send Selection", "Send Automatically")
def zoom(s):
"""Zoom in/out by factor `s`."""
viewbox = plot.getViewBox()
# scaleBy scales the view's bounds (the axis range)
viewbox.scaleBy((1 / s, 1 / s))
def fit_to_view():
viewbox = plot.getViewBox()
viewbox.autoRange()
zoom_in = QAction("Zoom in", self, triggered=lambda: zoom(1.25))
zoom_in.setShortcuts([
QKeySequence(QKeySequence.ZoomIn),
QKeySequence(self.tr("Ctrl+="))
])
zoom_out = QAction("Zoom out",
self,
shortcut=QKeySequence.ZoomOut,
triggered=lambda: zoom(1 / 1.25))
zoom_fit = QAction("Fit in view",
self,
shortcut=QKeySequence(Qt.ControlModifier
| Qt.Key_0),
triggered=fit_to_view)
self.addActions([zoom_in, zoom_out, zoom_fit])
def __init__(self):
super().__init__()
self.primary_data = None
self.more_data = OrderedDict()
self.mergebox = gui.vBox(self.controlArea, "Domain Merging")
box = gui.radioButtons(self.mergebox,
self,
"merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box,
self.tr("When there is no primary table, " +
"the domain should be:"))
for opts in self.domain_opts:
gui.appendRadioButton(box, self.tr(opts))
gui.separator(box)
label = gui.widgetLabel(
box,
self.tr("The resulting table will have a class only if there " +
"is no conflict between input classes."))
label.setWordWrap(True)
###
box = gui.vBox(self.controlArea,
self.tr("Source Identification"),
addSpace=False)
cb = gui.checkBox(box,
self,
"append_source_column",
self.tr("Append data source IDs"),
callback=self._source_changed)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(cb))
form = QFormLayout(spacing=8,
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
form.addRow(
self.tr("Feature name:"),
gui.lineEdit(ibox,
self,
"source_attr_name",
valueType=str,
callback=self._source_changed))
form.addRow(
self.tr("Place:"),
gui.comboBox(ibox,
self,
"source_column_role",
items=self.id_roles,
callback=self._source_changed))
ibox.layout().addLayout(form)
mleft, mtop, mright, _ = ibox.layout().getContentsMargins()
ibox.layout().setContentsMargins(mleft, mtop, mright, 4)
cb.disables.append(ibox)
cb.makeConsistent()
box = gui.auto_commit(self.controlArea,
self,
"auto_commit",
"Apply",
commit=self.apply,
orientation=Qt.Horizontal,
checkbox_label="Apply automatically")
box.button.setFixedWidth(180)
box.layout().insertStretch(0)
def __init__(self, parent=None):
super().__init__(parent)
self.geneMatcherSettings = [False, False, True, False]
self.data = None
self.referenceData = None
self.taxid_list = []
self.__genematcher = (None, fulfill(gene.matcher([])))
self.__invalidated = False
self.currentAnnotatedCategories = []
self.state = None
self.__state = OWSetEnrichment.Initializing
box = gui.widgetBox(self.controlArea, "Info")
self.infoBox = gui.widgetLabel(box, "Info")
self.infoBox.setText("No data on input.\n")
self.speciesComboBox = gui.comboBox(
self.controlArea, self,
"speciesIndex", "Species",
callback=self.__on_speciesIndexChanged)
box = gui.widgetBox(self.controlArea, "Entity names")
self.geneAttrComboBox = gui.comboBox(
box, self, "geneattr", "Entity feature", sendSelectedValue=0,
callback=self.updateAnnotations)
cb = gui.checkBox(
box, self, "genesinrows", "Use feature names",
callback=self.updateAnnotations,
disables=[(-1, self.geneAttrComboBox)])
cb.makeConsistent()
# gui.button(box, self, "Gene matcher settings",
# callback=self.updateGeneMatcherSettings,
# tooltip="Open gene matching settings dialog")
self.referenceRadioBox = gui.radioButtonsInBox(
self.controlArea,
self, "useReferenceData",
["All entities", "Reference set (input)"],
tooltips=["Use entire genome (for gene set enrichment) or all " +
"available entities for reference",
"Use entities from Reference Examples input signal " +
"as reference"],
box="Reference", callback=self.updateAnnotations)
self.referenceRadioBox.setEnabled(False)
box = gui.widgetBox(self.controlArea, "Entity Sets")
self.groupsWidget = QTreeWidget(self)
self.groupsWidget.setHeaderLabels(["Category"])
box.layout().addWidget(self.groupsWidget)
hLayout = QHBoxLayout()
hLayout.setSpacing(10)
hWidget = gui.widgetBox(self.mainArea, orientation=hLayout)
gui.spin(hWidget, self, "minClusterCount",
0, 100, label="Entities",
tooltip="Minimum entity count",
callback=self.filterAnnotationsChartView,
callbackOnReturn=True,
checked="useMinCountFilter",
checkCallback=self.filterAnnotationsChartView)
pvalfilterbox = gui.widgetBox(hWidget, orientation="horizontal")
cb = gui.checkBox(
pvalfilterbox, self, "useMaxPValFilter", "p-value",
callback=self.filterAnnotationsChartView)
sp = gui.doubleSpin(
pvalfilterbox, self, "maxPValue", 0.0, 1.0, 0.0001,
tooltip="Maximum p-value",
callback=self.filterAnnotationsChartView,
callbackOnReturn=True,
)
sp.setEnabled(self.useMaxPValFilter)
cb.toggled[bool].connect(sp.setEnabled)
pvalfilterbox.layout().setAlignment(cb, Qt.AlignRight)
pvalfilterbox.layout().setAlignment(sp, Qt.AlignLeft)
fdrfilterbox = gui.widgetBox(hWidget, orientation="horizontal")
cb = gui.checkBox(
fdrfilterbox, self, "useMaxFDRFilter", "FDR",
callback=self.filterAnnotationsChartView)
sp = gui.doubleSpin(
fdrfilterbox, self, "maxFDR", 0.0, 1.0, 0.0001,
tooltip="Maximum False discovery rate",
callback=self.filterAnnotationsChartView,
callbackOnReturn=True,
)
sp.setEnabled(self.useMaxFDRFilter)
cb.toggled[bool].connect(sp.setEnabled)
fdrfilterbox.layout().setAlignment(cb, Qt.AlignRight)
fdrfilterbox.layout().setAlignment(sp, Qt.AlignLeft)
self.filterLineEdit = QLineEdit(
self, placeholderText="Filter ..."
)
self.filterCompleter = QCompleter(self.filterLineEdit)
self.filterCompleter.setCaseSensitivity(Qt.CaseInsensitive)
self.filterLineEdit.setCompleter(self.filterCompleter)
hLayout.addWidget(self.filterLineEdit)
self.mainArea.layout().addWidget(hWidget)
self.filterLineEdit.textChanged.connect(
self.filterAnnotationsChartView)
self.annotationsChartView = QTreeView(
alternatingRowColors=True,
sortingEnabled=True,
selectionMode=QTreeView.ExtendedSelection,
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
uniformRowHeights=True,
)
self.annotationsChartView.setItemDelegateForColumn(
ResultsModel.Pval, RealDelegate(self, precision=4)
)
self.annotationsChartView.setItemDelegateForColumn(
ResultsModel.FDR, RealDelegate(self, precision=4)
)
self.annotationsChartView.viewport().setMouseTracking(True)
self.proxy = FilterProxyModel(parent=self, dynamicSortFilter=True)
model = ResultsModel(parent=self)
self.proxy.setSourceModel(model)
self.annotationsChartView.setModel(self.proxy)
self.annotationsChartView.selectionModel().selectionChanged.connect(
lambda: self.commit()
)
header = self.annotationsChartView.header()
contextEventFilter = gui.VisibleHeaderSectionContextEventFilter(
self.annotationsChartView
)
header.installEventFilter(contextEventFilter)
header.setSortIndicator(ResultsModel.Pval, Qt.AscendingOrder)
if self.headerState:
header.restoreState(self.headerState)
self.mainArea.layout().addWidget(self.annotationsChartView)
self.groupsWidget.itemClicked.connect(self.subsetSelectionChanged)
gui.auto_commit(self.controlArea, self, "autocommit", "Commit")
self.setBlocking(True)
task = EnsureDownloaded(
[(taxonomy.Taxonomy.DOMAIN, taxonomy.Taxonomy.FILENAME),
(geneset.sfdomain, "index.pck")]
)
task.finished.connect(self.__initialize_finish)
self.setStatusMessage("Initializing")
self._executor = ThreadExecutor(
parent=self, threadPool=QThreadPool(self))
self._executor.submit(task)
def __init__(self):
super().__init__()
# OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
# Control area
box = vBox(self.controlArea, True, margin=0)
self.gs_selection_component: GeneSetSelection = GeneSetSelection(self, box)
self.gs_selection_component.selection_changed.connect(self._on_selection_changed)
self.reference_radio_box = radioButtonsInBox(
self.controlArea,
self,
'use_reference_data',
['Entire genome', 'Reference gene set (input)'],
tooltips=['Use entire genome (for gene set enrichment)', 'Use reference set of genes'],
box='Reference',
callback=self._on_selection_changed,
)
self.reference_radio_box.setEnabled(False)
self.reference_genes: Optional[List[str]] = None
# Main area
self.filter_proxy_model = FilterProxyModel()
self.filter_proxy_model.setFilterKeyColumn(Header.term)
self.tree_view = QTreeView()
self.tree_view.setAlternatingRowColors(True)
self.tree_view.setSortingEnabled(True)
self.tree_view.sortByColumn(Header.count, Qt.DescendingOrder)
self.tree_view.setSelectionMode(QTreeView.ExtendedSelection)
self.tree_view.setEditTriggers(QTreeView.NoEditTriggers)
self.tree_view.viewport().setMouseTracking(True)
self.tree_view.setItemDelegateForColumn(Header.term, LinkStyledItemDelegate(self.tree_view))
self.tree_view.setItemDelegateForColumn(Header.genes, NumericalColumnDelegate(self))
self.tree_view.setItemDelegateForColumn(Header.count, NumericalColumnDelegate(self))
self.tree_view.setItemDelegateForColumn(Header.p_val, NumericalColumnDelegate(self, precision=2, notation='e'))
self.tree_view.setItemDelegateForColumn(Header.fdr, NumericalColumnDelegate(self, precision=2, notation='e'))
self.tree_view.setItemDelegateForColumn(Header.enrichment, NumericalColumnDelegate(self, precision=1))
self.tree_view.setItemDelegateForColumn(Header.reference, NumericalColumnDelegate(self))
self.tree_view.setModel(self.filter_proxy_model)
h_layout = QHBoxLayout()
h_layout.setSpacing(100)
h_widget = widgetBox(self.mainArea, orientation=h_layout)
spin(
h_widget,
self,
'min_count',
0,
1000,
label='Count',
tooltip='Minimum genes count',
checked='use_min_count',
callback=self.filter_view,
callbackOnReturn=True,
checkCallback=self.filter_view,
)
doubleSpin(
h_widget,
self,
'max_p_value',
0.0,
1.0,
0.0001,
label='p-value',
tooltip='Maximum p-value of the enrichment score',
checked='use_p_value',
callback=self.filter_view,
callbackOnReturn=True,
checkCallback=self.filter_view,
)
doubleSpin(
h_widget,
self,
'max_fdr',
0.0,
1.0,
0.0001,
label='FDR',
tooltip='Maximum false discovery rate',
checked='use_max_fdr',
callback=self.filter_view,
callbackOnReturn=True,
checkCallback=self.filter_view,
)
self.line_edit_filter = lineEdit(h_widget, self, 'search_pattern')
self.line_edit_filter.setPlaceholderText('Filter gene sets ...')
self.line_edit_filter.textChanged.connect(self.filter_view)
self.mainArea.layout().addWidget(self.tree_view)
self.tree_view.header().setSectionResizeMode(QHeaderView.ResizeToContents)
self.commit_button = auto_commit(self.controlArea, self, 'auto_commit', '&Commit', box=False)
self.input_data: Optional[Table] = None
self.num_of_selected_genes: int = 0
self.gene_info: Optional[GeneInfo] = None
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = None
self.data = None
self.data_desc = self.match_desc = self.nonmatch_desc = None
box = gui.vBox(self.controlArea, 'Conditions', stretch=100)
self.cond_list = QtGui.QTableWidget(box)
box.layout().addWidget(self.cond_list)
self.cond_list.setShowGrid(False)
self.cond_list.setSelectionMode(QtGui.QTableWidget.NoSelection)
self.cond_list.setColumnCount(3)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
self.cond_list.resizeColumnToContents(0)
self.cond_list.horizontalHeader().setResizeMode(
QtGui.QHeaderView.Stretch)
self.cond_list.viewport().setBackgroundRole(QtGui.QPalette.Window)
box2 = gui.hBox(box)
self.add_button = gui.button(box2,
self,
"Add condition",
callback=self.add_row)
self.add_all_button = gui.button(box2,
self,
"Add all variables",
callback=self.add_all)
self.remove_all_button = gui.button(box2,
self,
"Remove all",
callback=self.remove_all)
gui.rubber(box2)
info = gui.hBox(self.controlArea)
box_data_in = gui.vBox(info, 'Data In')
# self.data_in_rows = gui.widgetLabel(box_data_in, " ")
self.data_in_variables = gui.widgetLabel(box_data_in, " ")
gui.rubber(box_data_in)
box_data_out = gui.vBox(info, 'Data Out')
self.data_out_rows = gui.widgetLabel(box_data_out, " ")
# self.dataOutAttributesLabel = gui.widgetLabel(box_data_out, " ")
gui.rubber(box_data_out)
box = gui.hBox(self.controlArea)
box_setting = gui.vBox(box, 'Purging')
self.cb_pa = gui.checkBox(box_setting,
self,
"purge_attributes",
"Remove unused features",
callback=self.conditions_changed)
gui.separator(box_setting, height=1)
self.cb_pc = gui.checkBox(box_setting,
self,
"purge_classes",
"Remove unused classes",
callback=self.conditions_changed)
gui.auto_commit(box,
self,
"auto_commit",
label="Commit",
checkbox_label="Commit on change")
self.set_data(None)
self.resize(600, 400)
def __init__(self):
super().__init__()
self.matrix = None
self._tree = None
self._ordered_tree = None
self._sorted_matrix = None
self._sort_indices = None
self._selection = None
self.sorting_cb = gui.comboBox(
self.controlArea,
self,
"sorting",
box="Element Sorting",
items=["None", "Clustering", "Clustering with ordered leaves"],
callback=self._invalidate_ordering)
box = gui.vBox(self.controlArea, "Colors")
self.colormap_cb = gui.comboBox(box,
self,
"colormap",
callback=self._update_color)
self.colormap_cb.setIconSize(QSize(64, 16))
self.palettes = list(_color_palettes)
init_color_combo(self.colormap_cb, self.palettes, QSize(64, 16))
self.colormap_cb.setCurrentIndex(self.colormap)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
# form.addRow(
# "Gamma",
# gui.hSlider(box, self, "color_gamma", minValue=0.0, maxValue=1.0,
# step=0.05, ticks=True, intOnly=False,
# createLabel=False, callback=self._update_color)
# )
form.addRow(
"Low:",
gui.hSlider(box,
self,
"color_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
form.addRow(
"High:",
gui.hSlider(box,
self,
"color_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self._update_color))
box.layout().addLayout(form)
self.annot_combo = gui.comboBox(self.controlArea,
self,
"annotation_idx",
box="Annotations",
callback=self._invalidate_annotations,
contentsLength=12)
self.annot_combo.setModel(itemmodels.VariableListModel())
self.annot_combo.model()[:] = ["None", "Enumeration"]
self.controlArea.layout().addStretch()
gui.auto_commit(self.controlArea, self, "autocommit", "Send Selected")
self.view = pg.GraphicsView(background="w")
self.mainArea.layout().addWidget(self.view)
self.grid_widget = pg.GraphicsWidget()
self.grid = QGraphicsGridLayout()
self.grid_widget.setLayout(self.grid)
self.viewbox = pg.ViewBox(enableMouse=False, enableMenu=False)
self.viewbox.setAcceptedMouseButtons(Qt.NoButton)
self.viewbox.setAcceptHoverEvents(False)
self.grid.addItem(self.viewbox, 1, 1)
self.left_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Left,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.left_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.left_dendrogram.setAcceptHoverEvents(False)
self.top_dendrogram = DendrogramWidget(
self.grid_widget,
orientation=DendrogramWidget.Top,
selectionMode=DendrogramWidget.NoSelection,
hoverHighlightEnabled=False)
self.top_dendrogram.setAcceptedMouseButtons(Qt.NoButton)
self.top_dendrogram.setAcceptHoverEvents(False)
self.grid.addItem(self.left_dendrogram, 1, 0)
self.grid.addItem(self.top_dendrogram, 0, 1)
self.right_labels = TextList(alignment=Qt.AlignLeft)
self.bottom_labels = TextList(orientation=Qt.Horizontal,
alignment=Qt.AlignRight)
self.grid.addItem(self.right_labels, 1, 2)
self.grid.addItem(self.bottom_labels, 2, 1)
self.view.setCentralItem(self.grid_widget)
self.left_dendrogram.hide()
self.top_dendrogram.hide()
self.right_labels.hide()
self.bottom_labels.hide()
self.matrix_item = None
self.dendrogram = None
self.grid_widget.scene().installEventFilter(self)
def __init__(self):
super().__init__()
self.data = None # type: Optional[Orange.data.Table]
self._counts = None # type: Optional[np.ndarray]
box = gui.widgetBox(self.controlArea, "Info")
self._info = QLabel(box, wordWrap=True)
self._info.setText("No data in input\n")
box.layout().addWidget(self._info)
box = gui.widgetBox(self.controlArea, "Filter Type")
rbg = QButtonGroup(box, exclusive=True)
for id_ in [Cells, Genes, Data]:
name, _, tip = FilterInfo[id_]
b = QRadioButton(
name, toolTip=tip, checked=id_ == self.selected_filter_type
)
box.layout().addWidget(b)
rbg.addButton(b, id_)
rbg.buttonClicked[int].connect(self.set_filter_type)
box = gui.widgetBox(self.controlArea, "View")
self._showpoints = gui.checkBox(
box, self, "display_dotplot", "Show data points",
callback=self._update_dotplot
)
form = QFormLayout(
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow
)
self._filter_box = box = gui.widgetBox(
self.controlArea, "Filter", orientation=form
) # type: QGroupBox
self.threshold_stacks = (
QStackedWidget(enabled=self.limit_lower_enabled),
QStackedWidget(enabled=self.limit_upper_enabled),
)
finfo = np.finfo(np.float64)
for filter_ in [Cells, Genes, Data]:
if filter_ in {Cells, Genes}:
minimum = 0.0
ndecimals = 1
else:
minimum = finfo.min
ndecimals = 3
spinlower = QDoubleSpinBox(
self, minimum=minimum, maximum=finfo.max, decimals=ndecimals,
keyboardTracking=False,
)
spinupper = QDoubleSpinBox(
self, minimum=minimum, maximum=finfo.max, decimals=ndecimals,
keyboardTracking=False,
)
lower, upper = self.thresholds[filter_]
spinlower.setValue(lower)
spinupper.setValue(upper)
self.threshold_stacks[0].addWidget(spinlower)
self.threshold_stacks[1].addWidget(spinupper)
spinlower.valueChanged.connect(self._limitchanged)
spinupper.valueChanged.connect(self._limitchanged)
self.threshold_stacks[0].setCurrentIndex(self.selected_filter_type)
self.threshold_stacks[1].setCurrentIndex(self.selected_filter_type)
self.limit_lower_enabled_cb = cb = QCheckBox(
"Min", checked=self.limit_lower_enabled
)
cb.toggled.connect(self.set_lower_limit_enabled)
cb.setAttribute(Qt.WA_LayoutUsesWidgetRect, True)
form.addRow(cb, self.threshold_stacks[0])
self.limit_upper_enabled_cb = cb = QCheckBox(
"Max", checked=self.limit_upper_enabled
)
cb.toggled.connect(self.set_upper_limit_enabled)
cb.setAttribute(Qt.WA_LayoutUsesWidgetRect, True)
form.addRow(cb, self.threshold_stacks[1])
self.controlArea.layout().addStretch(10)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
self._view = pg.GraphicsView()
self._view.enableMouse(False)
self._view.setAntialiasing(True)
self._plot = plot = ViolinPlot()
self._plot.setDataPointsVisible(self.display_dotplot)
self._plot.setSelectionMode(
(ViolinPlot.Low if self.limit_lower_enabled else 0) |
(ViolinPlot.High if self.limit_upper_enabled else 0)
)
self._plot.selectionEdited.connect(self._limitchanged_plot)
self._view.setCentralWidget(self._plot)
self._plot.setTitle("Detected genes")
left = self._plot.getAxis("left") # type: pg.AxisItem
left.setLabel("Detected genes")
bottom = self._plot.getAxis("bottom") # type: pg.AxisItem
bottom.hide()
plot.setMouseEnabled(False, False)
plot.hideButtons()
self.mainArea.layout().addWidget(self._view)
# Coalescing commit timer
self._committimer = QTimer(self, singleShot=True)
self._committimer.timeout.connect(self.commit)
self.addAction(
QAction("Select All", self, shortcut=QKeySequence.SelectAll,
triggered=self._select_all)
)