def __init__(self):
OWDataProjectionWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.pca_projection = None # type: Optional[Table]
self.initialization = None # type: Optional[np.ndarray]
self.affinities = None # type: Optional[openTSNE.affinity.Affinities]
self.tsne_embedding = None # type: Optional[manifold.TSNEModel]
self.iterations_done = 0 # type: int
def __init__(self):
OWDataProjectionWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
#: Input dissimilarity matrix
self.matrix = None # type: Optional[DistMatrix]
#: Data table from the `self.matrix.row_items` (if present)
self.matrix_data = None # type: Optional[Table]
#: Input data table
self.signal_data = None
self.embedding = None # type: Optional[np.ndarray]
self.effective_matrix = None # type: Optional[DistMatrix]
self.graph.pause_drawing_pairs()
self.size_model = self.gui.points_models[2]
self.size_model.order = \
self.gui.points_models[2].order[:1] \
+ ("Stress", ) + \
self.gui.points_models[2].order[1:]
def __init__(self):
OWAnchorProjectionWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
# Init data
self.data = None
self.selected_data = None
# used for transforming the 'selected data' into the 'data' domain
self.selected_data_transformed = None
self.results = Result()
# info box
fbox = gui.widgetBox(self.controlArea, "Info")
self.info_fil = gui.label(fbox, self, 'Words displayed: 0')
# 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,
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,
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.NoSelection)
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):
OWAnchorProjectionWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.corpus = None
# Browse file box
fbox = gui.widgetBox(self.controlArea, "Corpus file", orientation=0)
self.file_widget = widgets.FileWidget(
recent_files=self.recent_files,
icon_size=(16, 16),
on_open=self.open_file,
dialog_format=self.dlgFormats,
dialog_title='Open Orange Document Corpus',
reload_label='Reload',
browse_label='Browse',
allow_empty=False,
minimal_width=250,
)
fbox.layout().addWidget(self.file_widget)
# dropdown to select title variable
self.title_model = DomainModel(valid_types=(StringVariable, ),
placeholder="(no title)")
gui.comboBox(self.controlArea,
self,
"title_variable",
box="Title variable",
model=self.title_model,
callback=self.update_feature_selection)
# Used Text Features
fbox = gui.widgetBox(self.controlArea, orientation=0)
ubox = gui.widgetBox(fbox, "Used text features")
self.used_attrs_model = VariableListModel(enable_dnd=True)
self.used_attrs_view = VariablesListItemView()
self.used_attrs_view.setModel(self.used_attrs_model)
ubox.layout().addWidget(self.used_attrs_view)
aa = self.used_attrs_model
aa.dataChanged.connect(self.update_feature_selection)
aa.rowsInserted.connect(self.update_feature_selection)
aa.rowsRemoved.connect(self.update_feature_selection)
# Ignored Text Features
ibox = gui.widgetBox(fbox, "Ignored text features")
self.unused_attrs_model = VariableListModel(enable_dnd=True)
self.unused_attrs_view = VariablesListItemView()
self.unused_attrs_view.setModel(self.unused_attrs_model)
ibox.layout().addWidget(self.unused_attrs_view)
# Documentation Data Sets & Report
box = gui.hBox(self.controlArea)
self.browse_documentation = gui.button(
box,
self,
"Browse documentation corpora",
callback=lambda: self.file_widget.browse(get_sample_corpora_dir()),
autoDefault=False,
)
# load first file
self.file_widget.select(0)
self.update_output_info()
self.update_input_info(None)
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):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
# ATTRIBUTES #
self.target_database = ENTREZ_ID
# input data
self.input_data = None
self.input_genes = None
self.tax_id = None
self.column_candidates = []
# input options
self.organisms = []
# gene matcher
self.gene_matcher = None
# progress bar
self.progress_bar = None
self._timer = QTimer()
self._timer.timeout.connect(self._apply_filter)
self._timer.setSingleShot(True)
# GUI SECTION #
# Control area
self.info_box = widgetLabel(
widgetBox(self.controlArea, "Info", addSpace=True),
'No data on input.\n')
organism_box = vBox(self.controlArea, 'Organism')
self.organism_select_combobox = comboBox(
organism_box,
self,
'selected_organism',
callback=self.on_input_option_change)
self.get_available_organisms()
self.organism_select_combobox.setCurrentIndex(self.selected_organism)
box = widgetBox(self.controlArea, 'Gene IDs in the input data')
self.gene_columns_model = itemmodels.DomainModel(
valid_types=(StringVariable, DiscreteVariable))
self.gene_column_combobox = comboBox(
box,
self,
'selected_gene_col',
label='Stored in data column',
model=self.gene_columns_model,
sendSelectedValue=True,
callback=self.on_input_option_change,
)
self.attr_names_checkbox = checkBox(
box,
self,
'use_attr_names',
'Stored as feature (column) names',
disables=[(-1, self.gene_column_combobox)],
callback=self.on_input_option_change,
)
self.gene_column_combobox.setDisabled(bool(self.use_attr_names))
output_box = vBox(self.controlArea, 'Output')
# separator(output_box)
# output_box.layout().addWidget(horizontal_line())
# separator(output_box)
self.exclude_radio = checkBox(output_box,
self,
'exclude_unmatched',
'Exclude unmatched genes',
callback=self.commit)
self.replace_radio = checkBox(output_box,
self,
'replace_id_with_symbol',
'Replace feature IDs with gene names',
callback=self.commit)
auto_commit(self.controlArea,
self,
"auto_commit",
"&Commit",
box=False)
rubber(self.controlArea)
# Main area
self.filter = lineEdit(self.mainArea,
self,
'search_pattern',
'Filter:',
callbackOnType=True,
callback=self.handle_filter_callback)
# rubber(self.radio_group)
self.mainArea.layout().addWidget(self.filter)
# set splitter
self.splitter = QSplitter()
self.splitter.setOrientation(Qt.Vertical)
self.table_model = GeneInfoModel()
self.table_view = QTableView()
self.table_view.setAlternatingRowColors(True)
self.table_view.viewport().setMouseTracking(True)
self.table_view.setSortingEnabled(True)
self.table_view.setShowGrid(False)
self.table_view.verticalHeader().hide()
# self.table_view.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.unknown_model = UnknownGeneInfoModel()
self.unknown_view = QTableView()
self.unknown_view.setModel(self.unknown_model)
self.unknown_view.verticalHeader().hide()
self.unknown_view.setShowGrid(False)
self.unknown_view.setSelectionMode(QAbstractItemView.NoSelection)
self.unknown_view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.splitter.addWidget(self.table_view)
self.splitter.addWidget(self.unknown_view)
self.splitter.setStretchFactor(0, 90)
self.splitter.setStretchFactor(1, 10)
self.mainArea.layout().addWidget(self.splitter)
def __init__(self):
OWDataProjectionWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.embedding = None # type: Optional[np.ndarray]
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.scorers: List[ScoreMeta] = []
self.out_domain_desc = None
self.data = None
self.problem_type_mode = ProblemType.CLASSIFICATION
# results caches
self.scorers_results = {}
self.methods_results = {}
if not self.selected_methods:
self.selected_methods = {method.name for method in SCORES
if method.is_default}
# GUI
self.ranksModel = model = TableModel(parent=self) # type: TableModel
self.ranksView = view = TableView(self) # type: TableView
self.mainArea.layout().addWidget(view)
view.setModel(model)
view.setColumnWidth(0, 30)
view.selectionModel().selectionChanged.connect(self.on_select)
def _set_select_manual():
self.setSelectionMethod(OWRank.SelectManual)
view.manualSelection.connect(_set_select_manual)
view.verticalHeader().sectionClicked.connect(_set_select_manual)
view.horizontalHeader().sectionClicked.connect(self.headerClick)
self.measuresStack = stacked = QStackedWidget(self)
self.controlArea.layout().addWidget(stacked)
for scoring_methods in (CLS_SCORES,
REG_SCORES,
[]):
box = gui.vBox(None, "Scoring Methods" if scoring_methods else None)
stacked.addWidget(box)
for method in scoring_methods:
box.layout().addWidget(QCheckBox(
method.name, self,
objectName=method.shortname, # To be easily found in tests
checked=method.name in self.selected_methods,
stateChanged=partial(self.methodSelectionChanged, method_name=method.name)))
gui.rubber(box)
gui.rubber(self.controlArea)
self.switchProblemType(ProblemType.CLASSIFICATION)
selMethBox = gui.vBox(self.buttonsArea, "Select Attributes")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.setSpacing(6)
self.selectButtons = QButtonGroup()
self.selectButtons.buttonClicked[int].connect(self.setSelectionMethod)
def button(text, buttonid, toolTip=None):
b = QRadioButton(text)
self.selectButtons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr("None"), OWRank.SelectNone)
b2 = button(self.tr("All"), OWRank.SelectAll)
b3 = button(self.tr("Manual"), OWRank.SelectManual)
b4 = button(self.tr("Best ranked:"), OWRank.SelectNBest)
s = gui.spin(selMethBox, self, "nSelected", 1, 999,
callback=lambda: self.setSelectionMethod(OWRank.SelectNBest),
addToLayout=False)
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(b4, 3, 0)
grid.addWidget(s, 3, 1)
self.selectButtons.button(self.selectionMethod).setChecked(True)
selMethBox.layout().addLayout(grid)
gui.auto_send(self.buttonsArea, self, "auto_apply")
self.resize(690, 500)
def __init__(self):
OWWidget.__init__(self)
ConcurrentWidgetMixin.__init__(self)
self.data: Optional[Table] = None
self.attr_name_to_variable: Optional[Table] = None
self.covariates_from_worker_result = None
self.time_var: Optional[str] = None
self.event_var: Optional[str] = None
gui.rubber(self.controlArea)
sel_method_box = gui.vBox(self.buttonsArea, 'Select Attributes')
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.setSpacing(6)
self.select_buttons = QButtonGroup()
self.select_buttons.buttonClicked[int].connect(
self.set_selection_method)
def button(text, buttonid, toolTip=None):
b = QRadioButton(text)
self.select_buttons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr('None'), OWRankSurvivalFeatures.select_none)
b2 = button(self.tr('Manual'), OWRankSurvivalFeatures.manual_selection)
b3 = button(self.tr('Best ranked:'),
OWRankSurvivalFeatures.select_n_best)
s = gui.spin(
sel_method_box,
self,
'n_selected',
1,
9999,
callback=lambda: self.set_selection_method(OWRankSurvivalFeatures.
select_n_best),
addToLayout=False,
)
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(s, 2, 1)
sel_method_box.layout().addLayout(grid)
self.select_buttons.button(self.selection_method).setChecked(True)
self.commit_button = gui.auto_commit(self.buttonsArea,
self,
'auto_commit',
'&Commit',
box=False)
# Main area
self.model = PyTableModel(parent=self)
self.table_view = TableView(parent=self)
self.table_view.setModel(self.model)
self.model.setHorizontalHeaderLabels([
'Log-Likelihood', 'Log-Likelihood Ratio', f'{"p".center(13)}',
'FDR'
])
self.table_view.setSizeAdjustPolicy(
QAbstractScrollArea.AdjustToContentsOnFirstShow)
self.table_view.selectionModel().selectionChanged.connect(
self.on_select)
def _set_select_manual():
self.set_selection_method(OWRankSurvivalFeatures.manual_selection)
self.table_view.manualSelection.connect(_set_select_manual)
self.table_view.verticalHeader().sectionClicked.connect(
_set_select_manual)
self.mainArea.layout().addWidget(self.table_view)