def __init__(self):
self.all_attrs = []
opts = gui.widgetBox(self.controlArea, 'Options')
gui.checkBox(opts, self, 'use_pacf',
label='Compute partial auto-correlation (PACF)',
callback=self.on_changed)
gui.checkBox(opts, self, 'use_confint',
label='Plot 95% significance interval',
callback=self.on_changed)
gui.listBox(self.controlArea, self, 'attrs',
labels='all_attrs',
box='Auto-correlated attribute(s)',
selectionMode=QListWidget.ExtendedSelection,
callback=self.on_changed)
plot = self.plot = Highchart(
self,
chart_zoomType='x',
plotOptions_line_marker_enabled=False,
plotOptions_column_borderWidth=0,
plotOptions_column_groupPadding=0,
plotOptions_series_pointWidth=3,
yAxis_min=-1.0,
yAxis_max=1.0,
xAxis_min=0,
xAxis_gridLineWidth=1,
yAxis_plotLines=[dict(value=0, color='#000', width=1, zIndex=2)],
yAxis_title_text='',
xAxis_title_text='period',
tooltip_headerFormat='Correlation at period: {point.key:.2f}<br/>',
tooltip_pointFormat='<span style="color:{point.color}">\u25CF</span> {point.y:.2f}<br/>',
)
self.mainArea.layout().addWidget(plot)
def __init__(self):
self.all_attrs = []
gui.listBox(self.controlArea, self, 'attrs',
labels='all_attrs',
box='Periodogram attribute(s)',
selectionMode=QListWidget.ExtendedSelection,
callback=self.on_changed)
plot = self.plot = Highchart(
self,
# enable_zoom=True,
chart_zoomType='x',
chart_type='column',
plotOptions_column_borderWidth=0,
plotOptions_column_groupPadding=0,
plotOptions_series_pointWidth=3,
plotOptions_line_marker_enabled=False,
yAxis_min=0,
yAxis_max=1.05,
yAxis_showLastLabel=True,
yAxis_endOnTick=False,
xAxis_min=0,
xAxis_gridLineWidth=1,
yAxis_title_text='',
xAxis_title_text='period',
tooltip_headerFormat='period: {point.key:.2f}<br/>',
tooltip_pointFormat='<span style="color:{point.color}">\u25CF</span> {point.y:.2f}<br/>',
)
self.mainArea.layout().addWidget(plot)
def __init__(self):
super().__init__()
self.grouping = []
self.attributes = []
self.stats = []
self.ddataset = None
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = self.label_width \
= 0
self.attr_list_box = gui.listBox(
self.controlArea, self, "attributes_select", "attributes",
box="Variable", callback=self.attr_changed)
self.attrCombo = gui.listBox(
self.controlArea, self, 'grouping_select', "grouping",
box="Grouping", callback=self.attr_changed)
self.sorting_combo = gui.radioButtonsInBox(
self.controlArea, self, 'display', box='Display',
callback=self.display_changed,
btnLabels=["Box plots", "Annotated boxes",
"Compare medians", "Compare means"])
self.stretching_box = gui.checkBox(
self.controlArea, self, 'stretched', "Stretch bars", box='Display',
callback=self.display_changed).box
gui.rubber(self.controlArea)
gui.widgetBox(self.mainArea, addSpace=True)
self.boxScene = QtGui.QGraphicsScene()
self.boxView = QtGui.QGraphicsView(self.boxScene)
self.boxView.setRenderHints(QtGui.QPainter.Antialiasing |
QtGui.QPainter.TextAntialiasing |
QtGui.QPainter.SmoothPixmapTransform)
self.mainArea.layout().addWidget(self.boxView)
self.posthoc_lines = []
e = gui.widgetBox(self.mainArea, addSpace=False, orientation=0)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.warning = gui.widgetBox(self.controlArea, "Warning:")
self.warning_info = gui.widgetLabel(self.warning, "")
self.warning.hide()
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.set_display_box()
dlg = self.createColorDialog()
self.discPalette = dlg.getDiscretePalette("discPalette")
def __init__(self, parent, rgbColors):
super().__init__(parent)
self.setCaption("Palette Editor")
self.setLayout(QVBoxLayout(self))
self.layout().setMargin(4)
hbox = gui.widgetBox(self, "Information" , orientation = 'horizontal')
gui.widgetLabel(hbox, '<p align="center">You can reorder colors in the list using the<br>buttons on the right or by dragging and dropping the items.<br>To change a specific color double click the item in the list.</p>')
hbox = gui.widgetBox(self, 1, orientation = 'horizontal')
self.discListbox = gui.listBox(hbox, self, enableDragDrop = 1)
vbox = gui.widgetBox(hbox, orientation = 'vertical')
buttonUPAttr = gui.button(vbox, self, "", callback = self.moveAttrUP, tooltip="Move selected colors up")
buttonDOWNAttr = gui.button(vbox, self, "", callback = self.moveAttrDOWN, tooltip="Move selected colors down")
buttonUPAttr.setIcon(QIcon(os.path.join(self.widgetDir, "icons/Dlg_up3.png")))
buttonUPAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed , QSizePolicy.Expanding))
buttonUPAttr.setMaximumWidth(30)
buttonDOWNAttr.setIcon(QIcon(os.path.join(self.widgetDir, "icons/Dlg_down3.png")))
buttonDOWNAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed , QSizePolicy.Expanding))
buttonDOWNAttr.setMaximumWidth(30)
self.connect(self.discListbox, QtCore.SIGNAL("itemDoubleClicked ( QListWidgetItem *)"), self.changeDiscreteColor)
box = gui.widgetBox(self, 1, orientation = "horizontal")
gui.button(box, self, "OK", self.accept)
gui.button(box, self, "Cancel", self.reject)
self.discListbox.setIconSize(QtCore.QSize(25, 25))
for ind, (r,g,b) in enumerate(rgbColors):
item = QListWidgetItem(ColorPixmap(QColor(r,g,b), 25), "Color %d" % (ind+1))
item.rgbColor = (r,g,b)
self.discListbox.addItem(item)
self.resize(300, 300)
def add_hidden_attributes(self, parent):
self.hidden_attributes_area = gui.vBox(parent, " Hidden attributes ")
self.hidden_attributes_listbox = gui.listBox(
self.hidden_attributes_area, self, "selected_hidden",
"_hidden_attributes",
dragDropCallback=self.trigger_attributes_changed,
enableDragDrop=True, selectionMode=QListWidget.ExtendedSelection)
def __init__(self):
super().__init__()
self.objects = {}
self.lb_objects = gui.listBox(self.controlArea, self, box="Inputs",
callback=self._on_selection_change,
sizeHint=QSize(300, 300))
self.lb_objects.setFocusPolicy(Qt.NoFocus)
def __init__(self, parent=None):
super().__init__(parent)
self.results = None
self.learners = []
self._invalidated = False
box = gui.widgetBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.widgetBox(self.controlArea, "Show")
combo = gui.comboBox(box, self, "selected_quantity",
items=self.quantities,
callback=self._update)
combo.setMinimumContentsLength(20)
combo.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
box = gui.widgetBox(self.controlArea, "Selection")
gui.button(box, self, "Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "None",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Append class predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Append probabilities",
callback=self._invalidate)
b = gui.button(box, self, "Commit", callback=self.commit, default=True)
cb = gui.checkBox(box, self, "autocommit", "Commit automatically")
gui.setStopper(self, b, cb, "_invalidated", callback=self.commit)
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.addWidget(QLabel("Predicted"), 0, 1, Qt.AlignCenter)
grid.addWidget(VerticalLabel("Correct Class"), 1, 0, Qt.AlignCenter)
self.tablemodel = QStandardItemModel()
self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers,
)
self.tableview.setModel(self.tablemodel)
self.tableview.selectionModel().selectionChanged.connect(
self._invalidate
)
grid.addWidget(self.tableview, 1, 1)
self.mainArea.layout().addLayout(grid)
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
self.learners_box = gui.listBox(
self.controlArea, self, "selected_learner", "learners", box=True,
callback=self._learner_changed
)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.outputbox, self, "autocommit",
"Send Selected", "Send Automatically", box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox, self, "selected_quantity",
items=self.quantities, label="Show: ",
orientation=Qt.Horizontal, callback=self._update)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
view.clicked.connect(self.cell_clicked)
box.layout().addWidget(view)
selbox = gui.hBox(box)
gui.button(selbox, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(selbox, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(selbox, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
def __init__(self,
rgbColors,
parent=None,
windowTitle="Palette Editor",
**kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(4, 4, 4, 4)
hbox = gui.hBox(self, "Information")
gui.widgetLabel(
hbox,
'<p align="center">You can reorder colors in the list using the'
'<br/>buttons on the right or by dragging and dropping the items.'
'<br/>To change a specific color double click the item in the '
'list.</p>')
hbox = gui.hBox(self, box=True)
self.discListbox = gui.listBox(hbox, self, enableDragDrop=1)
vbox = gui.vBox(hbox)
buttonUPAttr = gui.button(vbox,
self,
"",
callback=self.moveAttrUP,
tooltip="Move selected colors up")
buttonDOWNAttr = gui.button(vbox,
self,
"",
callback=self.moveAttrDOWN,
tooltip="Move selected colors down")
buttonUPAttr.setIcon(QIcon(gui.resource_filename("icons/Dlg_up3.png")))
buttonUPAttr.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonUPAttr.setMaximumWidth(30)
buttonDOWNAttr.setIcon(
QIcon(gui.resource_filename("icons/Dlg_down3.png")))
buttonDOWNAttr.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonDOWNAttr.setMaximumWidth(30)
self.discListbox.itemDoubleClicked.connect(self.changeDiscreteColor)
box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
accepted=self.accept,
rejected=self.reject)
self.layout().addWidget(box)
self.discListbox.setIconSize(QSize(25, 25))
for ind, (r, g, b) in enumerate(rgbColors):
item = QListWidgetItem(ColorPixmap(QColor(r, g, b), 25),
"Color %d" % (ind + 1))
item.rgbColor = (r, g, b)
self.discListbox.addItem(item)
self.resize(300, 300)
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.headers = []
self.learners_box = gui.listBox(
self.controlArea, self, "selected_learner", "learners", box=True,
callback=self._learner_changed
)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_apply(self.outputbox, self, "autocommit", box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox, self, "selected_quantity",
items=self.quantities, label="Show: ",
orientation=Qt.Horizontal, callback=self._update)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
view.clicked.connect(self.cell_clicked)
box.layout().addWidget(view)
selbox = gui.hBox(box)
gui.button(selbox, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(selbox, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(selbox, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
def __init__(self):
super().__init__()
if isinstance(self.selected_learner, list):
self.selected_learner = (self.selected_learner + [0])[0]
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Selected", "Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def __init__(self):
"""Widget creator."""
super().__init__()
#----------------------------------------------------------------------
# Other (non settings) attributes...
self.inputSeg = None
self.selectedCharacters = list()
self.characters = list()
self.mustLoad = True
if INSTALLED_MODELS:
self.model = INSTALLED_MODELS[0]
else:
self.model = ""
#----------------------------------------------------------------------
# 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",
sendIfPreCallback=None,
)
#----------------------------------------------------------------------
# User interface...
self.characterListbox = gui.listBox(
widget=self.controlArea,
master=self,
value="selectedCharacters",
labels="characters",
callback=None,
tooltip="List of identified characters",
)
gui.rubber(self.controlArea)
#----------------------------------------------------------------------
# Draw Info box and Send button...
self.sendButton.draw()
self.infoBox.draw()
self.infoBox.setText("Widget needs input.", "warning")
# Check that there's a model...
if not self.model:
self.noLanguageModelWarning()
def __init__(self):
super().__init__()
if isinstance(self.selected_learner, list):
self.selected_learner = (self.selected_learner + [0])[0]
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.vBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.vBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.vBox(self.controlArea, "Select")
gui.button(box, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.vBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Selected", "Send Automatically")
grid = QGridLayout()
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().hide()
view.verticalHeader().hide()
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
view.setShowGrid(False)
view.setItemDelegate(BorderedItemDelegate(Qt.white))
view.clicked.connect(self.cell_clicked)
grid.addWidget(view, 0, 0)
self.mainArea.layout().addLayout(grid)
def add_hidden_attributes(self, parent):
self.hidden_attributes_area = gui.widgetBox(parent,
" Hidden attributes ")
self.hidden_attributes_listbox = gui.listBox(
self.hidden_attributes_area,
self,
"selected_hidden",
"_hidden_attributes",
dragDropCallback=self.trigger_attributes_changed,
enableDragDrop=True,
selectionMode=QListWidget.ExtendedSelection)
def __init__(self, parent=None):
super().__init__(parent)
self.classes = []
self.data = None
self.annotation_variables = []
self.__groups = None
self.__selected_data_indices = []
# Setup GUI
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,
"display_individual",
"Expression Profiles",
callback=self.__update_visibility)
gui.checkBox(displaybox,
self,
"display_quartiles",
"Quartiles",
callback=self.__update_visibility)
group_box = gui.widgetBox(self.controlArea, "Classes")
self.group_listbox = gui.listBox(
group_box,
self,
"selected_classes",
"classes",
selectionMode=QListWidget.MultiSelection,
callback=self.__on_class_selection_changed)
self.unselectAllClassedQLB = gui.button(
group_box, self, "Unselect all", callback=self.__select_all_toggle)
self.annot_cb = gui.comboBox(self.controlArea,
self,
"annot_index",
box="Profile Labels",
callback=self.__update_tooltips)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
self.graph = pg.PlotWidget(background="w")
self.graph.setRenderHint(QPainter.Antialiasing, True)
self.graph.scene().selectionChanged.connect(
self.__on_curve_selection_changed)
self.mainArea.layout().addWidget(self.graph)
self.legend = pg.LegendItem(offset=(-30, 30))
self.legend.setParentItem(self.graph.plotItem)
self.legend_items = []
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.output_mask = None # Output corpus indices
self.document_contents = None # QTextDocument
self.document_holder = None # QTextEdit
self.features = [] # all attributes
# ---- CONTROL AREA ----
# Filtering results.
filter_result_box = gui.widgetBox(self.controlArea, 'Info')
self.info_all = gui.label(filter_result_box, self, 'All documents:')
self.info_fil = gui.label(filter_result_box, self, 'After filtering:')
# Feature selection.
self.feature_listbox = gui.listBox(
self.controlArea, self, 'selected_features', 'features',
selectionMode=QtGui.QListView.ExtendedSelection,
box='Displayed features', callback=self.load_documents,)
# Auto-commit box.
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data', 'Auto send is on')
# ---- MAIN AREA ----
# Search
self.filter_input = gui.lineEdit(self.mainArea, self, '',
orientation='horizontal',
label='RegExp Filter:')
self.filter_input.textChanged.connect(self.filter_input_changed)
h_box = gui.widgetBox(self.mainArea, orientation='horizontal', addSpace=True)
h_box.layout().setSpacing(0)
# Document list.
self.document_table = QTableView()
self.document_table.setSelectionBehavior(QTableView.SelectRows)
self.document_table.setSelectionMode(QTableView.ExtendedSelection)
self.document_table.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.document_table.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
self.document_table.horizontalHeader().setVisible(False)
h_box.layout().addWidget(self.document_table)
self.document_table_model = QStandardItemModel(self)
self.document_table.setModel(self.document_table_model)
self.document_table.setFixedWidth(200)
self.document_table.selectionModel().selectionChanged.connect(self.show_document)
# Document contents.
self.document_holder = QTextEdit()
self.document_holder.setReadOnly(True)
self.document_holder.setLineWrapMode(QTextEdit.WidgetWidth)
h_box.layout().addWidget(self.document_holder)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed,
contentsLength=8)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QtWidgets.QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box, self, "display_convex_hull",
"Show lift convex hull", callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QtWidgets.QFrame.StyledPanel)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self, parent=None):
super().__init__(parent)
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.widgetBox(self.controlArea, "Plot")
tbox = gui.widgetBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed,
contentsLength=8)
cbox = gui.widgetBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QtGui.QListView.MultiSelection,
callback=self._on_classifiers_changed)
gui.checkBox(box, self, "display_convex_hull",
"Show lift convex hull", callback=self._replot)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QtGui.QFrame.StyledPanel)
self.plot = pg.PlotItem()
self.plot.getViewBox().setMenuEnabled(False)
pen = QPen(self.palette().color(QtGui.QPalette.Text))
tickfont = QtGui.QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("P Rate")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self.graphButton.clicked.connect(self.save_graph)
def __init__(self):
super().__init__()
self.optionsBox = gui.widgetBox(self.controlArea, "Options")
gui.spin(
self.optionsBox,
self,
"proportion",
minv=10,
maxv=90,
step=10,
label="Sample Size [%]:",
callback=[self.selection, self.checkCommit],
)
gui.separator(self.controlArea)
self.listBox = gui.widgetBox(self.controlArea, "Columns")
gui.listBox(self.listBox,
self,
value="columnList",
labels="columnList",
callback=[self.selection, self.checkCommit])
def __init__(self):
self.all_attrs = []
opts = gui.widgetBox(self.controlArea, 'Options')
gui.checkBox(opts,
self,
'use_pacf',
label='Compute partial auto-correlation (PACF)',
callback=self.on_changed)
gui.checkBox(opts,
self,
'use_confint',
label='Plot 95% significance interval',
callback=self.on_changed)
gui.listBox(self.controlArea,
self,
'attrs',
labels='all_attrs',
box='Auto-correlated attribute(s)',
selectionMode=QListWidget.ExtendedSelection,
callback=self.on_changed)
plot = self.plot = Highchart(
self,
chart_zoomType='x',
plotOptions_line_marker_enabled=False,
plotOptions_column_borderWidth=0,
plotOptions_column_groupPadding=0,
plotOptions_series_pointWidth=3,
yAxis_min=-1.0,
yAxis_max=1.0,
xAxis_min=0,
xAxis_gridLineWidth=1,
yAxis_plotLines=[dict(value=0, color='#000', width=1, zIndex=2)],
yAxis_title_text='',
xAxis_title_text='period',
tooltip_headerFormat='Correlation at period: {point.key:.2f}<br/>',
tooltip_pointFormat=
'<span style="color:{point.color}">\u25CF</span> {point.y:.2f}<br/>',
)
self.mainArea.layout().addWidget(plot)
def __init__(self, parent=None):
super().__init__(parent)
self.data = None
self.results = None
self.learners = []
self.headers = []
box = gui.widgetBox(self.controlArea, "Learners")
self.learners_box = gui.listBox(
box, self, "selected_learner", "learners",
callback=self._learner_changed
)
box = gui.widgetBox(self.controlArea, "Show")
gui.comboBox(box, self, "selected_quantity", items=self.quantities,
callback=self._update)
box = gui.widgetBox(self.controlArea, "Select")
gui.button(box, self, "Correct",
callback=self.select_correct, autoDefault=False)
gui.button(box, self, "Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(box, self, "None",
callback=self.select_none, autoDefault=False)
self.outputbox = box = gui.widgetBox(self.controlArea, "Output")
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.controlArea, self, "autocommit",
"Send Data", "Auto send is on")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
grid.addWidget(QLabel("Predicted"), 0, 1, Qt.AlignCenter)
grid.addWidget(VerticalLabel("Actual Class"), 1, 0, Qt.AlignCenter)
self.tablemodel = QStandardItemModel(self)
view = self.tableview = QTableView(
editTriggers=QTableView.NoEditTriggers)
view.setModel(self.tablemodel)
view.horizontalHeader().setMinimumSectionSize(60)
view.selectionModel().selectionChanged.connect(self._invalidate)
grid.addWidget(view, 1, 1)
self.mainArea.layout().addLayout(grid)
def __init__(self):
self.data = None
self.all_attrs = []
gui.listBox(self.controlArea,
self,
'attrs',
labels='all_attrs',
box='Dataset attribute(s)',
selectionMode=QListWidget.ExtendedSelection,
callback=self.on_changed)
self.optionsBox = gui.widgetBox(self.controlArea, "KDE-2D Options")
gui.comboBox(self.optionsBox,
self,
"bw_methode",
orientation=Qt.Horizontal,
label="Bandwidth Method: ",
items=[d[0] for d in BW_METHOD],
callback=self._bw_methode)
self.optionsBox.setDisabled(True)
self.figure = plt.figure()
self.canvas = FigureCanvas(self.figure)
self.mainArea.layout().addWidget(self.canvas)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._replot,
contentsLength=8)
cbox = gui.vBox(box, "Classifier")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
box,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListWidget.MultiSelection,
callback=self._replot,
)
gui.checkBox(box,
self,
"display_rug",
"Show rug",
callback=self._on_display_rug_changed)
self.plotview = pg.GraphicsView(background="w")
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
axis = self.plot.getAxis("bottom")
axis.setLabel("Predicted Probability")
axis = self.plot.getAxis("left")
axis.setLabel("Observed Average")
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.widgetBox(self.controlArea, "Plot")
tbox = gui.widgetBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox,
self,
"target_index",
callback=self._replot,
contentsLength=8)
cbox = gui.widgetBox(box, "Classifier")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
box,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QtGui.QListWidget.MultiSelection,
callback=self._replot)
gui.checkBox(box,
self,
"display_rug",
"Show rug",
callback=self._on_display_rug_changed)
self.plotview = pg.GraphicsView(background="w")
self.plot = pg.PlotItem()
axis = self.plot.getAxis("bottom")
axis.setLabel("Predicted Probability")
axis = self.plot.getAxis("left")
axis.setLabel("Observed Average")
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self.graphButton.clicked.connect(self.save_graph)
def __init__(self):
super().__init__()
self._nhops = 2
self._edge_threshold = 0.5
self._n_max_neighbors = 20
self.selected_titles = []
self.titles = []
self.filter = ""
self.ids = []
self._selected_nodes = []
self._algorithm = 0
self._k_algorithm = 0.3
box = gui.widgetBox(self.controlArea, "Paper Selection", orientation="vertical")
gui.lineEdit(box, self, "filter", callback=self.filter_list, callbackOnType=True)
self.list_titles = gui.listBox(
box, self, "selected_titles", "titles", selectionMode=QListWidget.MultiSelection, callback=self.update_view
)
gui.separator(self.controlArea)
box_pref = gui.widgetBox(self.controlArea, "Preferences", orientation="vertical")
gui.spin(box_pref, self, "_nhops", 1, 6, 1, label="Number of hops: ", callback=self.update_view)
gui.spin(
box_pref, self, "_n_max_neighbors", 1, 100, 1, label="Max number of neighbors: ", callback=self.update_view
)
gui.doubleSpin(
box_pref, self, "_edge_threshold", 0, 1, step=0.01, label="Edge threshold: ", callback=self.update_view
)
gui.separator(self.controlArea)
box_alg = gui.widgetBox(self.controlArea, "Interest Propagation Algorithm", orientation="vertical")
radio_box = gui.radioButtonsInBox(box_alg, self, "_algorithm", [], callback=self.update_view)
gui.appendRadioButton(radio_box, self, "_algorithm", "Without Clustering", callback=self.update_view)
gui.doubleSpin(
gui.indentedBox(radio_box),
self,
"_k_algorithm",
0,
1,
step=0.01,
label="Parameter k: ",
callback=self.update_view,
)
gui.appendRadioButton(radio_box, self, "_algorithm", "With Clustering", callback=self.update_view)
self.inside_view = PubmedNetworkView(self)
self.send("Nx View", self.inside_view)
def __init__(self, parent=None):
super().__init__(parent)
self.classes = []
self.data = None
self.group_variables = []
self.graph_variables = []
self.__groups = None
# Setup GUI
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,
"display_individual",
"Line plots",
callback=self.__update_visibility)
gui.checkBox(displaybox,
self,
"display_quartiles",
"Box plot",
callback=self.__update_visibility)
group_box = gui.widgetBox(self.controlArea, "Group by")
self.cb_attr = gui.comboBox(group_box,
self,
"group_var",
sendSelectedValue=True,
callback=self.update_group_var)
self.group_listbox = gui.listBox(
group_box,
self,
"selected_classes",
"classes",
selectionMode=QtGui.QListWidget.MultiSelection,
callback=self.__on_class_selection_changed)
self.unselectAllClassedQLB = gui.button(
group_box, self, "Unselect all", callback=self.__select_all_toggle)
gui.rubber(self.controlArea)
self.graph = pg.PlotWidget(background="w", enableMenu=False)
self.graph.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.graph)
def __init__(self, parent=None):
super().__init__(parent)
self.classes = []
self.data = None
self.annotation_variables = []
self.__groups = None
self.__selected_data_indices = []
# Setup GUI
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, "display_individual",
"Expression Profiles",
callback=self.__update_visibility)
gui.checkBox(displaybox, self, "display_quartiles", "Quartiles",
callback=self.__update_visibility)
group_box = gui.widgetBox(self.controlArea, "Classes")
self.group_listbox = gui.listBox(
group_box, self, "selected_classes", "classes",
selectionMode=QListWidget.MultiSelection,
callback=self.__on_class_selection_changed)
self.unselectAllClassedQLB = gui.button(
group_box, self, "Unselect all",
callback=self.__select_all_toggle)
self.annot_cb = gui.comboBox(
self.controlArea, self, "annot_index", box="Profile Labels",
callback=self.__update_tooltips)
gui.rubber(self.controlArea)
gui.auto_commit(self.controlArea, self, "auto_commit", "Commit")
self.graph = pg.PlotWidget(background="w")
self.graph.setRenderHint(QPainter.Antialiasing, True)
self.graph.scene().selectionChanged.connect(
self.__on_curve_selection_changed)
self.mainArea.layout().addWidget(self.graph)
self.legend = pg.LegendItem(offset=(-30, 30))
self.legend.setParentItem(self.graph.plotItem)
self.legend_items = []
def __init__(self):
super().__init__()
self.data = None
self.results = None
self.learners = []
self.learners_box = gui.listBox(
self.controlArea, self, "selected_learner", "learners", box=True,
callback=self._learner_changed
)
self.outputbox = gui.vBox(self.controlArea, "Output")
box = gui.hBox(self.outputbox)
gui.checkBox(box, self, "append_predictions",
"Predictions", callback=self._invalidate)
gui.checkBox(box, self, "append_probabilities",
"Probabilities",
callback=self._invalidate)
gui.auto_commit(self.outputbox, self, "autocommit",
"Send Selected", "Send Automatically", box=False)
self.mainArea.layout().setContentsMargins(0, 0, 0, 0)
box = gui.vBox(self.mainArea, box=True)
sbox = gui.hBox(box)
gui.rubber(sbox)
gui.comboBox(sbox, self, "selected_quantity",
items=self.quantities, label="Show: ",
orientation=Qt.Horizontal, callback=self._update)
self.tableview = ContingencyTable(self)
box.layout().addWidget(self.tableview)
selbox = gui.hBox(box)
gui.button(selbox, self, "Select Correct",
callback=self.select_correct, autoDefault=False)
gui.button(selbox, self, "Select Misclassified",
callback=self.select_wrong, autoDefault=False)
gui.button(selbox, self, "Clear Selection",
callback=self.select_none, autoDefault=False)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._replot,
contentsLength=8)
cbox = gui.vBox(box, "Classifier")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
box, self, "selected_classifiers", "classifier_names",
selectionMode=QListWidget.MultiSelection,
callback=self._replot)
gui.checkBox(box, self, "display_rug", "Show rug",
callback=self._on_display_rug_changed)
self.plotview = pg.GraphicsView(background="w")
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
axis = self.plot.getAxis("bottom")
axis.setLabel("Predicted Probability")
axis = self.plot.getAxis("left")
axis.setLabel("Observed Average")
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self, rgbColors, parent=None, windowTitle="Palette Editor",
**kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(4, 4, 4, 4)
hbox = gui.hBox(self, "Information")
gui.widgetLabel(
hbox,
'<p align="center">You can reorder colors in the list using the'
'<br/>buttons on the right or by dragging and dropping the items.'
'<br/>To change a specific color double click the item in the '
'list.</p>')
hbox = gui.hBox(self, box=True)
self.discListbox = gui.listBox(hbox, self, enableDragDrop=1)
vbox = gui.vBox(hbox)
buttonUPAttr = gui.button(vbox, self, "", callback=self.moveAttrUP,
tooltip="Move selected colors up")
buttonDOWNAttr = gui.button(vbox, self, "", callback=self.moveAttrDOWN,
tooltip="Move selected colors down")
buttonUPAttr.setIcon(QIcon(gui.resource_filename("icons/Dlg_up3.png")))
buttonUPAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonUPAttr.setMaximumWidth(30)
buttonDOWNAttr.setIcon(QIcon(gui.resource_filename("icons/Dlg_down3.png")))
buttonDOWNAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonDOWNAttr.setMaximumWidth(30)
self.discListbox.itemDoubleClicked.connect(self.changeDiscreteColor)
box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
accepted=self.accept, rejected=self.reject)
self.layout().addWidget(box)
self.discListbox.setIconSize(QSize(25, 25))
for ind, (r, g, b) in enumerate(rgbColors):
item = QListWidgetItem(ColorPixmap(QColor(r, g, b), 25), "Color %d" % (ind + 1))
item.rgbColor = (r, g, b)
self.discListbox.addItem(item)
self.resize(300, 300)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.colors = []
self._curve_data = {}
box = gui.widgetBox(self.controlArea, "Plot")
tbox = gui.widgetBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(tbox, self, "target_index", callback=self._replot, contentsLength=8)
cbox = gui.widgetBox(box, "Classifier")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
box,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QtGui.QListWidget.MultiSelection,
callback=self._replot,
)
gui.checkBox(box, self, "display_rug", "Show rug", callback=self._on_display_rug_changed)
self.plotview = pg.GraphicsView(background="w")
self.plot = pg.PlotItem()
axis = self.plot.getAxis("bottom")
axis.setLabel("Predicted Probability")
axis = self.plot.getAxis("left")
axis.setLabel("Observed Average")
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self.graphButton.clicked.connect(self.save_graph)
def __init__(self):
super().__init__()
self.biogrid = obiBioGRID.BioGRID()
self.organisms, self.taxonomy = org_to_tax(self.biogrid.organisms())
self.organism_id = 0
self.attribute_id = 0
self.network = None
self.proteins = []
self.interactions = []
box1 = gui.widgetBox(self.controlArea, "Info")
self.info = gui.widgetLabel(box1, 'No database subset yet chosen.')
box2 = gui.widgetBox(self.controlArea, "Select database subset")
gui.widgetLabel(box2, 'Select organism.')
gui.comboBox(box2,
self,
"organism_id",
callback=self.organism_update_info,
items=self.taxonomy)
gui.widgetLabel(box2, 'Select attribute.')
gui.comboBox(box2,
self,
"attribute_id",
callback=self.attribute_update,
items=[a[0] for a in self.ATTRIBUTES])
self.conditions = []
self.conditions_index = []
self.conditions_box = gui.listBox(
box2,
self,
"conditions_index",
selectionMode=QListWidget.MultiSelection)
self.conditions_box.itemClicked.connect(self.attribute_update_info)
gui.button(self.controlArea, self, "Commit", callback=self.commit)
def __init__(self, parent=None):
super().__init__(parent)
self.classes = []
self.data = None
self.group_variables = []
self.graph_variables = []
self.__groups = None
# Setup GUI
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, "display_individual",
"Line plots",
callback=self.__update_visibility)
gui.checkBox(displaybox, self, "display_quartiles", "Box plot",
callback=self.__update_visibility)
group_box = gui.widgetBox(self.controlArea, "Group by")
self.cb_attr = gui.comboBox(
group_box, self, "group_var", sendSelectedValue=True,
callback=self.update_group_var)
self.group_listbox = gui.listBox(
group_box, self, "selected_classes", "classes",
selectionMode=QtGui.QListWidget.MultiSelection,
callback=self.__on_class_selection_changed)
self.unselectAllClassedQLB = gui.button(
group_box, self, "Unselect all",
callback=self.__select_all_toggle)
gui.rubber(self.controlArea)
self.graph = pg.PlotWidget(background="w", enableMenu=False)
self.graph.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.mainArea.layout().addWidget(self.graph)
def render_layout(self):
gui.separator(self.controlArea, 0, 6)
gui.checkBox(self.controlArea,
self,
'setting_first_and_last_values',
'Absolute first and last values.',
callback=self.settings_changed)
self.render_sliders(self.sliders(), 200, 2)
self.render_plot_views()
gui.separator(self.controlArea, 0, 6)
cbox = gui.vBox(self.controlArea, "Agents:")
cbox.setFlat(True)
self.list_box = gui.listBox(cbox,
self,
"selected_agents",
"agent_names",
selectionMode=QListView.MultiSelection,
callback=self.settings_changed)
def __init__(self, parent, rgbColors):
super().__init__(parent)
self.setCaption("Palette Editor")
self.setLayout(QVBoxLayout(self))
self.layout().setMargin(4)
hbox = gui.widgetBox(self, "Information", orientation='horizontal')
gui.widgetLabel(hbox,
'<p align="center">You can reorder colors in the list using the<br>buttons on the right or by dragging and dropping the items.<br>To change a specific color double click the item in the list.</p>')
hbox = gui.widgetBox(self, 1, orientation='horizontal')
self.discListbox = gui.listBox(hbox, self, enableDragDrop=1)
vbox = gui.widgetBox(hbox, orientation='vertical')
buttonUPAttr = gui.button(vbox, self, "", callback=self.moveAttrUP, tooltip="Move selected colors up")
buttonDOWNAttr = gui.button(vbox, self, "", callback=self.moveAttrDOWN, tooltip="Move selected colors down")
buttonUPAttr.setIcon(QIcon(os.path.join(environ.widget_install_dir, "icons/Dlg_up3.png")))
buttonUPAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonUPAttr.setMaximumWidth(30)
buttonDOWNAttr.setIcon(QIcon(os.path.join(environ.widget_install_dir, "icons/Dlg_down3.png")))
buttonDOWNAttr.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding))
buttonDOWNAttr.setMaximumWidth(30)
self.connect(self.discListbox, QtCore.SIGNAL("itemDoubleClicked ( QListWidgetItem *)"),
self.changeDiscreteColor)
box = gui.widgetBox(self, 1, orientation="horizontal")
gui.button(box, self, "OK", self.accept)
gui.button(box, self, "Cancel", self.reject)
self.discListbox.setIconSize(QtCore.QSize(25, 25))
for ind, (r, g, b) in enumerate(rgbColors):
item = QListWidgetItem(ColorPixmap(QColor(r, g, b), 25), "Color %d" % (ind + 1))
item.rgbColor = (r, g, b)
self.discListbox.addItem(item)
self.resize(300, 300)
def _create_layout(self):
self._add_graph()
box = gui.widgetBox(self.controlArea, "Relevance")
self.rel_slider = gui.hSlider(
box,
self,
"relevance",
minValue=0,
maxValue=1,
step=0.1,
intOnly=False,
labelFormat="%.1f",
callback_finished=self.on_params_change,
createLabel=True,
)
self.topic_box = gui.listBox(
self.controlArea,
self,
"selected_topic",
"topic_list",
box="Topics",
callback=self.on_params_change,
)
def __init__(self):
super().__init__(self)
gui.rubber(self.controlArea)
gui.rubber(self.mainArea)
self.info.set_output_summary(self.info.NoOutput)
box = gui.vBox(self.mainArea, "Configure data query")
self.radiobox = gui.radioButtons(box, self, "query_type", callback=self.radio_changed)
gui.appendRadioButton(self.radiobox, "All data")
gui.appendRadioButton(self.radiobox, "Interesting intervals")
ibox = gui.indentedBox(self.radiobox)
gui.spin(
ibox, self, "interval_len", 1, 100000, label="Interval length",
controlWidth=60, callback=self.number_changed)
gui.spin(
ibox, self, "n_intervals", 1, 100000, label="Number of intervals",
controlWidth=60, callback=self.number_changed)
gui.appendRadioButton(self.radiobox, "Custom intervals")
gui.appendRadioButton(self.radiobox, "Last n seconds")
nbox = gui.indentedBox(self.radiobox)
gui.spin(
nbox, self, "last_seconds", 1, 10000000, label="Last seconds",
controlWidth=60, callback=self.number_changed)
gui.appendRadioButton(self.radiobox, "Last n measurements on each sensor")
nmbox = gui.indentedBox(self.radiobox)
gui.spin(
nmbox, self, "last_measurements", 1, 10000000, label="Last measurements",
controlWidth=60, callback=self.number_changed)
self.radiobox.setDisabled(not self.query_controls)
self.objects = {}
self.lb_objects = gui.listBox(self.controlArea, self, "selected", "lb_labels", box="Deployments",
callback=self.sel_changed,
sizeHint=QSize(300, 300))
self.lb_objects.setFocusPolicy(Qt.NoFocus)
out_box = gui.vBox(self.mainArea, "Output")
self.out_box = gui.radioButtons(out_box, self, "output_type", callback=self.output_changed)
gui.appendRadioButton(self.out_box, "Matrix")
gui.appendRadioButton(self.out_box, "Tensor")
self.apply_button = gui.button(self.mainArea, self, self.tr("&Apply"),
callback=self.apply)
self.out_box.setDisabled(not self.query_controls)
self._executor = ThreadPoolExecutor(max_workers=1)
self._executor.submit(self.get_deployments())
def __init__(self, parent=None):
super().__init__(self, parent)
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, "Input")
self.labelDataInput = gui.widgetLabel(box, 'No data on input')
self.labelDataInput.setTextFormat(Qt.PlainText)
self.labelOutput = gui.widgetLabel(box, '')
self.x_var_model = itemmodels.VariableListModel()
self.comboBoxAttributesX = gui.comboBox(
self.controlArea, self, value='x_var_index', box='X Attribute',
callback=self.replot)
self.comboBoxAttributesX.setModel(self.x_var_model)
self.y_var_model = itemmodels.VariableListModel()
self.comboBoxAttributesY = gui.comboBox(
self.controlArea, self, value='y_var_index', box='Y Attribute',
callback=self.replot)
self.comboBoxAttributesY.setModel(self.y_var_model)
box = gui.widgetBox(self.controlArea, "Color by")
self.z_var_model = itemmodels.VariableListModel()
self.comboBoxClassvars = gui.comboBox(
box, self, value='z_var_index',
callback=self._on_z_var_changed)
self.comboBoxClassvars.setModel(self.z_var_model)
box = gui.widgetBox(box, 'Colors displayed')
box.setFlat(True)
self.z_values_view = gui.listBox(
box, self, "selected_z_values", "z_values",
callback=self._on_z_values_selection_changed,
selectionMode=QtGui.QListView.MultiSelection
)
self.mouseBehaviourBox = gui.radioButtons(
self.controlArea, self, value='mouse_mode',
btnLabels=('Drag', 'Select'),
box='Mouse left button behavior',
callback=self._update_mouse_mode
)
box = gui.widgetBox(self.controlArea, box='Display')
gui.button(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):
"""Widget creator."""
super().__init__()
# Other attributes...
self.inputSeg = None
self.outputSeg = None
self.dialect = None
self.selectedHeader = None
self.csvSeg = list()
# list of deleted segments
self.contentIsNone = list()
# list for gui
self.headerList = list()
self.content_column = 0
self.headerEdit = ""
# those are for the rename function
self.renamedHeader = None
self.isRenamed = False
self.dict_keys = list()
# preprocess
self.deleteQuotes = False
# 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",
sendIfPreCallback=None,
)
#self.header_there = False
#----------------------------------------------------------------------
# User interface...
# preprocess box...
self.preprocessBox = gui.widgetBox(
widget=self.controlArea,
box="Preprocess",
orientation="vertical",
)
# check box...
self.checkQuotes = gui.checkBox(
widget=self.preprocessBox,
master=self,
value='deleteQuotes',
label='delete quotation marks',
callback=self.delete_quotes,
)
# main box...
self.mainBox = gui.widgetBox(
widget=self.controlArea,
box="Click to select a header to modify",
orientation="vertical",
)
# List of all the headers (named with numbers if None)
self.headerListbox = gui.listBox(
widget=self.mainBox,
master=self,
value="selectedHeader",
labels="headerList",
callback=self.update_gui,
selectionMode=1, # can only choose one item
tooltip="list of all your headers",
)
# set "rename" button (must be aside the list)
self.renameHeader = gui.button(
widget=self.mainBox,
master=self,
label="rename",
callback=self.set_renamebox,
tooltip="click to rename header"
)
# set "use as content" button (must be aside the list)
self.iscontentHeader = gui.button(
widget=self.mainBox,
master=self,
label="use as content",
callback=self.content_changed,
tooltip="click to select as content"
)
#----------------------------------------------------------------------
# rename box...
self.renameBox = gui.widgetBox(
widget=self.controlArea,
box='Rename header',
orientation='horizontal',
addSpace=True,
)
gui.separator(widget=self.renameBox, height=3)
self.headerEditLine = gui.lineEdit(
widget=self.renameBox,
master=self,
value='headerEdit',
orientation='horizontal',
label='New header:',
tooltip=(
"Rename the selected header."
),
callback=lambda: self.renameButton.setDisabled(not self.headerEdit),
)
self.renameButton = gui.button(
widget=self.renameBox,
master=self,
label="rename",
callback=self.rename,
tooltip="click to rename header"
)
self.cancelButton = gui.button(
widget=self.renameBox,
master=self,
label="cancel",
callback=self.cancel,
tooltip="click to cancel renaming"
)
#----------------------------------------------------------------------
# interface parameters...
self.update_gui()
self.renameBox.setVisible(False)
gui.rubber(self.controlArea)
# Now Info box and Send button must be drawn...
self.sendButton.draw()
self.infoBox.draw()
self.infoBox.setText("Widget needs input", "warning")
# Send data if autoSend.
self.sendButton.sendIf()
def __init__(self):
super().__init__()
#: Input data table
self.data = None # type: Optional[Orange.data.Table]
#: A dict mapping input ids to PredictorSlot
self.predictors = OrderedDict() # type: Dict[object, PredictorSlot]
#: A class variable (prediction target)
self.class_var = None # type: Optional[Orange.data.Variable]
#: List of (discrete) class variable's values
self.class_values = [] # type: List[str]
box = gui.vBox(self.controlArea, "Info")
self.infolabel = gui.widgetLabel(
box, "No data on input.\nPredictors: 0\nTask: N/A")
self.infolabel.setMinimumWidth(150)
gui.button(box, self, "Restore Original Order",
callback=self._reset_order,
tooltip="Show rows in the original order")
self.classification_options = box = gui.vBox(
self.controlArea, "Options (classification)", spacing=-1,
addSpace=False)
gui.checkBox(box, self, "show_predictions", "Show predicted class",
callback=self._update_prediction_delegate)
b = gui.checkBox(box, self, "show_probabilities",
"Show predicted probabilities",
callback=self._update_prediction_delegate)
ibox = gui.indentedBox(box, sep=gui.checkButtonOffsetHint(b),
addSpace=False)
gui.listBox(ibox, self, "selected_classes", "class_values",
callback=self._update_prediction_delegate,
selectionMode=QListWidget.MultiSelection,
addSpace=False)
gui.checkBox(box, self, "draw_dist", "Draw distribution bars",
callback=self._update_prediction_delegate)
box = gui.vBox(self.controlArea, "Data View")
gui.checkBox(box, self, "show_attrs", "Show full data set",
callback=self._update_column_visibility)
box = gui.vBox(self.controlArea, "Output", spacing=-1)
self.checkbox_class = gui.checkBox(
box, self, "output_attrs", "Original data",
callback=self.commit)
self.checkbox_class = gui.checkBox(
box, self, "output_predictions", "Predictions",
callback=self.commit)
self.checkbox_prob = gui.checkBox(
box, self, "output_probabilities", "Probabilities",
callback=self.commit)
gui.rubber(self.controlArea)
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
handleWidth=2,
)
self.dataview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus
)
self.predictionsview = TableView(
verticalScrollBarPolicy=Qt.ScrollBarAlwaysOff,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOn,
horizontalScrollMode=QTableView.ScrollPerPixel,
selectionMode=QTableView.NoSelection,
focusPolicy=Qt.StrongFocus,
sortingEnabled=True,
)
self.predictionsview.setItemDelegate(PredictionsItemDelegate())
self.dataview.verticalHeader().hide()
dsbar = self.dataview.verticalScrollBar()
psbar = self.predictionsview.verticalScrollBar()
psbar.valueChanged.connect(dsbar.setValue)
dsbar.valueChanged.connect(psbar.setValue)
self.dataview.verticalHeader().setDefaultSectionSize(22)
self.predictionsview.verticalHeader().setDefaultSectionSize(22)
self.dataview.verticalHeader().sectionResized.connect(
lambda index, _, size:
self.predictionsview.verticalHeader()
.resizeSection(index, size)
)
self.splitter.addWidget(self.predictionsview)
self.splitter.addWidget(self.dataview)
self.mainArea.layout().addWidget(self.splitter)
def __init__(self):
super().__init__()
self.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.commit.deferred)
self.info_box = gui.widgetBox(self.controlArea, "Info")
self.info_label = gui.widgetLabel(self.info_box)
gui.auto_apply(self.buttonsArea, self, "auto_commit")
self.plotview = GraphicsView()
self.plot = PlotItem(enableMenu=False)
self.plot.parameter_setter = ParameterSetter(self.plot)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
for axis_name in ("bottom", "left"):
axis = self.plot.getAxis(axis_name)
# Remove the condition (that is, allow setting this for bottom
# axis) when pyqtgraph is fixed
# Issue: https://github.com/pyqtgraph/pyqtgraph/issues/930
# Pull request: https://github.com/pyqtgraph/pyqtgraph/pull/932
if axis_name != "bottom": # remove if when pyqtgraph is fixed
axis.setStyle(stopAxisAtTick=(True, True))
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
self._set_explanation()
VisualSettingsDialog(self, self.plot.parameter_setter.initial_settings)
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.corpus_docs = None # Documents generated from Corpus
self.output_mask = [] # Output corpus indices
self.doc_webview = None # WebView for showing content
self.search_features = [
] # two copies are needed since Display allows drag & drop
self.display_list_indices = [0]
# Info attributes
self.update_info()
info_box = gui.widgetBox(self.controlArea, 'Info')
gui.label(info_box, self, 'Documents: %(n_documents)s')
gui.label(info_box, self, 'Preprocessed: %(is_preprocessed)s')
gui.label(info_box, self, ' ◦ Tokens: %(n_tokens)s')
gui.label(info_box, self, ' ◦ Types: %(n_types)s')
gui.label(info_box, self, 'POS tagged: %(is_pos_tagged)s')
gui.label(info_box, self, 'N-grams range: %(ngram_range)s')
gui.label(info_box, self, 'Matching: %(n_matching)s')
# Search features
self.search_listbox = gui.listBox(
self.controlArea,
self,
'search_indices',
'search_features',
selectionMode=QListView.ExtendedSelection,
box='Search features',
callback=self.search_features_changed)
# Display features
display_box = gui.widgetBox(self.controlArea, 'Display features')
self.display_listbox = gui.listBox(
display_box,
self,
'display_list_indices',
'display_features',
selectionMode=QListView.ExtendedSelection,
callback=self.show_docs,
enableDragDrop=True)
self.show_tokens_checkbox = gui.checkBox(display_box,
self,
'show_tokens',
'Show Tokens && Tags',
callback=self.show_docs)
# Auto-commit box
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data',
'Auto send is on')
# Search
self.filter_input = gui.lineEdit(self.mainArea,
self,
'regexp_filter',
orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(
QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed),
label='RegExp Filter:')
self.filter_input.textChanged.connect(self.refresh_search)
# Main area
self.splitter = QSplitter(
orientation=Qt.Horizontal,
childrenCollapsible=False,
)
# Document list
self.doc_list = QTableView()
self.doc_list.setSelectionBehavior(QTableView.SelectRows)
self.doc_list.setSelectionMode(QTableView.ExtendedSelection)
self.doc_list.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.doc_list.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.doc_list.horizontalHeader().setVisible(False)
self.splitter.addWidget(self.doc_list)
self.doc_list_model = QStandardItemModel(self)
self.doc_list.setModel(self.doc_list_model)
self.doc_list.selectionModel().selectionChanged.connect(self.show_docs)
# Document contents
self.doc_webview = gui.WebviewWidget(self.splitter, debug=False)
self.doc_webview.loadFinished.connect(self.highlight_docs)
self.mainArea.layout().addWidget(self.splitter)
def __init__(self, parent=None):
super().__init__(parent)
self.results = None
self.classifier_names = []
self.perf_line = None
self.threshold_opints = []
box = gui.widgetBox(self.controlArea, "Plot")
tbox = gui.widgetBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed)
cbox = gui.widgetBox(box, "Classifiers")
cbox.setFlat(True)
gui.listBox(cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QtGui.QListView.MultiSelection,
callback=self._on_classifiers_changed)
abox = gui.widgetBox(box, "Average ROC Curves")
abox.setFlat(True)
gui.comboBox(abox, self, "roc_averaging",
items=["Merge (expected ROC perf.)", "Vertical",
"Threshold", "None"],
callback=self._replot)
hbox = gui.widgetBox(box, "ROC Convex Hull")
hbox.setFlat(True)
# gui.checkBox(hbox, self, "display_convex_hull",
# "Show ROC convex hull", callback=self._replot)
gui.checkBox(hbox, self, "display_convex_curve",
"Show convex ROC curves", callback=self._replot)
box = gui.widgetBox(self.controlArea, "Analysis")
# gui.checkBox(box, self, "display_perf_line", "Show performance line",
# callback=self._on_display_perf_line_changed)
gui.checkBox(box, self, "display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QtGui.QFrame.StyledPanel)
self.plot = pg.PlotItem()
pen = QtGui.QPen(self.palette().color(QtGui.QPalette.Text))
tickfont = QtGui.QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0))
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
"""Widget creator."""
super().__init__()
# Other attributes...
self.inputTable = None
self.listEntries = 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.send_data,
infoBoxAttribute="infoBox",
sendIfPreCallback=self.updateGUI,
)
# User interface...
# Filter box (advanced settings only)
optionsBox = gui.widgetBox(
widget=self.controlArea,
box="Options",
orientation="vertical",
)
method_combo = gui.comboBox(
widget=optionsBox,
master=self,
value="method",
items=[
"Latent Dirichlet allocation",
"Latent semantic indexing",
"Correspondence analysis",
],
sendSelectedValue=True,
orientation="horizontal",
label="Method:",
labelWidth=120,
callback=self.sendButton.settingsChanged,
tooltip=("Please select the desired topic modelling method.\n"),
)
method_combo.setMinimumWidth(120)
gui.separator(widget=optionsBox, height=3)
self.numTopicsSpin = gui.spin(
widget=optionsBox,
master=self,
value='numTopics',
minv=1,
maxv=999,
orientation='horizontal',
label=u'Number of topics:',
labelWidth=120,
callback=self.sendButton.settingsChanged,
keyboardTracking=False,
tooltip=(
u"Please select the desired number of topics in output tables."
),
)
gui.separator(widget=optionsBox, height=3)
gui.listBox(
widget=optionsBox,
master=self,
labels='listEntries',
tooltip=(u"TODO"),
)
gui.separator(widget=self.controlArea, height=3)
gui.rubber(self.controlArea)
# Now Info box and Send button must be drawn...
self.sendButton.draw()
self.infoBox.draw()
self.infoBox.setText("Widget needs input", "warning")
# Send data if autoSend.
self.sendButton.sendIf()
self.setMinimumWidth(350)
self.adjustSizeWithTimer()
def __init__(self):
super().__init__()
self.grouping = []
self.attributes = []
self.stats = []
self.dataset = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = 0
self.label_width = 0
self.attr_list_box = gui.listBox(
self.controlArea, self, "attributes_select", "attributes",
box="Variable", callback=self.attr_changed,
sizeHint=QtCore.QSize(200, 150))
self.attr_list_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
box = gui.widgetBox(self.controlArea, "Grouping")
self.group_list_box = gui.listBox(
box, self, 'grouping_select', "grouping",
callback=self.attr_changed,
sizeHint=QtCore.QSize(200, 100))
self.group_list_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
# TODO: move Compare median/mean to grouping box
self.display_box = gui.widgetBox(self.controlArea, "Display")
gui.checkBox(self.display_box, self, "show_annotations", "Annotate",
callback=self.display_changed)
self.compare_rb = gui.radioButtonsInBox(
self.display_box, self, 'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.display_changed)
self.stretching_box = gui.checkBox(
self.controlArea, self, 'stretched', "Stretch bars", box='Display',
callback=self.display_changed).box
gui.widgetBox(self.mainArea, addSpace=True)
self.box_scene = QtGui.QGraphicsScene()
self.box_view = QtGui.QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QtGui.QPainter.Antialiasing |
QtGui.QPainter.TextAntialiasing |
QtGui.QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
e = gui.widgetBox(self.mainArea, addSpace=False, orientation=0)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.warning = gui.widgetBox(self.controlArea, "Warning:")
self.warning_info = gui.widgetLabel(self.warning, "")
self.warning.hide()
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.disc_palette = colorpalette.ColorPaletteGenerator()
self.update_display_box()
self.graphButton.clicked.connect(self.save_graph)
def __init__(self):
"""Init of the module: UI and variables definition"""
super().__init__()
# queryBox indexes
self.indicesPanier = list()
#----------------------------------------------------------------------
# User interface...
self.infoBox = InfoBox(widget=self.controlArea, )
#-------------------------#
# Main widget boxes #
#-------------------------#
sourceBox = gui.widgetBox(
widget=self.controlArea,
box=u'Source',
orientation='vertical',
addSpace=False,
)
self.filterBox = gui.widgetBox(
widget=self.controlArea,
box=u'Filters',
orientation='vertical',
addSpace=False,
)
self.includeOuterBox = gui.widgetBox(
widget=self.controlArea,
box=u'Include',
orientation='vertical',
addSpace=False,
)
self.requestsBox = gui.widgetBox(
widget=self.controlArea,
orientation='horizontal',
addSpace=False,
)
panierBox = gui.widgetBox(
widget=self.controlArea,
orientation='vertical',
box=u'Selection',
addSpace=False,
)
#-------------------#
# Send button #
#-------------------#
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.send_data,
infoBoxAttribute='infoBox',
)
#------------------------#
# Query box elements #
#------------------------#
self.choiceBox = gui.comboBox(
widget=sourceBox,
master=self,
value='mode',
label="Mode:",
callback=self.mode_changed,
tooltip="Choose mode",
orientation='horizontal',
sendSelectedValue=True,
items=["Subreddit", "URL", "Full text"],
labelWidth=135,
)
self.modeBox = gui.widgetBox(
widget=sourceBox,
orientation='horizontal',
addSpace=False,
)
self.urlBox = gui.widgetBox(
widget=sourceBox,
orientation='horizontal',
addSpace=False,
)
gui.lineEdit(
widget=self.urlBox,
master=self,
value='URL',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
label=u'Search with URL:',
labelWidth=135,
)
self.subredditBox = gui.widgetBox(
widget=sourceBox,
orientation='horizontal',
addSpace=False,
)
gui.lineEdit(
widget=self.subredditBox,
master=self,
value='subreddit',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
label=u'reddit.com/r/...:',
labelWidth=135,
)
self.fullTextBox = gui.widgetBox(
widget=sourceBox,
orientation='horizontal',
addSpace=False,
)
gui.lineEdit(
widget=self.fullTextBox,
master=self,
value='fullText',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
label=u'Search on reddit:',
labelWidth=135,
)
#----------------------------#
# Filters box elements #
#----------------------------#
self.subredditFilter = gui.widgetBox(
widget=self.filterBox,
orientation='horizontal',
addSpace=False,
)
gui.comboBox(
widget=self.subredditFilter,
master=self,
value='sortBy',
label=u'Sort by:',
tooltip="Choose mode to sort your posts",
orientation='horizontal',
sendSelectedValue=True,
callback=self.checkSubredditSortMode,
items=["Hot", "New", "Controversial", "Top", "Rising"],
labelWidth=135,
)
self.fullTextFilter = gui.widgetBox(
widget=self.filterBox,
orientation='horizontal',
addSpace=False,
)
gui.comboBox(
widget=self.fullTextFilter,
master=self,
value='sortByFT',
label="Sort by:",
tooltip="Choose mode",
orientation='horizontal',
sendSelectedValue=True,
callback=self.checkSearchSortMode,
items=["Relevance", "Top", "New", "Comments"],
labelWidth=135,
)
self.timeBox = gui.widgetBox(
widget=self.filterBox,
orientation='horizontal',
addSpace=False,
)
gui.comboBox(
widget=self.timeBox,
master=self,
value='postedAt',
label=u'Time:',
tooltip="Choose mode to sort your posts",
orientation='horizontal',
callback=self.sendButton.settingsChanged,
sendSelectedValue=True,
items=["All", "Past day", "Past hour", "Past month", "Past year"],
labelWidth=135,
)
gui.spin(
widget=self.filterBox,
master=self,
value="amount",
minv=1,
maxv=10000,
label="Max amount of posts:",
labelWidth=135,
orientation="horizontal",
callback=self.sendButton.settingsChanged,
tooltip="Select the amount of posts that you want",
)
#--------------------------#
# Include box elements #
#--------------------------#
self.includeBox = gui.widgetBox(
widget=self.includeOuterBox,
orientation='horizontal',
addSpace=False,
)
gui.checkBox(
widget=self.includeBox,
master=self,
value='includeImage',
label=u'Include images',
callback=self.mode_changed,
)
gui.checkBox(
widget=self.includeBox,
master=self,
value='includeComments',
label=u'Include comments',
callback=self.mode_changed,
)
#--------------------------#
# Request box elements #
#--------------------------#
self.refreshButton = gui.button(
widget=self.requestsBox,
master=self,
label=u'Refresh the Data',
callback=self.refresh_content,
)
if len(self.labelsPanier) == 0:
self.refreshButton.setDisabled(True)
self.fetchButton = gui.button(
widget=self.requestsBox,
master=self,
label=u'Add Request',
callback=self.confirm_settings,
)
#--------------------------#
# Results box elements #
#--------------------------#
panier = gui.listBox(
widget=panierBox,
master=self,
value="indicesPanier",
labels="labelsPanier",
callback=lambda: self.removeButton.setDisabled(self.indicesPanier
== list()),
tooltip="List of imported corpora.",
)
panier.setMinimumHeight(120)
panier.setSelectionMode(3)
self.update_list(self.labelsPanier)
removalBox = gui.widgetBox(
widget=panierBox,
orientation='horizontal',
addSpace=False,
)
self.removeButton = gui.button(
widget=removalBox,
master=self,
label="Remove from selection",
callback=self.removePressed,
tooltip="Remove the selected corpus.",
)
self.removeButton.setDisabled(True)
self.clearButton = gui.button(
widget=removalBox,
master=self,
label="Clear selection",
callback=self.clearPressed,
tooltip="Remove all corpora from selection.",
)
if len(self.labelsPanier) == 0:
self.clearButton.setDisabled(True)
#------------------------#
# End of definitions #
#------------------------#
gui.separator(widget=self.controlArea, height=3) # Spacer
gui.rubber(self.controlArea)
# Info box...
self.sendButton.draw()
self.infoBox.draw()
self.mode_changed()
self.sendButton.settingsChanged()
# Send data if autoSend...
self.sendButton.sendIf()
def __init__(self):
"""Widget creator."""
super().__init__()
# ATTRIBUTS
# searchFunction
self.searchResults = None
self.inputSeg = None
# newQuery = attribut box lineEdit (search something)
self.titleQuery = ''
self.authorQuery = ''
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 (songs) in a list
self.createdInputs = 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 books",
orientation="vertical",
)
self.cacheGenerationButton = gui.button(
widget=queryBox,
master=self,
label="Generate cache",
callback=self.generate_cache,
tooltip="Generate the gutenberg cache, this might take a while...",
)
# Allows to enter specific text to the research
# Uses "newQuery" attribut
gui.lineEdit(
widget=queryBox,
master=self,
value='titleQuery',
orientation='horizontal',
label=u"Title: ",
labelWidth=120,
tooltip=("Enter a string"),
)
# gui.lineEdit(
# widget=queryBox,
# master=self,
# value='authorQuery',
# orientation='horizontal',
# label=u"Author: ",
# labelWidth=120,
# 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=[
"10", "20", "30", "40", "50", "60", "70", "80", "90", "100",
"200", "300", "400", "500", "1000"
],
sendSelectedValue=True,
orientation="horizontal",
label="Number of results: ",
labelWidth=120,
tooltip=("Please select the desired search.\n"),
)
# Reasearch button
# Uses "searchFunction" attribut
self.searchButton = gui.button(
widget=queryBox,
master=self,
label="Search",
callback=self.search,
tooltip="Connect Genius and make a research",
)
self.titleListbox = gui.listBox(
widget=queryBox,
master=self,
value="selectedTitles", # setting (list)
labels="titleLabels", # setting (list)
callback=lambda: self.addButton.setDisabled(self.selectedTitles ==
list()),
tooltip="The list of titles whose content will be imported",
)
self.titleListbox.setMinimumHeight(150)
self.titleListbox.setSelectionMode(3)
boxbutton = gui.widgetBox(
widget=queryBox,
box=False,
orientation='horizontal',
)
# Add songs button
self.addButton = gui.button(
widget=boxbutton,
master=self,
label=u'Add to corpus',
callback=self.add,
tooltip=(u"Move the selected book downward in your corpus."),
)
self.addButton.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)
# area where confirmed songs are moved and stocked
mytitleBox = gui.widgetBox(
widget=self.controlArea,
box="Corpus",
orientation="vertical",
)
self.mytitleListbox = gui.listBox(
widget=mytitleBox,
master=self,
value="myTitles",
labels="mytitleLabels",
callback=lambda: self.removeButton.setDisabled(self.myTitles ==
list()),
tooltip="The list of books which will be imported",
)
self.mytitleListbox.setMinimumHeight(150)
self.mytitleListbox.setSelectionMode(3)
boxbutton2 = gui.widgetBox(
widget=mytitleBox,
box=False,
orientation='horizontal',
)
# Remove songs button
self.removeButton = gui.button(
widget=boxbutton2,
master=self,
label=u'Remove from corpus',
callback=self.remove,
tooltip=(u"Remove the selected book from your corpus."),
)
self.removeButton.setDisabled(True)
# Delete all confirmed texts button
self.clearmyBasketButton = gui.button(
widget=boxbutton2,
master=self,
label=u'Clear corpus',
callback=self.clearmyBasket,
tooltip=(u"Remove all books from your corpus."),
)
self.clearmyBasketButton.setDisabled(True)
gui.separator(widget=mytitleBox, height=3)
gui.rubber(self.controlArea)
#----------------------------------------------------------------------
# Draw Info box and Send button
self.sendButton.draw()
self.searchButton.setDefault(True)
self.infoBox.draw()
# Update the selections list
self.updateMytitleLabels()
# Send data if autoSend.
self.sendButton.sendIf()
def __init__(self, parent=None):
super().__init__(self, parent)
self.dataset = None
self.z_values = []
self._root = None
self._displayed_root = None
self._item = None
self._cache = {}
self.colors = colorpalette.ColorPaletteGenerator(10)
self.sampling_box = box = gui.widgetBox(self.controlArea, "Sampling")
sampling_options = self.sample_times_captions + self.sample_percentages_captions
gui.comboBox(box, self, "sample_level", items=sampling_options, callback=self.update_sample)
gui.button(box, self, "Sharpen", self.sharpen)
box = gui.widgetBox(self.controlArea, "Input")
self.labelDataInput = gui.widgetLabel(box, "No data on input")
self.labelDataInput.setTextFormat(Qt.PlainText)
self.labelOutput = gui.widgetLabel(box, "")
self.x_var_model = itemmodels.VariableListModel()
self.comboBoxAttributesX = gui.comboBox(
self.controlArea, self, value="x_var_index", box="X Attribute", callback=self.replot
)
self.comboBoxAttributesX.setModel(self.x_var_model)
self.y_var_model = itemmodels.VariableListModel()
self.comboBoxAttributesY = gui.comboBox(
self.controlArea, self, value="y_var_index", box="Y Attribute", callback=self.replot
)
self.comboBoxAttributesY.setModel(self.y_var_model)
box = gui.widgetBox(self.controlArea, "Color by")
self.z_var_model = itemmodels.VariableListModel()
self.comboBoxClassvars = gui.comboBox(box, self, value="z_var_index", callback=self._on_z_var_changed)
self.comboBoxClassvars.setModel(self.z_var_model)
box1 = gui.widgetBox(box, "Colors displayed", margin=0)
box1.setFlat(True)
self.z_values_view = gui.listBox(
box1,
self,
"selected_z_values",
"z_values",
callback=self._on_z_values_selection_changed,
selectionMode=QtGui.QListView.MultiSelection,
addSpace=False,
)
box1 = gui.widgetBox(box, "Color Scale", margin=0)
box1.setFlat(True)
gui.comboBox(
box1,
self,
"color_scale",
items=["Linear", "Square root", "Logarithmic"],
callback=self._on_color_scale_changed,
)
self.mouseBehaviourBox = gui.radioButtons(
self.controlArea,
self,
value="mouse_mode",
btnLabels=("Drag", "Select"),
box="Mouse left button behavior",
callback=self._update_mouse_mode,
)
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, parent=None):
super().__init__(self, parent)
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)
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)
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)
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)
self.graphButton.clicked.connect(self.save_graph)
def __init__(self):
super().__init__()
self.grouping = []
self.attributes = []
self.stats = []
self.dataset = None
self.posthoc_lines = []
self.label_txts = self.mean_labels = self.boxes = self.labels = \
self.label_txts_all = self.attr_labels = self.order = []
self.p = -1.0
self.scale_x = self.scene_min_x = self.scene_width = 0
self.label_width = 0
self.attr_list_box = gui.listBox(self.controlArea,
self,
"attributes_select",
"attributes",
box="Variable",
callback=self.attr_changed,
sizeHint=QtCore.QSize(200, 150))
self.attr_list_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
box = gui.vBox(self.controlArea, "Grouping")
self.group_list_box = gui.listBox(box,
self,
'grouping_select',
"grouping",
callback=self.attr_changed,
sizeHint=QtCore.QSize(200, 100))
self.group_list_box.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.MinimumExpanding)
# TODO: move Compare median/mean to grouping box
self.display_box = gui.vBox(self.controlArea, "Display")
gui.checkBox(self.display_box,
self,
"show_annotations",
"Annotate",
callback=self.display_changed)
self.compare_rb = gui.radioButtonsInBox(
self.display_box,
self,
'compare',
btnLabels=["No comparison", "Compare medians", "Compare means"],
callback=self.display_changed)
self.stretching_box = gui.checkBox(self.controlArea,
self,
'stretched',
"Stretch bars",
box='Display',
callback=self.display_changed).box
gui.vBox(self.mainArea, addSpace=True)
self.box_scene = QtGui.QGraphicsScene()
self.box_view = QtGui.QGraphicsView(self.box_scene)
self.box_view.setRenderHints(QtGui.QPainter.Antialiasing
| QtGui.QPainter.TextAntialiasing
| QtGui.QPainter.SmoothPixmapTransform)
self.box_view.viewport().installEventFilter(self)
self.mainArea.layout().addWidget(self.box_view)
e = gui.hBox(self.mainArea, addSpace=False)
self.infot1 = gui.widgetLabel(e, "<center>No test results.</center>")
self.mainArea.setMinimumWidth(650)
self.stats = self.dist = self.conts = []
self.is_continuous = False
self.update_display_box()
def __init__(self):
"""Widget creator."""
super().__init__()
# Other attributes...
self.inputSeg = None
self.morphology = dict()
self.selectedMainWord = None
self.mainWords = list()
self.selectedParse = None
self.parses = list()
self.selectedStemForParse = None
self.stemsForParse = list()
self.selectedSuffixForParse = None
self.suffixesForParse = list()
self.selectedMainSignature = None
self.mainSignatures = list()
self.wordsForSig = list()
self.stemsForSig = list()
self.suffixesForSig = 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",
sendIfPreCallback=None,
)
# User interface...
# A) Control area...
# Options box...
optionsBox = gui.widgetBox(
widget=self.controlArea,
box="Options",
orientation="vertical",
)
gui.spin(
widget=optionsBox,
master=self,
value='minStemLen',
label='Minimum length of stems: ',
callback=self.sendButton.sendIf,
labelWidth=180,
tooltip=(
'Select the minimum number of required characters in stems'),
minv=LOWER_MIN_STEM_LEN,
maxv=MAX_MORPH_LEN,
step=1,
)
gui.separator(widget=optionsBox, height=2)
gui.rubber(self.controlArea)
# B) Main area...
font = QFont()
font.setFamily('Courier')
font.setStyleHint(QFont.Courier)
font.setPixelSize(12)
# Tabs...
self.tabs = QTabWidget()
self.wordTab = QWidget()
self.signatureTab = QWidget()
self.tabs.addTab(self.wordTab, "Words")
self.tabs.addTab(self.signatureTab, "Signatures")
# Words tab...
wordTabBox = QHBoxLayout()
wordBox = gui.widgetBox(
widget=self.wordTab,
orientation="horizontal",
margin=5,
)
wordBoxRight = gui.widgetBox(widget=wordBox)
self.mainWordListbox = gui.listBox(
widget=wordBoxRight,
master=self,
value="selectedMainWord",
labels="mainWords",
callback=self.mainWordSelected,
tooltip="Select a word to display its possible parses.",
)
self.mainWordListbox.setFont(font)
gui.separator(widget=wordBox, width=3)
wordBoxLeft = gui.widgetBox(widget=wordBox)
gui.label(
widget=wordBoxLeft,
master=self,
label="Parse(s):",
)
self.parsesListbox = gui.listBox(
widget=wordBoxLeft,
master=self,
value="selectedParse",
labels="parses",
callback=self.parseSelected,
tooltip="Select a parse to display the corresponding signature.",
)
self.parsesListbox.setFont(font)
self.sigForParseBox = gui.widgetBox(
widget=wordBoxLeft,
box="Signature",
)
gui.label(
widget=self.sigForParseBox,
master=self,
label="Stem(s):",
)
self.stemsForParseListbox = gui.listBox(
widget=self.sigForParseBox,
master=self,
labels="stemsForParse",
tooltip="Stems associated with the parse selected above.",
)
gui.separator(widget=self.sigForParseBox, height=2)
gui.label(
widget=self.sigForParseBox,
master=self,
label="Suffixes(s):",
)
self.suffixesForParseListbox = gui.listBox(
widget=self.sigForParseBox,
master=self,
labels="suffixesForParse",
tooltip="Suffixes associated with the parse selected above.",
)
wordTabBox.addWidget(wordBox)
self.wordTab.setLayout(wordTabBox)
# Signature tab...
signatureTabBox = QHBoxLayout()
signatureBox = gui.widgetBox(
widget=self.signatureTab,
orientation="horizontal",
margin=5,
)
signatureBoxRight = gui.widgetBox(widget=signatureBox)
self.mainSignatureListbox = gui.listBox(
widget=signatureBoxRight,
master=self,
value="selectedMainSignature",
labels="mainSignatures",
callback=self.mainSignatureSelected,
tooltip="Select a signature to display its contents.",
)
self.mainSignatureListbox.setFont(font)
gui.separator(widget=signatureBox, width=3)
signatureBoxLeft = gui.widgetBox(widget=signatureBox)
gui.label(
widget=signatureBoxLeft,
master=self,
label="Words:",
)
self.wordsForSigListbox = gui.listBox(
widget=signatureBoxLeft,
master=self,
labels="wordsForSig",
tooltip="Words associated with the selected signature.",
)
self.wordsForSigListbox.setFont(font)
gui.label(
widget=signatureBoxLeft,
master=self,
label="Stem(s):",
)
self.stemsForSigListbox = gui.listBox(
widget=signatureBoxLeft,
master=self,
labels="stemsForSig",
tooltip="Stems associated with the selected signature.",
)
self.stemsForSigListbox.setFont(font)
gui.label(
widget=signatureBoxLeft,
master=self,
label="Suffixes(s):",
)
self.suffixesForSigListbox = gui.listBox(
widget=signatureBoxLeft,
master=self,
labels="suffixesForSig",
tooltip="Suffixes associated with the selected signature.",
)
self.suffixesForSigListbox.setFont(font)
signatureTabBox.addWidget(signatureBox)
self.signatureTab.setLayout(signatureTabBox)
self.mainArea.layout().addWidget(self.tabs)
# Now Info box and Send button must be drawn...
self.sendButton.draw()
self.infoBox.draw()
self.infoBox.setText("Widget needs input", "warning")
self.setMinimumWidth(602)
self.setMinimumHeight(317)
self.adjustSizeWithTimer()
# Send data if autoSend.
self.sendButton.sendIf()
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
self._tooltip_cache = None
box = gui.vBox(self.controlArea, "Plot")
self.target_cb = gui.comboBox(box,
self,
"target_index",
label="Target",
orientation=Qt.Horizontal,
callback=self._on_target_changed,
contentsLength=8,
searchable=True)
gui.widgetLabel(box, "Classifiers")
line_height = 4 * QFontMetrics(self.font()).lineSpacing()
self.classifiers_list_box = gui.listBox(
box,
self,
"selected_classifiers",
"classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed,
sizeHint=QSize(0, line_height))
abox = gui.vBox(self.controlArea, "Curves")
gui.comboBox(abox,
self,
"roc_averaging",
items=[
"Merge Predictions from Folds", "Mean TP Rate",
"Mean TP and FP at Threshold",
"Show Individual Curves"
],
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_curve",
"Show convex ROC curves",
callback=self._replot)
gui.checkBox(abox,
self,
"display_convex_hull",
"Show ROC convex hull",
callback=self._replot)
box = gui.vBox(self.controlArea, "Analysis")
gui.checkBox(box,
self,
"display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box,
self,
"display_perf_line",
"Show performance line",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
gui.indentedBox(box, orientation=grid)
sp = gui.spin(box,
self,
"fp_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FP Cost:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box,
self,
"fn_cost",
1,
1000,
10,
alignment=Qt.AlignRight,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FN Cost:"))
grid.addWidget(sp, 1, 1)
self.target_prior_sp = gui.spin(box,
self,
"target_prior",
1,
99,
alignment=Qt.AlignRight,
callback=self._on_target_prior_changed)
self.target_prior_sp.setSuffix(" %")
self.target_prior_sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior probability:"))
grid.addWidget(self.target_prior_sp, 2, 1)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plotview.scene().sigMouseMoved.connect(self._on_mouse_moved)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
self.results = None
self.classifier_names = []
self.perf_line = None
self.colors = []
self._curve_data = {}
self._plot_curves = {}
self._rocch = None
self._perf_line = None
box = gui.vBox(self.controlArea, "Plot")
tbox = gui.vBox(box, "Target Class")
tbox.setFlat(True)
self.target_cb = gui.comboBox(
tbox, self, "target_index", callback=self._on_target_changed,
contentsLength=8)
cbox = gui.vBox(box, "Classifiers")
cbox.setFlat(True)
self.classifiers_list_box = gui.listBox(
cbox, self, "selected_classifiers", "classifier_names",
selectionMode=QListView.MultiSelection,
callback=self._on_classifiers_changed)
abox = gui.vBox(box, "Combine ROC Curves From Folds")
abox.setFlat(True)
gui.comboBox(abox, self, "roc_averaging",
items=["Merge Predictions from Folds", "Mean TP Rate",
"Mean TP and FP at Threshold", "Show Individual Curves"],
callback=self._replot)
hbox = gui.vBox(box, "ROC Convex Hull")
hbox.setFlat(True)
gui.checkBox(hbox, self, "display_convex_curve",
"Show convex ROC curves", callback=self._replot)
gui.checkBox(hbox, self, "display_convex_hull",
"Show ROC convex hull", callback=self._replot)
box = gui.vBox(self.controlArea, "Analysis")
gui.checkBox(box, self, "display_def_threshold",
"Default threshold (0.5) point",
callback=self._on_display_def_threshold_changed)
gui.checkBox(box, self, "display_perf_line", "Show performance line",
callback=self._on_display_perf_line_changed)
grid = QGridLayout()
ibox = gui.indentedBox(box, orientation=grid)
sp = gui.spin(box, self, "fp_cost", 1, 1000, 10,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FP Cost:"), 0, 0)
grid.addWidget(sp, 0, 1)
sp = gui.spin(box, self, "fn_cost", 1, 1000, 10,
callback=self._on_display_perf_line_changed)
grid.addWidget(QLabel("FN Cost:"))
grid.addWidget(sp, 1, 1)
sp = gui.spin(box, self, "target_prior", 1, 99,
callback=self._on_display_perf_line_changed)
sp.setSuffix("%")
sp.addAction(QAction("Auto", sp))
grid.addWidget(QLabel("Prior target class probability:"))
grid.addWidget(sp, 2, 1)
self.plotview = pg.GraphicsView(background="w")
self.plotview.setFrameStyle(QFrame.StyledPanel)
self.plot = pg.PlotItem(enableMenu=False)
self.plot.setMouseEnabled(False, False)
self.plot.hideButtons()
pen = QPen(self.palette().color(QPalette.Text))
tickfont = QFont(self.font())
tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11))
axis = self.plot.getAxis("bottom")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("FP Rate (1-Specificity)")
axis = self.plot.getAxis("left")
axis.setTickFont(tickfont)
axis.setPen(pen)
axis.setLabel("TP Rate (Sensitivity)")
self.plot.showGrid(True, True, alpha=0.1)
self.plot.setRange(xRange=(0.0, 1.0), yRange=(0.0, 1.0), padding=0.05)
self.plotview.setCentralItem(self.plot)
self.mainArea.layout().addWidget(self.plotview)
def __init__(self):
super().__init__()
# Search filters attributs
self.newQuery = ''
self.type_results = 'Title'
#self.genre_searched = 'Comedy'
self.filter_results = 'Popularity'
self.nbr_results = '10'
# Results box attributs
self.titleLabels = list()
self.selectedTitles = list()
# selections box attributs
self.myTitles = list()
self.mytitleLabels = list()
# stocks the imdbpy instance
self.ia = imdb.IMDb()
# stock all the inputs (movie names) in a list
self.createdInputs = list()
# Mandatory declaration of the info box and the send button
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
sendIfPreCallback=None,
)
#----------------------------------------------------------------------
# User interface...
# Creation of the different working areas
self.queryBox = gui.widgetBox(
widget=self.controlArea,
box="Query",
orientation="horizontal",
)
self.genreBox = gui.widgetBox(
widget=self.controlArea,
box="Query",
orientation="horizontal",
)
self.filterBox = gui.widgetBox(
widget=self.controlArea,
box="Query options",
orientation="horizontal",
)
searchButtonBox = gui.widgetBox(
widget=self.controlArea,
orientation="vertical",
)
resultBox = gui.widgetBox(
widget=self.controlArea,
box="Search results",
orientation="vertical",
)
# List Box where all the searched movies are stocked
self.titleListbox = gui.listBox(
widget=resultBox,
master=self,
value="selectedTitles",
labels="titleLabels",
callback=lambda: self.addButton.setDisabled(self.selectedTitles ==
list()),
tooltip="The list of titles whose content will be imported",
)
self.titleListbox.doubleClicked.connect(self.addToCorpus)
self.titleListbox.setMinimumHeight(150)
self.titleListbox.setSelectionMode(3)
resultButtonBox = gui.widgetBox(
widget=resultBox,
box=False,
orientation='horizontal',
)
corpusBox = gui.widgetBox(
widget=self.controlArea,
box="Corpus",
orientation="vertical",
)
# Corpus where confirmed movies are moved and stocked
self.mytitleListbox = gui.listBox(
widget=corpusBox,
master=self,
value="myTitles",
labels="mytitleLabels",
callback=lambda: self.removeButton.setDisabled(self.myTitles ==
list()),
tooltip="The list of titles whose content will be imported",
)
self.mytitleListbox.doubleClicked.connect(self.remove)
self.mytitleListbox.setMinimumHeight(150)
self.mytitleListbox.setSelectionMode(3)
corpusButtonBox = gui.widgetBox(
widget=corpusBox,
box=False,
orientation='horizontal',
)
# Allows to enter specific text to the research
gui.lineEdit(
widget=self.queryBox,
master=self,
value='newQuery',
orientation='horizontal',
label=u"Search: ",
labelWidth=120,
tooltip=("Enter a string"),
)
# Allows to choose a type of search
searchType = gui.comboBox(
widget=self.queryBox,
master=self,
value="type_results",
items=[
"Title",
"Actor",
#"Genre",
],
sendSelectedValue=True,
callback=self.mode_changed,
orientation="horizontal",
label="Search by: ",
labelWidth=120,
tooltip=("Please select the desired search.\n"),
)
"""genreTypes = gui.comboBox(
widget=self.genreBox,
master=self,
value="genre_searched",
items=[
"Comedy",
"Action",
"Drama",
"Horror",
],
sendSelectedValue=True,
orientation="horizontal",
label="Search Type: ",
labelWidth=120,
tooltip=(
"Please select the desired search.\n"
),
)
"""
searchTypeGenre = gui.comboBox(
widget=self.genreBox,
master=self,
value="type_results",
items=[
"Title",
"Actor",
"Genre",
],
sendSelectedValue=True,
callback=self.mode_changed,
orientation="horizontal",
label="Search Type: ",
labelWidth=120,
tooltip=("Please select the desired search.\n"),
)
# Allows to chose a filter for the search
self.searchFilter = gui.comboBox(
widget=self.filterBox,
master=self,
value="filter_results",
items=[
"Year",
"Alphabetical",
"Random",
],
sendSelectedValue=True,
orientation="horizontal",
label="Sort by: ",
labelWidth=120,
tooltip=("Please select the desired search.\n"),
)
# Allows to choose the wanted results numberp (10 by 10)
self.searchNbr = gui.comboBox(
widget=self.filterBox,
master=self,
value="nbr_results",
items=[
"10",
"20",
"30",
"40",
"50",
],
sendSelectedValue=True,
orientation="horizontal",
label="Results' number: ",
labelWidth=120,
tooltip=("Please select the desired search.\n"),
)
# Reasearch button
# Uses "searchMovies" attribute
self.searchButton = gui.button(
widget=searchButtonBox,
master=self,
label="Search",
callback=self.searchMovies,
tooltip="Connect to imdbpy and make a research",
)
# Add movies button
self.addButton = gui.button(
widget=resultButtonBox,
master=self,
label=u'Add to corpus',
callback=self.addToCorpus,
tooltip=(u"Move the selected movie downward in your corpus."),
)
self.addButton.setDisabled(True)
# Clear button
# Uses "clearResults" function
self.clearButton = gui.button(
widget=resultButtonBox,
master=self,
label="Clear results",
callback=self.clearResults,
tooltip="Clear results",
)
self.clearButton.setDisabled(True)
#gui.separator(widget=queryBox, height=3)
# Remove movie button
self.removeButton = gui.button(
widget=corpusButtonBox,
master=self,
label=u'Remove from corpus',
callback=self.remove,
tooltip=(u"Remove the selected movie from your corpus."),
)
self.removeButton.setDisabled(True)
# Delete all confirmed movies button
self.clearmyBasket = gui.button(
widget=corpusButtonBox,
master=self,
label=u'Clear corpus',
callback=self.clearCorpus,
tooltip=(u"Remove all movies from your corpus."),
)
self.clearmyBasket.setDisabled(True)
gui.separator(widget=corpusBox, height=3)
gui.rubber(self.controlArea)
#----------------------------------------------------------------------
# Draw Info box and Send button
self.sendButton.draw()
self.searchButton.setDefault(True)
self.infoBox.draw()
#self.mode_changed()
self.updateCorpus()
self.mode_changed()
# Send data if autoSend.
self.sendButton.sendIf()
def __init__(self):
super().__init__()
#self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="node_label_attrs"), ContextField("attributes", selected="tooltipAttributes"), "color"])}
self.view = GraphView(self)
self.mainArea.layout().addWidget(self.view)
self.graph_attrs = []
self.acceptingEnterKeypress = False
self.node_label_attrs = []
self.tooltipAttributes = []
self.searchStringTimer = QTimer(self)
self.markInputItems = None
self.node_color_attr = 0
self.node_size_attr = 0
self.nHighlighted = 0
self.nSelected = 0
self.verticesPerEdge = 0
self.edgesPerVertex = 0
self.lastVertexSizeColumn = ''
self.lastColorColumn = ''
self.lastLabelColumns = set()
self.lastTooltipColumns = set()
self.items_matrix = None
self.number_of_nodes_label = 0
self.number_of_edges_label = 0
self.graph = None
self.setMinimumWidth(600)
self.tabs = gui.tabWidget(self.controlArea)
self.displayTab = gui.createTabPage(self.tabs, "Display")
self.markTab = gui.createTabPage(self.tabs, "Marking")
def on_tab_changed(index):
self.tabIndex = index
self.set_selection_mode()
self.tabs.currentChanged.connect(on_tab_changed)
self.tabs.setCurrentIndex(self.tabIndex)
ib = gui.widgetBox(self.displayTab, "Info")
gui.label(ib, self, "Nodes: %(number_of_nodes_label)i (%(verticesPerEdge).2f per edge)")
gui.label(ib, self, "Edges: %(number_of_edges_label)i (%(edgesPerVertex).2f per node)")
box = gui.widgetBox(self.displayTab, "Nodes")
self.relayout_button = gui.button(box, self, 'Re-layout',
callback=self.relayout, autoDefault=False)
self.view.positionsChanged.connect(lambda _: self.progressbar.advance())
def animationFinished():
self.relayout_button.setEnabled(True)
self.progressbar.finish()
self.view.animationFinished.connect(animationFinished)
self.colorCombo = gui.comboBox(
box, self, "node_color_attr", label='Color:',
orientation='horizontal', callback=self.set_node_colors)
self.invertNodeSizeCheck = self.maxNodeSizeSpin = QWidget() # Forward declaration
self.nodeSizeCombo = gui.comboBox(
box, self, "node_size_attr",
label='Size:',
orientation='horizontal',
callback=self.set_node_sizes)
hb = gui.widgetBox(box, orientation="horizontal")
hb.layout().addStretch(1)
self.minNodeSizeSpin = gui.spin(
hb, self, "minNodeSize", 1, 50, step=1, label="Min:",
callback=self.set_node_sizes)
self.minNodeSizeSpin.setValue(8)
gui.separator(hb)
self.maxNodeSizeSpin = gui.spin(
hb, self, "maxNodeSize", 10, 200, step=5, label="Max:",
callback=self.set_node_sizes)
self.maxNodeSizeSpin.setValue(50)
gui.separator(hb)
self.invertNodeSizeCheck = gui.checkBox(
hb, self, "invertNodeSize", "Invert",
callback=self.set_node_sizes)
hb = gui.widgetBox(self.displayTab, box="Node labels | tooltips",
orientation="horizontal", addSpace=False)
self.attListBox = gui.listBox(
hb, self, "node_label_attrs", "graph_attrs",
selectionMode=QListWidget.MultiSelection,
sizeHint=QSize(100, 100),
callback=self._on_node_label_attrs_changed)
self.tooltipListBox = gui.listBox(
hb, self, "tooltipAttributes", "graph_attrs",
selectionMode=QListWidget.MultiSelection,
sizeHint=QSize(100, 100),
callback=self._clicked_tooltip_lstbox)
eb = gui.widgetBox(self.displayTab, "Edges", orientation="vertical")
self.checkbox_relative_edges = gui.checkBox(
eb, self, 'relativeEdgeWidths', 'Relative edge widths',
callback=self.set_edge_sizes)
self.checkbox_show_weights = gui.checkBox(
eb, self, 'showEdgeWeights', 'Show edge weights',
callback=self.set_edge_labels)
ib = gui.widgetBox(self.markTab, "Info", orientation="vertical")
gui.label(ib, self, "Nodes: %(number_of_nodes_label)i")
gui.label(ib, self, "Selected: %(nSelected)i")
gui.label(ib, self, "Highlighted: %(nHighlighted)i")
def on_selection_change():
self.nSelected = len(self.view.getSelected())
self.nHighlighted = len(self.view.getHighlighted())
self.set_selection_mode()
self.commit()
self.view.selectionChanged.connect(on_selection_change)
ib = gui.widgetBox(self.markTab, "Highlight nodes ...")
ribg = gui.radioButtonsInBox(ib, self, "selectionMode", callback=self.set_selection_mode)
gui.appendRadioButton(ribg, "None")
gui.appendRadioButton(ribg, "... whose attributes contain:")
self.ctrlMarkSearchString = gui.lineEdit(gui.indentedBox(ribg), self, "markSearchString", callback=self._set_search_string_timer, callbackOnType=True)
self.searchStringTimer.timeout.connect(self.set_selection_mode)
gui.appendRadioButton(ribg, "... neighbours of selected, ≤ N hops away")
ib = gui.indentedBox(ribg, orientation=0)
self.ctrlMarkDistance = gui.spin(ib, self, "markDistance", 1, 100, 1, label="Hops:",
callback=lambda: self.set_selection_mode(SelectionMode.NEIGHBORS))
ib.layout().addStretch(1)
gui.appendRadioButton(ribg, "... with at least N connections")
gui.appendRadioButton(ribg, "... with at most N connections")
ib = gui.indentedBox(ribg, orientation=0)
self.ctrlMarkNConnections = gui.spin(ib, self, "markNConnections", 0, 1000000, 1, label="Connections:",
callback=lambda: self.set_selection_mode(SelectionMode.AT_MOST_N if self.selectionMode == SelectionMode.AT_MOST_N else SelectionMode.AT_LEAST_N))
ib.layout().addStretch(1)
gui.appendRadioButton(ribg, "... with more connections than any neighbor")
gui.appendRadioButton(ribg, "... with more connections than average neighbor")
gui.appendRadioButton(ribg, "... with most connections")
ib = gui.indentedBox(ribg, orientation=0)
self.ctrlMarkNumber = gui.spin(ib, self, "markNBest", 1, 1000000, 1,
label="Number of nodes:",
callback=lambda: self.set_selection_mode(SelectionMode.MOST_CONN))
ib.layout().addStretch(1)
self.markInputRadioButton = gui.appendRadioButton(ribg, "... given in the ItemSubset input signal")
self.markInput = 0
ib = gui.indentedBox(ribg)
self.markInputCombo = gui.comboBox(ib, self, 'markInput',
callback=lambda: self.set_selection_mode(SelectionMode.FROM_INPUT))
self.markInputRadioButton.setEnabled(False)
gui.auto_commit(ribg, self, 'do_auto_commit', 'Output changes')
self.markTab.layout().addStretch(1)
self.set_graph(None)
self.set_selection_mode()
def __init__(self):
super().__init__()
self.corpus = None # Corpus
self.corpus_docs = None # Documents generated from Corpus
self.output_mask = [] # Output corpus indices
self.doc_webview = None # WebView for showing content
self.search_features = [] # two copies are needed since Display allows drag & drop
self.display_features = []
# Info attributes
self.update_info()
info_box = gui.widgetBox(self.controlArea, 'Info')
gui.label(info_box, self, 'Documents: %(n_documents)s')
gui.label(info_box, self, 'Preprocessed: %(is_preprocessed)s')
gui.label(info_box, self, ' ◦ Tokens: %(n_tokens)s')
gui.label(info_box, self, ' ◦ Types: %(n_types)s')
gui.label(info_box, self, 'POS tagged: %(is_pos_tagged)s')
gui.label(info_box, self, 'N-grams range: %(ngram_range)s')
gui.label(info_box, self, 'Matching: %(n_matching)s')
# Search features
self.search_listbox = gui.listBox(
self.controlArea, self, 'search_indices', 'search_features',
selectionMode=QtGui.QListView.ExtendedSelection,
box='Search features', callback=self.regenerate_docs,)
# Display features
display_box = gui.widgetBox(self.controlArea, 'Display features')
self.display_listbox = gui.listBox(
display_box, self, 'display_indices', 'display_features',
selectionMode=QtGui.QListView.ExtendedSelection,
callback=self.show_docs, enableDragDrop=True)
self.show_tokens_checkbox = gui.checkBox(display_box, self, 'show_tokens',
'Show Tokens && Tags', callback=self.show_docs)
# Auto-commit box
gui.auto_commit(self.controlArea, self, 'autocommit', 'Send data', 'Auto send is on')
# Search
self.filter_input = gui.lineEdit(self.mainArea, self, '',
orientation=Qt.Horizontal,
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed),
label='RegExp Filter:')
self.filter_input.textChanged.connect(self.refresh_search)
# Main area
self.splitter = QtGui.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(QtGui.QAbstractItemView.NoEditTriggers)
self.doc_list.horizontalHeader().setResizeMode(QtGui.QHeaderView.Stretch)
self.doc_list.horizontalHeader().setVisible(False)
self.splitter.addWidget(self.doc_list)
self.doc_list_model = QStandardItemModel(self)
self.doc_list.setModel(self.doc_list_model)
self.doc_list.selectionModel().selectionChanged.connect(self.show_docs)
# Document contents
self.doc_webview = gui.WebviewWidget(self.splitter, self, debug=True)
self.mainArea.layout().addWidget(self.splitter)
def __init__(self):
widget.OWWidget.__init__(self)
RecentPathsWidgetMixin.__init__(self)
self.domain = None
self.data = None
self.loaded_file = ""
self.sheets = []
self.lb = gui.listBox(self.controlArea, self, "file_idx",
selectionMode=QListWidget.MultiSelection)
layout = QGridLayout()
gui.widgetBox(self.controlArea, margin=0, orientation=layout)
file_button = gui.button(
None, self, ' ...', callback=self.browse_files, autoDefault=False)
file_button.setIcon(self.style().standardIcon(
QStyle.SP_DirOpenIcon))
file_button.setSizePolicy(Policy.Maximum, Policy.Fixed)
layout.addWidget(file_button, 0, 0)
remove_button = gui.button(
None, self, 'Remove', callback=self.remove_item)
clear_button = gui.button(
None, self, 'Clear', callback=self.clear)
layout.addWidget(remove_button, 0, 1)
layout.addWidget(clear_button, 0, 2)
reload_button = gui.button(
None, self, "Reload", callback=self.load_data, autoDefault=False)
reload_button.setIcon(self.style().standardIcon(QStyle.SP_BrowserReload))
reload_button.setSizePolicy(Policy.Fixed, Policy.Fixed)
layout.addWidget(reload_button, 0, 7)
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 = QLabel()
self.sheet_label.setText('Sheet')
self.sheet_label.setSizePolicy(
Policy.MinimumExpanding, Policy.Fixed)
self.sheet_box.layout().addWidget(
self.sheet_label, Qt.AlignLeft)
self.sheet_box.layout().addWidget(
self.sheet_combo, Qt.AlignVCenter)
layout.addWidget(self.sheet_box, 2, 1)
self.sheet_box.hide()
layout.addWidget(self.sheet_box, 0, 5)
label_box = gui.hBox(None, addToLayout=False, margin=0)
label = gui.lineEdit(label_box, self, "label", callback=self.set_label,
label="Label", orientation=Qt.Horizontal)
layout.addWidget(label_box, 0, 6)
layout.setColumnStretch(3, 2)
box = gui.widgetBox(self.controlArea, "Columns (Double click to edit)")
self.domain_editor = DomainEditor(self)
self.editor_model = self.domain_editor.model()
box.layout().addWidget(self.domain_editor)
for i, rp in enumerate(self.recent_paths):
self.lb.addItem(rp.abspath)
# TODO unresolved paths just disappear! Modify _relocate_recent_files
box = gui.hBox(self.controlArea)
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.setEnabled(False)
self.apply_button.setFixedWidth(170)
self.editor_model.dataChanged.connect(
lambda: self.apply_button.setEnabled(True))
self._update_sheet_combo()
self.load_data()
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
# Other attributes...
self.segmentation = None
self.createdInputs = list()
self.fileLabels = list()
self.selectedFileLabels = list()
self.newFiles = u''
self.newAnnotationKey = u''
self.newAnnotationValue = u''
self.pdfPassword = u'' # SuperTextFiles
self.ocrForce = False # SuperTextFiles
self.ocrLanguages = u'eng' # SuperTextFiles
self.infoBox = InfoBox(widget=self.controlArea)
self.sendButton = SendButton(
widget=self.controlArea,
master=self,
callback=self.sendData,
infoBoxAttribute='infoBox',
sendIfPreCallback=self.updateGUI,
)
self.advancedSettings = AdvancedSettings(
widget=self.controlArea,
master=self,
callback=self.sendButton.settingsChanged,
)
# GUI...
# Advanced settings checkbox...
self.advancedSettings.draw()
# BASIC GUI...
# Basic file box
basicFileBox = gui.widgetBox(
widget=self.controlArea,
box=u'Source',
orientation='vertical',
addSpace=False,
)
basicFileBoxLine1 = gui.widgetBox(
widget=basicFileBox,
box=False,
orientation='horizontal',
)
gui.lineEdit(
widget=basicFileBoxLine1,
master=self,
value='file',
orientation='horizontal',
label=u'File path:',
labelWidth=101,
callback=self.sendButton.settingsChanged,
tooltip=(u"The path of the file."),
)
gui.separator(widget=basicFileBoxLine1, width=5)
gui.button(
widget=basicFileBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(u"Open a dialog for selecting file."),
)
gui.separator(widget=basicFileBox, width=3)
advancedEncodingsCombobox = gui.comboBox(
widget=basicFileBox,
master=self,
value='encoding',
items=getPredefinedEncodings(),
sendSelectedValue=True,
orientation='horizontal',
label=u'Encoding:',
labelWidth=101,
callback=self.sendButton.settingsChanged,
tooltip=(u"Select input file(s) encoding."),
)
addSeparatorAfterDefaultEncodings(advancedEncodingsCombobox)
addAutoDetectEncoding(advancedEncodingsCombobox)
gui.separator(widget=basicFileBox, width=3)
self.advancedSettings.basicWidgets.append(basicFileBox)
self.advancedSettings.basicWidgetsAppendSeparator()
# ADVANCED GUI...
defaultLabelWidth = 120 # SuperTextFiles
# File box
fileBox = gui.widgetBox(
widget=self.controlArea,
box=u'Sources',
orientation='vertical',
addSpace=False,
)
fileBoxLine1 = gui.widgetBox(
widget=fileBox,
box=False,
orientation='horizontal',
addSpace=True,
)
self.fileListbox = gui.listBox(
widget=fileBoxLine1,
master=self,
value='selectedFileLabels',
labels='fileLabels',
callback=self.updateFileBoxButtons,
tooltip=(
u"The list of files whose content will be imported.\n"
u"\nIn the output segmentation, the content of each\n"
u"file appears in the same position as in the list.\n"
u"\nColumn 1 shows the file's name.\n"
u"Column 2 shows the file's annotation (if any).\n"
# Start SuperTextFiles
# u"Column 3 shows the file's encoding." # removed
u"Column 3 shows the file's password (if any).\n"
u"Column 4 shows the file's languages (if any).\n"
u"Column 5 shows if OCR is forced.\n"
u"Column 6 shows the file's encoding."
# End SuperTextFiles
),
)
font = QFont()
font.setFamily('Courier')
font.setStyleHint(QFont.Courier)
font.setPixelSize(12)
self.fileListbox.setFont(font)
fileBoxCol2 = gui.widgetBox(
widget=fileBoxLine1,
orientation='vertical',
)
self.moveUpButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Move Up',
callback=self.moveUp,
tooltip=(u"Move the selected file upward in the list."),
)
self.moveDownButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Move Down',
callback=self.moveDown,
tooltip=(u"Move the selected file downward in the list."),
)
self.removeButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Remove',
callback=self.remove,
tooltip=(u"Remove the selected file from the list."),
)
self.clearAllButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Clear All',
callback=self.clearAll,
tooltip=(u"Remove all files from the list."),
)
self.exportButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Export List',
callback=self.exportList,
tooltip=(u"Open a dialog for selecting a file where the file\n"
u"list can be exported in JSON format."),
)
self.importButton = gui.button(
widget=fileBoxCol2,
master=self,
label=u'Import List',
callback=self.importList,
tooltip=(u"Open a dialog for selecting a file list to\n"
u"import (in JSON format). Files from this list\n"
u"will be added to those already imported."),
)
fileBoxLine2 = gui.widgetBox(
widget=fileBox,
box=False,
orientation='vertical',
)
# Add file box
addFileBox = gui.widgetBox(
widget=fileBoxLine2,
box=True,
orientation='vertical',
)
addFileBoxLine1 = gui.widgetBox(
widget=addFileBox,
orientation='horizontal',
)
gui.lineEdit(
widget=addFileBoxLine1,
master=self,
value='newFiles',
orientation='horizontal',
label=u'File path(s):',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(u"The paths of the files that will be added to the\n"
u"list when button 'Add' is clicked.\n\n"
u"Successive paths must be separated with ' / ' \n"
u"(whitespace + slash + whitespace). Their order in\n"
u"the list will be the same as in this field."),
)
gui.separator(widget=addFileBoxLine1, width=5)
gui.button(
widget=addFileBoxLine1,
master=self,
label=u'Browse',
callback=self.browse,
tooltip=(u"Open a dialog for selecting files.\n\n"
u"To select multiple files at once, either draw a\n"
u"selection box around them, or use shift and/or\n"
u"ctrl + click.\n\n"
u"Selected file paths will appear in the field to\n"
u"the left of this button afterwards, ready to be\n"
u"added to the list when button 'Add' is clicked."),
)
gui.separator(widget=addFileBox, width=3)
basicEncodingsCombobox = gui.comboBox(
widget=addFileBox,
master=self,
value='encoding',
items=getPredefinedEncodings(),
sendSelectedValue=True,
orientation='horizontal',
label=u'Encoding:',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(u"Select input file(s) encoding."),
)
addSeparatorAfterDefaultEncodings(basicEncodingsCombobox)
addAutoDetectEncoding(basicEncodingsCombobox)
self.encoding = self.encoding
gui.separator(widget=addFileBox, width=3)
gui.lineEdit(
widget=addFileBox,
master=self,
value='newAnnotationKey',
orientation='horizontal',
label=u'Annotation key:',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(u"This field lets you specify a custom annotation\n"
u"key associated with each file that is about to be\n"
u"added to the list."),
)
gui.separator(widget=addFileBox, width=3)
gui.lineEdit(
widget=addFileBox,
master=self,
value='newAnnotationValue',
orientation='horizontal',
label=u'Annotation value:',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(u"This field lets you specify the annotation value\n"
u"associated with the above annotation key."),
)
### Start SuperTextFiles addition
gui.separator(widget=addFileBox, width=3)
# Field for PDF password
gui.lineEdit(
widget=addFileBox,
master=self,
value='pdfPassword',
orientation='horizontal',
label=u'PDF password:'******'ocrLanguages',
orientation='horizontal',
label=u'OCR Language(s):',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(u"This field lets you specify languages\n"
u"for the OCR process. Ex.: fra+ita"),
)
gui.checkBox(
widget=addFileBox,
master=self,
value='ocrForce',
label=u'Force OCR',
labelWidth=defaultLabelWidth,
callback=self.updateGUI,
tooltip=(u"Force to use an OCR detection on this file"),
)
### End SuperTextFiles addition
gui.separator(widget=addFileBox, width=3)
self.addButton = gui.button(
widget=addFileBox,
master=self,
label=u'Add',
callback=self.add,
tooltip=(u"Add the file(s) currently displayed in the\n"
u"'Files' text field to the list.\n\n"
u"Each of these files will be associated with the\n"
u"specified encoding and annotation (if any).\n\n"
u"Other files may be selected afterwards and\n"
u"assigned a different encoding and annotation."),
)
self.advancedSettings.advancedWidgets.append(fileBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
# Options box...
optionsBox = gui.widgetBox(
widget=self.controlArea,
box=u'Options',
orientation='vertical',
addSpace=False,
)
optionsBoxLine1 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.checkBox(
widget=optionsBoxLine1,
master=self,
value='importFilenames',
label=u'Import file names with key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(u"Import file names as annotations."),
)
self.importFilenamesKeyLineEdit = gui.lineEdit(
widget=optionsBoxLine1,
master=self,
value='importFilenamesKey',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
tooltip=(u"Annotation key for importing file names."),
)
gui.separator(widget=optionsBox, width=3)
optionsBoxLine2 = gui.widgetBox(
widget=optionsBox,
box=False,
orientation='horizontal',
)
gui.checkBox(
widget=optionsBoxLine2,
master=self,
value='autoNumber',
label=u'Auto-number with key:',
labelWidth=180,
callback=self.sendButton.settingsChanged,
tooltip=(u"Annotate files with increasing numeric indices."),
)
self.autoNumberKeyLineEdit = gui.lineEdit(
widget=optionsBoxLine2,
master=self,
value='autoNumberKey',
orientation='horizontal',
callback=self.sendButton.settingsChanged,
tooltip=(u"Annotation key for file auto-numbering."),
)
gui.separator(widget=optionsBox, width=3)
self.advancedSettings.advancedWidgets.append(optionsBox)
self.advancedSettings.advancedWidgetsAppendSeparator()
gui.rubber(self.controlArea)
# Send button...
self.sendButton.draw()
# Info box...
self.infoBox.draw()
self.adjustSizeWithTimer()
QTimer.singleShot(0, self.sendButton.sendIf)
def __init__(self):
super().__init__()
#self.contextHandlers = {"": DomainContextHandler("", [ContextField("attributes", selected="node_label_attrs"), ContextField("attributes", selected="tooltipAttributes"), "color"])}
self.networkCanvas = networkCanvas = OWNxCanvas(self)
self.graph_attrs = []
self.edges_attrs = []
self.node_label_attrs = []
self.tooltipAttributes = []
self.edgeLabelAttributes = []
self.autoSendSelection = False
self.graphShowGrid = 1 # show gridlines in the graph
self.markNConnections = 2
self.markNumber = 0
self.markProportion = 0
self.markSearchString = ""
self.markDistance = 2
self.frSteps = 1
self.hubs = 0
self.node_color_attr = 0
self.edgeColor = 0
self.node_size_attr = 0
self.nShown = self.nHidden = self.nHighlighted = self.nSelected = self.verticesPerEdge = self.edgesPerVertex = 0
self.optimizeWhat = 1
self.maxNodeSize = 50
self.labelsOnMarkedOnly = 0
self.invertNodeSize = 0
self.optMethod = 0
self.lastVertexSizeColumn = ''
self.lastColorColumn = ''
self.lastLabelColumns = set()
self.lastTooltipColumns = set()
self.showWeights = 0
self.selectedEdgeSchemaIndex = 0
self.items_matrix = None
self.showDistances = 0
self.showMissingValues = 0
self.fontSize = 12
self.fontWeight = 1
self.mdsTorgerson = 0
self.mdsAvgLinkage = 1
self.mdsSteps = 10000
self.mdsRefresh = 50
self.mdsStressDelta = 0.0000001
self.showTextMiningInfo = 0
self.toolbarSelection = 0
self.minComponentEdgeWidth = 10
self.maxComponentEdgeWidth = 70
self.mdsFromCurrentPos = 0
self.tabIndex = 0
self.number_of_nodes_label = -1
self.number_of_edges_label = -1
self.opt_from_curr = False
self.checkSendMarkedNodes = True
self.checkSendSelectedNodes = True
self.marked_nodes = []
self._network_view = None
self.graph = None
self.graph_base = None
self.networkCanvas.showMissingValues = self.showMissingValues
class ViewBox(pg.ViewBox):
def __init__(self):
super().__init__()
def mouseDragEvent(self, ev):
if not ev.isFinish():
return super().mouseDragEvent(ev)
if self.state['mouseMode'] != self.RectMode:
return
# Tap into pg.ViewBox's rbScaleBox ... it'll be fine.
self.rbScaleBox.hide()
ax = QRectF(pg.Point(ev.buttonDownPos(ev.button())),
pg.Point(ev.pos()))
ax = self.childGroup.mapRectFromParent(ax)
networkCanvas.selectNodesInRect(ax)
self.setMouseMode(self.PanMode)
ev.accept()
def mouseClickEvent(self, ev):
if ev.button() == Qt.LeftButton:
if networkCanvas.is_animating:
networkCanvas.is_animating = False
ev.accept()
else:
networkCanvas.mouseClickEvent(ev)
super().mouseClickEvent(ev)
class PlotItem(pg.PlotItem):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for axis in ('bottom', 'left'):
self.hideAxis(axis)
def _path(filename):
return os.path.join(os.path.dirname(__file__), 'icons', filename + '.png')
self.rectBtn = pg.ButtonItem(_path('button_rect'), parentItem=self)
self.rectBtn.clicked.connect(self.rectBtnClicked)
self._qtBaseClass.setParentItem(self.autoBtn, None)
self.autoBtn.hide()
self.autoBtn = pg.ButtonItem(_path('button_autoscale'), parentItem=self)
self.autoBtn.mode = 'auto'
self.autoBtn.clicked.connect(self.autoBtnClicked)
self.textEnterToSelect = pg.TextItem(
html='<div style="background-color:#f0f0f0; padding:5px;">'
'<font color="#444444"><b>Press <tt>Enter</tt> to add '
'<i><font color="{}">highlighted</font></i> nodes to '
'<i><font color="{}">selection</font></i> ...</font></b></div>'
.format(NodePenColor.HIGHLIGHTED, NodePenColor.SELECTED))
self.textEnterToSelect.setParentItem(self)
self.textEnterToSelect.hide()
def rectBtnClicked(self, ev):
self.vb.setMouseMode(self.vb.RectMode)
def updateButtons(self):
self.autoBtn.show()
def resizeEvent(self, ev):
super().resizeEvent(ev)
btnRect = self.mapRectFromItem(self.rectBtn, self.rectBtn.boundingRect())
LEFT_OFFSET, BOTTOM_OFFSET = 3, 5
y = self.size().height() - btnRect.height() - BOTTOM_OFFSET
self.autoBtn.setPos(LEFT_OFFSET, y)
self.rectBtn.setPos(2*LEFT_OFFSET + btnRect.width(), y)
self.textEnterToSelect.setPos(LEFT_OFFSET, BOTTOM_OFFSET)
class PlotWidget(pg.PlotWidget):
def __init__(self, *args, **kwargs):
pg.GraphicsView.__init__(self, *args, **kwargs)
plot = PlotWidget(self, background='w')
plot.plotItem = PlotItem(enableAutoRange=True, viewBox=ViewBox())
plot.setCentralItem(plot.plotItem)
# Required, copied from pg.PlotWidget constructor
for m in ['addItem', 'removeItem', 'autoRange', 'clear', 'setXRange',
'setYRange', 'setRange', 'setAspectLocked', 'setMouseEnabled',
'setXLink', 'setYLink', 'enableAutoRange', 'disableAutoRange',
'setLimits', 'register', 'unregister', 'viewRect']:
setattr(plot, m, getattr(plot.plotItem, m))
plot.plotItem.sigRangeChanged.connect(plot.viewRangeChanged)
self.textEnterToSelect = plot.plotItem.textEnterToSelect
plot.setFrameStyle(QFrame.StyledPanel)
plot.setMinimumSize(500, 500)
plot.setAspectLocked(True)
plot.addItem(self.networkCanvas)
self.mainArea.layout().addWidget(plot)
self.tabs = gui.tabWidget(self.controlArea)
self.displayTab = gui.createTabPage(self.tabs, "Display")
self.markTab = gui.createTabPage(self.tabs, "Marking")
def showTextOnMarkingTab(index):
if self.tabs.widget(index) == self.markTab:
self.set_mark_mode()
else:
self.acceptingEnterKeypress = False
self.tabs.currentChanged.connect(showTextOnMarkingTab)
self.tabs.setCurrentIndex(self.tabIndex)
self.connect(self.tabs, SIGNAL("currentChanged(int)"), lambda index: setattr(self, 'tabIndex', index))
ib = gui.widgetBox(self.displayTab, "Info")
gui.label(ib, self, "Nodes: %(number_of_nodes_label)i (%(verticesPerEdge).2f per edge)")
gui.label(ib, self, "Edges: %(number_of_edges_label)i (%(edgesPerVertex).2f per node)")
box = gui.widgetBox(self.displayTab, "Nodes")
self.optCombo = gui.comboBox(
box, self, "optMethod", label='Layout:',
orientation='horizontal', callback=self.graph_layout_method)
for layout in Layout.all: self.optCombo.addItem(layout)
self.optMethod = Layout.all.index(Layout.FHR)
self.optCombo.setCurrentIndex(self.optMethod)
self.colorCombo = gui.comboBox(
box, self, "node_color_attr", label='Color by:',
orientation='horizontal', callback=self.set_node_colors)
hb = gui.widgetBox(box, orientation="horizontal", addSpace=False)
hb.layout().addWidget(QLabel('Size by:', hb))
self.nodeSizeCombo = gui.comboBox(
hb, self, "node_size_attr", callback=self.set_node_sizes)
self.maxNodeSizeSpin = gui.spin(
hb, self, "maxNodeSize", 5, 200, step=10, label="Max:",
callback=self.set_node_sizes)
self.maxNodeSizeSpin.setValue(50)
self.invertNodeSizeCheck = gui.checkBox(
hb, self, "invertNodeSize", "Invert",
callback=self.set_node_sizes)
lb = gui.widgetBox(box, "Node labels | tooltips", orientation="vertical", addSpace=False)
hb = gui.widgetBox(lb, orientation="horizontal", addSpace=False)
self.attListBox = gui.listBox(
hb, self, "node_label_attrs", "graph_attrs",
selectionMode=QListWidget.MultiSelection,
callback=self._on_node_label_attrs_changed)
self.tooltipListBox = gui.listBox(
hb, self, "tooltipAttributes", "graph_attrs",
selectionMode=QListWidget.MultiSelection,
callback=self._clicked_tooltip_lstbox)
eb = gui.widgetBox(self.displayTab, "Edges", orientation="vertical")
self.checkbox_relative_edges = gui.checkBox(
eb, self, 'networkCanvas.relative_edge_widths', 'Relative edge widths',
callback=self.networkCanvas.set_edge_sizes)
self.checkbox_show_weights = gui.checkBox(
eb, self, 'networkCanvas.show_edge_weights', 'Show edge weights',
callback=self.networkCanvas.set_edge_labels)
self.edgeColorCombo = gui.comboBox(
eb, self, "edgeColor", label='Color by:', orientation='horizontal',
callback=self.set_edge_colors)
elb = gui.widgetBox(eb, "Edge labels", addSpace=False)
self.edgeLabelListBox = gui.listBox(
elb, self, "edgeLabelAttributes", "edges_attrs",
selectionMode=QListWidget.MultiSelection,
callback=self._clicked_edge_label_listbox)
elb.setEnabled(False)
ib = gui.widgetBox(self.markTab, "Info", orientation="vertical")
gui.label(ib, self, "Nodes: %(number_of_nodes_label)i")
gui.label(ib, self, "Selected: %(nSelected)i")
gui.label(ib, self, "Highlighted: %(nHighlighted)i")
ib = gui.widgetBox(self.markTab, "Highlight nodes ...")
ribg = gui.radioButtonsInBox(ib, self, "hubs", [], "Mark", callback=self.set_mark_mode)
gui.appendRadioButton(ribg, "None")
gui.appendRadioButton(ribg, "... whose attributes contain:")
self.ctrlMarkSearchString = gui.lineEdit(gui.indentedBox(ribg), self, "markSearchString", callback=self._set_search_string_timer, callbackOnType=True)
self.searchStringTimer = QTimer(self)
self.connect(self.searchStringTimer, SIGNAL("timeout()"), self.set_mark_mode)
gui.appendRadioButton(ribg, "... neighbours of selected, ≤ N hops away")
ib = gui.indentedBox(ribg, orientation=0)
self.ctrlMarkDistance = gui.spin(ib, self, "markDistance", 1, 100, 1, label="Distance:",
callback=lambda: self.set_mark_mode(SelectionMode.NEIGHBORS))
#self.ctrlMarkFreeze = gui.button(ib, self, "&Freeze", value="graph.freezeNeighbours", toggleButton = True)
gui.appendRadioButton(ribg, "... with at least N connections")
gui.appendRadioButton(ribg, "... with at most N connections")
self.ctrlMarkNConnections = gui.spin(gui.indentedBox(ribg), self, "markNConnections", 0, 1000000, 1, label="N:",
callback=lambda: self.set_mark_mode(SelectionMode.AT_MOST_N if self.hubs == SelectionMode.AT_MOST_N else SelectionMode.AT_LEAST_N))
gui.appendRadioButton(ribg, "... with more connections than any neighbor")
gui.appendRadioButton(ribg, "... with more connections than average neighbor")
gui.appendRadioButton(ribg, "... with most connections")
ib = gui.indentedBox(ribg)
#~ self.ctrlMarkNumber = gui.spin(ib, self, "markNumber", 1, 1000000, 1, label="Number of nodes:", callback=(lambda h=7: self.set_mark_mode(h)))
self.ctrlMarkNumber = gui.spin(ib, self, "markNumber", 1, 1000000, 1, label="Number of nodes:", callback=lambda: self.set_mark_mode(SelectionMode.MOST_CONN))
gui.auto_commit(ribg, self, 'do_auto_commit', 'Output changes')
#ib = gui.widgetBox(self.markTab, "General", orientation="vertical")
#self.checkSendMarkedNodes = True
self.toolbar = gui.widgetBox(self.controlArea, orientation='horizontal')
#~ G = self.networkCanvas.gui
#~ self.zoomSelectToolbar = G.zoom_select_toolbar(self.toolbar, nomargin=True, buttons=
#~ G.default_zoom_select_buttons +
#~ [
#~ G.Spacing,
#~ ("buttonM2S", "Marked to selection", None, None, "marked_to_selected", 'Dlg_Mark2Sel'),
#~ ("buttonS2M", "Selection to marked", None, None, "selected_to_marked", 'Dlg_Sel2Mark'),
#~ ("buttonHSEL", "Hide selection", None, None, "hide_selection", 'Dlg_HideSelection'),
#~ ("buttonSSEL", "Show all nodes", None, None, "show_selection", 'Dlg_ShowSelection'),
#~ #("buttonUN", "Hide unselected", None, None, "hideUnSelectedVertices", 'Dlg_SelectedNodes'),
#~ #("buttonSW", "Show all nodes", None, None, "showAllVertices", 'Dlg_clear'),
#~ ])
#~ self.zoomSelectToolbar.buttons[G.SendSelection].clicked.connect(self.send_data)
#~ self.zoomSelectToolbar.buttons[G.SendSelection].clicked.connect(self.send_marked_nodes)
#~ self.zoomSelectToolbar.buttons[("buttonHSEL", "Hide selection", None, None, "hide_selection", 'Dlg_HideSelection')].clicked.connect(self.hide_selection)
#~ self.zoomSelectToolbar.buttons[("buttonSSEL", "Show all nodes", None, None, "show_selection", 'Dlg_ShowSelection')].clicked.connect(self.show_selection)
#self.zoomSelectToolbar.buttons[G.SendSelection].hide()
self.set_mark_mode()
self.displayTab.layout().addStretch(1)
self.markTab.layout().addStretch(1)
self.graph_layout_method()
self.set_graph(None)
self.setMinimumWidth(900)
