def __init__(self): super().__init__() # The main label of the Control's GUI. # gui.label(self.controlArea, self, "Spark Context") self.conf = SparkConf() all_prefedined = dict(self.conf.getAll()) # Create parameters Box. box = gui.widgetBox(self.controlArea, "Spark Application", addSpace = True) self.gui_parameters = OrderedDict() main_parameters = OrderedDict() main_parameters['spark.app.name'] = 'OrangeSpark' main_parameters['spark.master'] = 'yarn-client' main_parameters["spark.executor.instances"] = "8" main_parameters["spark.executor.cores"] = "4" main_parameters["spark.executor.memory"] = "8g" main_parameters["spark.driver.cores"] = "4" main_parameters["spark.driver.memory"] = "2g" main_parameters["spark.logConf"] = "false" main_parameters["spark.app.id"] = "dummy" for k, v in main_parameters.items(): default_value = all_prefedined.setdefault(k, v) self.gui_parameters[k] = GuiParam(parent_widget = box, label = k, default_value = v) all_prefedined.pop(k) for k, v in all_prefedined.items(): self.gui_parameters[k] = GuiParam(parent_widget = box, label = k, default_value = str(v)) action_box = gui.widgetBox(box) # Action Button self.create_sc_btn = gui.button(action_box, self, label = 'Submit', callback = self.create_context)
def __init__(self): super().__init__() self.data = None self.input_vars = () self._invalidated = False box = gui.widgetBox(self.controlArea, "Domain Features") self.domain_model = itemmodels.VariableListModel() self.domain_view = QListView( selectionMode=QListView.SingleSelection ) self.domain_view.setModel(self.domain_model) self.domain_view.selectionModel().selectionChanged.connect( self._on_selection_changed) box.layout().addWidget(self.domain_view) box = gui.widgetBox(self.controlArea, "Reset") gui.button(box, self, "Reset selected", callback=self.reset_selected) gui.button(box, self, "Reset all", callback=self.reset_all) gui.auto_commit(self.controlArea, self, "autocommit", "Commit", "Commit on change is on") box = gui.widgetBox(self.mainArea, "Edit") self.editor_stack = QtGui.QStackedWidget() self.editor_stack.addWidget(DiscreteVariableEditor()) self.editor_stack.addWidget(ContinuousVariableEditor()) self.editor_stack.addWidget(VariableEditor()) box.layout().addWidget(self.editor_stack)
def __init__(self): super().__init__() self.data = None self.db = None box = gui.widgetBox(self.controlArea, "Parameters") gui.spin(box, self, "min_samples", 1, 100, 1, callback=self._invalidate, label="Core point neighbors") gui.doubleSpin(box, self, "eps", 0.1, 0.9, 0.1, callback=self._invalidate, label="Neighborhood distance") box = gui.widgetBox(self.controlArea, self.tr("Distance Metric")) gui.comboBox(box, self, "metric_idx", items=list(zip(*self.METRICS))[0], callback=self._invalidate) box = gui.widgetBox(self.controlArea, "Output") gui.comboBox(box, self, "place_cluster_ids", label="Append cluster id as ", orientation="horizontal", callback=self.send_data, items=self.OUTPUT_METHODS) gui.lineEdit(box, self, "output_name", label="Name: ", orientation="horizontal", callback=self.send_data) gui.auto_commit(self.controlArea, self, "auto_run", "Run", checkbox_label="Run after any change ", orientation="horizontal") gui.rubber(self.controlArea) self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width()) self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self): super().__init__() self.data = None self.learner = None self.preprocessors = None self.model = None gui.lineEdit(self.controlArea, self, 'model_name', box='Name', tooltip='The name will identify this model in other ' 'widgets') gui.comboBox(self.controlArea, self, "attribute_score", box='Feature selection', items=[name for name, _ in self.scores]) box = gui.widgetBox(self.controlArea, 'Pruning') gui.spin(box, self, "min_leaf", 1, 1000, label="Min. instances in leaves ", checked="limit_min_leaf") gui.spin(box, self, "min_internal", 1, 1000, label="Stop splitting nodes with less instances than ", checked="limit_min_internal") gui.spin(box, self, "max_depth", 1, 1000, label="Limit the depth to ", checked="limit_depth") box = gui.widgetBox(self.controlArea, True, orientation="horizontal") box.layout().addWidget(self.report_button) gui.separator(box, 20) self.btn_apply = gui.button(box, self, "&Apply", callback=self.apply, disabled=0, default=True) self.apply()
def __init__(self): super().__init__() self.data = None self.preprocessors = None box = gui.widgetBox(self.controlArea, "Learner/Predictor Name") gui.lineEdit(box, self, "learner_name") box = gui.widgetBox(self.controlArea, "Regularization") box = gui.radioButtons( box, self, "reg_type", btnLabels=["No regularization", "Ridge regression", "Lasso regression"], callback=self._reg_type_changed) gui.separator(box) self.alpha_box = box2 = gui.widgetBox(box, margin=0) gui.widgetLabel(box2, "Regularization strength") self.alpha_slider = gui.hSlider( box2, self, "alpha_index", minValue=0, maxValue=len(self.alphas) - 1, callback=self._alpha_changed, createLabel=False) box3 = gui.widgetBox(box, orientation="horizontal") box3.layout().setAlignment(Qt.AlignCenter) self.alpha_label = gui.widgetLabel(box3, "") self._set_alpha_label() gui.auto_commit(self.controlArea, self, "autosend", "Apply", checkbox_label="Apply on every change") self.layout().setSizeConstraint(QLayout.SetFixedSize) self.alpha_slider.setEnabled(self.reg_type != self.OLS) self.commit()
def add_main_layout(self): box = gui.widgetBox(self.controlArea, "Parameters") self.base_estimator = self.DEFAULT_BASE_ESTIMATOR self.base_label = gui.label( box, self, "Base estimator: " + self.base_estimator.name.title()) self.n_estimators_spin = gui.spin( box, self, "n_estimators", 1, 100, label="Number of estimators:", alignment=Qt.AlignRight, controlWidth=80, callback=self.settings_changed) self.learning_rate_spin = gui.doubleSpin( box, self, "learning_rate", 1e-5, 1.0, 1e-5, label="Learning rate:", decimals=5, alignment=Qt.AlignRight, controlWidth=80, callback=self.settings_changed) self.random_seed_spin = gui.spin( box, self, "random_seed", 0, 2 ** 31 - 1, controlWidth=80, label="Fixed seed for random generator:", alignment=Qt.AlignRight, callback=self.settings_changed, checked="use_random_seed", checkCallback=self.settings_changed) # Algorithms box = gui.widgetBox(self.controlArea, "Boosting method") self.cls_algorithm_combo = gui.comboBox( box, self, "algorithm_index", label="Classification algorithm:", items=self.algorithms, orientation=Qt.Horizontal, callback=self.settings_changed) self.reg_algorithm_combo = gui.comboBox( box, self, "loss_index", label="Regression loss function:", items=self.losses, orientation=Qt.Horizontal, callback=self.settings_changed)
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.widgetBox(self.mainArea, boxCaption) box = gui.widgetBox(buttBox, orientation="horizontal") self.__dict__["exCont" + paletteName + "Left"] = ColorButton(self, box, color=QColor(initialColor1)) self.__dict__["exCont" + paletteName + "View"] = PaletteView(box) self.__dict__["exCont" + paletteName + "Right"] = ColorButton(self, box, color=QColor(initialColor2)) self.__dict__["exCont" + paletteName + "passThroughColors"] = passThroughColors self.__dict__["exCont" + paletteName + "passThroughColorsCheckbox"] = gui.checkBox(buttBox, self, "exCont" + paletteName + "passThroughColors", "Use pass-through colors", callback=self.colorSchemaChange) box = gui.widgetBox(buttBox, "Pass-through colors", orientation="horizontal") for i, (color, check) in enumerate(extendedPassThroughColors): self.__dict__["exCont" + paletteName + "passThroughColor" + str(i)] = check self.__dict__["exCont" + paletteName + "passThroughColor" + str(i) + "Checkbox"] = cb = gui.checkBox(box, self, "exCont" + paletteName + "passThroughColor" + str( i), "", tooltip="Use color", callback=self.colorSchemaChange) self.__dict__["exCont" + paletteName + "color" + str(i)] = ColorButton(self, box, color=QColor(color)) if i < len(extendedPassThroughColors) - 1: gui.rubber(box) self.__dict__["exCont" + paletteName + "colorCount"] = len(extendedPassThroughColors) self.exContPaletteNames.append(paletteName)
def __init__(self): super().__init__() gui.label(self.controlArea, self, "from pandas:") self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) self.allSQLSelectWidgets.append(self) # set default settings self.domain = None self.recentConnections = list() self.recentConnections.append("(none)") self.queryFile = None self.query = "" self.lastQuery = None if self.lastQuery is not None: self.query = self.lastQuery sources = pyodbc.dataSources() dsns = list(sources.keys()) dsns.sort() for dsn in dsns: self.recentConnections.append("DSN={dsn}".format(dsn=dsn)) self.connectString = self.recentConnections[0] self.connectBox = gui.widgetBox(self.controlArea, "Database") self.connectLineEdit = gui.lineEdit(self.connectBox, self, "connectString", callback=None) self.connectCombo = gui.comboBox( self.connectBox, self, "connectString", items=self.recentConnections, valueType=str, sendSelectedValue=True ) self.button = gui.button(self.connectBox, self, "connect", callback=self.connectDB, disabled=0) # query self.splitCanvas = QSplitter(QtCore.Qt.Vertical, self.mainArea) self.mainArea.layout().addWidget(self.splitCanvas) self.textBox = gui.widgetBox(self, "HiveQL") self.splitCanvas.addWidget(self.textBox) self.queryTextEdit = QPlainTextEdit(self.query, self) self.textBox.layout().addWidget(self.queryTextEdit) self.selectBox = gui.widgetBox(self.controlArea, "Select statement") # self.selectSubmitBox = QHGroupBox("", self.selectBox) # self.queryTextEdit.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)) # self.queryTextEdit.setMinimumWidth(300) # self.connect(self.queryTextEdit, SIGNAL('returnPressed()'), self.executeQuery) gui.button(self.selectBox, self, "Open...", callback=self.openScript) gui.button(self.selectBox, self, "Save...", callback=self.saveScript) self.selectBox.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)) gui.button(self.selectBox, self, "format SQL!", callback=self.format_sql, disabled=0) gui.button(self.selectBox, self, "execute!", callback=self.executeQuery, disabled=0) self.domainBox = gui.widgetBox(self.controlArea, "Domain") self.domainLabel = gui.label(self.domainBox, self, "") # info self.infoBox = gui.widgetBox(self.controlArea, "Info") self.info = [] self.info.append(gui.label(self.infoBox, self, "No data loaded.")) self.info.append(gui.label(self.infoBox, self, "")) self.resize(300, 300) self.cnxn = None
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.preprocessors = None self.data = None box = gui.widgetBox(self.controlArea, "Learner/Model Name") gui.lineEdit(box, self, "learner_name") box = gui.widgetBox(self.controlArea, "Neighbors") gui.spin(box, self, "n_neighbors", 1, 100, label="Number of neighbors") box = gui.widgetBox(box, "Metric") box.setFlat(True) box.layout().setContentsMargins(0, 0, 0, 0) gui.comboBox(box, self, "metric_index", items=["Euclidean", "Manhattan", "Maximal", "Mahalanobis"]) self.metrics = ["euclidean", "manhattan", "chebyshev", "mahalanobis"] gui.button(self.controlArea, self, "Apply", callback=self.apply, default=True) self.controlArea.layout().addWidget(self.report_button) layout = self.layout() self.layout().setSizeConstraint(layout.SetFixedSize) self.apply()
def __init__(self): super().__init__() self.data = None self.preprocessors = None box = gui.widgetBox(self.controlArea, self.tr("Name")) gui.lineEdit(box, self, "learner_name") box = gui.widgetBox(self.controlArea, box=True) gui.comboBox(box, self, "penalty_type", label="Regularization type: ", items=self.penalty_types, orientation="horizontal", addSpace=4) gui.widgetLabel(box, "Strength:") box2 = gui.widgetBox(gui.indentedBox(box), orientation="horizontal") gui.widgetLabel(box2, "Weak").setStyleSheet("margin-top:6px") gui.hSlider(box2, self, "C_index", minValue=0, maxValue=len(self.C_s) - 1, callback=self.set_c, createLabel=False) gui.widgetLabel(box2, "Strong").setStyleSheet("margin-top:6px") box2 = gui.widgetBox(box, orientation="horizontal") box2.layout().setAlignment(Qt.AlignCenter) self.c_label = gui.widgetLabel(box2) box = gui.widgetBox(self.controlArea, orientation="horizontal", margin=0) box.layout().addWidget(self.report_button) gui.button(box, self, "&Apply", callback=self.apply, default=True) self.set_c() self.apply()
def __init__(self, parent=None): widget.OWWidget.__init__(self, parent) box = gui.widgetBox(self.controlArea, "Multinomial attributes") gui.radioButtonsInBox( box, self, "multinomial_treatment", btnLabels=[x[0] for x in self.multinomial_treats], callback=self.settings_changed) box = gui.widgetBox(self.controlArea, "Continuous attributes") gui.radioButtonsInBox( box, self, "continuous_treatment", btnLabels=[x[0] for x in self.continuous_treats], callback=self.settings_changed) box = gui.widgetBox(self.controlArea, "Discrete class attribute") gui.radioButtonsInBox( box, self, "class_treatment", btnLabels=[t[0] for t in self.class_treats], callback=self.settings_changed) zbbox = gui.widgetBox(self.controlArea, "Value range") gui.radioButtonsInBox( zbbox, self, "zero_based", btnLabels=self.value_ranges, callback=self.settings_changed) gui.auto_commit(self.controlArea, self, "autosend", "Apply") self.data = None self.resize(150, 300)
def __init__(self): super().__init__() self.data = None 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.removedAttrs = "-" self.reducedAttrs = "-" self.resortedAttrs = "-" self.removedClasses = "-" self.reducedClasses = "-" self.resortedClasses = "-" boxAt = gui.widgetBox(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.widgetBox(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.widgetBox(self.controlArea, 'Statistics', addSpace=True) for label, value in self.stat_labels: gui.label(box3, self, "{}: %({})s".format(label, value)) gui.auto_commit(self.controlArea, self, "autoSend", "Send Data", checkbox_label="Send automatically", orientation="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 _create_layout(self): self.mainArea.layout().addWidget(self.graphview) info = gui.widgetBox(self.controlArea, 'Info') gui.label(info, self, '%(n_object_types)d object types') gui.label(info, self, '%(n_relations)d relations') # Table view of relation details info = gui.widgetBox(self.controlArea, 'Relations') class TableView(gui.TableView): def __init__(self, parent=None, **kwargs): super().__init__(parent, **kwargs) self._parent = parent self.bold_font = self.BoldFontDelegate(self) # member because PyQt sometimes unrefs too early self.setItemDelegateForColumn(2, self.bold_font) self.setItemDelegateForColumn(4, self.bold_font) self.horizontalHeader().setVisible(False) def selectionChanged(self, selected, deselected): super().selectionChanged(selected, deselected) if not selected: assert len(deselected) > 0 relation = None else: assert len(selected) == 1 data = self._parent.tablemodel[selected[0].top()][0] relation = Relation(data) self._parent.send(Output.RELATION, relation) model = self.tablemodel = PyTableModel(parent=self) table = self.table = TableView(self, selectionMode=TableView.SingleSelection) table.setModel(model) info.layout().addWidget(self.table) gui.lineEdit(self.controlArea, self, 'pref_algo_name', 'Fuser name:', orientation='horizontal', callback=self.checkcommit, enterPlaceholder=True) gui.radioButtons(self.controlArea, self, 'pref_algorithm', [i[0] for i in DECOMPOSITION_ALGO], box='Decomposition algorithm', callback=self.checkcommit) gui.radioButtons(self.controlArea, self, 'pref_initialization', INITIALIZATION_ALGO, box='Initialization algorithm', callback=self.checkcommit) slider = gui.hSlider( self.controlArea, self, 'pref_n_iterations', 'Maximum number of iterations', minValue=10, maxValue=500, createLabel=True, callback=self.checkcommit) slider.setTracking(False) self.slider_rank = gui.hSlider(self.controlArea, self, 'pref_rank', 'Factorization rank', minValue=1, maxValue=100, createLabel=True, labelFormat=" %d%%", callback=self.checkcommit) self.slider_rank.setTracking(False) gui.auto_commit(self.controlArea, self, "autorun", "Run", checkbox_label="Run after any change ")
def __init__(self, parent, windowTitle="New York Times API key"): super().__init__(parent, windowTitle=windowTitle) self.parent = parent self.setLayout(QVBoxLayout()) self.layout().setMargin(10) self.mainArea = gui.widgetBox(self) self.layout().addWidget(self.mainArea) # Combo box. self.api_key_combo = QComboBox(self.mainArea) self.api_key_combo.setEditable(True) self.api_key_combo.activated[int].connect(self.select_api_key) self.mainArea.layout().addWidget(self.api_key_combo) # Buttons self.button_box = gui.widgetBox(self.mainArea, orientation="horizontal") gui.button(self.button_box, self, "Check", self.check_api_key) gui.button(self.button_box, self, "OK", self.accept_changes) gui.button(self.button_box, self, "Cancel", self.reject_changes) # Label self.label_box = gui.widgetBox(self, orientation="horizontal") self.api_key_check_label = gui.label(self.label_box, self, "") if self.parent.api_key_is_valid: self.api_key_check_label.setText("API key is valid.") else: self.api_key_check_label.setText("API key NOT validated!") # Load the most recent API keys. self.set_key_list()
def _add_controls(self): infobox = gui.widgetBox(self.controlArea, "Info") self.infoLabel = gui.widgetLabel(infobox, "No data on input.") displaybox = gui.widgetBox(self.controlArea, "Display") gui.checkBox(displaybox, self, "show_profiles", "Lines", callback=self.__show_profiles_changed, tooltip="Plot lines") gui.checkBox(displaybox, self, "show_range", "Range", callback=self.__show_range_changed, tooltip="Plot range between 10th and 90th percentile") gui.checkBox(displaybox, self, "show_mean", "Mean", callback=self.__show_mean_changed, tooltip="Plot mean curve") gui.checkBox(displaybox, self, "show_error", "Error bars", callback=self.__show_error_changed, tooltip="Show standard deviation") self.group_vars = DomainModel( placeholder="None", separators=False, valid_types=DiscreteVariable) self.group_view = gui.listView( self.controlArea, self, "group_var", box="Group by", model=self.group_vars, callback=self.__group_var_changed) self.group_view.setEnabled(False) self.group_view.setMinimumSize(QSize(30, 100)) self.group_view.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored) plot_gui = OWPlotGUI(self) plot_gui.box_zoom_select(self.controlArea) gui.rubber(self.controlArea) gui.auto_commit(self.controlArea, self, "auto_commit", "Send Selection", "Send Automatically")
def __init__(self, parent=None): super().__init__(parent) self.data = None self.preprocessors = None box = gui.widgetBox(self.controlArea, "Learner/Predictor Name") gui.lineEdit(box, self, "learner_name") box = gui.widgetBox(self.controlArea, "Options") box = gui.radioButtons(box, self, "reg_type", callback=self._reg_type_changed) gui.appendRadioButton(box, "Ordinary linear regression") gui.appendRadioButton(box, "Ridge regression") ibox = gui.indentedBox(box) gui.doubleSpin(ibox, self, "ridgealpha", 0.0, 1000.0, label="alpha:") self.ridge_box = ibox gui.appendRadioButton(box, "Lasso regression") ibox = gui.indentedBox(box) gui.doubleSpin(ibox, self, "lassoalpha", 0.0, 1000.0, label="alpha") self.lasso_box = ibox gui.button(self.controlArea, self, "Apply", callback=self.apply, default=True) self.layout().setSizeConstraint(QLayout.SetFixedSize) self.ridge_box.setEnabled(self.reg_type == self.Ridge) self.lasso_box.setEnabled(self.reg_type == self.Lasso) self.apply()
def __init__(self): super().__init__() self.corpus = None self.preprocessor = None self.normalization = None # Pre-processing info. pp_info_box = gui.widgetBox(self.controlArea, "Pre-processing info") pp_info = "Includes punctuation: {}\n" \ "Lowercase: {}\n" \ "Transformation: {}\n" \ "Stop words removed: {}\n" \ "TF-IDF performed: {}\n" \ "Normalization: {}"\ .format(False, False, None, None, self.use_tfidf, self.normalization) self.pp_info_label = gui.label(pp_info_box, self, pp_info) # TF-IDF. tfidf_box = gui.widgetBox(self.controlArea, "TF-IDF", addSpace=False) self.tfidf_chbox = gui.checkBox(tfidf_box, self, "use_tfidf", "Use TF-IDF") self.tfidf_chbox.stateChanged.connect(self._tfidf_changed) ibox = gui.indentedBox(tfidf_box) self.norm_combo = gui.comboBox(ibox, self, 'normalization_type', items=self._normalization_options, label="Normalization:") self.norm_combo.activated[int].connect(self._select_normalization) self.norm_combo.setEnabled(self.use_tfidf) gui.button(self.controlArea, self, "&Apply", callback=self.apply, default=True)
def __init__(self): super().__init__() # options box self.options_box = gui.widgetBox(self.controlArea, "Data") opts = dict( widget=self.options_box, master=self, orientation=Qt.Horizontal, callback=self.restart, sendSelectedValue=True, maximumContentsLength=15) self.cbx = gui.comboBox(value='attr_x', label='X: ', **opts) self.cby = gui.comboBox(value='attr_y', label='Y: ', **opts) self.centroids_box = gui.widgetBox(self.controlArea, "Centroids") self.centroid_numbers_spinner = gui.spin( self.centroids_box, self, 'number_of_clusters', minv=1, maxv=10, step=1, label='Number of centroids:', alignment=Qt.AlignRight, callback=self.number_of_clusters_change) self.restart_button = gui.button( self.centroids_box, self, "Randomize Positions", callback=self.restart) gui.separator(self.centroids_box) self.lines_checkbox = gui.checkBox( self.centroids_box, self, 'lines_to_centroids', 'Show membership lines', callback=self.complete_replot) # control box gui.separator(self.controlArea, 20, 20) self.step_box = gui.widgetBox(self.controlArea, "Manually step through") self.step_button = gui.button( self.step_box, self, self.STEP_BUTTONS[1], callback=self.step) self.step_back_button = gui.button( self.step_box, self, "Step Back", callback=self.step_back) self.run_box = gui.widgetBox(self.controlArea, "Run") self.auto_play_speed_spinner = gui.hSlider( self.run_box, self, 'auto_play_speed', label='Speed:', minValue=0, maxValue=1.91, step=0.1, intOnly=False, createLabel=False) self.auto_play_button = gui.button( self.run_box, self, self.AUTOPLAY_BUTTONS[0], callback=self.auto_play) gui.rubber(self.controlArea) # disable until data loaded self.set_disabled_all(True) # graph in mainArea self.scatter = Scatterplot( click_callback=self.graph_clicked, drop_callback=self.centroid_dropped, xAxis_gridLineWidth=0, yAxis_gridLineWidth=0, tooltip_enabled=False, debug=False) # Just render an empty chart so it shows a nice 'No data to display' self.scatter.chart() self.mainArea.layout().addWidget(self.scatter)
def __init__(self): super().__init__() self.data = None self.orig_domain = None self.disc_colors = [] self.cont_colors = [] box = gui.widgetBox(self.controlArea, "Discrete variables", orientation="horizontal") self.disc_model = DiscColorTableModel() disc_view = self.disc_view = DiscreteTable(self.disc_model) disc_view.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents) self.disc_model.dataChanged.connect(self._on_data_changed) box.layout().addWidget(disc_view) box = gui.widgetBox(self.controlArea, "Numeric variables", orientation="horizontal") self.cont_model = ContColorTableModel() cont_view = self.cont_view = ContinuousTable(self, self.cont_model) cont_view.setColumnWidth(1, 256) self.cont_model.dataChanged.connect(self._on_data_changed) box.layout().addWidget(cont_view) box = gui.auto_commit(self.controlArea, self, "auto_apply", "Send data", orientation="horizontal", checkbox_label="Resend data on every change") box.layout().insertSpacing(0, 20) box.layout().insertWidget(0, self.report_button)
def _add_kernel_box(self): # Initialize with the widest label to measure max width self.kernel_eq = self.kernels[-1][1] self.kernel_box = box = gui.widgetBox( self.controlArea, "Kernel", orientation="horizontal") buttonbox = gui.radioButtonsInBox( box, self, "kernel_type", btnLabels=[k[0] for k in self.kernels], callback=self._on_kernel_changed, addSpace=20) buttonbox.layout().setSpacing(10) gui.rubber(buttonbox) parambox = gui.widgetBox(box) gui.label(parambox, self, "Kernel: %(kernel_eq)s") common = dict(orientation="horizontal", alignment=Qt.AlignRight, controlWidth=80) spbox = gui.widgetBox(parambox, orientation="horizontal") gui.rubber(spbox) inbox = gui.widgetBox(spbox) gamma = gui.doubleSpin( inbox, self, "gamma", 0.0, 10.0, 0.01, label=" g: ", **common) coef0 = gui.doubleSpin( inbox, self, "coef0", 0.0, 10.0, 0.01, label=" c: ", **common) degree = gui.doubleSpin( inbox, self, "degree", 0.0, 10.0, 0.5, label=" d: ", **common) self._kernel_params = [gamma, coef0, degree] gui.rubber(parambox) # This is the maximal height (all double spins are visible) # and the maximal width (the label is initialized to the widest one) box.layout().activate() box.setFixedHeight(box.sizeHint().height()) box.setMinimumWidth(box.sizeHint().width())
def __init__(self, parent=None): super().__init__(parent) self.train_data = None self.test_data = None #: An Ordered dictionary with current inputs and their testing #: results. self.learners = OrderedDict() sbox = gui.widgetBox(self.controlArea, "Sampling") rbox = gui.radioButtons( sbox, self, "resampling", callback=self._param_changed ) gui.appendRadioButton(rbox, "Cross validation") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "k_folds", 2, 50, label="Number of folds:", callback=self.kfold_changed) gui.appendRadioButton(rbox, "Leave one out") gui.appendRadioButton(rbox, "Random sampling") ibox = gui.indentedBox(rbox) gui.spin(ibox, self, "n_repeat", 2, 50, label="Repeat train/test", callback=self.bootstrap_changed) gui.widgetLabel(ibox, "Relative training set size:") gui.hSlider(ibox, self, "sample_p", minValue=1, maxValue=100, ticks=20, vertical=False, labelFormat="%d %%", callback=self.bootstrap_changed) gui.appendRadioButton(rbox, "Test on train data") gui.appendRadioButton(rbox, "Test on test data") rbox.layout().addSpacing(5) gui.button(rbox, self, "Apply", callback=self.apply) self.cbox = gui.widgetBox(self.controlArea, "Target class") self.class_selection_combo = gui.comboBox(self.cbox, self, "class_selection", items=[], callback=self._select_class, sendSelectedValue=True, valueType=str) gui.rubber(self.controlArea) self.view = QTreeView( rootIsDecorated=False, uniformRowHeights=True, wordWrap=True, editTriggers=QTreeView.NoEditTriggers ) header = self.view.header() header.setResizeMode(QHeaderView.ResizeToContents) header.setDefaultAlignment(Qt.AlignCenter) header.setStretchLastSection(False) self.result_model = QStandardItemModel() self.view.setModel(self.result_model) self.view.setItemDelegate(ItemDelegate()) self._update_header() box = gui.widgetBox(self.mainArea, "Evaluation Results") box.layout().addWidget(self.view)
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 _setup_layout(self): self.controlArea.setMinimumWidth(self.controlArea.sizeHint().width()) self.layout().setSizeConstraint(QLayout.SetFixedSize) widget_box = widgetBox(self.controlArea, 'Info') self.input_data_info = widgetLabel(widget_box, self._NO_DATA_INFO_TEXT) self.connection_info = widgetLabel(widget_box, "") widget_box = widgetBox(self.controlArea, 'Settings') self.cb_image_attr = comboBox( widget=widget_box, master=self, value='cb_image_attr_current_id', label='Image attribute:', orientation=Qt.Horizontal, callback=self._cb_image_attr_changed ) self.auto_commit_widget = auto_commit( widget=self.controlArea, master=self, value='_auto_apply', label='Apply', checkbox_label='Auto Apply', commit=self.commit )
def __init__(self): super().__init__() gui.label(self.controlArea, self, "Spark DataFrame") self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) self.allSQLSelectWidgets.append(self) # set default settings self.domain = None self.queryFile = None self.query = '' self.lastQuery = None # self.loadSettings() if self.lastQuery is not None: self.query = self.lastQuery # query self.splitCanvas = QSplitter(QtCore.Qt.Vertical, self.mainArea) self.mainArea.layout().addWidget(self.splitCanvas) self.textBox = gui.widgetBox(self, 'SparkSQL') self.splitCanvas.addWidget(self.textBox) self.queryTextEdit = QPlainTextEdit(self.query, self) self.textBox.layout().addWidget(self.queryTextEdit) self.selectBox = gui.widgetBox(self.controlArea, "Select statement") self.selectBox.setSizePolicy(QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)) gui.button(self.selectBox, self, 'format SQL!', callback = self.format_sql, disabled = 0) gui.button(self.selectBox, self, 'execute!', callback = self.executeQuery, disabled = 0) # info self.infoBox = gui.widgetBox(self.controlArea, "Info") self.info = [] self.info.append(gui.label(self.infoBox, self, 'No data loaded.')) self.info.append(gui.label(self.infoBox, self, '')) self.resize(300, 300)
def __init__(self): super().__init__() self.data = None """The LazyTable that will be send.""" # GUI: as simple as possible for now box = gui.widgetBox(self.controlArea, "SAMP Info") self.infoa = gui.widgetLabel(widget=box, label='SAMP status unknown.') box_input_catalog = gui.widgetBox(box, orientation=0) self.input_catalog_text = gui.widgetLabel(widget=box_input_catalog , label='Catalog') self.input_catalog = gui.lineEdit(widget=box_input_catalog , master=self, value='catalog_of_interest') #self.resize(100,50) self.button_disconnect = gui.button(self.controlArea, self, "&Disconnect", callback=self.disconnect_samp, default=False) self.button_connect = gui.button(self.controlArea, self, "&Connect", callback=self.connect_samp, default=False) self.button_disconnect.setHidden(True) #gui.button(self.controlArea, self, "&Pull Rows", callback=self.pull_rows, default=False) gui.button(self.controlArea, self, "&Set Table", callback=self.we_have_a_new_table, default=False) # Create a SAMP client and connect to HUB. # Do not make the client in __init__ because this does not allow # the client to disconnect and reconnect again. self.samp_client = None self.connect_samp()
def __init__(self): super().__init__() # The main label of the Control's GUI. # gui.label(self.controlArea, self, "Spark Context") # Create parameters Box. box = gui.widgetBox(self.controlArea, "Spark SQL Table", addSpace = True) self.gui_parameters = OrderedDict() if self.hc: self.databases = [i.result for i in self.hc.sql("show databases").collect()] default_value = self.saved_gui_params.get('database', 'default') if default_value not in self.databases: self.databases.append(default_value) self.database = default_value self.refresh_databases_btn = gui.button(box, self, label = 'Refresh databases', callback = self.fill_database_list) self.gui_parameters['database'] = GuiParam(parent_widget = box, list_values = self.databases, label = 'Database', default_value = default_value, callback_func = self.refresh_database) default_value = self.saved_gui_params.get('table', '') self.gui_parameters['table'] = GuiParam(parent_widget = box, label = 'Table', default_value = default_value, list_values = [default_value]) self.refresh_database(self.gui_parameters['database'].get_value()) action_box = gui.widgetBox(box) # Action Button self.create_sc_btn = gui.button(action_box, self, label = 'Submit', callback = self.submit)
def __init__(self, parent=None): super().__init__(parent) self.matrix = None self.items = None self.linkmatrix = None self.root = None self._displayed_root = None self.cutoff_height = 0.0 gui.comboBox(gui.widgetBox(self.controlArea, "Linkage"), self, "linkage", items=LINKAGE, callback=self._invalidate_clustering) box = gui.widgetBox(self.controlArea, "Annotation") self.label_cb = gui.comboBox(box, self, "annotation_idx", callback=self._update_labels) self.label_cb.setModel(itemmodels.VariableListModel()) self.label_cb.model()[:] = ["None", "Enumeration"] box = gui.radioButtons(self.controlArea, self, "pruning", box="Pruning", callback=self._invalidate_pruning) grid = QGridLayout() box.layout().addLayout(grid) grid.addWidget(gui.appendRadioButton(box, "None", addToLayout=False), 0, 0) self.max_depth_spin = gui.spin(box, self, "max_depth", minv=1, maxv=100, callback=self._invalidate_pruning, keyboardTracking=False) grid.addWidget( gui.appendRadioButton(box, "Max depth", addToLayout=False), 1, 0) grid.addWidget(self.max_depth_spin, 1, 1) box = gui.radioButtons(self.controlArea, self, "selection_method", box="Selection", callback=self._selection_method_changed) grid = QGridLayout() box.layout().addLayout(grid) grid.addWidget(gui.appendRadioButton(box, "Manual", addToLayout=False), 0, 0) grid.addWidget( gui.appendRadioButton(box, "Height ratio", addToLayout=False), 1, 0) self.cut_ratio_spin = gui.spin(box, self, "cut_ratio", 0, 100, step=1e-1, spinType=float, callback=self._selection_method_changed) self.cut_ratio_spin.setSuffix("%") grid.addWidget(self.cut_ratio_spin, 1, 1) grid.addWidget(gui.appendRadioButton(box, "Top N", addToLayout=False), 2, 0) self.top_n_spin = gui.spin(box, self, "top_n", 1, 20, callback=self._selection_method_changed) grid.addWidget(self.top_n_spin, 2, 1) box.layout().addLayout(grid) self.controlArea.layout().addStretch() box = gui.widgetBox(self.controlArea, "Output") gui.checkBox(box, self, "append_clusters", "Append cluster IDs", callback=self._invalidate_output) ibox = gui.indentedBox(box) name_edit = gui.lineEdit(ibox, self, "cluster_name") name_edit.editingFinished.connect(self._invalidate_output) cb = gui.comboBox( ibox, self, "cluster_role", callback=self._invalidate_output, items=["Attribute", "Class variable", "Meta variable"]) form = QFormLayout(fieldGrowthPolicy=QFormLayout.AllNonFixedFieldsGrow, labelAlignment=Qt.AlignLeft, spacing=8) form.addRow("Name", name_edit) form.addRow("Place", cb) ibox.layout().addSpacing(5) ibox.layout().addLayout(form) ibox.layout().addSpacing(5) gui.auto_commit(box, self, "autocommit", "Send data", "Auto send is on", box=False) self.scene = QGraphicsScene() self.view = QGraphicsView( self.scene, horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff, verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn, alignment=Qt.AlignLeft | Qt.AlignVCenter) def axis_view(orientation): ax = pg.AxisItem(orientation=orientation, maxTickLength=7) scene = QGraphicsScene() scene.addItem(ax) view = QGraphicsView( scene, horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff, verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn, alignment=Qt.AlignLeft | Qt.AlignVCenter) view.setFixedHeight(ax.size().height()) ax.line = SliderLine(orientation=Qt.Horizontal, length=ax.size().height()) scene.addItem(ax.line) return view, ax self.top_axis_view, self.top_axis = axis_view("top") self.mainArea.layout().setSpacing(1) self.mainArea.layout().addWidget(self.top_axis_view) self.mainArea.layout().addWidget(self.view) self.bottom_axis_view, self.bottom_axis = axis_view("bottom") self.mainArea.layout().addWidget(self.bottom_axis_view) self._main_graphics = QGraphicsWidget() self._main_layout = QGraphicsLinearLayout(Qt.Horizontal) self._main_layout.setSpacing(1) self._main_graphics.setLayout(self._main_layout) self.scene.addItem(self._main_graphics) self.dendrogram = DendrogramWidget() self.dendrogram.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding) self.dendrogram.selectionChanged.connect(self._invalidate_output) self.dendrogram.selectionEdited.connect(self._selection_edited) fm = self.fontMetrics() self.dendrogram.setContentsMargins(5, fm.lineSpacing() / 2, 5, fm.lineSpacing() / 2) self.labels = GraphicsSimpleTextList() self.labels.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.labels.setAlignment(Qt.AlignLeft) self.labels.setMaximumWidth(200) self.labels.layout().setSpacing(0) self._main_layout.addItem(self.dendrogram) self._main_layout.addItem(self.labels) self._main_layout.setAlignment(self.dendrogram, Qt.AlignLeft | Qt.AlignVCenter) self._main_layout.setAlignment(self.labels, Qt.AlignLeft | Qt.AlignVCenter) self.view.viewport().installEventFilter(self) self.top_axis_view.viewport().installEventFilter(self) self.bottom_axis_view.viewport().installEventFilter(self) self._main_graphics.installEventFilter(self) self.cut_line = SliderLine(self.dendrogram, orientation=Qt.Horizontal) self.cut_line.valueChanged.connect(self._dendrogram_slider_changed) self.cut_line.hide() self.bottom_axis.line.valueChanged.connect(self._axis_slider_changed) self.top_axis.line.valueChanged.connect(self._axis_slider_changed) self.dendrogram.geometryChanged.connect(self._dendrogram_geom_changed) self._set_cut_line_visible(self.selection_method == 1)
def __init__(self, parent=None): super().__init__(self, parent) self.clusterDataset = None self.referenceDataset = None self.ontology = None self.annotations = None self.loadedAnnotationCode = None self.treeStructRootKey = None self.probFunctions = [ statistics.Binomial(), statistics.Hypergeometric() ] self.selectedTerms = [] self.selectionChanging = 0 self.__state = State.Ready self.__scheduletimer = QTimer(self, singleShot=True) self.__scheduletimer.timeout.connect(self.__update) ############# # GUI ############# self.tabs = gui.tabWidget(self.controlArea) # Input tab self.inputTab = gui.createTabPage(self.tabs, "Input") box = gui.widgetBox(self.inputTab, "Info") self.infoLabel = gui.widgetLabel(box, "No data on input\n") gui.button( box, self, "Ontology/Annotation Info", callback=self.ShowInfo, tooltip="Show information on loaded ontology and annotations") box = gui.widgetBox(self.inputTab, "Organism") self.annotationComboBox = gui.comboBox( box, self, "annotationIndex", items=[], callback=self.__invalidateAnnotations, tooltip="Select organism") genebox = gui.widgetBox(self.inputTab, "Gene Names") self.geneAttrIndexCombo = gui.comboBox( genebox, self, "geneAttrIndex", callback=self.__invalidate, tooltip="Use this attribute to extract gene names from input data") self.geneAttrIndexCombo.setDisabled(self.useAttrNames) self.useAttrNames_checkbox = gui.checkBox( genebox, self, "useAttrNames", "Use column names", tooltip="Use column names for gene names", callback=self.__invalidate) self.useAttrNames_checkbox.toggled[bool].connect( self.geneAttrIndexCombo.setDisabled) self.referenceRadioBox = gui.radioButtonsInBox( self.inputTab, self, "useReferenceDataset", ["Entire genome", "Reference set (input)"], tooltips=[ "Use entire genome for reference", "Use genes from Referece Examples input signal as reference" ], box="Reference", callback=self.__invalidate) self.referenceRadioBox.buttons[1].setDisabled(True) gui.radioButtonsInBox( self.inputTab, self, "aspectIndex", ["Biological process", "Cellular component", "Molecular function"], box="Aspect", callback=self.__invalidate) # Filter tab self.filterTab = gui.createTabPage(self.tabs, "Filter") box = gui.widgetBox(self.filterTab, "Filter GO Term Nodes") gui.checkBox( box, self, "filterByNumOfInstances", "Genes", callback=self.FilterAndDisplayGraph, tooltip="Filter by number of input genes mapped to a term") ibox = gui.indentedBox(box) gui.spin(ibox, self, 'minNumOfInstances', 1, 100, step=1, label='#:', labelWidth=15, callback=self.FilterAndDisplayGraph, callbackOnReturn=True, tooltip="Min. number of input genes mapped to a term") gui.checkBox(box, self, "filterByPValue_nofdr", "p-value", callback=self.FilterAndDisplayGraph, tooltip="Filter by term p-value") gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue_nofdr', 1e-8, 1, step=1e-8, label='p:', labelWidth=15, callback=self.FilterAndDisplayGraph, callbackOnReturn=True, tooltip="Max term p-value") # use filterByPValue for FDR, as it was the default in prior versions gui.checkBox(box, self, "filterByPValue", "FDR", callback=self.FilterAndDisplayGraph, tooltip="Filter by term FDR") gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue', 1e-8, 1, step=1e-8, label='p:', labelWidth=15, callback=self.FilterAndDisplayGraph, callbackOnReturn=True, tooltip="Max term p-value") box = gui.widgetBox(box, "Significance test") gui.radioButtonsInBox( box, self, "probFunc", ["Binomial", "Hypergeometric"], tooltips=[ "Use binomial distribution test", "Use hypergeometric distribution test" ], callback=self.__invalidate) # TODO: only update the p values box = gui.widgetBox(self.filterTab, "Evidence codes in annotation", addSpace=True) self.evidenceCheckBoxDict = {} for etype in go.evidenceTypesOrdered: ecb = QCheckBox(etype, toolTip=go.evidenceTypes[etype], checked=self.useEvidenceType[etype]) ecb.toggled.connect(self.__on_evidenceChanged) box.layout().addWidget(ecb) self.evidenceCheckBoxDict[etype] = ecb # Select tab self.selectTab = gui.createTabPage(self.tabs, "Select") box = gui.radioButtonsInBox(self.selectTab, self, "selectionDirectAnnotation", ["Directly or Indirectly", "Directly"], box="Annotated genes", callback=self.ExampleSelection) box = gui.widgetBox(self.selectTab, "Output", addSpace=True) gui.radioButtonsInBox( box, self, "selectionDisjoint", btnLabels=[ "All selected genes", "Term-specific genes", "Common term genes" ], tooltips=[ "Outputs genes annotated to all selected GO terms", "Outputs genes that appear in only one of selected GO terms", "Outputs genes common to all selected GO terms" ], callback=[self.ExampleSelection, self.UpdateAddClassButton]) self.addClassCB = gui.checkBox(box, self, "selectionAddTermAsClass", "Add GO Term as class", callback=self.ExampleSelection) # ListView for DAG, and table for significant GOIDs self.DAGcolumns = [ 'GO term', 'Cluster', 'Reference', 'p-value', 'FDR', 'Genes', 'Enrichment' ] self.splitter = QSplitter(Qt.Vertical, self.mainArea) self.mainArea.layout().addWidget(self.splitter) # list view self.listView = GOTreeWidget(self.splitter) self.listView.setSelectionMode(QTreeView.ExtendedSelection) self.listView.setAllColumnsShowFocus(1) self.listView.setColumnCount(len(self.DAGcolumns)) self.listView.setHeaderLabels(self.DAGcolumns) self.listView.header().setSectionsClickable(True) self.listView.header().setSortIndicatorShown(True) self.listView.header().setSortIndicator( self.DAGcolumns.index('p-value'), Qt.DescendingOrder) self.listView.setSortingEnabled(True) self.listView.setItemDelegateForColumn( 6, EnrichmentColumnItemDelegate(self)) self.listView.setRootIsDecorated(True) self.listView.itemSelectionChanged.connect(self.ViewSelectionChanged) # table of significant GO terms self.sigTerms = QTreeWidget(self.splitter) self.sigTerms.setColumnCount(len(self.DAGcolumns)) self.sigTerms.setHeaderLabels(self.DAGcolumns) self.sigTerms.setSortingEnabled(True) self.sigTerms.setSelectionMode(QTreeView.ExtendedSelection) self.sigTerms.header().setSortIndicator( self.DAGcolumns.index('p-value'), Qt.DescendingOrder) self.sigTerms.setItemDelegateForColumn( 6, EnrichmentColumnItemDelegate(self)) self.sigTerms.itemSelectionChanged.connect(self.TableSelectionChanged) self.sigTableTermsSorted = [] self.graph = {} self.originalGraph = None self.inputTab.layout().addStretch(1) self.filterTab.layout().addStretch(1) self.selectTab.layout().addStretch(1) class AnnotationSlot(SimpleNamespace): taxid = ... # type: str name = ... # type: str filename = ... # type:str @staticmethod def parse_tax_id(f_name): return f_name.split('.')[1] available_annotations = [ AnnotationSlot(taxid=AnnotationSlot.parse_tax_id(annotation_file), name=taxonomy.common_taxid_to_name( AnnotationSlot.parse_tax_id(annotation_file)), filename=FILENAME_ANNOTATION.format( AnnotationSlot.parse_tax_id(annotation_file))) for _, annotation_file in serverfiles.ServerFiles().listfiles( DOMAIN) if annotation_file != FILENAME_ONTOLOGY ] self.availableAnnotations = sorted(available_annotations, key=lambda a: a.name) self.annotationComboBox.clear() for a in self.availableAnnotations: self.annotationComboBox.addItem(a.name) self.annotationComboBox.setCurrentIndex(self.annotationIndex) self.annotationIndex = self.annotationComboBox.currentIndex() self._executor = ThreadExecutor()
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 = [ ("number_of_nodes", True, "Number of nodes", GRAPHLEVEL, lambda G: G.number_of_nodes()), ("number_of_edges", True, "Number of edges", GRAPHLEVEL, lambda G: G.number_of_edges()), ("average_degree", True, "Average degree", GRAPHLEVEL, lambda G: np.average(list(G.degree().values()))), ("diameter", False, "Diameter", GRAPHLEVEL, nx.diameter), ("radius", False, "Radius", GRAPHLEVEL, nx.radius), ("average_shortest_path_length", False, "Average shortest path length", GRAPHLEVEL, nx.average_shortest_path_length), ("density", True, "Density", GRAPHLEVEL, nx.density), ("degree_assortativity_coefficient", False, \ "Degree assortativity coefficient", GRAPHLEVEL, \ nx.degree_assortativity_coefficient if \ hasattr(nx, "degree_assortativity_coefficient") else None), # additional attr needed #("attribute_assortativity_coefficient", False, "Attribute assortativity coefficient", GRAPHLEVEL, nx.attribute_assortativity_coefficient), #("numeric_assortativity_coefficient", False, "Numeric assortativity coefficient", GRAPHLEVEL, nx.numeric_assortativity_coefficient), ("degree_pearson_correlation_coefficient", False, \ "Degree pearson correlation coefficient", GRAPHLEVEL, \ nx.degree_pearson_correlation_coefficient if\ hasattr(nx, "degree_pearson_correlation_coefficient") else None), ("estrada_index", False, "Estrada index", GRAPHLEVEL, \ nx.estrada_index if hasattr(nx, "estrada_index") else None), ("graph_clique_number", False, "Graph clique number", GRAPHLEVEL, nx.graph_clique_number), ("graph_number_of_cliques", False, "Graph number of cliques", GRAPHLEVEL, nx.graph_number_of_cliques), ("transitivity", False, "Graph transitivity", GRAPHLEVEL, nx.transitivity), ("average_clustering", False, "Average clustering coefficient", GRAPHLEVEL, nx.average_clustering), ("number_connected_components", False, "Number of connected components", GRAPHLEVEL, nx.number_connected_components), ("number_strongly_connected_components", False, "Number of strongly connected components", GRAPHLEVEL, nx.number_strongly_connected_components), ("number_weakly_connected_components", False, "Number of weakly connected components", GRAPHLEVEL, nx.number_weakly_connected_components), ("number_attracting_components", False, "Number of attracting components", GRAPHLEVEL, nx.number_attracting_components), # TODO: input parameters #("max_flow", False, "Maximum flow", GRAPHLEVEL, nx.max_flow), #("min_cut", False, "Minimum cut", GRAPHLEVEL, nx.min_cut), #("ford_fulkerson", False, "Maximum single-commodity flow (Ford-Fulkerson)", GRAPHLEVEL, nx.ford_fulkerson), #("min_cost_flow_cost", False, "min_cost_flow_cost", GRAPHLEVEL, nx.min_cost_flow_cost), # returns dict of dict #("shortest_path_length", False, "Shortest path length", GRAPHLEVEL, nx.shortest_path_length), ("degree", False, "Degree", NODELEVEL, nx.degree), ("in_degree", False, "In-degree", NODELEVEL, lambda G: G.in_degree()), ("out_degree", False, "Out-degree", NODELEVEL, lambda G: G.out_degree()), ("average_neighbor_degree", False, "Average neighbor degree", NODELEVEL, nx.average_neighbor_degree), ("clustering", False, "Clustering coefficient", NODELEVEL, nx.clustering), ("triangles", False, "Number of triangles", NODELEVEL, nx.triangles), ("square_clustering", False, "Squares clustering coefficient", NODELEVEL, nx.square_clustering), ("number_of_cliques", False, "Number of cliques", NODELEVEL, nx.number_of_cliques), ("degree_centrality", False, "Degree centrality", NODELEVEL, nx.degree_centrality), ("in_degree_centrality", False, "In-egree centrality", NODELEVEL, nx.in_degree_centrality), ("out_degree_centrality", False, "Out-degree centrality", NODELEVEL, nx.out_degree_centrality), ("closeness_centrality", False, "Closeness centrality", NODELEVEL, nx.closeness_centrality), ("betweenness_centrality", False, "Betweenness centrality", NODELEVEL, nx.betweenness_centrality), ("current_flow_closeness_centrality", False, "Information centrality", NODELEVEL, nx.current_flow_closeness_centrality), ("current_flow_betweenness_centrality", False, "Random-walk betweenness centrality", NODELEVEL, nx.current_flow_betweenness_centrality), ("approximate_current_flow_betweenness_centrality", False, \ "Approx. random-walk betweenness centrality", NODELEVEL, \ nx.approximate_current_flow_betweenness_centrality if \ hasattr(nx, "approximate_current_flow_betweenness_centrality") \ else None), ("eigenvector_centrality", False, "Eigenvector centrality", NODELEVEL, nx.eigenvector_centrality), ("eigenvector_centrality_numpy", False, "Eigenvector centrality (NumPy)", NODELEVEL, nx.eigenvector_centrality_numpy), ("load_centrality", False, "Load centrality", NODELEVEL, nx.load_centrality), ("core_number", False, "Core number", NODELEVEL, nx.core_number), ("eccentricity", False, "Eccentricity", NODELEVEL, nx.eccentricity), ("closeness_vitality", False, "Closeness vitality", NODELEVEL, nx.closeness_vitality), ] """ TODO: add average-degree_connectivity is_bipartite is_chordal katz_centrality katz_centrality_numpy communicability communicability_exp communicability_centrality communicability_centrality_exp communicability_betweenness_centrality average_node_connectivity is_directed_acyclic_graph center ?? """ self.methods = [method for method in self.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[1]) 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)) for name, default, label, type, algorithm in self.methods: if type == NODELEVEL: box = gui.widgetBox(self.nodeIndices, orientation="horizontal") elif type == GRAPHLEVEL: box = gui.widgetBox(self.graphIndices, 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)
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=QGridLayout()) layout = boxes.layout() layout.setColumnStretch(0, 1) layout.setColumnStretch(1, 1) box_data = gui.vBox(boxes, 'Data', addToLayout=False) self.data_in_variables = gui.widgetLabel(box_data, " ") self.data_out_rows = gui.widgetLabel(box_data, " ") layout.addWidget(box_data, 0, 0) box_setting = gui.vBox(boxes, 'Purging', addToLayout=False) self.cb_pa = gui.checkBox(box_setting, self, "purge_attributes", "Remove unused features", callback=self.conditions_changed) gui.separator(box_setting, height=1) self.cb_pc = gui.checkBox(box_setting, self, "purge_classes", "Remove unused classes", callback=self.conditions_changed) layout.addWidget(box_setting, 0, 1) self.report_button.setFixedWidth(120) gui.rubber(self.buttonsArea.layout()) layout.addWidget(self.buttonsArea, 1, 0) acbox = gui.auto_commit(None, self, "auto_commit", label="Send", orientation=Qt.Horizontal, checkbox_label="Send automatically") layout.addWidget(acbox, 1, 1) self.set_data(None) self.resize(600, 400)
def __init__(self): """Widget creator.""" super().__init__() # ATTRIBUTS # searchFunction self.searchResults = None self.inputSeg = None # newQuery = attribut box lineEdit (search something) self.newQuery = '' self.nbr_results = 10 # Results box attributs self.titleLabels = list() self.selectedTitles = list() # selections box attributs self.myTitles = list() self.mytitleLabels = list() # stock all the inputs (scripts) in a list self.createdInputs = list() self.path_storage = list() # Next two instructions are helpers from TextableUtils. Corresponding # interface elements are declared here and actually drawn below (at # their position in the UI)... self.infoBox = InfoBox(widget=self.controlArea) #self.sendButton = SendButton( # widget=self.controlArea, # master=self, # callback=self.sendData, # infoBoxAttribute="infoBox", #) # User interface... # Create the working area queryBox = gui.widgetBox( widget=self.controlArea, box="Search movie", orientation="vertical", ) # Allows to enter specific text to the research # Uses "newQuery" attribute gui.lineEdit( widget=queryBox, master=self, value='newQuery', orientation='horizontal', label=u"Movie title: ", labelWidth=100, tooltip=("Enter a string"), ) # Allows to choose the wanted results numberp (10 by 10) queryNbr = gui.comboBox( widget=queryBox, master=self, value="nbr_results", items=[ "5", "10", "20", "30", "40", "50", ], sendSelectedValue=True, orientation="horizontal", label="Number of results: ", labelWidth=120, tooltip=("Please select the desired search.\n"), ) # Research button # Use "searchFunction" attibute self.searchButton = gui.button( widget=queryBox, master=self, label='Search', callback=self.searchFunction, tooltip='Search for the movie', ) # Reasearch button # Uses "searchFunction" attribute self.titleListbox = gui.listBox( widget=queryBox, master=self, value="selectedTitles", # setting (list) labels="titleLabels", # setting (list) callback=lambda: self.selectButton.setDisabled(self.selectedTitles == list()), tooltip="Select the movie you want to get the script of", ) self.titleListbox.setMinimumHeight(120) self.titleListbox.setSelectionMode(3) boxbutton = gui.widgetBox( widget=queryBox, box=False, orientation='horizontal', ) # select button # Uses "select" function self.selectButton = gui.button( widget=boxbutton, master=self, label="Select", callback=self.sendData, tooltip="Select", ) self.selectButton.setDisabled(True) # Clear button # Uses "clearResults" function self.clearButton = gui.button( widget=boxbutton, master=self, label="Clear results", callback=self.clearResults, tooltip="Clear results", ) self.clearButton.setDisabled(True) gui.separator(widget=queryBox, height=3) gui.rubber(self.controlArea) #---------------------------------------------------------------------- # Draw Info box and Send button # self.sendButton.draw() # self.searchButton.setDefault(True) self.infoBox.draw()
def __init__(self, parent=None): widget.OWWidget.__init__(self, parent) self.min_value, self.max_value = \ self.thresholds.get(self.Scores[self.score_index][0], (1, 0)) #: Input data set self.data = None #: Current target group selection self.targets = [] #: The computed scores self.scores = None #: The computed scores from label permutations self.nulldist = None self.__scores_future = self.__scores_state = None self.__in_progress = False self.test_f = { OWDifferentialExpression.LowTail: test_low, OWDifferentialExpression.HighTail: test_high, OWDifferentialExpression.TwoTail: test_two_tail, } self.histogram = Histogram(enableMouse=False, enableMenu=False, background="w") self.histogram.enableAutoRange(enable=False) self.histogram.getPlotItem().hideButtons() # hide auto range button self.histogram.getViewBox().setMouseEnabled(False, False) self.histogram.selectionChanged.connect( self.__on_histogram_plot_selection_changed) self.histogram.selectionEdited.connect(self._invalidate_selection) self.mainArea.layout().addWidget(self.histogram) box = gui.widgetBox(self.controlArea, "Info") self.dataInfoLabel = gui.widgetLabel(box, "No data on input.\n") self.dataInfoLabel.setWordWrap(True) self.selectedInfoLabel = gui.widgetLabel(box, "\n") box1 = gui.widgetBox(self.controlArea, "Scoring Method") gui.comboBox( box1, self, "score_index", items=[sm[0] for sm in self.Scores], callback=[self.on_scoring_method_changed, self.update_scores]) box = gui.widgetBox(self.controlArea, "Target Labels") self.label_selection_widget = guiutils.LabelSelectionWidget(self) self.label_selection_widget.setMaximumHeight(150) box.layout().addWidget(self.label_selection_widget) self.label_selection_widget.groupChanged.connect( self.on_label_activated) self.label_selection_widget.groupSelectionChanged.connect( self.on_target_changed) box = gui.widgetBox(self.controlArea, "Selection") box.layout().setSpacing(0) self.max_value_spin = gui.doubleSpin(box, self, "max_value", minv=-1e6, maxv=1e6, step=1e-6, label="Upper threshold:", callback=self.update_boundary, callbackOnReturn=True) self.low_value_spin = gui.doubleSpin(box, self, "min_value", minv=-1e6, maxv=1e6, step=1e-6, label="Lower threshold:", callback=self.update_boundary, callbackOnReturn=True) check = gui.checkBox(box, self, "compute_null", "Compute null distribution", callback=self.update_scores) perm_spin = gui.spin(box, self, "permutations_count", minv=1, maxv=50, label="Permutations:", callback=self.update_scores, callbackOnReturn=True) check.disables.append(perm_spin) box1 = gui.widgetBox(box, orientation='horizontal') pval_spin = gui.doubleSpin(box1, self, "alpha_value", minv=2e-7, maxv=1.0, step=1e-7, label="α-value:") pval_select = gui.button(box1, self, "Select", callback=self.select_p_best, autoDefault=False) check.disables.append(pval_spin) check.disables.append(pval_select) check.makeConsistent() box1 = gui.widgetBox(box, orientation='horizontal') gui.spin(box1, self, "n_best", 0, 10000, step=1, label="Best Ranked:") gui.button(box1, self, "Select", callback=self.select_n_best, autoDefault=False) box = gui.widgetBox(self.controlArea, "Output") acbox = gui.auto_commit(box, self, "auto_commit", "Commit", box=None) acbox.button.setDefault(True) gui.checkBox(box, self, "add_scores_to_output", "Add gene scores to output", callback=self._invalidate_selection) gui.rubber(self.controlArea) self.on_scoring_method_changed() self._executor = concurrent.ThreadExecutor()
def __init__(self, *args, **kwargs): """Initialize a Message widget""" super().__init__(*args, **kwargs) # Other attributes... self.segmentation = None self.createdInputs = list() self.noLanguageParameterWarning = ( "Please make sure that at least one language parameter " "file is installed in your Treetagger 'lib' directory, " "then click 'Reload language parameter files'." ) self.noTreetaggerPathWarning = ( "Please click 'Locate Treetagger' below and select the " "base directory of a valid Treetagger distribution." ) self.TreetaggerPath = ( treetaggerwrapper.locate_treetagger() or self.lookupSavedTreetaggerPath() ) self.infoBox = InfoBox(widget=self.controlArea) self.sendButton = SendButton( widget=self.controlArea, master=self, callback=self.sendData, infoBoxAttribute=u"infoBox", sendIfPreCallback=self.updateGUI ) gui.separator(self.controlArea, height=3) self.optionsBox = gui.widgetBox( self.controlArea, u"Options", ) self.languageCombobox = gui.comboBox( widget=self.optionsBox, master=self, value="language", items=list(), sendSelectedValue=True, orientation=u"horizontal", label="Input language:", labelWidth=180, callback=self.sendButton.settingsChanged, tooltip=( u"Select the language of the input text." ), ) self.languageCombobox.setMinimumWidth(120) gui.separator(self.optionsBox, height=3) gui.comboBox( widget=self.optionsBox, master=self, value="outputFormat", items=[ "segment into words", "add XML tags", ], sendSelectedValue=True, orientation=u"horizontal", label="Output format:", labelWidth=180, callback=self.sendButton.settingsChanged, tooltip=( u"Select the format of the output:\n\n" u"Segment into words: each word is in a separate segment,\n" u"with lemma and POS-tag as annotations.\n\n" u"Add XML tags: output segments correspond to input segments\n" u"and each word is tagged in XML as a 'w' element with\n" u"lemma and POS-tag as attributes." ), ) gui.separator(self.optionsBox, height=3) gui.checkBox( widget=self.optionsBox, master=self, value="replaceUnknown", label="Output token in place of [unknown] lemmas", callback=self.sendButton.settingsChanged, tooltip=( u"For out-of-vocabulary words, the word form is used as the\n" u"lemma (in place of Treetagger's default 'unknown' code)." ), ) gui.rubber(self.controlArea) self.sendButton.draw() self.infoBox.draw() self.locateTreetaggerBox=gui.widgetBox( self.controlArea, addSpace=False, ) gui.separator(self.locateTreetaggerBox, height=3) self.treetaggerButton = gui.button( widget=self.locateTreetaggerBox, master=self, label="Locate Treetagger", callback=self.validateTreetagger, tooltip=( u"Click to select the location of the Treetagger base\n" u"directory (containing the 'lib' and 'bin' subdirectories)." ), ) self.sendButton.sendIf() self.adjustSizeWithTimer()
def __init__(self): super().__init__() self.controlArea = QtGui.QWidget(self.leftWidgetPart) self.layout().addWidget(self.controlArea) layout = QtGui.QGridLayout() self.controlArea.setLayout(layout) layout.setMargin(4) box = gui.widgetBox(self.controlArea, "Available Variables", addToLayout=False) self.filter_edit = QtGui.QLineEdit() self.filter_edit.setToolTip("Filter the list of available variables.") box.layout().addWidget(self.filter_edit) if hasattr(self.filter_edit, "setPlaceholderText"): self.filter_edit.setPlaceholderText("Filter") self.completer = QtGui.QCompleter() self.completer.setCompletionMode(QtGui.QCompleter.InlineCompletion) self.completer_model = QtGui.QStringListModel() self.completer.setModel(self.completer_model) self.completer.setModelSorting( QtGui.QCompleter.CaseSensitivelySortedModel) self.filter_edit.setCompleter(self.completer) self.completer_navigator = CompleterNavigator(self) self.filter_edit.installEventFilter(self.completer_navigator) self.available_attrs = VariablesListItemModel() self.available_attrs_proxy = VariableFilterProxyModel() self.available_attrs_proxy.setSourceModel(self.available_attrs) self.available_attrs_view = VariablesListItemView() self.available_attrs_view.setModel(self.available_attrs_proxy) aa = self.available_attrs aa.dataChanged.connect(self.update_completer_model) aa.rowsInserted.connect(self.update_completer_model) aa.rowsRemoved.connect(self.update_completer_model) self.available_attrs_view.selectionModel().selectionChanged.connect( partial(self.update_interface_state, self.available_attrs_view)) self.filter_edit.textChanged.connect(self.update_completer_prefix) self.filter_edit.textChanged.connect( self.available_attrs_proxy.set_filter_string) box.layout().addWidget(self.available_attrs_view) layout.addWidget(box, 0, 0, 3, 1) box = gui.widgetBox(self.controlArea, "Features", addToLayout=False) self.used_attrs = VariablesListItemModel() self.used_attrs_view = VariablesListItemView() self.used_attrs_view.setModel(self.used_attrs) self.used_attrs_view.selectionModel().selectionChanged.connect( partial(self.update_interface_state, self.used_attrs_view)) box.layout().addWidget(self.used_attrs_view) layout.addWidget(box, 0, 2, 1, 1) box = gui.widgetBox(self.controlArea, "Class", addToLayout=False) self.class_attrs = ClassVarListItemModel() self.class_attrs_view = ClassVariableItemView() self.class_attrs_view.setModel(self.class_attrs) self.class_attrs_view.selectionModel().selectionChanged.connect( partial(self.update_interface_state, self.class_attrs_view)) self.class_attrs_view.setMaximumHeight(24) box.layout().addWidget(self.class_attrs_view) layout.addWidget(box, 1, 2, 1, 1) box = gui.widgetBox(self.controlArea, "Meta Attributes", addToLayout=False) self.meta_attrs = VariablesListItemModel() self.meta_attrs_view = VariablesListItemView() self.meta_attrs_view.setModel(self.meta_attrs) self.meta_attrs_view.selectionModel().selectionChanged.connect( partial(self.update_interface_state, self.meta_attrs_view)) box.layout().addWidget(self.meta_attrs_view) layout.addWidget(box, 2, 2, 1, 1) bbox = gui.widgetBox(self.controlArea, addToLayout=False, margin=0) layout.addWidget(bbox, 0, 1, 1, 1) self.up_attr_button = gui.button(bbox, self, "Up", callback=partial( self.move_up, self.used_attrs_view)) self.move_attr_button = gui.button(bbox, self, ">", callback=partial( self.move_selected, self.used_attrs_view)) self.down_attr_button = gui.button(bbox, self, "Down", callback=partial( self.move_down, self.used_attrs_view)) bbox = gui.widgetBox(self.controlArea, addToLayout=False, margin=0) layout.addWidget(bbox, 1, 1, 1, 1) self.move_class_button = gui.button(bbox, self, ">", callback=partial( self.move_selected, self.class_attrs_view, exclusive=True)) bbox = gui.widgetBox(self.controlArea, addToLayout=False, margin=0) layout.addWidget(bbox, 2, 1, 1, 1) self.up_meta_button = gui.button(bbox, self, "Up", callback=partial( self.move_up, self.meta_attrs_view)) self.move_meta_button = gui.button(bbox, self, ">", callback=partial( self.move_selected, self.meta_attrs_view)) self.down_meta_button = gui.button(bbox, self, "Down", callback=partial( self.move_down, self.meta_attrs_view)) bbox = gui.widgetBox(self.controlArea, orientation="horizontal", addToLayout=False, margin=0) gui.button(bbox, self, "Apply", callback=self.commit) gui.button(bbox, self, "Reset", callback=self.reset) layout.addWidget(bbox, 3, 0, 1, 3) layout.setRowStretch(0, 4) layout.setRowStretch(1, 0) layout.setRowStretch(2, 2) layout.setHorizontalSpacing(0) self.controlArea.setLayout(layout) self.data = None self.output_report = None self.original_completer_items = [] self.resize(500, 600) # For automatic widget testing using self._guiElements.extend([ (QtGui.QListView, self.available_attrs_view), (QtGui.QListView, self.used_attrs_view), (QtGui.QListView, self.class_attrs_view), (QtGui.QListView, self.meta_attrs_view), ])
def _insert_buttons_area(self): self.buttonsArea = gui.widgetBox( self.left_side, addSpace=0, spacing=9, orientation=self.buttons_area_orientation)
def __init__(self): super().__init__() self.domain = None self.graph = None self.auto_items = None self.net_index = 0 self.data_index = 0 #GUI self.controlArea.layout().setContentsMargins(4, 4, 4, 4) self.box = gui.widgetBox(self.controlArea, box="Graph File", orientation="vertical") hb = gui.widgetBox(self.box, orientation="horizontal") self.filecombo = gui.comboBox(hb, self, "net_index", callback=self.selectNetFile) self.filecombo.setMinimumWidth(250) button = gui.button(hb, self, '...', callback=self.browseNetFile, disabled=0) button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon)) button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed) button = gui.button(hb, self, 'Reload', callback=self.reload) button.setIcon(self.style().standardIcon(QStyle.SP_BrowserReload)) chb = gui.widgetBox(self.box, orientation="horizontal") gui.checkBox(chb, self, "auto_table", "Build graph data table automatically", callback=self.selectNetFile) self.databox = gui.widgetBox(self.controlArea, box="Vertices Data File", orientation="vertical") vdf = gui.widgetBox(self.databox, orientation="horizontal") self.datacombo = gui.comboBox(vdf, self, "data_index", callback=self.selectDataFile) self.datacombo.setMinimumWidth(250) button = gui.button(vdf, self, '...', callback=self.browseDataFile, disabled=0) button.setIcon(self.style().standardIcon(QStyle.SP_DirOpenIcon)) button.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Fixed) button = gui.button(vdf, self, 'Reload', callback=self.reload_data) button.setIcon(self.style().standardIcon(QStyle.SP_BrowserReload)) # info box = gui.widgetBox(self.controlArea, "Info") self.info = gui.widgetLabel(box, 'No data loaded.') gui.rubber(self.controlArea) self.resize(150, 100) self.populate_comboboxes() self.reload()
def __init__(self): super().__init__() self.data = None self.samplingBox = [None, None] self.sampleSizeBox = [None, None] self.cvBox = [None, None] box = gui.widgetBox(self.controlArea, "Information") self.dataInfoLabel = gui.widgetLabel(box, 'No data on input.') self.outputInfoLabel = gui.widgetLabel(box, ' ') form = QtGui.QFormLayout( formAlignment=Qt.AlignLeft | Qt.AlignTop, labelAlignment=Qt.AlignLeft, fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow) box = gui.widgetBox(self.controlArea, "Options", orientation=form) cb = gui.checkBox(box, self, "stratified", "Stratified (if possible)", callback=self.settingsChanged, addToLayout=False) form.addRow(cb, QtGui.QWidget()) cb = gui.checkBox(box, self, "useSeed", "Random seed:", callback=self.settingsChanged, addToLayout=False) spin = gui.spin(box, self, "seed", minv=0, maxv=2**31 - 1, callback=self.settingsChanged, addToLayout=False) form.addRow(cb, spin) box = gui.widgetBox(self.controlArea, self.tr("Sampling Type")) sampling = gui.radioButtons(box, self, "samplingType", callback=self.samplingTypeChanged) gui.appendRadioButton(sampling, "Random Sampling:") self.samplingBox[0] = ibox = gui.indentedBox(sampling) ibox.setEnabled(self.samplingType == OWDataSampler.RandomSampling) ibox = gui.radioButtons(ibox, self, "sampleSizeType", callback=self.sampleSizeTypeChanged) gui.checkBox(ibox, self, "replacement", "With replacement", callback=self.settingsChanged) gui.appendRadioButton(ibox, "Sample size:") self.sampleSizeSpin = gui.spin(gui.indentedBox(ibox), self, "sampleSizeNumber", minv=1, maxv=2**31 - 1, callback=self.settingsChanged) self.sampleSizeSpin.setEnabled(self.sampleSizeType == self.Fixed) gui.appendRadioButton(ibox, "Sample proportions:") self.sampleSizePercentageSlider = gui.hSlider( gui.indentedBox(ibox), self, "sampleSizePercentage", minValue=1, maxValue=100, ticks=10, labelFormat="%d%%", callback=self.settingsChanged) self.sampleSizePercentageSlider.setEnabled( self.sampleSizeType == self.Ratio) self.sampleSizeBox = [ self.sampleSizeSpin, self.sampleSizePercentageSlider ] gui.appendRadioButton(sampling, "Cross Validation:") self.samplingBox[1] = ibox = gui.indentedBox(sampling, addSpace=True) ibox.setEnabled(self.samplingType == OWDataSampler.CrossValidation) form = QtGui.QFormLayout( formAlignment=Qt.AlignLeft | Qt.AlignTop, labelAlignment=Qt.AlignLeft, fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow) bbox = gui.radioButtons(ibox, self, "cvType", orientation=form, callback=self.cvTypeChanged, addSpace=True) bbox.setContentsMargins(1, 1, 1, 1) kfold_rb = gui.appendRadioButton(bbox, "K-Fold:", insertInto=None, addToLayout=False) loo_rb = gui.appendRadioButton(bbox, "Leave one out", insertInto=None, addToLayout=False) kfold_spin = gui.spin(ibox, self, "numberOfFolds", 2, 100, addToLayout=False, callback=self.numberOfFoldsChanged) kfold_spin.setEnabled(self.cvType == self.KFold) form.addRow(kfold_rb, kfold_spin) form.addRow(loo_rb) self.cvBox = [kfold_spin] self.selectedFoldSpin = gui.spin(ibox, self, "selectedFold", 1, 100, addToLayout=False) form.addRow(QtGui.QLabel("Selected fold:"), self.selectedFoldSpin) gui.button(self.controlArea, self, "Sample Data", callback=self.commit)
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:")) for opts in self.domain_opts: gui.appendRadioButton(box, self.tr(opts)) gui.separator(box) label = gui.widgetLabel( box, self.tr("The resulting table will have 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.id_roles)) ibox.layout().addLayout(form) mleft, mtop, mright, _ = ibox.layout().getContentsMargins() ibox.layout().setContentsMargins(mleft, mtop, mright, 4) cb.disables.append(ibox) cb.makeConsistent() gui.separator(self.controlArea, 8) box = gui.widgetBox( self.controlArea, True, orientation="horizontal", ) box.layout().addWidget(self.report_button) gui.separator(box, 20) gui.button(box, self, self.tr("Apply Changes"), callback=self.apply, default=True)
def __init__(self): super().__init__() RecentPathsWComboMixin.__init__(self) self.domain = None self.data = None self.loaded_file = "" self.reader = None layout = QtGui.QGridLayout() gui.widgetBox(self.controlArea, margin=0, orientation=layout) vbox = gui.radioButtons(None, self, "source", box=True, addSpace=True, callback=self.load_data, addToLayout=False) rb_button = gui.appendRadioButton(vbox, "File:", addToLayout=False) layout.addWidget(rb_button, 0, 0, QtCore.Qt.AlignVCenter) box = gui.hBox(None, addToLayout=False, margin=0) box.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed) self.file_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed) self.file_combo.activated[int].connect(self.select_file) box.layout().addWidget(self.file_combo) layout.addWidget(box, 0, 1) file_button = gui.button(None, self, '...', callback=self.browse_file, autoDefault=False) file_button.setIcon(self.style().standardIcon( QtGui.QStyle.SP_DirOpenIcon)) file_button.setSizePolicy(Policy.Maximum, Policy.Fixed) layout.addWidget(file_button, 0, 2) reload_button = gui.button(None, self, "Reload", callback=self.load_data, autoDefault=False) reload_button.setIcon(self.style().standardIcon( QtGui.QStyle.SP_BrowserReload)) reload_button.setSizePolicy(Policy.Fixed, Policy.Fixed) layout.addWidget(reload_button, 0, 3) self.sheet_box = gui.hBox(None, addToLayout=False, margin=0) self.sheet_combo = gui.comboBox(None, self, "xls_sheet", callback=self.select_sheet, sendSelectedValue=True) self.sheet_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed) self.sheet_label = QtGui.QLabel() self.sheet_label.setText('Sheet') self.sheet_label.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed) self.sheet_box.layout().addWidget(self.sheet_label, QtCore.Qt.AlignLeft) self.sheet_box.layout().addWidget(self.sheet_combo, QtCore.Qt.AlignVCenter) layout.addWidget(self.sheet_box, 2, 1) self.sheet_box.hide() rb_button = gui.appendRadioButton(vbox, "URL:", addToLayout=False) layout.addWidget(rb_button, 3, 0, QtCore.Qt.AlignVCenter) self.url_combo = url_combo = QtGui.QComboBox() url_model = NamedURLModel(self.sheet_names) url_model.wrap(self.recent_urls) url_combo.setModel(url_model) url_combo.setSizePolicy(Policy.MinimumExpanding, Policy.Fixed) url_combo.setEditable(True) url_combo.setInsertPolicy(url_combo.InsertAtTop) url_edit = url_combo.lineEdit() l, t, r, b = url_edit.getTextMargins() url_edit.setTextMargins(l + 5, t, r, b) layout.addWidget(url_combo, 3, 1, 3, 3) url_combo.activated.connect(self._url_set) box = gui.vBox(self.controlArea, "Info") self.info = gui.widgetLabel(box, 'No data loaded.') self.warnings = gui.widgetLabel(box, '') box = gui.widgetBox(self.controlArea, "Columns (Double click to edit)") domain_editor = DomainEditor(self.variables) self.editor_model = domain_editor.model() box.layout().addWidget(domain_editor) box = gui.hBox(self.controlArea) gui.button(box, self, "Browse documentation data sets", callback=lambda: self.browse_file(True), autoDefault=False) gui.rubber(box) box.layout().addWidget(self.report_button) self.report_button.setFixedWidth(170) self.apply_button = gui.button(box, self, "Apply", callback=self.apply_domain_edit) self.apply_button.hide() self.apply_button.setFixedWidth(170) self.editor_model.dataChanged.connect(self.apply_button.show) self.set_file_list() # Must not call open_file from within __init__. open_file # explicitly re-enters the event loop (by a progress bar) QtCore.QTimer.singleShot(0, self.load_data) self.setAcceptDrops(True)
def __init__(self): super().__init__() #: input data self.data = None self.class_var = None #: Current variable discretization state self.var_state = {} #: Saved variable discretization settings (context setting) self.saved_var_states = {} self.method = 0 self.k = 5 self.cutpoints = [] box = gui.vBox(self.controlArea, self.tr("Default Discretization")) self.default_bbox = rbox = gui.radioButtons( box, self, "default_method", callback=self._default_disc_changed) rb = gui.hBox(rbox) self.left = gui.vBox(rb) right = gui.vBox(rb) rb.layout().setStretch(0, 1) rb.layout().setStretch(1, 1) options = self.options = [ self.tr("Default"), self.tr("Leave numeric"), self.tr("Entropy-MDL discretization"), self.tr("Equal-frequency discretization"), self.tr("Equal-width discretization"), self.tr("Remove numeric variables") ] for opt in options[1:]: t = gui.appendRadioButton(rbox, opt) # This condition is ugly, but it keeps the same order of # options for backward compatibility of saved schemata [right, self.left][opt.startswith("Equal")].layout().addWidget(t) gui.separator(right, 18, 18) def _intbox(parent, attr, callback): box = gui.indentedBox(parent) s = gui.spin(box, self, attr, minv=2, maxv=10, label="Num. of intervals:", callback=callback) s.setMaximumWidth(60) s.setAlignment(Qt.AlignRight) gui.rubber(s.box) return box.box self.k_general = _intbox(self.left, "default_k", self._default_disc_changed) self.k_general.layout().setContentsMargins(0, 0, 0, 0) vlayout = QHBoxLayout() box = gui.widgetBox(self.controlArea, "Individual Attribute Settings", orientation=vlayout, spacing=8) # List view with all attributes self.varview = QListView( selectionMode=QListView.ExtendedSelection, uniformItemSizes=True, ) self.varview.setItemDelegate(DiscDelegate()) self.varmodel = itemmodels.VariableListModel() self.varview.setModel(self.varmodel) self.varview.selectionModel().selectionChanged.connect( self._var_selection_changed) vlayout.addWidget(self.varview) # Controls for individual attr settings self.bbox = controlbox = gui.radioButtons( box, self, "method", callback=self._disc_method_changed) vlayout.addWidget(controlbox) for opt in options[:5]: gui.appendRadioButton(controlbox, opt) self.k_specific = _intbox(controlbox, "k", self._disc_method_changed) gui.appendRadioButton(controlbox, "Remove attribute") gui.rubber(controlbox) controlbox.setEnabled(False) self.controlbox = controlbox box = gui.auto_apply(self.controlArea, self, "autosend") box.button.setFixedWidth(180) box.layout().insertStretch(0) self._update_spin_positions() self.info.set_input_summary(self.info.NoInput) self.info.set_output_summary(self.info.NoOutput)
def __init__(self): super().__init__() self.corpus = None # Corpus self.corpus_docs = None # Documents generated from Corpus self.doc_webview = None # WebView for showing content self.search_features = [] # two copies are needed since Display allows drag & drop self.display_list_indices = [0] # Info attributes self.update_info() info_box = gui.widgetBox(self.controlArea, 'Info') gui.label(info_box, self, 'Documents: %(n_documents)s') gui.label(info_box, self, 'Preprocessed: %(is_preprocessed)s') gui.label(info_box, self, ' ◦ Tokens: %(n_tokens)s') gui.label(info_box, self, ' ◦ Types: %(n_types)s') gui.label(info_box, self, 'POS tagged: %(is_pos_tagged)s') gui.label(info_box, self, 'N-grams range: %(ngram_range)s') gui.label(info_box, self, 'Matching: %(n_matching)s') # Search features self.search_listbox = gui.listBox( self.controlArea, self, 'search_indices', 'search_features', selectionMode=QListView.ExtendedSelection, box='Search features', callback=self.search_features_changed) # Display features display_box = gui.widgetBox(self.controlArea, 'Display features') self.display_listbox = gui.listBox( display_box, self, 'display_list_indices', 'display_features', selectionMode=QListView.ExtendedSelection, callback=self.show_docs, enableDragDrop=True) self.show_tokens_checkbox = gui.checkBox(display_box, self, 'show_tokens', 'Show Tokens && Tags', callback=self.show_docs) # Auto-commit box gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data', 'Auto send is on') # Search self.filter_input = gui.lineEdit(self.mainArea, self, 'regexp_filter', orientation=Qt.Horizontal, sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed), label='RegExp Filter:') self.filter_input.textChanged.connect(self.refresh_search) # Main area self.splitter = QSplitter( orientation=Qt.Horizontal, childrenCollapsible=False, ) # Document list self.doc_list = QTableView() self.doc_list.setSelectionBehavior(QTableView.SelectRows) self.doc_list.setSelectionMode(QTableView.ExtendedSelection) self.doc_list.setEditTriggers(QAbstractItemView.NoEditTriggers) self.doc_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch) self.doc_list.horizontalHeader().setVisible(False) self.splitter.addWidget(self.doc_list) self.doc_list_model = QStandardItemModel(self) self.doc_list.setModel(self.doc_list_model) self.doc_list.selectionModel().selectionChanged.connect( self.selection_changed ) # Document contents self.doc_webview = gui.WebviewWidget(self.splitter, debug=False) self.mainArea.layout().addWidget(self.splitter)
def __init__(self): super().__init__() self.data = None # type: Optional[Table] self.clusterings = {} self.__executor = ThreadExecutor(parent=self) self.__task = None # type: Optional[Task] layout = QGridLayout() bg = gui.radioButtonsInBox( self.controlArea, self, "optimize_k", orientation=layout, box="Number of Clusters", callback=self.update_method, ) layout.addWidget( gui.appendRadioButton(bg, "Fixed:", addToLayout=False), 1, 1) sb = gui.hBox(None, margin=0) gui.spin( sb, self, "k", minv=2, maxv=30, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_k) gui.rubber(sb) layout.addWidget(sb, 1, 2) layout.addWidget( gui.appendRadioButton(bg, "From", addToLayout=False), 2, 1) ftobox = gui.hBox(None) ftobox.layout().setContentsMargins(0, 0, 0, 0) layout.addWidget(ftobox, 2, 2) gui.spin( ftobox, self, "k_from", minv=2, maxv=29, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_from) gui.widgetLabel(ftobox, "to") gui.spin( ftobox, self, "k_to", minv=3, maxv=30, controlWidth=60, alignment=Qt.AlignRight, callback=self.update_to) gui.rubber(ftobox) box = gui.vBox(self.controlArea, "Initialization") gui.comboBox( box, self, "smart_init", items=[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) self.apply_button = gui.auto_commit( self.buttonsArea, self, "auto_commit", "Apply", box=None, commit=self.commit) gui.rubber(self.controlArea) box = gui.vBox(self.mainArea, box="Silhouette Scores") self.mainArea.setVisible(self.optimize_k) self.table_model = ClusterTableModel(self) table = self.table_view = QTableView(self.mainArea) table.setModel(self.table_model) table.setSelectionMode(QTableView.SingleSelection) table.setSelectionBehavior(QTableView.SelectRows) table.setItemDelegate(gui.ColoredBarItemDelegate(self, color=Qt.cyan)) table.selectionModel().selectionChanged.connect(self.select_row) table.setMaximumWidth(200) table.horizontalHeader().setStretchLastSection(True) table.horizontalHeader().hide() table.setShowGrid(False) box.layout().addWidget(table)
def __init__(self): super().__init__() self.dataset = None self.z_values = [] self._root = None self._displayed_root = None self._item = None self._cache = {} self.colors = colorpalette.ColorPaletteGenerator(10) box = gui.widgetBox(self.controlArea, "Axes") self.x_var_model = itemmodels.VariableListModel() self.comboBoxAttributesX = gui.comboBox(box, self, value='x_var_index', callback=self.replot, contentsLength=12) self.comboBoxAttributesX.setModel(self.x_var_model) self.y_var_model = itemmodels.VariableListModel() self.comboBoxAttributesY = gui.comboBox(box, self, value='y_var_index', callback=self.replot, contentsLength=12) self.comboBoxAttributesY.setModel(self.y_var_model) box = gui.widgetBox(self.controlArea, "Color") self.z_var_model = itemmodels.VariableListModel() self.comboBoxClassvars = gui.comboBox(box, self, value='z_var_index', callback=self._on_z_var_changed, contentsLength=12) self.comboBoxClassvars.setModel(self.z_var_model) self.z_values_view = gui.listBox( box, self, "selected_z_values", "z_values", callback=self._on_z_values_selection_changed, selectionMode=QtGui.QListView.MultiSelection, addSpace=False) gui.comboBox(box, self, "color_scale", label="Scale: ", orientation="horizontal", items=["Linear", "Square root", "Logarithmic"], callback=self._on_color_scale_changed) self.sampling_box = gui.widgetBox(self.controlArea, "Sampling") sampling_options = (self.sample_times_captions + self.sample_percentages_captions) self.sample_combo = gui.comboBox(self.sampling_box, self, 'sample_level', items=sampling_options, callback=self.update_sample) gui.button(self.sampling_box, self, "Sharpen", self.sharpen) gui.rubber(self.controlArea) self.plot = pg.PlotWidget(background="w") self.plot.setMenuEnabled(False) self.plot.setFrameStyle(QtGui.QFrame.StyledPanel) self.plot.setMinimumSize(500, 500) def font_resize(font, factor, minsize=None, maxsize=None): font = QtGui.QFont(font) fontinfo = QtGui.QFontInfo(font) size = fontinfo.pointSizeF() * factor if minsize is not None: size = max(size, minsize) if maxsize is not None: size = min(size, maxsize) font.setPointSizeF(size) return font axisfont = font_resize(self.font(), 0.8, minsize=11) axispen = QtGui.QPen(self.palette().color(QtGui.QPalette.Text)) axis = self.plot.getAxis("bottom") axis.setTickFont(axisfont) axis.setPen(axispen) axis = self.plot.getAxis("left") axis.setTickFont(axisfont) axis.setPen(axispen) self.plot.getViewBox().sigTransformChanged.connect( self._on_transform_changed) self.mainArea.layout().addWidget(self.plot)
def __init__(self): super().__init__() gui.label(self.controlArea, self, "from pandas:") self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Maximum) self.allSQLSelectWidgets.append(self) # set default settings self.domain = None self.recentConnections = list() self.recentConnections.append("(none)") self.queryFile = None self.query = '' self.lastQuery = None if self.lastQuery is not None: self.query = self.lastQuery sources = pyodbc.dataSources() dsns = list(sources.keys()) dsns.sort() for dsn in dsns: self.recentConnections.append("DSN={dsn}".format(dsn=dsn)) self.connectString = self.recentConnections[0] self.connectBox = gui.widgetBox(self.controlArea, "Database") self.connectLineEdit = gui.lineEdit(self.connectBox, self, 'connectString', callback=None) self.connectCombo = gui.comboBox(self.connectBox, self, 'connectString', items=self.recentConnections, valueType=str, sendSelectedValue=True) self.button = gui.button(self.connectBox, self, 'connect', callback=self.connectDB, disabled=0) # query self.splitCanvas = QSplitter(QtCore.Qt.Vertical, self.mainArea) self.mainArea.layout().addWidget(self.splitCanvas) self.textBox = gui.widgetBox(self, 'HiveQL') self.splitCanvas.addWidget(self.textBox) self.queryTextEdit = QPlainTextEdit(self.query, self) self.textBox.layout().addWidget(self.queryTextEdit) self.selectBox = gui.widgetBox(self.controlArea, "Select statement") # self.selectSubmitBox = QHGroupBox("", self.selectBox) # self.queryTextEdit.setSizePolicy(QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)) # self.queryTextEdit.setMinimumWidth(300) # self.connect(self.queryTextEdit, SIGNAL('returnPressed()'), self.executeQuery) gui.button(self.selectBox, self, "Open...", callback=self.openScript) gui.button(self.selectBox, self, "Save...", callback=self.saveScript) self.selectBox.setSizePolicy( QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)) gui.button(self.selectBox, self, 'format SQL!', callback=self.format_sql, disabled=0) gui.button(self.selectBox, self, 'execute!', callback=self.executeQuery, disabled=0) self.domainBox = gui.widgetBox(self.controlArea, "Domain") self.domainLabel = gui.label(self.domainBox, self, '') # info self.infoBox = gui.widgetBox(self.controlArea, "Info") self.info = [] self.info.append(gui.label(self.infoBox, self, 'No data loaded.')) self.info.append(gui.label(self.infoBox, self, '')) self.resize(300, 300) self.cnxn = None
def __init__(self): super().__init__() self.rf_model = None self.forest = None self.instances = None self.clf_dataset = None self.color_palette = None # CONTROL AREA # Tree info area box_info = gui.widgetBox(self.controlArea, 'Forest') self.ui_info = gui.widgetLabel(box_info) # Display controls area box_display = gui.widgetBox(self.controlArea, 'Display') self.ui_depth_slider = gui.hSlider( box_display, self, 'depth_limit', label='Depth', ticks=False, ) # type: QSlider self.ui_target_class_combo = gui.comboBox( box_display, self, 'target_class_index', label='Target class', orientation=Qt.Horizontal, items=[], contentsLength=8, ) # type: gui.OrangeComboBox self.ui_size_calc_combo = gui.comboBox( box_display, self, 'size_calc_idx', label='Size', orientation=Qt.Horizontal, items=list(zip(*self.SIZE_CALCULATION))[0], contentsLength=8, ) # type: gui.OrangeComboBox self.ui_zoom_slider = gui.hSlider( box_display, self, 'zoom', label='Zoom', ticks=False, minValue=100, maxValue=400, createLabel=False, intOnly=False, ) # type: QSlider # Stretch to fit the rest of the unsused area gui.rubber(self.controlArea) self.controlArea.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) # MAIN AREA self.forest_model = PythagoreanForestModel(parent=self) self.forest_model.update_item_size(self.zoom) self.ui_depth_slider.valueChanged.connect( self.forest_model.update_depth) self.ui_target_class_combo.currentIndexChanged.connect( self.forest_model.update_target_class) self.ui_zoom_slider.valueChanged.connect( self.forest_model.update_item_size) self.ui_size_calc_combo.currentIndexChanged.connect( self.forest_model.update_size_calc) self.list_delegate = PythagorasTreeDelegate(parent=self) self.list_view = ClickToClearSelectionListView(parent=self) self.list_view.setWrapping(True) self.list_view.setFlow(QListView.LeftToRight) self.list_view.setResizeMode(QListView.Adjust) self.list_view.setModel(self.forest_model) self.list_view.setItemDelegate(self.list_delegate) self.list_view.setSpacing(2) self.list_view.setSelectionMode(QListView.SingleSelection) self.list_view.selectionModel().selectionChanged.connect(self.commit) self.list_view.setUniformItemSizes(True) self.mainArea.layout().addWidget(self.list_view) self.resize(800, 500) # Clear to set sensible default values self.clear()
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', '30°', '45°', '60°') 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') class TableView(gui.TableView): def __init__(self, parent): super().__init__(parent) self._parent = parent self.__nope = False def setModel(self, model): """Otherwise QTableView.setModel() calls QAbstractItemView.setSelectionModel() which resets selection, calling selectionChanged() and overwriting any selected_words setting that may have been saved.""" self.__nope = True super().setModel(model) self.__nope = False def selectionChanged(self, selected, deselected): nonlocal model, proxymodel super().selectionChanged(selected, deselected) if not self.__nope: words = { model[proxymodel.mapToSource(index).row()][1] for index in self.selectionModel().selectedIndexes() } self._parent.update_selection(words, self) def update_selection(self, words): nonlocal model, proxymodel selection = QItemSelection() for i, (_, word) in enumerate(model): if word in words: index = proxymodel.mapFromSource(model.index(i, 1)) selection.select(index, index) self.__nope = True self.clearSelection() self.selectionModel().select( selection, QItemSelectionModel.Select | QItemSelectionModel.Rows) self.__nope = False view = self.tableview = TableView(self) model = self.tablemodel = PyTableModel(parent=self) proxymodel = QSortFilterProxyModel( self, dynamicSortFilter=True, sortCaseSensitivity=Qt.CaseInsensitive, sortRole=Qt.EditRole) proxymodel.setSourceModel(model) model.setHorizontalHeaderLabels(['Weight', 'Word']) view.setModel(proxymodel) box.layout().addWidget(view)
def __init__(self): super().__init__() # sets self.curvePoints, self.steps equidistant points from # 1/self.steps to 1 self.updateCurvePoints() self.scoring = [("Classification Accuracy", Orange.evaluation.scoring.CA), ("AUC", Orange.evaluation.scoring.AUC), ("Precision", Orange.evaluation.scoring.Precision), ("Recall", Orange.evaluation.scoring.Recall)] #: input data on which to construct the learning curve self.data = None #: optional test data self.testdata = 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() # [start-snippet-3] #: The current evaluating task (if any) self._task = None # type: Optional[Task] #: An executor we use to submit learner evaluations into a thread pool self._executor = ThreadExecutor() # [end-snippet-3] # 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.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") self.plot = pg.PlotItem(enableMenu=False) 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()
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, parent=None): super().__init__(parent) #: input data self.data = None #: Current variable discretization state self.var_state = {} #: Saved variable discretization settings (context setting) self.saved_var_states = {} self.method = 0 self.k = 5 box = gui.widgetBox( self.controlArea, self.tr("Default Discretization")) self.default_bbox = rbox = gui.radioButtons( box, self, "default_method", callback=self._default_disc_changed) options = [ self.tr("Default"), self.tr("Leave continuous"), self.tr("Entropy-MDL discretization"), self.tr("Equal-frequency discretization"), self.tr("Equal-width discretization"), self.tr("Remove continuous attributes") ] for opt in options[1:5]: gui.appendRadioButton(rbox, opt) gui.hSlider(gui.indentedBox(rbox), self, "default_k", minValue=2, maxValue=10, label="Num. of intervals:", callback=self._default_disc_changed) gui.appendRadioButton(rbox, options[-1]) vlayout = QHBoxLayout() box = gui.widgetBox( self.controlArea, "Individual Attribute Settings", orientation=vlayout, spacing=8 ) # List view with all attributes self.varview = QListView( selectionMode=QListView.ExtendedSelection ) self.varview.setItemDelegate(DiscDelegate()) self.varmodel = itemmodels.VariableListModel() self.varview.setModel(self.varmodel) self.varview.selectionModel().selectionChanged.connect( self._var_selection_changed ) vlayout.addWidget(self.varview) # Controls for individual attr settings self.bbox = controlbox = gui.radioButtons( box, self, "method", callback=self._disc_method_changed ) vlayout.addWidget(controlbox) for opt in options[:5]: gui.appendRadioButton(controlbox, opt) gui.hSlider(gui.indentedBox(controlbox), self, "k", minValue=2, maxValue=10, label="Num. of intervals:", callback=self._disc_method_changed) gui.appendRadioButton(controlbox, options[-1]) gui.rubber(controlbox) controlbox.setEnabled(False) self.controlbox = controlbox bbox = QDialogButtonBox(QDialogButtonBox.Apply) self.controlArea.layout().addWidget(bbox) bbox.accepted.connect(self.commit) button = bbox.button(QDialogButtonBox.Apply) button.clicked.connect(self.commit)
def __init__(self): super().__init__() self.data = None self.n_inliers = self.n_outliers = None box = gui.widgetBox(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.widgetBox(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.widgetBox(ibox, box=None, orientation='horizontal') 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.controlArea, self, "Detect Outliers", callback=self.commit) self.layout().setSizeConstraint(QtGui.QLayout.SetFixedSize)
def __init__(self): super().__init__() # Instance variables self.forest_type = self.CLASSIFICATION self.model = None self.forest_adapter = None self.dataset = None self.clf_dataset = None # We need to store refernces to the trees and grid items self.grid_items, self.ptrees = [], [] 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)), ('Logarithmic', lambda x: log(x * self.size_log_scale)), ] self.REGRESSION_COLOR_CALC = [ ('None', lambda _, __: 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, 'Forest') self.ui_info = gui.widgetLabel(box_info, label='') # Display controls area box_display = gui.widgetBox(self.controlArea, 'Display') self.ui_depth_slider = gui.hSlider(box_display, self, 'depth_limit', label='Depth', ticks=False, callback=self.max_depth_changed) self.ui_target_class_combo = gui.comboBox( box_display, self, 'target_class_index', label='Target class', orientation=Qt.Horizontal, items=[], contentsLength=8, callback=self.target_colors_changed) self.ui_size_calc_combo = gui.comboBox( box_display, self, 'size_calc_idx', label='Size', orientation=Qt.Horizontal, items=list(zip(*self.SIZE_CALCULATION))[0], contentsLength=8, callback=self.size_calc_changed) self.ui_zoom_slider = gui.hSlider(box_display, self, 'zoom', label='Zoom', ticks=False, minValue=20, maxValue=150, callback=self.zoom_changed, createLabel=False) # Stretch to fit the rest of the unsused area gui.rubber(self.controlArea) self.controlArea.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding) # MAIN AREA self.scene = QGraphicsScene(self) self.scene.selectionChanged.connect(self.commit) self.grid = OWGrid() self.grid.geometryChanged.connect(self._update_scene_rect) self.scene.addItem(self.grid) self.view = QGraphicsView(self.scene) self.view.setRenderHint(QPainter.Antialiasing, True) self.view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn) self.mainArea.layout().addWidget(self.view) self.resize(800, 500) self.clear()
def __init__(self, parent=None): super().__init__(self, parent) self.clusterDataset = None self.referenceDataset = None self.ontology = None self.annotations = None self.loadedAnnotationCode = "---" self.treeStructRootKey = None self.probFunctions = [stats.Binomial(), stats.Hypergeometric()] self.selectedTerms = [] self.selectionChanging = 0 self.__state = OWGOEnrichmentAnalysis.Initializing self.annotationCodes = [] ############# ## GUI ############# self.tabs = gui.tabWidget(self.controlArea) ## Input tab self.inputTab = gui.createTabPage(self.tabs, "Input") box = gui.widgetBox(self.inputTab, "Info") self.infoLabel = gui.widgetLabel(box, "No data on input\n") gui.button( box, self, "Ontology/Annotation Info", callback=self.ShowInfo, tooltip="Show information on loaded ontology and annotations") box = gui.widgetBox(self.inputTab, "Organism") self.annotationComboBox = gui.comboBox(box, self, "annotationIndex", items=self.annotationCodes, callback=self._updateEnrichment, tooltip="Select organism") genebox = gui.widgetBox(self.inputTab, "Gene Names") self.geneAttrIndexCombo = gui.comboBox( genebox, self, "geneAttrIndex", callback=self._updateEnrichment, tooltip="Use this attribute to extract gene names from input data") self.geneAttrIndexCombo.setDisabled(self.useAttrNames) cb = gui.checkBox(genebox, self, "useAttrNames", "Use column names", tooltip="Use column names for gene names", callback=self._updateEnrichment) cb.toggled[bool].connect(self.geneAttrIndexCombo.setDisabled) gui.button(genebox, self, "Gene matcher settings", callback=self.UpdateGeneMatcher, tooltip="Open gene matching settings dialog") self.referenceRadioBox = gui.radioButtonsInBox( self.inputTab, self, "useReferenceDataset", ["Entire genome", "Reference set (input)"], tooltips=[ "Use entire genome for reference", "Use genes from Referece Examples input signal as reference" ], box="Reference", callback=self._updateEnrichment) self.referenceRadioBox.buttons[1].setDisabled(True) gui.radioButtonsInBox( self.inputTab, self, "aspectIndex", ["Biological process", "Cellular component", "Molecular function"], box="Aspect", callback=self._updateEnrichment) ## Filter tab self.filterTab = gui.createTabPage(self.tabs, "Filter") box = gui.widgetBox(self.filterTab, "Filter GO Term Nodes") gui.checkBox( box, self, "filterByNumOfInstances", "Genes", callback=self.FilterAndDisplayGraph, tooltip="Filter by number of input genes mapped to a term") ibox = gui.indentedBox(box) gui.spin(ibox, self, 'minNumOfInstances', 1, 100, step=1, label='#:', labelWidth=15, callback=self.FilterAndDisplayGraph, callbackOnReturn=True, tooltip="Min. number of input genes mapped to a term") gui.checkBox(box, self, "filterByPValue_nofdr", "p-value", callback=self.FilterAndDisplayGraph, tooltip="Filter by term p-value") gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue_nofdr', 1e-8, 1, step=1e-8, label='p:', labelWidth=15, callback=self.FilterAndDisplayGraph, callbackOnReturn=True, tooltip="Max term p-value") #use filterByPValue for FDR, as it was the default in prior versions gui.checkBox(box, self, "filterByPValue", "FDR", callback=self.FilterAndDisplayGraph, tooltip="Filter by term FDR") gui.doubleSpin(gui.indentedBox(box), self, 'maxPValue', 1e-8, 1, step=1e-8, label='p:', labelWidth=15, callback=self.FilterAndDisplayGraph, callbackOnReturn=True, tooltip="Max term p-value") box = gui.widgetBox(box, "Significance test") gui.radioButtonsInBox(box, self, "probFunc", ["Binomial", "Hypergeometric"], tooltips=[ "Use binomial distribution test", "Use hypergeometric distribution test" ], callback=self._updateEnrichment) box = gui.widgetBox(self.filterTab, "Evidence codes in annotation", addSpace=True) self.evidenceCheckBoxDict = {} for etype in go.evidenceTypesOrdered: ecb = QCheckBox(etype, toolTip=go.evidenceTypes[etype], checked=self.useEvidenceType[etype]) ecb.toggled.connect(self.__on_evidenceChanged) box.layout().addWidget(ecb) self.evidenceCheckBoxDict[etype] = ecb ## Select tab self.selectTab = gui.createTabPage(self.tabs, "Select") box = gui.radioButtonsInBox(self.selectTab, self, "selectionDirectAnnotation", ["Directly or Indirectly", "Directly"], box="Annotated genes", callback=self.ExampleSelection) box = gui.widgetBox(self.selectTab, "Output", addSpace=True) gui.radioButtonsInBox( box, self, "selectionDisjoint", btnLabels=[ "All selected genes", "Term-specific genes", "Common term genes" ], tooltips=[ "Outputs genes annotated to all selected GO terms", "Outputs genes that appear in only one of selected GO terms", "Outputs genes common to all selected GO terms" ], callback=[self.ExampleSelection, self.UpdateAddClassButton]) self.addClassCB = gui.checkBox(box, self, "selectionAddTermAsClass", "Add GO Term as class", callback=self.ExampleSelection) # ListView for DAG, and table for significant GOIDs self.DAGcolumns = [ 'GO term', 'Cluster', 'Reference', 'p-value', 'FDR', 'Genes', 'Enrichment' ] self.splitter = QSplitter(Qt.Vertical, self.mainArea) self.mainArea.layout().addWidget(self.splitter) # list view self.listView = GOTreeWidget(self.splitter) self.listView.setSelectionMode(QTreeView.ExtendedSelection) self.listView.setAllColumnsShowFocus(1) self.listView.setColumnCount(len(self.DAGcolumns)) self.listView.setHeaderLabels(self.DAGcolumns) self.listView.header().setSectionsClickable(True) self.listView.header().setSortIndicatorShown(True) self.listView.setSortingEnabled(True) self.listView.setItemDelegateForColumn( 6, EnrichmentColumnItemDelegate(self)) self.listView.setRootIsDecorated(True) self.listView.itemSelectionChanged.connect(self.ViewSelectionChanged) # table of significant GO terms self.sigTerms = QTreeWidget(self.splitter) self.sigTerms.setColumnCount(len(self.DAGcolumns)) self.sigTerms.setHeaderLabels(self.DAGcolumns) self.sigTerms.setSortingEnabled(True) self.sigTerms.setSelectionMode(QTreeView.ExtendedSelection) self.sigTerms.setItemDelegateForColumn( 6, EnrichmentColumnItemDelegate(self)) self.sigTerms.itemSelectionChanged.connect(self.TableSelectionChanged) self.sigTableTermsSorted = [] self.graph = {} self.inputTab.layout().addStretch(1) self.filterTab.layout().addStretch(1) self.selectTab.layout().addStretch(1) self.setBlocking(True) self._executor = ThreadExecutor() self._init = EnsureDownloaded([(taxonomy.Taxonomy.DOMAIN, taxonomy.Taxonomy.FILENAME), ("GO", "taxonomy.pickle")]) self._init.finished.connect(self.__initialize_finish) self._executor.submit(self._init)
def __init__(self): super().__init__() box0 = gui.widgetBox(self.controlArea, " ",orientation="horizontal") #widget buttons: compute, set defaults, help gui.button(box0, self, "Compute", callback=self.compute) gui.button(box0, self, "Defaults", callback=self.defaults) gui.button(box0, self, "Help", callback=self.help1) self.process_showers() box = gui.widgetBox(self.controlArea, " ",orientation="vertical") idx = -1 #widget index 0 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "ELECTRONENERGY", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 1 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "ELECTRONENERGYSPREAD", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 2 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "ELECTRONCURRENT", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 3 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "ELECTRONBEAMSIZEH", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 4 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "ELECTRONBEAMSIZEV", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 5 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "ELECTRONBEAMDIVERGENCEH", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 6 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "ELECTRONBEAMDIVERGENCEV", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 7 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "PERIODID", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 8 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "NPERIODS", label=self.unitLabels()[idx], addSpace=True, valueType=int, validator=QIntValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 9 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "KV", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 10 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "DISTANCE", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 11 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "GAPH", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 12 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "GAPV", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 13 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "PHOTONENERGYMIN", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 14 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "PHOTONENERGYMAX", label=self.unitLabels()[idx], addSpace=True, valueType=float, validator=QDoubleValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 15 idx += 1 box1 = gui.widgetBox(box) gui.lineEdit(box1, self, "PHOTONENERGYPOINTS", label=self.unitLabels()[idx], addSpace=True, valueType=int, validator=QIntValidator()) self.show_at(self.unitFlags()[idx], box1) #widget index 16 idx += 1 box1 = gui.widgetBox(box) gui.comboBox(box1, self, "METHOD", label=self.unitLabels()[idx], addSpace=True, items=['US', 'URGENT', 'SRW'], valueType=int, orientation="horizontal") self.show_at(self.unitFlags()[idx], box1) gui.rubber(self.controlArea)
def __init__(self): super().__init__() self.data = None self._pca = None self._transformed = None self._variance_ratio = None self._cumulative = None self._init_projector() # Components Selection form = QFormLayout() box = gui.widgetBox(self.controlArea, "Components Selection", orientation=form) self.components_spin = gui.spin( box, self, "ncomponents", 1, MAX_COMPONENTS, callback=self._update_selection_component_spin, keyboardTracking=False, addToLayout=False) self.components_spin.setSpecialValueText("All") self.variance_spin = gui.spin( box, self, "variance_covered", 1, 100, callback=self._update_selection_variance_spin, keyboardTracking=False, addToLayout=False) self.variance_spin.setSuffix("%") form.addRow("Components:", self.components_spin) form.addRow("Explained variance:", self.variance_spin) # Options self.options_box = gui.vBox(self.controlArea, "Options") self.normalize_box = gui.checkBox(self.options_box, self, "normalize", "Normalize variables", callback=self._update_normalize, attribute=Qt.WA_LayoutUsesWidgetRect) self.maxp_spin = gui.spin(self.options_box, self, "maxp", 1, MAX_COMPONENTS, label="Show only first", callback=self._setup_plot, keyboardTracking=False) gui.rubber(self.controlArea) gui.auto_apply(self.buttonsArea, self, "auto_commit") self.plot = SliderGraph("Principal Components", "Proportion of variance", self._on_cut_changed) self.mainArea.layout().addWidget(self.plot) self._update_normalize()
def add_main_layout(self): # this is part of init, pylint: disable=attribute-defined-outside-init form = QFormLayout() form.setFieldGrowthPolicy(form.AllNonFixedFieldsGrow) form.setLabelAlignment(Qt.AlignLeft) gui.widgetBox(self.controlArea, True, orientation=form) form.addRow( "Neurons in hidden layers:", gui.lineEdit( None, self, "hidden_layers_input", orientation=Qt.Horizontal, callback=self.settings_changed, tooltip="A list of integers defining neurons. Length of list " "defines the number of layers. E.g. 4, 2, 2, 3.", placeholderText="e.g. 10,")) form.addRow( "Activation:", gui.comboBox(None, self, "activation_index", orientation=Qt.Horizontal, label="Activation:", items=[i for i in self.act_lbl], callback=self.settings_changed)) form.addRow( "Solver:", gui.comboBox(None, self, "solver_index", orientation=Qt.Horizontal, label="Solver:", items=[i for i in self.solv_lbl], callback=self.settings_changed)) self.reg_label = QLabel() slider = gui.hSlider(None, self, "alpha_index", minValue=0, maxValue=len(self.alphas) - 1, callback=lambda: (self.set_alpha(), self.settings_changed()), createLabel=False) form.addRow(self.reg_label, slider) self.set_alpha() form.addRow( "Maximal number of iterations:", gui.spin(None, self, "max_iterations", 10, 1000000, step=10, label="Max iterations:", orientation=Qt.Horizontal, alignment=Qt.AlignRight, callback=self.settings_changed)) form.addRow( gui.checkBox(None, self, "replicable", label="Replicable training", callback=self.settings_changed, attribute=Qt.WA_LayoutUsesWidgetRect))