def __init__(self):
self.all_attrs = []
opts = gui.widgetBox(self.controlArea, 'Options')
gui.checkBox(opts, self, 'use_pacf',
label='Compute partial auto-correlation (PACF)',
callback=self.on_changed)
gui.checkBox(opts, self, 'use_confint',
label='Plot 95% significance interval',
callback=self.on_changed)
gui.listBox(self.controlArea, self, 'attrs',
labels='all_attrs',
box='Auto-correlated attribute(s)',
selectionMode=QListWidget.ExtendedSelection,
callback=self.on_changed)
plot = self.plot = Highchart(
self,
chart_zoomType='x',
plotOptions_line_marker_enabled=False,
plotOptions_column_borderWidth=0,
plotOptions_column_groupPadding=0,
plotOptions_series_pointWidth=3,
yAxis_min=-1.0,
yAxis_max=1.0,
xAxis_min=0,
xAxis_gridLineWidth=1,
yAxis_plotLines=[dict(value=0, color='#000', width=1, zIndex=2)],
yAxis_title_text='',
xAxis_title_text='period',
tooltip_headerFormat='Correlation at period: {point.key:.2f}<br/>',
tooltip_pointFormat='<span style="color:{point.color}">\u25CF</span> {point.y:.2f}<br/>',
)
self.mainArea.layout().addWidget(plot)
def __init__(self):
super().__init__()
self.data = None
grid = QGridLayout()
gui.widgetBox(self.controlArea, orientation=grid)
grid.addWidget(
gui.checkBox(
None, self, "add_type_annotations",
"Add type annotations to header",
tooltip=
"Some formats (Tab-delimited, Comma-separated) can include \n"
"additional information about variables types in header rows.",
callback=self._update_messages),
0, 0, 1, 2)
grid.setRowMinimumHeight(1, 8)
grid.addWidget(
gui.checkBox(
None, self, "auto_save", "Autosave when receiving new data",
callback=self._update_messages),
2, 0, 1, 2)
grid.setRowMinimumHeight(3, 8)
self.bt_save = gui.button(None, self, "Save", callback=self.save_file)
grid.addWidget(self.bt_save, 4, 0)
grid.addWidget(
gui.button(None, self, "Save as ...", callback=self.save_file_as),
4, 1)
self.adjustSize()
self._update_messages()
def __init__(self):
super().__init__()
self.data = None
self.reference = None
self.distances = None
box = gui.vBox(self.controlArea, "Info")
self.data_info_label = gui.widgetLabel(box, "")
self.reference_info_label = gui.widgetLabel(box, "")
self._set_label_text("data")
self._set_label_text("reference")
box = gui.vBox(self.controlArea, box=True)
gui.comboBox(
box, self, "distance_index", orientation=Qt.Horizontal,
label="Distance: ", items=[d[0] for d in METRICS],
callback=self.recompute)
gui.spin(
box, self, "n_neighbors", label="Number of neighbors:",
step=1, spinType=int, minv=0, maxv=100, callback=self.apply)
gui.checkBox(
box, self, "exclude_reference",
label="Exclude rows (equal to) references",
callback=self.apply)
self.apply_button = gui.auto_commit(
self.controlArea, self, "auto_apply", "&Apply", commit=self.apply)
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__()
# sets self.curvePoints, self.steps equidistant points from
# 1/self.steps to 1
self.updateCurvePoints()
# [start-snippet-2]
self.scoring = [
("Classification Accuracy", Orange.evaluation.scoring.CA),
("AUC", Orange.evaluation.scoring.AUC),
("Precision", Orange.evaluation.scoring.Precision),
("Recall", Orange.evaluation.scoring.Recall)
]
# [end-snippet-2]
#: input data on which to construct the learning curve
self.data = None
#: A {input_id: Learner} mapping of current learners from input channel
self.learners = OrderedDict()
#: A {input_id: List[Results]} mapping of input id to evaluation
#: results list, one for each curve point
self.results = OrderedDict()
#: A {input_id: List[float]} mapping of input id to learning curve
#: point scores
self.curves = OrderedDict()
# GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infoa = gui.widgetLabel(box, 'No data on input.')
self.infob = gui.widgetLabel(box, 'No learners.')
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Evaluation Scores")
gui.comboBox(box, self, "scoringF",
items=[x[0] for x in self.scoring],
callback=self._invalidate_curves)
gui.separator(self.controlArea)
box = gui.widgetBox(self.controlArea, "Options")
gui.spin(box, self, 'folds', 2, 100, step=1,
label='Cross validation folds: ', keyboardTracking=False,
callback=lambda:
self._invalidate_results() if self.commitOnChange else None
)
gui.spin(box, self, 'steps', 2, 100, step=1,
label='Learning curve points: ', keyboardTracking=False,
callback=[self.updateCurvePoints,
lambda: self._invalidate_results() if self.commitOnChange else None])
gui.checkBox(box, self, 'commitOnChange', 'Apply setting on any change')
self.commitBtn = gui.button(box, self, "Apply Setting",
callback=self._invalidate_results,
disabled=True)
gui.rubber(self.controlArea)
# table widget
self.table = gui.table(self.mainArea,
selectionMode=QTableWidget.NoSelection)
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 _create_layout(self):
self._new_webview()
box = gui.widgetBox(self.controlArea, 'Info')
self.topic_info = gui.label(box, self, '%(n_topic_words)d words in a topic')
gui.label(box, self, '%(documents_info_str)s')
box = gui.widgetBox(self.controlArea, 'Cloud preferences')
gui.checkBox(box, self, 'words_color', 'Color words', callback=self.on_cloud_pref_change)
TILT_VALUES = ('no', 'slight', 'more', 'full')
gui.valueSlider(box, self, 'words_tilt', label='Words tilt:',
values=list(range(len(TILT_VALUES))),
callback=self.on_cloud_pref_change,
labelFormat=lambda x: TILT_VALUES[x])
gui.button(box, None, 'Regenerate word cloud', callback=self.on_cloud_pref_change)
box = gui.widgetBox(self.controlArea, 'Words && weights')
self.table = gui.TableWidget(box,
col_labels=['Weight', 'Word'],
multi_selection=True,
select_rows=True)
def _selection_changed(selected, deselected):
for index in deselected.indexes():
data = self.table.rowData(index.row())
self.selected_words.remove(data)
for index in selected.indexes():
data = self.table.rowData(index.row())
self.selected_words.add(data)
self.cloud_reselect()
self.table.selectionChanged = _selection_changed
def _check_box(self, widget, value, label, cb_name):
'''
Adds a :obj:`.QCheckBox` to ``widget``.
When the checkbox is toggled, the attribute ``value`` of the plot object is set to the checkbox' check state,
and the callback ``cb_name`` is called.
'''
gui.checkBox(widget, self._plot, value, label, callback=self._get_callback(cb_name))
def __init__(self):
super().__init__()
self.cap = None
self.snapshot_flash = 0
self.IMAGE_DIR = tempfile.mkdtemp(prefix='Orange-WebcamCapture-')
self.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
box = self.controlArea
image = self.imageLabel = QLabel(
margin=0,
alignment=Qt.AlignCenter,
sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored))
box.layout().addWidget(image, 100)
self.name_edit = line_edit = gui.lineEdit(
box, self, 'image_title', 'Title:', orientation=Qt.Horizontal)
line_edit.setPlaceholderText(self.DEFAULT_TITLE)
hbox = gui.hBox(box)
gui.checkBox(hbox, self, 'avatar_filter', 'Avatar filter')
button = self.capture_button = QPushButton('Capture', self,
clicked=self.capture_image)
hbox.layout().addWidget(button, 1000)
box.layout().addWidget(hbox)
timer = QTimer(self, interval=40)
timer.timeout.connect(self.update_webcam_image)
timer.start()
def __init__(self):
super().__init__()
self.component = DummyComponent(self)
self.foo_control = gui.checkBox(self.controlArea, self, "foo", "")
self.component_foo_control = \
gui.checkBox(self.controlArea, self, "component.foo", "")
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__()
# Control GUI
box = gui.widgetBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input\nPredictors: 0\nTask: N/A"
)
self.infolabel.setMinimumWidth(200)
box = gui.widgetBox(self.controlArea, "Options")
self.checkbox_class = gui.checkBox(box, self, "show_class",
"Show predicted class",
callback=self.flipClass)
self.checkbox_prob = gui.checkBox(box, self, "show_probabilities",
"Show predicted probabilities",
callback=self.flipProb)
QtGui.qApp.processEvents()
QtCore.QTimer.singleShot(0, self.fix_size)
#: input data
self.data = None
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict()
#: A class variable (prediction target)
self.class_var = None
def __init__(self, parent=None, signalManager=None, stored_settings=None):
super(OWSql, self).__init__(parent=parent,
signalManager=signalManager,
stored_settings=stored_settings)
self._connection = None
vbox = gui.widgetBox(self.controlArea, "Server", addSpace=True)
box = gui.widgetBox(vbox)
self.servertext = QtGui.QLineEdit(box)
self.servertext.setPlaceholderText('Server')
if self.host:
self.servertext.setText(self.host if not self.port else
'{}:{}'.format(self.host, self.port))
box.layout().addWidget(self.servertext)
self.databasetext = QtGui.QLineEdit(box)
self.databasetext.setPlaceholderText('Database')
if self.database:
self.databasetext.setText(self.database)
box.layout().addWidget(self.databasetext)
self.usernametext = QtGui.QLineEdit(box)
self.usernametext.setPlaceholderText('Username')
if self.username:
self.usernametext.setText(self.username)
box.layout().addWidget(self.usernametext)
self.passwordtext = QtGui.QLineEdit(box)
self.passwordtext.setPlaceholderText('Password')
self.passwordtext.setEchoMode(QtGui.QLineEdit.Password)
if self.password:
self.passwordtext.setText(self.password)
box.layout().addWidget(self.passwordtext)
tables = gui.widgetBox(box, orientation='horizontal')
self.tablecombo = QtGui.QComboBox(tables)
tables.layout().addWidget(self.tablecombo)
self.tablecombo.activated[int].connect(self.select_table)
self.connectbutton = gui.button(
tables, self, '↻', callback=self.connect)
self.connectbutton.setSizePolicy(
QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
tables.layout().addWidget(self.connectbutton)
self.custom_sql = gui.widgetBox(box, orientation='vertical')
self.custom_sql.setVisible(False)
self.sqltext = QtGui.QTextEdit(self.custom_sql)
self.sqltext.setPlainText(self.sql)
self.custom_sql.layout().addWidget(self.sqltext)
self.executebtn = gui.button(
self.custom_sql, self, 'Execute', callback=self.open_table)
box.layout().addWidget(self.custom_sql)
gui.checkBox(box, self, "guess_values",
"Auto-discover discrete variables.",
callback=self.open_table)
self.connect()
if self.table:
self.open_table()
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 createExtendedContinuousPalette(
self, paletteName, boxCaption,
passThroughColors=0, initialColor1=Qt.white, initialColor2=Qt.black,
extendedPassThroughColors=((Qt.red, 1), (Qt.black, 1), (Qt.green, 1))):
buttBox = gui.vBox(self.mainArea, boxCaption)
box = gui.hBox(buttBox)
def _set(keypart, val):
self.__dict__["exCont{}{}".format(paletteName, keypart)] = val
_set("Left", ColorButton(self, box, color=QColor(initialColor1)))
_set("View", PaletteView(box))
_set("Right", ColorButton(self, box, color=QColor(initialColor2)))
_set("passThroughColors", passThroughColors)
_set("passThroughColorsCheckbox",
gui.checkBox(buttBox, self,
"exCont" + paletteName + "passThroughColors",
"Use pass-through colors",
callback=self.colorSchemaChange))
box = gui.hBox(buttBox, "Pass-through colors")
for i, (color, check) in enumerate(extendedPassThroughColors):
_set("passThroughColor" + str(i), check)
_set("passThroughColor" + str(i) + "Checkbox", gui.checkBox(
box, self,
"exCont" + paletteName + "passThroughColor" + str(i),
"", tooltip="Use color", callback=self.colorSchemaChange))
_set("color" + str(i), ColorButton(self, box, color=QColor(color)))
if i < len(extendedPassThroughColors) - 1:
gui.rubber(box)
_set("colorCount", len(extendedPassThroughColors))
self.exContPaletteNames.append(paletteName)
def __init__(self):
super().__init__()
box = gui.widgetBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input\nPredictors: 0\nTask: N/A")
self.infolabel.setMinimumWidth(150)
box = gui.widgetBox(self.controlArea, "Output")
self.checkbox_class = gui.checkBox(
box, self, "show_attrs", "Original data", callback=self.commit)
self.checkbox_class = gui.checkBox(
box, self, "show_predictions", "Predictions", callback=self.commit)
self.checkbox_prob = gui.checkBox(
box, self, "show_probabilities", "Probabilities",
callback=self.commit)
#: input data
self.data = None
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict()
#: A class variable (prediction target)
self.class_var = None
# enforce fixed size but provide a sensible minimum width constraint.
self.layout().activate()
self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width())
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def add_annotation_settings(self, parent):
box = gui.widgetBox(parent, "Statistical Information")
gui.comboBox(box, self, "graph.show_statistics", label="Statistics: ", orientation="horizontal", labelWidth=90,
items=["No statistics", "Means, deviations", "Median, quartiles"], callback=self.update_graph,
sendSelectedValue=False, valueType=int)
gui.checkBox(box, self, 'graph.show_distributions', 'Show distributions', callback=self.update_graph,
tooltip="Show bars with distribution of class values (only for discrete attributes)")
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):
super().__init__()
self.data = None
self.groups = None
self.CVSettings = (self.stratified, self.numberOfFolds)
infoBox = gui.widgetBox(self.controlArea, "Information")
self.dataInfoLabel = gui.widgetLabel(infoBox, 'No data on input.')
self.outputInfoLabel = gui.widgetLabel(infoBox, ' ')
optionsBox = gui.widgetBox(self.controlArea, "Options")
le = gui.lineEdit(optionsBox, self, "randomSeed", "Random seed: ",
orientation=0, controlWidth=60,
validator=QtGui.QIntValidator())
s = le.sizeHint().height() - 2
b = gui.toolButton(le.box, self, width=s, height=s,
callback=lambda: le.setText(""))
b.setIcon(b.style().standardIcon(b.style().SP_DialogCancelButton))
gui.rubber(le.box)
gui.checkBox(optionsBox, self, "stratified", "Stratified, if possible")
sampling = gui.radioButtons(
self.controlArea, self, "samplingType", box="Sampling type",
addSpace=True)
gui.appendRadioButton(sampling, "Random Sampling:")
indRndSmpl = gui.indentedBox(sampling)
sizeType = gui.radioButtons(
indRndSmpl, self, "sampleSizeType",
callback=lambda: self.chooseSampling(0))
gui.appendRadioButton(sizeType, "Sample size:", insertInto=indRndSmpl)
self.sampleSizeSpin = gui.spin(
gui.indentedBox(indRndSmpl), self, "sampleSizeNumber",
1, 1000000000, callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(0)])
gui.appendRadioButton(sizeType, "Sample proportions:",
insertInto=indRndSmpl)
gui.hSlider(gui.indentedBox(indRndSmpl), self,
"sampleSizePercentage",
minValue=1, maxValue=100, ticks=10, labelFormat="%d%%",
callback=[lambda: self.chooseSampling(0),
lambda: self.chooseSizeType(1)])
gui.appendRadioButton(sampling, "Cross Validation:")
crossValidIndent = gui.indentedBox(sampling)
gui.spin(
crossValidIndent, self, "numberOfFolds", 2, 100,
label="Number of folds:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
self.selectedFoldSpin = gui.spin(
crossValidIndent, self, "selectedFold", 1, 100,
label="Selected fold:",
callback=[self.updateSelectedFoldSpin,
lambda: self.chooseSampling(1)])
gui.button(self.controlArea, self, "Sample Data",
callback=self.sendData)
def __init__(self, parent=None):
super().__init__(parent)
self.taxids = taxonomy.common_taxids()
self.current_taxid_index = self.taxids.index(self.taxid)
self.data = None
self.geneinfo = None
self.nettask = None
self._invalidated = False
box = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box, "No data on input\n")
box = gui.widgetBox(self.controlArea, "Organism")
self.organism_cb = gui.comboBox(
box, self, "current_taxid_index",
items=map(taxonomy.name, self.taxids),
callback=self._update_organism
)
box = gui.widgetBox(self.controlArea, "Genes")
self.genes_cb = gui.comboBox(
box, self, "gene_var_index", callback=self._update_query_genes
)
self.varmodel = itemmodels.VariableListModel()
self.genes_cb.setModel(self.varmodel)
gui.checkBox(
box, self, "use_attr_names",
"Use attribute names",
callback=self._update_query_genes
)
box = gui.widgetBox(self.controlArea, "Network")
gui.comboBox(
box, self, "network_source",
items=[s.name for s in SOURCES],
callback=self._on_source_db_changed
)
gui.checkBox(
box, self, "include_neighborhood",
"Include immediate gene neighbors",
callback=self.invalidate
)
self.score_spin = gui.doubleSpin(
box, self, "min_score", 0.0, 1.0, step=0.001,
label="Minimal edge score",
callback=self.invalidate
)
self.score_spin.setEnabled(SOURCES[self.network_source].score_filter)
box = gui.widgetBox(self.controlArea, "Commit")
gui.button(box, self, "Retrieve", callback=self.commit, default=True)
self.setSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
self.executor = ThreadExecutor()
def add_main_layout(self):
box = gui.vBox(self.controlArea, True)
# the checkbox is put into vBox for alignemnt with other checkboxes
gui.checkBox(gui.vBox(box), self, "binary_trees", "Induce binary tree",
callback=self.settings_changed)
for label, check, setting, fromv, tov in self.spin_boxes:
gui.spin(box, self, setting, fromv, tov, label=label, checked=check,
alignment=Qt.AlignRight, callback=self.settings_changed,
checkCallback=self.settings_changed, controlWidth=80)
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.old_purge_classes = True
self.conditions = []
self.last_output_conditions = 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')
cb = gui.checkBox(box_setting, self, "purge_attributes",
"Remove unused values/features",
callback=self.on_purge_change)
self.purgeClassesCB = gui.checkBox(
gui.indentedBox(box_setting, sep=gui.checkButtonOffsetHint(cb)),
self, "purge_classes", "Remove unused classes",
callback=self.on_purge_change)
box_commit = gui.widgetBox(box, 'Commit')
gui.checkBox(box_commit, self, "update_on_change", "Commit on change")
gui.button(box_commit, self, "Commit", self.output_data, default=True)
self.set_data(None)
self.resize(600, 400)
def add_main_layout(self):
# var models
self.x_var_model = itemmodels.VariableListModel()
self.y_var_model = itemmodels.VariableListModel()
# options box
self.options_box = gui.widgetBox(self.controlArea, "Options")
opts = dict(
widget=self.options_box, master=self, orientation=Qt.Horizontal)
opts_combo = dict(opts, **dict(sendSelectedValue=True,
maximumContentsLength=15))
self.cbx = gui.comboBox(
value='attr_x', label='X: ', callback=self.apply, **opts_combo)
self.cby = gui.comboBox(
value='attr_y', label='Y: ', callback=self.apply, **opts_combo)
self.target_class_combobox = gui.comboBox(
value='target_class', label='Target: ',
callback=self.apply, **opts_combo)
self.degree_spin = gui.spin(
value='degree', label='Polynomial expansion:',
minv=1, maxv=5, step=1, callback=self.init_learner,
alignment=Qt.AlignRight, controlWidth=70, **opts)
self.cbx.setModel(self.x_var_model)
self.cby.setModel(self.y_var_model)
# plot properties box
self.plot_properties_box = gui.widgetBox(
self.controlArea, "Plot Properties")
self.legend_enabled_checkbox = gui.checkBox(
self.plot_properties_box, self, 'legend_enabled',
label="Show legend", callback=self.replot)
self.contours_enabled_checkbox = gui.checkBox(
self.plot_properties_box, self, 'contours_enabled',
label="Show contours", callback=self.plot_contour)
self.contour_step_slider = gui.spin(
self.plot_properties_box, self, 'contour_step',
minv=0.10, maxv=0.50, step=0.05, callback=self.plot_contour,
label='Contour step:', decimals=2, spinType=float,
alignment=Qt.AlignRight, controlWidth=70)
gui.rubber(self.controlArea)
# chart
self.scatter = Scatterplot(
xAxis_gridLineWidth=0, yAxis_gridLineWidth=0,
xAxis_startOnTick=False, xAxis_endOnTick=False,
yAxis_startOnTick=False, yAxis_endOnTick=False,
xAxis_lineWidth=0, yAxis_lineWidth=0,
yAxis_tickWidth=1, title_text='', tooltip_shared=False)
# Just render an empty chart so it shows a nice 'No data to display'
self.scatter.chart()
self.mainArea.layout().addWidget(self.scatter)
self.init_learner()
def __init__(self, parent=None):
super().__init__(parent)
self.results = None
self.learners = []
self._invalidated = False
box = gui.widgetBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.widgetBox(self.controlArea, "Show")
combo = gui.comboBox(box, self, "selected_quantity",
items=self.quantities,
callback=self._update)
combo.setMinimumContentsLength(20)
combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
box = gui.widgetBox(self.controlArea, "Selection")
gui.button(box, self, "Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "None",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Append class predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Append probabilities",
callback=self._invalidate)
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
cb = gui.checkBox(box, self, "autocommit", "Commit automatically")
gui.setStopper(self, b, cb, "_invalidated", callback=self.commit)
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.addWidget(QLabel("Predicted"), 0, 1, Qt.AlignCenter)
grid.addWidget(VerticalLabel("Correct Class"), 1, 0, Qt.AlignCenter)
self.tablemodel = QStandardItemModel()
self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers,
)
self.tableview.setModel(self.tablemodel)
self.tableview.selectionModel().selectionChanged.connect(
self._invalidate
)
grid.addWidget(self.tableview, 1, 1)
self.mainArea.layout().addLayout(grid)
def __init__(self):
super().__init__()
self.data = None
self.filename = ""
self.basename = ""
self.type_ext = ""
self.compress_ext = ""
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.annotations_cb = gui.checkBox(
None, self, "add_type_annotations", label="Add type annotations",
)
form.addRow(self.annotations_cb, None)
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):
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 add_group_settings(self, parent):
box = gui.vBox(parent, "Groups")
box2 = gui.hBox(box)
gui.checkBox(box2, self, "graph.group_lines", "Group lines into", tooltip="Show clusters instead of lines",
callback=self.update_graph)
gui.spin(box2, self, "graph.number_of_groups", 0, 30, callback=self.update_graph)
gui.label(box2, self, "groups")
box2 = gui.hBox(box)
gui.spin(box2, self, "graph.number_of_steps", 0, 100, label="In no more than", callback=self.update_graph)
gui.label(box2, self, "steps")
def __init__(self):
super().__init__()
# Init data
self.data = None
self.selected_data = None
self.selected_data_transformed = None # used for transforming the 'selected data' into the 'data' domain
self.words = []
self.p_values = []
self.fdr_values = []
# Info section
fbox = gui.widgetBox(self.controlArea, "Info")
self.info_all = gui.label(fbox, self, 'Cluster words:')
self.info_sel = gui.label(fbox, self, 'Selected words:')
self.info_fil = gui.label(fbox, self, 'After filtering:')
# Filtering settings
fbox = gui.widgetBox(self.controlArea, "Filter")
hbox = gui.widgetBox(fbox, orientation=0)
self.chb_p = gui.checkBox(hbox, self, "filter_by_p", "p-value",
callback=self.filter_and_display,
tooltip="Filter by word p-value")
self.spin_p = gui.doubleSpin(hbox, self, 'filter_p_value',
1e-4, 1, step=1e-4, labelWidth=15,
callback=self.filter_and_display,
callbackOnReturn=True,
tooltip="Max p-value for word")
self.spin_p.setEnabled(self.filter_by_p)
hbox = gui.widgetBox(fbox, orientation=0)
self.chb_fdr = gui.checkBox(hbox, self, "filter_by_fdr", "FDR",
callback=self.filter_and_display,
tooltip="Filter by word FDR")
self.spin_fdr = gui.doubleSpin(hbox, self, 'filter_fdr_value',
1e-4, 1, step=1e-4, labelWidth=15,
callback=self.filter_and_display,
callbackOnReturn=True,
tooltip="Max p-value for word")
self.spin_fdr.setEnabled(self.filter_by_fdr)
gui.rubber(self.controlArea)
# Word's list view
self.cols = ['Word', 'p-value', 'FDR']
self.sig_words = QTreeWidget()
self.sig_words.setColumnCount(len(self.cols))
self.sig_words.setHeaderLabels(self.cols)
self.sig_words.setSortingEnabled(True)
self.sig_words.setSelectionMode(QTreeView.ExtendedSelection)
self.sig_words.sortByColumn(2, 0) # 0 is ascending order
for i in range(len(self.cols)):
self.sig_words.resizeColumnToContents(i)
self.mainArea.layout().addWidget(self.sig_words)
def __init__(self, parent=None):
super().__init__(parent)
self.inputs = OrderedDict()
self.dist_color = QtGui.QColor(*self.dist_color_RGB)
self.selectionChangedFlag = False
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")
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):
super().__init__()
self._inputs = OrderedDict()
self.__pending_selected_rows = self.selected_rows
self.selected_rows = None
self.__pending_selected_cols = self.selected_cols
self.selected_cols = None
self.dist_color = QColor(*self.dist_color_RGB)
info_box = gui.vBox(self.controlArea, "信息")
self.info_ex = gui.widgetLabel(
info_box,
'没有输入数据。',
)
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)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.vBox(self.controlArea, "变量")
self.c_show_attribute_labels = gui.checkBox(
box,
self,
"show_attribute_labels",
"显示变量标签（如果存在）",
callback=self._on_show_variable_labels_changed)
gui.checkBox(box,
self,
"show_distributions",
'可视化数值',
callback=self._on_distribution_color_changed)
gui.checkBox(box,
self,
"color_by_class",
'按实例分类上色',
callback=self._on_distribution_color_changed)
box = gui.vBox(self.controlArea, "选择")
gui.checkBox(box,
self,
"select_rows",
"选择整行",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
reset = gui.button(None,
self,
"恢复原始顺序",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
self.buttonsArea.layout().insertWidget(0, reset)
gui.auto_send(self.buttonsArea, self, "auto_commit")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
def color_settings_box(self):
box = gui.vBox(self)
self.color_cb = gui.comboBox(box,
self,
"palette_index",
label="Color:",
labelWidth=50,
orientation=Qt.Horizontal)
self.color_cb.setIconSize(QSize(64, 16))
palettes = _color_palettes
self.palette_index = min(self.palette_index, len(palettes) - 1)
model = color_palette_model(palettes, self.color_cb.iconSize())
model.setParent(self)
self.color_cb.setModel(model)
self.color_cb.activated.connect(self.update_color_schema)
self.color_cb.setCurrentIndex(self.palette_index)
gui.checkBox(box,
self,
"show_legend",
label="Show legend",
callback=self.update_legend_visible)
form = QFormLayout(formAlignment=Qt.AlignLeft,
labelAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow)
def limit_changed():
self.update_levels()
self.reset_thresholds()
self._level_low_le = lineEditDecimalOrNone(self,
self,
"level_low",
callback=limit_changed)
self._level_low_le.validator().setDefault(0)
form.addRow("Low limit:", self._level_low_le)
self._level_high_le = lineEditDecimalOrNone(self,
self,
"level_high",
callback=limit_changed)
self._level_high_le.validator().setDefault(1)
form.addRow("High limit:", self._level_high_le)
self._threshold_low_slider = lowslider = gui.hSlider(
box,
self,
"threshold_low",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_levels)
self._threshold_high_slider = highslider = gui.hSlider(
box,
self,
"threshold_high",
minValue=0.0,
maxValue=1.0,
step=0.05,
ticks=True,
intOnly=False,
createLabel=False,
callback=self.update_levels)
form.addRow("Low:", lowslider)
form.addRow("High:", highslider)
box.layout().addLayout(form)
self.update_legend_visible()
return box
def __init__(self):
super().__init__()
self.data = None
self.n_inliers = self.n_outliers = None
box = gui.vBox(self.controlArea, "Information")
self.data_info_label = gui.widgetLabel(box, self.data_info_default)
self.in_out_info_label = gui.widgetLabel(box, self.in_out_info_default)
box = gui.vBox(self.controlArea, "Outlier Detection Method")
detection = gui.radioButtons(box, self, "outlier_method")
gui.appendRadioButton(detection,
"One class SVM with non-linear kernel (RBF)")
ibox = gui.indentedBox(detection)
tooltip = "An upper bound on the fraction of training errors and a " \
"lower bound of the fraction of support vectors"
gui.widgetLabel(ibox, 'Nu:', tooltip=tooltip)
self.nu_slider = gui.hSlider(ibox,
self,
"nu",
minValue=1,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.nu_changed,
tooltip=tooltip)
self.gamma_spin = gui.spin(ibox,
self,
"gamma",
label="Kernel coefficient:",
step=1e-2,
spinType=float,
minv=0.01,
maxv=10,
callback=self.gamma_changed)
gui.separator(detection, 12)
self.rb_cov = gui.appendRadioButton(detection, "Covariance estimator")
ibox = gui.indentedBox(detection)
self.l_cov = gui.widgetLabel(ibox, 'Contamination:')
self.cont_slider = gui.hSlider(ibox,
self,
"cont",
minValue=0,
maxValue=100,
ticks=10,
labelFormat="%d %%",
callback=self.cont_changed)
ebox = gui.hBox(ibox)
self.cb_emp_cov = gui.checkBox(ebox,
self,
"empirical_covariance",
"Support fraction:",
callback=self.empirical_changed)
self.support_fraction_spin = gui.spin(
ebox,
self,
"support_fraction",
step=1e-1,
spinType=float,
minv=0.1,
maxv=10,
callback=self.support_fraction_changed)
gui.separator(detection, 12)
gui.button(self.buttonsArea,
self,
"Detect Outliers",
callback=self.commit)
self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self, parent=None, signalManager=None, name=" GEO Data Sets"):
OWWidget.__init__(self, parent, signalManager, name)
self.selectionChanged = False
self.filterString = ""
self.datasetName = ""
## GUI
box = gui.widgetBox(self.controlArea, "Info", addSpace=True)
self.infoBox = gui.widgetLabel(box, "Initializing\n\n")
box = gui.widgetBox(self.controlArea, "Output", addSpace=True)
gui.radioButtonsInBox(box, self, "outputRows",
["Genes in rows", "Samples in rows"], "Rows",
callback=self.commitIf)
gui.checkBox(box, self, "mergeSpots", "Merge spots of same gene",
callback=self.commitIf)
gui.separator(box)
self.nameEdit = gui.lineEdit(
box, self, "datasetName", "Data set name",
tooltip="Override the default output data set name",
callback=self.onNameEdited
)
self.nameEdit.setPlaceholderText("")
if sys.version_info < (3, ):
box = gui.widgetBox(self.controlArea, "Commit", addSpace=True)
self.commitButton = gui.button(
box, self, "Commit", callback=self.commit)
cb = gui.checkBox(box, self, "autoCommit", "Commit on any change")
gui.setStopper(self, self.commitButton, cb, "selectionChanged",
self.commit)
else:
gui.auto_commit(self.controlArea, self, "autoCommit", "Commit",
box="Commit")
self.commitIf = self.commit
gui.rubber(self.controlArea)
gui.widgetLabel(self.mainArea, "Filter")
self.filterLineEdit = QLineEdit(
textChanged=self.filter
)
self.completer = TokenListCompleter(
self, caseSensitivity=Qt.CaseInsensitive
)
self.filterLineEdit.setCompleter(self.completer)
self.mainArea.layout().addWidget(self.filterLineEdit)
splitter = QSplitter(Qt.Vertical, self.mainArea)
self.mainArea.layout().addWidget(splitter)
self.treeWidget = QTreeView(splitter)
self.treeWidget.setSelectionMode(QTreeView.SingleSelection)
self.treeWidget.setRootIsDecorated(False)
self.treeWidget.setSortingEnabled(True)
self.treeWidget.setAlternatingRowColors(True)
self.treeWidget.setUniformRowHeights(True)
self.treeWidget.setEditTriggers(QTreeView.NoEditTriggers)
linkdelegate = gui.LinkStyledItemDelegate(self.treeWidget)
self.treeWidget.setItemDelegateForColumn(1, linkdelegate)
self.treeWidget.setItemDelegateForColumn(8, linkdelegate)
self.treeWidget.setItemDelegateForColumn(
0, gui.IndicatorItemDelegate(self.treeWidget,
role=Qt.DisplayRole))
proxyModel = MySortFilterProxyModel(self.treeWidget)
self.treeWidget.setModel(proxyModel)
self.treeWidget.selectionModel().selectionChanged.connect(
self.updateSelection
)
self.treeWidget.viewport().setMouseTracking(True)
splitterH = QSplitter(Qt.Horizontal, splitter)
box = gui.widgetBox(splitterH, "Description")
self.infoGDS = gui.widgetLabel(box, "")
self.infoGDS.setWordWrap(True)
gui.rubber(box)
box = gui.widgetBox(splitterH, "Sample Annotations")
self.annotationsTree = QTreeWidget(box)
self.annotationsTree.setHeaderLabels(
["Type (Sample annotations)", "Sample count"]
)
self.annotationsTree.setRootIsDecorated(True)
box.layout().addWidget(self.annotationsTree)
self.annotationsTree.itemChanged.connect(
self.annotationSelectionChanged
)
self._annotationsUpdating = False
self.splitters = splitter, splitterH
for sp, setting in zip(self.splitters, self.splitterSettings):
sp.splitterMoved.connect(self.splitterMoved)
sp.restoreState(setting)
self.searchKeys = ["dataset_id", "title", "platform_organism",
"description"]
self.gds = []
self.gds_info = None
self.resize(1000, 600)
self.setBlocking(True)
self.setEnabled(False)
self.progressBarInit()
self._executor = ThreadExecutor()
func = partial(get_gds_model,
methodinvoke(self, "_setProgress", (float,)))
self._inittask = Task(function=func)
self._inittask.finished.connect(self._initializemodel)
self._executor.submit(self._inittask)
self._datatask = None
def create_gui(self):
""" create the GUI """
gui.label(self.controlArea, self,
"All files in the selected directory and subsequent subdirectories will be included in the conversion,"
"\nand output in a single .tsv file")
gui.separator(self.controlArea, height=16)
statusBox = gui.widgetBox(self.controlArea, "Status")
inputBox = gui.vBox(self.controlArea, "Input")
outputBox = gui.widgetBox(self.controlArea, "Output")
self.statusLabel = gui.label(statusBox, self, "Select directories, and press process to start")
# input GUI
layout = QGridLayout()
gui.widgetBox(inputBox, margin=0, orientation=layout)
label = QLabel("Directory:")
lineEdit = gui.lineEdit(None, self, "input_directory",
orientation=Qt.Horizontal,
tooltip="Tooltip",
placeholderText="input directory")
layout.addWidget(label, 0, 1)
layout.addWidget(lineEdit, 0, 2)
if found_tkinter:
button = gui.button(None, self, "Browse", callback=self.browse_folder_input)
layout.addWidget(button, 0, 3)
checkbox = gui.checkBox(None, self, 'enable_filter', "Enable filter")
layout.addWidget(checkbox, 2, 1)
layout.addWidget(QLabel("Only include files from the subdirectories:"), 2, 2)
filter = gui.lineEdit(None, self, "filter_directories",
orientation=Qt.AlignLeft,
tooltip="Tooltip",
placeholderText="filter directories")
layout.addWidget(filter, 2, 3)
# output GUI
layout2 = QGridLayout()
gui.widgetBox(outputBox, margin=0, orientation=layout2)
label2 = QLabel("Output directory:")
lineEdit2 = gui.lineEdit(None, self, "output_directory",
orientation=Qt.AlignLeft,
tooltip="Tooltip",
placeholderText="input directory")
label3 = QLabel("Output file:")
lineEdit3 = gui.lineEdit(None, self, "output_file",
orientation=Qt.Horizontal,
tooltip="Tooltip",
placeholderText="input directory")
layout2.addWidget(label2, 0, 1)
layout2.addWidget(lineEdit2, 0, 2)
layout2.addWidget(label3, 1, 1)
layout2.addWidget(lineEdit3, 1, 2)
if found_tkinter:
button2 = gui.button(None, self, "Browse", callback=self.browse_folder_output)
layout2.addWidget(button2, 0, 3)
# Process button
layout3 = QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout3)
btn1 = gui.button(None, self, "Process", callback=self.process)
btn2 = gui.button(None, self, "Output file > corpus", callback=self.output_corpus)
layout3.addWidget(btn1, 0, 0)
layout3.addWidget(btn2, 0, 1)
def __init__(self):
super().__init__()
self.results = None
self.scores = None
self.classifier_names = []
self.colors = []
self.line = None
self._last_score_value = -1
box = gui.vBox(self.controlArea, box="Settings")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="Target:",
orientation=Qt.Horizontal,
callback=self.target_index_changed,
contentsLength=8,
searchable=True)
gui.checkBox(box,
self,
"display_rug",
"Show rug",
callback=self._on_display_rug_changed)
gui.checkBox(box,
self,
"fold_curves",
"Curves for individual folds",
callback=self._replot)
self.classifiers_list_box = gui.listBox(
self.controlArea,
self,
"selected_classifiers",
"classifier_names",
box="Classifier",
selectionMode=QListWidget.ExtendedSelection,
sizePolicy=(QSizePolicy.Preferred, QSizePolicy.Preferred),
sizeHint=QSize(150, 40),
callback=self._on_selection_changed)
box = gui.vBox(self.controlArea, "Metrics")
combo = gui.comboBox(box,
self,
"score",
items=(metric.name for metric in Metrics),
callback=self.score_changed)
self.explanation = gui.widgetLabel(box,
wordWrap=True,
fixedWidth=combo.sizeHint().width())
self.explanation.setContentsMargins(8, 8, 0, 0)
font = self.explanation.font()
font.setPointSizeF(0.85 * font.pointSizeF())
self.explanation.setFont(font)
gui.radioButtons(box,
self,
value="output_calibration",
btnLabels=("Sigmoid calibration",
"Isotonic calibration"),
label="Output model calibration",
callback=self.apply)
self.info_box = gui.widgetBox(self.controlArea, "Info")
self.info_label = gui.widgetLabel(self.info_box)
gui.auto_apply(self.controlArea,
self,
"auto_commit",
commit=self.apply)
self.plotview = pg.GraphicsView(background="w")
axes = {
"bottom": AxisItem(orientation="bottom"),
"left": AxisItem(orientation="left")
}
self.plot = PlotItem(enableMenu=False, axisItems=axes)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
for axis_name in ("bottom", "left"):
axis = self.plot.getAxis(axis_name)
axis.setPen(pg.mkPen(color=0.0))
# Remove the condition (that is, allow setting this for bottom
# axis) when pyqtgraph is fixed
# Issue: https://github.com/pyqtgraph/pyqtgraph/issues/930
# Pull request: https://github.com/pyqtgraph/pyqtgraph/pull/932
if axis_name != "bottom": # remove if when pyqtgraph is fixed
axis.setStyle(stopAxisAtTick=(True, True))
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self._set_explanation()
VisualSettingsDialog(self, PlotItem.initial_settings)
def __init__(self):
super().__init__()
self._axis_font = QFont()
self._axis_font.setPixelSize(12)
self._label_font = QFont()
self._label_font.setPixelSize(11)
self.dataset = None
self.stats = []
self.dist = self.conts = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.scale_x = 1
self.scene_min_x = self.scene_max_x = self.scene_width = 0
self.label_width = 0
self.attrs = VariableListModel()
sorted_model = SortProxyModel(sortRole=Qt.UserRole)
sorted_model.setSourceModel(self.attrs)
sorted_model.sort(0)
box = gui.vBox(self.controlArea, "Variable")
view = self.attr_list = ListViewSearch()
view.setModel(sorted_model)
view.setSelectionMode(view.SingleSelection)
view.selectionModel().selectionChanged.connect(self.attr_changed)
view.setMinimumSize(QSize(30, 30))
# Any other policy than Ignored will let the QListBox's scrollbar
# set the minimal height (see the penultimate paragraph of
# http://doc.qt.io/qt-4.8/qabstractscrollarea.html#addScrollBarWidget)
view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored)
box.layout().addWidget(view)
gui.checkBox(box,
self,
"order_by_importance",
"Order by relevance to subgroups",
tooltip="Order by 𝜒² or ANOVA over the subgroups",
callback=self.apply_attr_sorting)
self.group_vars = VariableListModel(placeholder="None")
sorted_model = SortProxyModel(sortRole=Qt.UserRole)
sorted_model.setSourceModel(self.group_vars)
sorted_model.sort(0)
box = gui.vBox(self.controlArea, "Subgroups")
view = self.group_list = ListViewSearch()
view.setModel(sorted_model)
view.selectionModel().selectionChanged.connect(self.grouping_changed)
view.setMinimumSize(QSize(30, 30))
# See the comment above
view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored)
box.layout().addWidget(view)
gui.checkBox(box,
self,
"order_grouping_by_importance",
"Order by relevance to variable",
tooltip="Order by 𝜒² or ANOVA over the variable values",
callback=self.apply_group_sorting)
# TODO: move Compare median/mean to grouping box
# The vertical size policy is needed to let only the list views expand
self.display_box = gui.vBox(self.controlArea,
"Display",
sizePolicy=(QSizePolicy.Minimum,
QSizePolicy.Maximum))
gui.checkBox(self.display_box,
self,
"show_annotations",
"Annotate",
callback=self.update_graph)
self.compare_rb = gui.radioButtonsInBox(
self.display_box,
self,
'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.update_graph)
# The vertical size policy is needed to let only the list views expand
self.stretching_box = box = gui.vBox(self.controlArea,
box="Display",
sizePolicy=(QSizePolicy.Minimum,
QSizePolicy.Fixed))
self.stretching_box.sizeHint = self.display_box.sizeHint
gui.checkBox(box,
self,
'stretched',
"Stretch bars",
callback=self.update_graph,
stateWhenDisabled=False)
gui.checkBox(box,
self,
'show_labels',
"Show box labels",
callback=self.update_graph)
self.sort_cb = gui.checkBox(box,
self,
'sort_freqs',
"Sort by subgroup frequencies",
callback=self.update_graph,
stateWhenDisabled=False)
gui.vBox(self.mainArea)
self.box_scene = QGraphicsScene(self)
self.box_scene.selectionChanged.connect(self.on_selection_changed)
self.box_view = QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QPainter.Antialiasing
| QPainter.TextAntialiasing
| QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
self.stat_test = ""
self.mainArea.setMinimumWidth(300)
self.update_box_visibilities()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.api = None
self.corpus = None
self.api_dlg = self.APICredentialsDialog(self)
self.api_dlg.accept(silent=True)
# Set API key button
gui.button(self.controlArea,
self,
'Twitter API Key',
callback=self.open_key_dialog,
tooltip='Set the API key for this widget.',
focusPolicy=Qt.NoFocus)
# Query
query_box = gui.hBox(self.controlArea, 'Query')
layout = QGridLayout()
layout.setVerticalSpacing(5)
layout.setColumnStretch(2, 1) # stretch last columns
layout.setColumnMinimumWidth(1, 15) # add some space for checkbox
ROW = 0
COLUMNS = 3
def add_row(label, items):
nonlocal ROW, COLUMNS
layout.addWidget(QLabel(label), ROW, 0)
if isinstance(items, tuple):
for i, item in enumerate(items):
layout.addWidget(item, ROW, 1 + i)
else:
layout.addWidget(items, ROW, 1, 1, COLUMNS - 1)
ROW += 1
# Query input
add_row(
'Query word list:',
ListEdit(self, 'word_list', 'Multiple lines are joined with OR.',
80, self))
# Search mode
add_row(
'Search by:',
gui.comboBox(self,
self,
'mode',
items=self.MODES,
callback=self.mode_toggle))
# Language
self.language_combo = ComboBox(self,
'language',
items=(('Any', None), ) +
tuple(sorted(lang2code.items())))
add_row('Language:', self.language_combo)
# Max tweets
add_row(
'Max tweets:',
gui.spin(self,
self,
'max_tweets',
minv=1,
maxv=10000,
checked='limited_search'))
# Retweets
self.retweets_checkbox = gui.checkBox(self,
self,
'allow_retweets',
'',
minimumHeight=30)
add_row('Allow retweets:', self.retweets_checkbox)
# Collect Results
add_row('Collect results:', gui.checkBox(self, self, 'collecting', ''))
query_box.layout().addLayout(layout)
self.controlArea.layout().addWidget(
CheckListLayout('Text includes',
self,
'text_includes',
self.attributes,
cols=2,
callback=self.set_text_features))
self.tweets_info_label = gui.label(self.controlArea,
self,
self.tweets_info.format(0),
box='Info')
# Buttons
self.button_box = gui.hBox(self.controlArea)
self.button_box.layout().addWidget(self.report_button)
self.search_button = gui.button(self.button_box,
self,
'Search',
self.start_stop,
focusPolicy=Qt.NoFocus)
self.mode_toggle()
self.setFocus() # to widget itself to show placeholder for query_edit
def add_visual_settings(self, parent):
box = gui.widgetBox(parent, "Visual Settings")
gui.checkBox(box, self, 'graph.show_attr_values', 'Show attribute values', callback=self.update_graph)
gui.checkBox(box, self, 'graph.use_splines', 'Show splines', callback=self.update_graph,
tooltip="Show lines using splines")
self.graph.gui.show_legend_check_box(box)
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='Learners',
callback=self._learner_changed)
self.outputbox = gui.vBox(self.buttonsArea)
box = gui.hBox(self.outputbox)
gui.checkBox(box,
self,
"append_predictions",
"预测",
callback=self._invalidate)
gui.checkBox(box,
self,
"append_probabilities",
"概率",
callback=self._invalidate)
gui.auto_apply(self.outputbox, self, "autocommit", box=False)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox,
self,
"selected_quantity",
items=self.Chinese_quantities,
label="显示: ",
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,
"选择正确分类",
callback=self.select_correct,
autoDefault=False)
gui.button(selbox,
self,
"选择错误分类",
callback=self.select_wrong,
autoDefault=False)
gui.button(selbox,
self,
"清除选定内容",
callback=self.select_none,
autoDefault=False)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed,
contentsLength=8)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
abox = gui.vBox(box, "Combine ROC Curves From Folds")
abox.setFlat(True)
gui.comboBox(abox, self, "roc_averaging",
items=["Merge Predictions from Folds", "Mean TP Rate",
"Mean TP and FP at Threshold", "Show Individual Curves"],
callback=self._replot)
hbox = gui.vBox(box, "ROC Convex Hull")
hbox.setFlat(True)
gui.checkBox(hbox, self, "display_convex_curve",
"Show convex ROC curves", callback=self._replot)
gui.checkBox(hbox, self, "display_convex_hull",
"Show ROC convex hull", callback=self._replot)
box = gui.vBox(self.controlArea, "Analysis")
gui.checkBox(box, self, "display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box, self, "display_perf_line", "Show performance line",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box, self, "fp_cost", 1, 1000, 10,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FP Cost:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box, self, "fn_cost", 1, 1000, 10,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FN Cost:"))
grid.addWidget(sp, 1, 1)
sp = gui.spin(box, self, "target_prior", 1, 99,
callback=self._on_display_perf_line_changed)
sp.setSuffix("%")
sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior target class probability:"))
grid.addWidget(sp, 2, 1)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
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):
super().__init__()
self.primary_data = None
self.more_data = OrderedDict()
mergebox = gui.widgetBox(self.controlArea, "Domains merging")
box = gui.radioButtons(
mergebox, self, "merge_type",
callback=self._merge_type_changed)
gui.widgetLabel(
box, self.tr("When there is no primary table, " +
"the domain should be:"))
gui.appendRadioButton(
box, self.tr("Union of attributes appearing in all tables"))
gui.appendRadioButton(
box, self.tr("Intersection of attributes in all tables"))
gui.separator(box)
label = gui.widgetLabel(
box,
self.tr("The resulting table will have class only if there " +
"is no conflict between input classes."))
label.setWordWrap(True)
###
box = gui.widgetBox(
self.controlArea, self.tr("Source identification"),
addSpace=False)
cb = gui.checkBox(
box, self, "append_source_column",
self.tr("Append data source IDs"))
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(cb))
form = QtGui.QFormLayout(
spacing=8,
labelAlignment=Qt.AlignLeft,
formAlignment=Qt.AlignLeft,
fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow
)
form.addRow(
self.tr("Feature name"),
gui.lineEdit(ibox, self, "source_attr_name", valueType=str))
form.addRow(
self.tr("Place"),
gui.comboBox(
ibox, self, "source_column_role",
items=[self.tr("Class attribute"),
self.tr("Attribute"),
self.tr("Meta attribute")])
)
ibox.layout().addLayout(form)
mleft, mtop, mright, _ = ibox.layout().getContentsMargins()
ibox.layout().setContentsMargins(mleft, mtop, mright, 4)
cb.disables.append(ibox)
cb.makeConsistent()
gui.button(
self.controlArea, self, self.tr("Apply Changes"),
callback=self.apply, default=True
)
def __init__(self):
super().__init__()
#: Input data table
self.data = None # type: Optional[Orange.data.Table]
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict() # type: Dict[object, PredictorSlot]
#: A class variable (prediction target)
self.class_var = None # type: Optional[Orange.data.Variable]
#: List of (discrete) class variable's values
self.class_values = [] # type: List[str]
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input.\nPredictors: 0\nTask: N/A")
self.infolabel.setMinimumWidth(150)
gui.button(box,
self,
"Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
self.classification_options = box = gui.vBox(self.controlArea,
"Show",
spacing=-1,
addSpace=False)
gui.checkBox(box,
self,
"show_predictions",
"Predicted class",
callback=self._update_prediction_delegate)
b = gui.checkBox(box,
self,
"show_probabilities",
"Predicted probabilities for:",
callback=self._update_prediction_delegate)
ibox = gui.indentedBox(box,
sep=gui.checkButtonOffsetHint(b),
addSpace=False)
gui.listBox(ibox,
self,
"selected_classes",
"class_values",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.MultiSelection,
addSpace=False)
gui.checkBox(box,
self,
"draw_dist",
"Draw distribution bars",
callback=self._update_prediction_delegate)
box = gui.vBox(self.controlArea, "Data View")
gui.checkBox(box,
self,
"show_attrs",
"Show full dataset",
callback=self._update_column_visibility)
box = gui.vBox(self.controlArea, "Output", spacing=-1)
self.checkbox_class = gui.checkBox(box,
self,
"output_attrs",
"Original data",
callback=self.commit)
self.checkbox_class = gui.checkBox(box,
self,
"output_predictions",
"Predictions",
callback=self.commit)
self.checkbox_prob = gui.checkBox(box,
self,
"output_probabilities",
"Probabilities",
callback=self.commit)
gui.rubber(self.controlArea)
self.vsplitter = QSplitter(orientation=Qt.Vertical,
childrenCollapsible=True,
handleWidth=2)
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2,
)
self.dataview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus)
self.predictionsview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus,
sortingEnabled=True,
)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size: self.predictionsview.verticalHeader(
).resizeSection(index, size))
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.score_table = ScoreTable(self)
self.vsplitter.addWidget(self.splitter)
self.vsplitter.addWidget(self.score_table.view)
self.vsplitter.setStretchFactor(0, 5)
self.vsplitter.setStretchFactor(1, 1)
self.mainArea.layout().addWidget(self.vsplitter)
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.available_scales = sorted(
MODELS.values(), key=lambda x: x["order"])
# create grid
grid = QGridLayout()
gui.widgetBox(self.controlArea, orientation=grid)
# image attribute selection
hbox_attr = gui.hBox(None)
self.cb_image_attr = gui.comboBox(
widget=hbox_attr,
master=self,
value='image_attr_current_index',
label='Image attribute',
orientation=Qt.Horizontal,
callback=self.setting_changed
)
grid.addWidget(hbox_attr, 1, 0, 1, 2)
# Scale images option
hbox_scale = gui.hBox(None)
gui.checkBox(
widget=hbox_scale,
master=self,
value="use_scale",
label="Scale images to ",
callback=self.setting_changed
)
self.scale_combo = gui.comboBox(
widget=hbox_scale,
master=self,
value="scale_index",
items=["{} ({}×{})".format(v["name"], *v["target_image_size"])
for v in self.available_scales],
callback=self.setting_changed
)
grid.addWidget(hbox_scale, 3, 0, 1, 2)
# file format
hbox_format = gui.hBox(None)
gui.comboBox(
widget=hbox_format,
master=self,
value="file_format_index",
label="File format",
items=[x.upper() for x in SUPPORTED_FILE_FORMATS],
orientation=Qt.Horizontal,
callback=self.setting_changed
)
grid.addWidget(hbox_format, 4, 0, 1, 2)
# auto save
grid.addWidget(
gui.checkBox(
widget=None,
master=self,
value="auto_save",
label="Autosave when receiving new data or settings change",
callback=self._update_messages),
5, 0, 1, 2)
# buttons
self.bt_save = gui.button(None, self, "Save", callback=self.save_file)
grid.addWidget(self.bt_save, 7, 0)
grid.addWidget(
gui.button(None, self, "Save as ...", callback=self.save_file_as),
7, 1)
grid.setRowMinimumHeight(5, 8)
grid.setRowMinimumHeight(6, 20)
self.scale_combo.setEnabled(self.use_scale)
self.adjustSize()
self._update_messages()
def __init__(self):
super().__init__()
self.data = None # type: Optional[Table]
self.__pending_selection = self.selection # type: Optional[int]
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, "Preprocessing")
gui.checkBox(box,
self,
"normalize",
"Normalize columns",
callback=self.invalidate)
box = gui.vBox(self.controlArea, "Initialization")
gui.comboBox(box,
self,
"smart_init",
items=[m[0] for m in 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)
box = gui.vBox(self.mainArea, box="Silhouette Scores")
if self.optimize_k:
self.mainArea.setVisible(True)
self.left_side.setContentsMargins(0, 0, 0, 0)
else:
self.mainArea.setVisible(False)
self.left_side.setContentsMargins(0, 0, 4, 0)
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)
self.apply_button = gui.auto_apply(self.buttonsArea,
self,
"auto_commit",
commit=self.commit)
def __init__(self):
super().__init__()
self._inputs = OrderedDict()
self.__pending_selected_rows = self.selected_rows
self.selected_rows = None
self.__pending_selected_cols = self.selected_cols
self.selected_cols = None
self.dist_color = QColor(*self.dist_color_RGB)
info_box = gui.vBox(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)
info_box.setMinimumWidth(200)
gui.separator(self.controlArea)
box = gui.vBox(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 numeric 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.vBox(self.controlArea, "Selection")
gui.checkBox(box,
self,
"select_rows",
"Select full rows",
callback=self._on_select_rows_changed)
gui.rubber(self.controlArea)
reset = gui.button(None,
self,
"Restore Original Order",
callback=self.restore_order,
tooltip="Show rows in the original order",
autoDefault=False)
self.buttonsArea.layout().insertWidget(0, reset)
gui.auto_send(self.buttonsArea, self, "auto_commit")
# GUI with tabs
self.tabs = gui.tabWidget(self.mainArea)
self.tabs.currentChanged.connect(self._on_current_tab_changed)
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)
box = gui.widgetBox(self.controlArea, "Entity Sets")
self.groupsWidget = QtGui.QTreeWidget(self)
self.groupsWidget.setHeaderLabels(["Category"])
box.layout().addWidget(self.groupsWidget)
hLayout = QtGui.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.useMaxFDRFilter)
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 = QtGui.QLineEdit(self,
placeholderText="Filter ...")
self.filterCompleter = QtGui.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 = QtGui.QTreeView(
alternatingRowColors=True,
sortingEnabled=True,
selectionMode=QtGui.QTreeView.ExtendedSelection,
rootIsDecorated=False,
editTriggers=QtGui.QTreeView.NoEditTriggers,
)
self.annotationsChartView.viewport().setMouseTracking(True)
self.mainArea.layout().addWidget(self.annotationsChartView)
contextEventFilter = gui.VisibleHeaderSectionContextEventFilter(
self.annotationsChartView)
self.annotationsChartView.header().installEventFilter(
contextEventFilter)
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=QtCore.QThreadPool(self))
self._executor.submit(task)
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 = QTableWidget(box,
showGrid=False,
selectionMode=QTableWidget.NoSelection)
box.layout().addWidget(self.cond_list)
self.cond_list.setColumnCount(4)
self.cond_list.setRowCount(0)
self.cond_list.verticalHeader().hide()
self.cond_list.horizontalHeader().hide()
for i in range(3):
self.cond_list.horizontalHeader().setSectionResizeMode(
i, QHeaderView.Stretch)
self.cond_list.horizontalHeader().resizeSection(3, 30)
self.cond_list.viewport().setBackgroundRole(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=QHBoxLayout())
layout = boxes.layout()
box_setting = gui.vBox(boxes, addToLayout=False, box=True)
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, 1)
self.report_button.setFixedWidth(120)
gui.rubber(self.buttonsArea.layout())
layout.addWidget(self.buttonsArea)
acbox = gui.auto_send(None, self, "auto_commit")
layout.addWidget(acbox, 1)
layout.setAlignment(acbox, Qt.AlignBottom)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
self.set_data(None)
self.resize(600, 400)
def _init_ui(self):
# implement your user interface here (for setting hyperparameters)
gui.separator(self.controlArea)
box1 = gui.widgetBox(self.controlArea, "Hyperparameter:Algorithm")
box2 = gui.widgetBox(self.controlArea, "Hyperparameter:Columns")
line1 = gui.widgetBox(
box1,
box=None,
orientation=1,
margin=None,
spacing=20,
)
line2 = gui.widgetBox(
box1,
box=None,
orientation=1,
margin=None,
spacing=20,
)
line3 = gui.widgetBox(
box1,
box=None,
orientation=1,
margin=None,
spacing=20,
)
line4 = gui.widgetBox(
box1,
box=None,
orientation=1,
margin=None,
spacing=20,
)
line5 = gui.widgetBox(
box1,
box=None,
orientation=1,
margin=None,
spacing=20,
)
line6 = gui.widgetBox(
box1,
box=None,
orientation=1,
margin=None,
spacing=20,
)
line7 = gui.widgetBox(
box1,
box=None,
orientation=1,
margin=None,
spacing=20,
)
gui.doubleSpin(
line1,
self,
"train_contamination",
minv=0.,
maxv=0.5,
step=0.0001,
label="contamination",
)
gui.lineEdit(line2, self, 'encoder_neurons', label='encoder_neurons')
gui.doubleSpin(
line1,
self,
"validation_size",
minv=0.,
maxv=1.,
step=0.0001,
label="validation_size",
)
gui.comboBox(line3,
self,
"loss_func",
label='loss_func',
items=['mean_squared_error'])
gui.comboBox(line3,
self,
"optimizer",
label='optimizer',
items=[
'adam', 'sgd', 'rmsprop', 'nadam', 'adamax',
'adadelta', 'adagrad'
])
gui.lineEdit(line2, self, 'epochs', label='epochs')
gui.lineEdit(line4, self, 'batch_size', label='batch_size')
gui.doubleSpin(
line4,
self,
"dropout_rate",
minv=0.,
maxv=1.,
step=0.0001,
label="dropout_rate",
)
gui.lineEdit(line5, self, 'feature_dim', label='feature_dim')
gui.lineEdit(line5, self, 'hidden_dim', label='hidden_dim')
gui.lineEdit(line6, self, 'decoder_neurons', label='decoder_neurons')
gui.comboBox(
line7,
self,
"activation",
label='activation',
items=['relu', 'sigmoid', 'selu', 'tanh', 'softplus', 'softsign'])
gui.comboBox(line7,
self,
"diff_group_method",
label='diff_group_method',
items=['average', 'max', 'min'])
gui.doubleSpin(
box2,
self,
"contamination",
minv=0.,
maxv=1.,
step=0.001,
label="Input contamination, float in (0,0.5].",
# callbackOnReturn = True,
# checked = "BoundedFloat"
)
gui.checkBox(box2,
self,
"return_subseq_inds",
label='If return subsequence index.',
callback=None)
gui.checkBox(box2,
self,
"use_semantic_types",
label='Mannally select columns if active.',
callback=None)
gui.lineEdit(
box2,
self,
"use_columns_buf",
label=
'Column index to use when use_semantic_types is activated. Tuple, e.g. (0,1,2)',
validator=None,
callback=self._use_columns_callback)
gui.lineEdit(
box2,
self,
"exclude_columns_buf",
label=
'Column index to exclude when use_semantic_types is activated. Tuple, e.g. (0,1,2)',
validator=None,
callback=self._exclude_columns_callback)
gui.comboBox(
box2,
self,
"return_result",
label='Output results.',
items=['new', 'append', 'replace'],
)
gui.checkBox(box2,
self,
"add_index_columns",
label='Keep index in the outputs.',
callback=None)
gui.checkBox(box2,
self,
"error_on_no_input",
label='Error on no input.',
callback=None)
gui.comboBox(
box2,
self,
"return_semantic_type",
label='Semantic type attach with results.',
items=[
'https://metadata.datadrivendiscovery.org/types/Attribute',
'https://metadata.datadrivendiscovery.org/types/ConstructedAttribute'
],
)
# Only for test
# gui.button(box, self, "Print Hyperparameters", callback=self._print_hyperparameter)
gui.auto_apply(box2, self, "autosend", box=False)
self.data = None
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
def __init__(self):
super().__init__()
self.old_purge_classes = True
self.conditions = []
self.last_output_conditions = 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')
cb = gui.checkBox(box_setting,
self,
"purge_attributes",
"Remove unused values/features",
callback=self.on_purge_change)
self.purgeClassesCB = gui.checkBox(gui.indentedBox(
box_setting, sep=gui.checkButtonOffsetHint(cb)),
self,
"purge_classes",
"Remove unused classes",
callback=self.on_purge_change)
box_commit = gui.widgetBox(box, 'Commit')
gui.checkBox(box_commit, self, "update_on_change", "Commit on change")
gui.button(box_commit, self, "Commit", self.output_data, default=True)
self.set_data(None)
self.resize(600, 400)
def _init_layout(self):
"""Initialize widget layout."""
# Control area
info_box = gui.widgetBox(self.controlArea, "Info", addSpace=True)
self._info_label = gui.widgetLabel(info_box, "Initializing\n\n")
box = gui.vBox(self.controlArea, "Average intervals:")
self.ch_month = gui.checkBox(box,
self,
"include_month",
"Month",
callback=self.commit_if)
self.ch_year = gui.checkBox(box,
self,
"include_year",
'Year',
callback=self.commit_if)
self.ch_decade = gui.checkBox(box,
self,
"include_decade",
'Decade',
callback=self.commit_if)
box = gui.vBox(self.controlArea, "Data Types")
gui.checkBox(box,
self,
"include_temperature",
"Temperature",
callback=self.commit_if)
gui.checkBox(box,
self,
"include_precipitation",
'Precipitation',
callback=self.commit_if)
output_box = gui.widgetBox(self.controlArea, "Output", addSpace=True)
gui.radioButtonsInBox(output_box,
self,
"output_type", ["Countries", "Time Series"],
"Rows",
callback=self.output_type_selected)
gui.checkBox(output_box,
self,
"use_country_names",
"Use Country names",
callback=self.commit_if)
self.output_type = 0
# pylint: disable=duplicate-code
gui.separator(output_box)
gui.auto_commit(self.controlArea,
self,
"auto_commit",
"Commit",
box="Commit")
gui.rubber(self.controlArea)
# Main area
box = gui.widgetBox(self.mainArea, "Countries")
self.country_tree = CountryTreeWidget(
self.mainArea,
self.country_selection,
commit_callback=self.commit_if,
default_colapse=True,
default_select=False,
)
countriesdict = countries.get_countries_dict()
if countriesdict is not None:
self.country_tree.set_data(countriesdict)
box.layout().addWidget(self.country_tree)
self.resize(500, 400) # why does this not work
def __init__(self):
super().__init__()
self.__pending_selection = self.selection
self._optimizer = None
self._optimizer_thread = None
self.stop_optimization = False
self.data = self.cont_x = None
self.cells = self.member_data = None
self.selection = None
# self.colors holds a palette or None when we need to draw same-colored
# circles. This happens by user's choice or when the color attribute
# is numeric and has no defined values, so we can't construct bins
self.colors: Optional[DiscretePalette] = None
self.thresholds = self.bin_labels = None
box = gui.vBox(self.controlArea, box="SOM")
shape = gui.comboBox(box,
self,
"",
items=("Hexagonal grid", "Square grid"))
shape.setCurrentIndex(1 - self.hexagonal)
box2 = gui.indentedBox(box, 10)
auto_dim = gui.checkBox(box2,
self,
"auto_dimension",
"Set dimensions automatically",
callback=self.on_auto_dimension_changed)
self.manual_box = box3 = gui.hBox(box2)
spinargs = dict(value="",
widget=box3,
master=self,
minv=5,
maxv=100,
step=5,
alignment=Qt.AlignRight)
spin_x = gui.spin(**spinargs)
spin_x.setValue(self.size_x)
gui.widgetLabel(box3, "×")
spin_y = gui.spin(**spinargs)
spin_y.setValue(self.size_y)
gui.rubber(box3)
self.manual_box.setEnabled(not self.auto_dimension)
initialization = gui.comboBox(box,
self,
"initialization",
items=("Initialize with PCA",
"Random initialization",
"Replicable random"))
start = gui.button(box,
self,
"Restart",
callback=self.restart_som_pressed,
sizePolicy=(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed))
self.opt_controls = self.OptControls(shape, auto_dim, spin_x, spin_y,
initialization, start)
box = gui.vBox(self.controlArea, "Color")
gui.comboBox(box,
self,
"attr_color",
searchable=True,
callback=self.on_attr_color_change,
model=DomainModel(placeholder="(Same color)",
valid_types=DomainModel.PRIMITIVE))
gui.checkBox(box,
self,
"pie_charts",
label="Show pie charts",
callback=self.on_pie_chart_change)
gui.checkBox(box,
self,
"size_by_instances",
label="Size by number of instances",
callback=self.on_attr_size_change)
gui.rubber(self.controlArea)
self.scene = QGraphicsScene(self)
self.view = SomView(self.scene)
self.view.setMinimumWidth(400)
self.view.setMinimumHeight(400)
self.view.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.view.setRenderHint(QPainter.Antialiasing)
self.view.selection_changed.connect(self.on_selection_change)
self.view.selection_moved.connect(self.on_selection_move)
self.view.selection_mark_changed.connect(self.on_selection_mark_change)
self.mainArea.layout().addWidget(self.view)
self.elements = None
self.grid = None
self.grid_cells = None
self.legend = None
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box,
self,
"display_convex_hull",
"Show lift convex hull",
callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
# Instance variables
self.tree_type = self.GENERAL
self.model = None
self.instances = None
self.clf_dataset = None
# The tree adapter instance which is passed from the outside
self.tree_adapter = None
self.legend = None
self.color_palette = None
# Different methods to calculate the size of squares
self.SIZE_CALCULATION = [
('Normal', lambda x: x),
('Square root', lambda x: sqrt(x)),
# The +1 is there so that we don't get division by 0 exceptions
('Logarithmic', lambda x: log(x * self.size_log_scale + 1)),
]
# Color modes for regression trees
self.REGRESSION_COLOR_CALC = [
('None', lambda _, __: QtGui.QColor(255, 255, 255)),
('Class mean', self._color_class_mean),
('Standard deviation', self._color_stddev),
]
# CONTROL AREA
# Tree info area
box_info = gui.widgetBox(self.controlArea, 'Tree Info')
self.info = gui.widgetLabel(box_info)
# Display settings area
box_display = gui.widgetBox(self.controlArea, 'Display Settings')
self.depth_slider = gui.hSlider(box_display,
self,
'depth_limit',
label='Depth',
ticks=False,
callback=self.update_depth)
self.target_class_combo = gui.comboBox(box_display,
self,
'target_class_index',
label='Target class',
orientation='horizontal',
items=[],
contentsLength=8,
callback=self.update_colors)
self.size_calc_combo = gui.comboBox(
box_display,
self,
'size_calc_idx',
label='Size',
orientation='horizontal',
items=list(zip(*self.SIZE_CALCULATION))[0],
contentsLength=8,
callback=self.update_size_calc)
self.log_scale_box = gui.hSlider(box_display,
self,
'size_log_scale',
label='Log scale factor',
minValue=1,
maxValue=100,
ticks=False,
callback=self.invalidate_tree)
# Plot properties area
box_plot = gui.widgetBox(self.controlArea, 'Plot Properties')
gui.checkBox(box_plot,
self,
'tooltips_enabled',
label='Enable tooltips',
callback=self.update_tooltip_enabled)
gui.checkBox(box_plot,
self,
'show_legend',
label='Show legend',
callback=self.update_show_legend)
# Stretch to fit the rest of the unsused area
gui.rubber(self.controlArea)
self.controlArea.setSizePolicy(QtGui.QSizePolicy.Preferred,
QtGui.QSizePolicy.Expanding)
# MAIN AREA
# The QGraphicsScene doesn't actually require a parent, but not linking
# the widget to the scene causes errors and a segfault on close due to
# the way Qt deallocates memory and deletes objects.
self.scene = TreeGraphicsScene(self)
self.scene.selectionChanged.connect(self.commit)
self.view = TreeGraphicsView(self.scene, padding=(150, 150))
self.view.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.view)
self.ptree = PythagorasTreeViewer()
self.scene.addItem(self.ptree)
self.view.set_central_widget(self.ptree)
self.resize(800, 500)
# Clear the widget to correctly set the intial values
self.clear()
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.data = None
self.valid_data = self.valid_group_data = None
self.bar_items = []
self.curve_items = []
self.curve_descriptions = None
self.binnings = []
self.last_click_idx = None
self.drag_operation = self.DragNone
self.key_operation = None
self._user_var_bins = {}
varview = gui.listView(
self.controlArea, self, "var", box="Variable",
model=DomainModel(valid_types=DomainModel.PRIMITIVE,
separators=False),
callback=self._on_var_changed)
gui.checkBox(
varview.box, self, "sort_by_freq", "Sort categories by frequency",
callback=self._on_sort_by_freq, stateWhenDisabled=False)
box = self.continuous_box = gui.vBox(self.controlArea, "Distribution")
slider = gui.hSlider(
box, self, "number_of_bins",
label="Bin width", orientation=Qt.Horizontal,
minValue=0, maxValue=max(1, len(self.binnings) - 1),
createLabel=False, callback=self._on_bins_changed)
self.bin_width_label = gui.widgetLabel(slider.box)
self.bin_width_label.setFixedWidth(35)
self.bin_width_label.setAlignment(Qt.AlignRight)
slider.sliderReleased.connect(self._on_bin_slider_released)
gui.comboBox(
box, self, "fitted_distribution", label="Fitted distribution",
orientation=Qt.Horizontal, items=(name[0] for name in self.Fitters),
callback=self._on_fitted_dist_changed)
self.smoothing_box = gui.indentedBox(box, 40)
gui.hSlider(
self.smoothing_box, self, "kde_smoothing",
label="Smoothing", orientation=Qt.Horizontal,
minValue=2, maxValue=20, callback=self.replot)
gui.checkBox(
box, self, "hide_bars", "Hide bars", stateWhenDisabled=False,
callback=self._on_hide_bars_changed,
disabled=not self.fitted_distribution)
box = gui.vBox(self.controlArea, "Columns")
gui.comboBox(
box, self, "cvar", label="Split by", orientation=Qt.Horizontal,
searchable=True,
model=DomainModel(placeholder="(None)",
valid_types=(DiscreteVariable), ),
callback=self._on_cvar_changed, contentsLength=18)
gui.checkBox(
box, self, "stacked_columns", "Stack columns",
callback=self.replot)
gui.checkBox(
box, self, "show_probs", "Show probabilities",
callback=self._on_show_probabilities_changed)
gui.checkBox(
box, self, "cumulative_distr", "Show cumulative distribution",
callback=self._on_show_cumulative)
gui.auto_apply(self.controlArea, self, commit=self.apply)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
self._set_smoothing_visibility()
self._setup_plots()
self._setup_legend()
def __init__(self):
super().__init__()
self.data = None
# The following lists are of the same length as self.active_rules
#: list of pairs with counts of matches for each patter when the
# patterns are applied in order and when applied on the entire set,
# disregarding the preceding patterns
self.match_counts = []
#: list of list of QLineEdit: line edit pairs for each pattern
self.line_edits = []
#: list of QPushButton: list of remove buttons
self.remove_buttons = []
#: list of list of QLabel: pairs of labels with counts
self.counts = []
combo = gui.comboBox(self.controlArea,
self,
"attribute",
label="From column: ",
box=True,
orientation=Qt.Horizontal,
callback=self.update_rules,
model=DomainModel(valid_types=(StringVariable,
DiscreteVariable)))
# Don't use setSizePolicy keyword argument here: it applies to box,
# not the combo
combo.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
patternbox = gui.vBox(self.controlArea, box=True)
#: QWidget: the box that contains the remove buttons, line edits and
# count labels. The lines are added and removed dynamically.
self.rules_box = rules_box = QGridLayout()
patternbox.layout().addLayout(self.rules_box)
box = gui.hBox(patternbox)
gui.button(box,
self,
"+",
callback=self.add_row,
autoDefault=False,
flat=True,
minimumSize=(QSize(20, 20)))
gui.rubber(box)
self.rules_box.setColumnMinimumWidth(1, 70)
self.rules_box.setColumnMinimumWidth(0, 10)
self.rules_box.setColumnStretch(0, 1)
self.rules_box.setColumnStretch(1, 1)
self.rules_box.setColumnStretch(2, 100)
rules_box.addWidget(QLabel("Name"), 0, 1)
rules_box.addWidget(QLabel("Substring"), 0, 2)
rules_box.addWidget(QLabel("#Instances"), 0, 3, 1, 2)
self.update_rules()
gui.lineEdit(self.controlArea,
self,
"class_name",
label="Name for the new class:",
box=True,
orientation=Qt.Horizontal)
optionsbox = gui.vBox(self.controlArea, box=True)
gui.checkBox(optionsbox,
self,
"match_beginning",
"Match only at the beginning",
callback=self.options_changed)
gui.checkBox(optionsbox,
self,
"case_sensitive",
"Case sensitive",
callback=self.options_changed)
box = gui.hBox(self.controlArea)
gui.rubber(box)
gui.button(box,
self,
"Apply",
autoDefault=False,
width=180,
callback=self.apply)
# TODO: Resizing upon changing the number of rules does not work
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
def __init__(self):
super().__init__()
self.backend = None
self.data_desc_table = None
self.database_desc = None
vbox = gui.vBox(self.controlArea, "Server", addSpace=True)
box = gui.vBox(vbox)
self.backendmodel = BackendModel(Backend.available_backends())
self.backendcombo = QComboBox(box)
if len(self.backendmodel):
self.backendcombo.setModel(self.backendmodel)
else:
self.Error.no_backends()
box.setEnabled(False)
box.layout().addWidget(self.backendcombo)
self.servertext = QLineEdit(box)
self.servertext.setPlaceholderText('Server')
self.servertext.setToolTip('Server')
if self.host:
self.servertext.setText(self.host if not self.port else '{}:{}'.
format(self.host, self.port))
box.layout().addWidget(self.servertext)
self.databasetext = QLineEdit(box)
self.databasetext.setPlaceholderText('Database[/Schema]')
self.databasetext.setToolTip('Database or optionally Database/Schema')
if self.database:
self.databasetext.setText(
self.database if not self.schema else '{}/{}'.
format(self.database, self.schema))
box.layout().addWidget(self.databasetext)
self.usernametext = QLineEdit(box)
self.usernametext.setPlaceholderText('Username')
self.usernametext.setToolTip('Username')
if self.username:
self.usernametext.setText(self.username)
box.layout().addWidget(self.usernametext)
self.passwordtext = QLineEdit(box)
self.passwordtext.setPlaceholderText('Password')
self.passwordtext.setToolTip('Password')
self.passwordtext.setEchoMode(QLineEdit.Password)
if self.password:
self.passwordtext.setText(self.password)
box.layout().addWidget(self.passwordtext)
tables = gui.hBox(box)
self.tablemodel = TableModel()
self.tablecombo = QComboBox(
minimumContentsLength=35,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength)
self.tablecombo.setModel(self.tablemodel)
self.tablecombo.setToolTip('table')
tables.layout().addWidget(self.tablecombo)
self.tablecombo.activated[int].connect(self.select_table)
self.connectbutton = gui.button(tables,
self,
'↻',
callback=self.connect)
self.connectbutton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
tables.layout().addWidget(self.connectbutton)
self.custom_sql = gui.vBox(box)
self.custom_sql.setVisible(False)
self.sqltext = QTextEdit(self.custom_sql)
self.sqltext.setPlainText(self.sql)
self.custom_sql.layout().addWidget(self.sqltext)
mt = gui.hBox(self.custom_sql)
cb = gui.checkBox(mt, self, 'materialize', 'Materialize to table ')
cb.setToolTip('Save results of the query in a table')
le = gui.lineEdit(mt, self, 'materialize_table_name')
le.setToolTip('Save results of the query in a table')
self.executebtn = gui.button(self.custom_sql,
self,
'Execute',
callback=self.open_table)
box.layout().addWidget(self.custom_sql)
gui.checkBox(box,
self,
"guess_values",
"Auto-discover discrete variables",
callback=self.open_table)
gui.checkBox(box,
self,
"download",
"Download data to local memory",
callback=self.open_table)
gui.rubber(self.buttonsArea)
QTimer.singleShot(0, self.connect)
def __init__(self):
super().__init__()
self.controlArea = QWidget(self.controlArea)
self.layout().addWidget(self.controlArea)
layout = QGridLayout()
self.controlArea.setLayout(layout)
layout.setContentsMargins(4, 4, 4, 4)
self.methods = [method for method in METHODS if method[-1] is not None]
self.tab_index = 0
self.mutex = QMutex()
self.graph = None
self.items = None # items set by Items signal
self.items_graph = None # items set by graph.items by Network signal
self.items_analysis = None # items to output and merge with analysis result
self.job_queue = []
self.job_working = []
self.analfeatures = []
self.analdata = {}
for method in self.methods:
setattr(self, method[0], method[0] in self.enabled_methods)
setattr(self, "lbl_" + method[0], "")
self.tabs = gui.tabWidget(self.controlArea)
self.tabs.setMinimumWidth(450)
self.graphIndices = gui.createTabPage(self.tabs, "Graph-level indices")
self.nodeIndices = gui.createTabPage(self.tabs, "Node-level indices")
self.tabs.setCurrentIndex(self.tab_index)
self.tabs.currentChanged.connect(
lambda index: setattr(self, 'tab_index', index))
a = {NODELEVEL: self.nodeIndices, GRAPHLEVEL: self.graphIndices}
for name, _, label, type, algorithm in self.methods:
box = gui.widgetBox(a[type], orientation="horizontal")
gui.checkBox(box,
self,
name,
label=label,
callback=lambda n=name: self.method_clicked(n))
box.layout().addStretch(1)
lbl = gui.label(box, self, "%(lbl_" + name + ")s")
setattr(self, "tool_" + name, lbl)
self.graphIndices.layout().addStretch(1)
self.nodeIndices.layout().addStretch(1)
autobox = gui.auto_commit(None,
self,
"auto_commit",
"Commit",
commit=self.analyze)
layout.addWidget(autobox, 3, 0, 1, 1)
cancel = gui.button(None,
self,
"Cancel",
callback=lambda: self.stop_job(current=False))
autobox.layout().insertWidget(3, cancel)
autobox.layout().insertSpacing(2, 10)
cancel.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
