def setup_method_layout(self):
self.methods = [method() for method in self.methods]
self.buttons = []
for i, method in enumerate(self.methods):
cb = QCheckBox(self.textify(method.name))
cb.setChecked(i in self.checked)
cb.stateChanged.connect(self.update_value)
cb.setToolTip(self.get_tooltip(method))
self.method_layout.addWidget(cb)
self.buttons.append(cb)
class UpdateOptionsWidget(QWidget):
"""
A Widget with download/update/remove options.
"""
#: Install/update button was clicked
installClicked = Signal()
#: Remove button was clicked.
removeClicked = Signal()
def __init__(self, state=AVAILABLE, parent=None):
QWidget.__init__(self, parent)
layout = QHBoxLayout()
layout.setSpacing(1)
layout.setContentsMargins(1, 1, 1, 1)
self.checkButton = QCheckBox()
layout.addWidget(self.checkButton)
self.setLayout(layout)
self.setMinimumHeight(20)
self.setMaximumHeight(20)
self.state = -1
self.setState(state)
def setState(self, state):
"""
Set the current update state for the widget (AVAILABLE,
CURRENT, OUTDATED or DEPRECTED).
"""
self.state = state
self._update()
def _update(self):
if self.state == AVAILABLE:
self.checkButton.setChecked(False)
elif self.state == CURRENT:
self.checkButton.setChecked(True)
elif self.state == OUTDATED:
self.checkButton.setChecked(True)
elif self.state == DEPRECATED:
self.checkButton.setChecked(True)
else:
raise ValueError("Invalid state %r" % self._state)
try:
self.checkButton.clicked.disconnect() # Remove old signals if they exist
except Exception:
pass
if not self.checkButton.isChecked(): # Switch signals if the file is present or not
self.checkButton.clicked.connect(self.installClicked)
else:
self.checkButton.clicked.connect(self.removeClicked)
class Randomize(BaseEditor):
RandomizeClasses, RandomizeAttributes, RandomizeMetas = _Randomize.Type
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.setLayout(QVBoxLayout())
form = QFormLayout()
self.__rand_type_cb = QComboBox()
self.__rand_type_cb.addItems(["Classes",
"Features",
"Meta data"])
self.__rand_type_cb.currentIndexChanged.connect(self.changed)
self.__rand_type_cb.activated.connect(self.edited)
self.__rand_seed_ch = QCheckBox()
self.__rand_seed_ch.clicked.connect(self.edited)
form.addRow("Randomize:", self.__rand_type_cb)
form.addRow("Replicable shuffling:", self.__rand_seed_ch)
self.layout().addLayout(form)
def setParameters(self, params):
rand_type = params.get("rand_type", Randomize.RandomizeClasses)
self.__rand_type_cb.setCurrentIndex(
enum_to_index(_Randomize.Type, rand_type))
self.__rand_seed_ch.setChecked(params.get("rand_seed", 1) or 0)
def parameters(self):
return {"rand_type": index_to_enum(_Randomize.Type,
self.__rand_type_cb.currentIndex()),
"rand_seed": 1 if self.__rand_seed_ch.isChecked() else None}
@staticmethod
def createinstance(params):
rand_type = params.get("rand_type", Randomize.RandomizeClasses)
rand_seed = params.get("rand_seed", 1)
return _Randomize(rand_type=rand_type, rand_seed=rand_seed)
def __repr__(self):
return "{}, {}".format(self.__rand_type_cb.currentText(),
"Replicable" if self.__rand_seed_ch.isChecked()
else "Not replicable")
def __init__(self, title, master, attr, items, cols=1, callback=None):
super().__init__(title=title)
self.master = master
self.attr = attr
self.items = items
self.callback = callback
self.current_values = getattr(self.master, self.attr)
layout = QGridLayout()
self.setLayout(layout)
nrows = len(items) // cols + bool(len(items) % cols)
self.boxes = []
for i, value in enumerate(self.items):
box = QCheckBox(value)
box.setChecked(value in self.current_values)
box.stateChanged.connect(self.synchronize)
self.boxes.append(box)
layout.addWidget(box, i % nrows, i // nrows)
def setupUi(self):
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
self.__mainLayout = QVBoxLayout()
self.__mainLayout.setContentsMargins(0, 40, 0, 40)
self.__mainLayout.setSpacing(65)
self.layout().addLayout(self.__mainLayout)
self.setStyleSheet(WELCOME_WIDGET_BUTTON_STYLE)
bottom_bar = QWidget(objectName="bottom-bar")
bottom_bar_layout = QHBoxLayout()
bottom_bar_layout.setContentsMargins(20, 10, 20, 10)
bottom_bar.setLayout(bottom_bar_layout)
bottom_bar.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Maximum)
check = QCheckBox(self.tr("Show at startup"), bottom_bar)
check.setChecked(False)
self.__showAtStartupCheck = check
feedback = QLabel(
'<a href="http://orange.biolab.si/survey/long.html">Help us improve!</a>')
feedback.setTextInteractionFlags(Qt.TextBrowserInteraction)
feedback.setOpenExternalLinks(True)
bottom_bar_layout.addWidget(check, alignment=Qt.AlignVCenter | \
Qt.AlignLeft)
bottom_bar_layout.addWidget(feedback, alignment=Qt.AlignVCenter | \
Qt.AlignRight)
self.layout().addWidget(bottom_bar, alignment=Qt.AlignBottom,
stretch=1)
self.setSizeGripEnabled(False)
self.setFixedSize(620, 390)
class SchemeInfoDialog(QDialog):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.scheme = None
self.__autoCommit = True
self.__setupUi()
def __setupUi(self):
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSpacing(0)
self.editor = SchemeInfoEdit(self)
self.editor.layout().setContentsMargins(20, 20, 20, 20)
self.editor.layout().setSpacing(15)
self.editor.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
heading = self.tr("Workflow Info")
heading = "<h3>{0}</h3>".format(heading)
self.heading = QLabel(heading, self, objectName="heading")
# Insert heading
self.editor.layout().insertRow(0, self.heading)
self.buttonbox = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Horizontal,
self
)
# Insert button box
self.editor.layout().addRow(self.buttonbox)
widget = StyledWidget(self, objectName="auto-show-container")
check_layout = QHBoxLayout()
check_layout.setContentsMargins(20, 10, 20, 10)
self.__showAtNewSchemeCheck = \
QCheckBox(self.tr("Show when I make a New Workflow."),
self,
objectName="auto-show-check",
checked=False,
)
check_layout.addWidget(self.__showAtNewSchemeCheck)
check_layout.addWidget(
QLabel(self.tr("You can also edit Workflow Info later "
"(File -> Workflow Info)."),
self,
objectName="auto-show-info"),
alignment=Qt.AlignRight)
widget.setLayout(check_layout)
widget.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
if self.__autoCommit:
self.buttonbox.accepted.connect(self.editor.commit)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
layout.addWidget(self.editor, stretch=10)
layout.addWidget(widget)
self.setLayout(layout)
def setShowAtNewScheme(self, checked):
"""
Set the 'Show at new scheme' check state.
"""
self.__showAtNewSchemeCheck.setChecked(checked)
def showAtNewScheme(self):
"""
Return the check state of the 'Show at new scheme' check box.
"""
return self.__showAtNewSchemeCheck.isChecked()
def setAutoCommit(self, auto):
if self.__autoCommit != auto:
self.__autoCommit = auto
if auto:
self.buttonbox.accepted.connect(self.editor.commit)
else:
self.buttonbox.accepted.disconnect(self.editor.commit)
def setScheme(self, scheme):
"""Set the scheme to display/edit.
"""
self.scheme = scheme
self.editor.setScheme(scheme)
class DiscreteVariableEditor(VariableEditor):
"""An editor widget for editing a discrete variable.
Extends the :class:`VariableEditor` to enable editing of
variables values.
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
form = self.layout().itemAt(0)
assert isinstance(form, QFormLayout)
self.ordered_cb = QCheckBox(
"Ordered", self, toolTip="Is this an ordered categorical."
)
self.ordered_cb.toggled.connect(self._set_ordered)
#: A list model of discrete variable's values.
self.values_model = itemmodels.PyListModel(
flags=Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsEditable
)
vlayout = QVBoxLayout(spacing=1, margin=0)
self.values_edit = QListView(
editTriggers=QListView.DoubleClicked | QListView.EditKeyPressed
)
self.values_edit.setItemDelegate(CategoriesEditDelegate(self))
self.values_edit.setModel(self.values_model)
self.values_model.dataChanged.connect(self.on_values_changed)
self.values_edit.selectionModel().selectionChanged.connect(
self.on_value_selection_changed)
self.values_model.layoutChanged.connect(self.on_value_selection_changed)
self.values_model.rowsMoved.connect(self.on_value_selection_changed)
vlayout.addWidget(self.values_edit)
hlayout = QHBoxLayout(spacing=1, margin=0)
self.categories_action_group = group = QActionGroup(
self, objectName="action-group-categories", enabled=False
)
self.move_value_up = QAction(
"\N{UPWARDS ARROW}", group,
toolTip="Move the selected item up.",
shortcut=QKeySequence(Qt.ControlModifier | Qt.AltModifier |
Qt.Key_BracketLeft),
shortcutContext=Qt.WidgetShortcut,
)
self.move_value_up.triggered.connect(self.move_up)
self.move_value_down = QAction(
"\N{DOWNWARDS ARROW}", group,
toolTip="Move the selected item down.",
shortcut=QKeySequence(Qt.ControlModifier | Qt.AltModifier |
Qt.Key_BracketRight),
shortcutContext=Qt.WidgetShortcut,
)
self.move_value_down.triggered.connect(self.move_down)
self.add_new_item = QAction(
"+", group,
objectName="action-add-item",
toolTip="Append a new item.",
shortcut=QKeySequence(QKeySequence.New),
shortcutContext=Qt.WidgetShortcut,
)
self.remove_item = QAction(
"\N{MINUS SIGN}", group,
objectName="action-remove-item",
toolTip="Delete the selected item.",
shortcut=QKeySequence(QKeySequence.Delete),
shortcutContext=Qt.WidgetShortcut,
)
self.add_new_item.triggered.connect(self._add_category)
self.remove_item.triggered.connect(self._remove_category)
button1 = FixedSizeButton(
self, defaultAction=self.move_value_up,
accessibleName="Move up"
)
button2 = FixedSizeButton(
self, defaultAction=self.move_value_down,
accessibleName="Move down"
)
button3 = FixedSizeButton(
self, defaultAction=self.add_new_item,
accessibleName="Add"
)
button4 = FixedSizeButton(
self, defaultAction=self.remove_item,
accessibleName="Remove"
)
self.values_edit.addActions([self.move_value_up, self.move_value_down,
self.add_new_item, self.remove_item])
hlayout.addWidget(button1)
hlayout.addWidget(button2)
hlayout.addSpacing(3)
hlayout.addWidget(button3)
hlayout.addWidget(button4)
hlayout.addStretch(10)
vlayout.addLayout(hlayout)
form.insertRow(1, "", self.ordered_cb)
form.insertRow(2, "Values:", vlayout)
QWidget.setTabOrder(self.name_edit, self.ordered_cb)
QWidget.setTabOrder(self.ordered_cb, self.values_edit)
QWidget.setTabOrder(self.values_edit, button1)
QWidget.setTabOrder(button1, button2)
QWidget.setTabOrder(button2, button3)
QWidget.setTabOrder(button3, button4)
def set_data(self, var, transform=()):
# type: (Optional[Categorical], Sequence[Transform]) -> None
"""
Set the variable to edit.
"""
# pylint: disable=too-many-branches
super().set_data(var, transform)
tr = None # type: Optional[CategoriesMapping]
ordered = None # type: Optional[ChangeOrdered]
for tr_ in transform:
if isinstance(tr_, CategoriesMapping):
tr = tr_
if isinstance(tr_, ChangeOrdered):
ordered = tr_
items = []
if tr is not None:
ci_index = {c: i for i, c in enumerate(var.categories)}
for ci, cj in tr.mapping:
if ci is None and cj is not None:
# level added
item = {
Qt.EditRole: cj,
EditStateRole: ItemEditState.Added,
SourcePosRole: None
}
elif ci is not None and cj is None:
# ci level dropped
item = {
Qt.EditRole: ci,
EditStateRole: ItemEditState.Dropped,
SourcePosRole: ci_index[ci],
SourceNameRole: ci
}
elif ci is not None and cj is not None:
# rename or reorder
item = {
Qt.EditRole: cj,
EditStateRole: ItemEditState.NoState,
SourcePosRole: ci_index[ci],
SourceNameRole: ci
}
else:
assert False, "invalid mapping: {!r}".format(tr.mapping)
items.append(item)
elif var is not None:
items = [
{Qt.EditRole: c,
EditStateRole: ItemEditState.NoState,
SourcePosRole: i,
SourceNameRole: c}
for i, c in enumerate(var.categories)
]
else:
items = []
with disconnected(self.values_model.dataChanged,
self.on_values_changed):
self.values_model.clear()
self.values_model.insertRows(0, len(items))
for i, item in enumerate(items):
self.values_model.setItemData(
self.values_model.index(i, 0),
item
)
if ordered is not None:
self.ordered_cb.setChecked(ordered.ordered)
elif var is not None:
self.ordered_cb.setChecked(isinstance(var, Ordered))
self.add_new_item.actionGroup().setEnabled(var is not None)
def __categories_mapping(self):
# type: () -> CategoriesMappingType
model = self.values_model
source = self.var.categories
res = []
for i in range(model.rowCount()):
midx = model.index(i, 0)
category = midx.data(Qt.EditRole)
source_pos = midx.data(SourcePosRole) # type: Optional[int]
if source_pos is not None:
source_name = source[source_pos]
else:
source_name = None
state = midx.data(EditStateRole)
if state == ItemEditState.Dropped:
res.append((source_name, None))
elif state == ItemEditState.Added:
res.append((None, category))
else:
res.append((source_name, category))
return res
def get_data(self):
"""Retrieve the modified variable
"""
var, tr = super().get_data()
if var is None:
return var, tr
mapping = self.__categories_mapping()
if any(_1 != _2 or _2 != _3
for (_1, _2), _3 in zip_longest(mapping, var.categories)):
tr.append(CategoriesMapping(mapping))
ordered = self.ordered_cb.isChecked()
if ordered != isinstance(var, Ordered):
tr.append(ChangeOrdered(ordered))
return var, tr
def clear(self):
"""Clear the model state.
"""
super().clear()
self.values_model.clear()
def move_rows(self, rows, offset):
if not rows:
return
assert len(rows) == 1
i = rows[0].row()
if offset > 0:
offset += 1
self.values_model.moveRows(QModelIndex(), i, 1, QModelIndex(), i + offset)
self.variable_changed.emit()
def move_up(self):
rows = self.values_edit.selectionModel().selectedRows()
self.move_rows(rows, -1)
def move_down(self):
rows = self.values_edit.selectionModel().selectedRows()
self.move_rows(rows, 1)
@Slot()
def on_values_changed(self):
self.variable_changed.emit()
@Slot()
def on_value_selection_changed(self):
rows = self.values_edit.selectionModel().selectedRows()
if rows:
i = rows[0].row()
self.move_value_up.setEnabled(i)
self.move_value_down.setEnabled(i != self.values_model.rowCount() - 1)
else:
self.move_value_up.setEnabled(False)
self.move_value_down.setEnabled(False)
def _remove_category(self):
"""
Remove the current selected category.
If the item is an existing category present in the source variable it
is marked as removed in the view. But if it was added in the set
transformation it is removed entirely from the model and view.
"""
view = self.values_edit
rows = view.selectionModel().selectedRows(0)
if not rows:
return
assert len(rows) == 1
index = rows[0] # type: QModelIndex
model = index.model()
state = index.data(EditStateRole)
pos = index.data(Qt.UserRole)
if pos is not None and pos >= 0:
# existing level -> only mark/toggle its dropped state
model.setData(
index,
ItemEditState.Dropped if state != ItemEditState.Dropped
else ItemEditState.NoState,
EditStateRole)
elif state == ItemEditState.Added:
# new level -> remove it
model.removeRow(index.row())
else:
assert False, "invalid state '{}' for {}" \
.format(state, index.row())
def _add_category(self):
"""
Add a new category
"""
view = self.values_edit
model = view.model()
with disconnected(model.dataChanged, self.on_values_changed,
Qt.UniqueConnection):
row = model.rowCount()
if not model.insertRow(model.rowCount()):
return
index = model.index(row, 0)
model.setItemData(
index, {
Qt.EditRole: "",
SourcePosRole: None,
EditStateRole: ItemEditState.Added
}
)
view.setCurrentIndex(index)
view.edit(index)
self.on_values_changed()
def _set_ordered(self, ordered):
self.ordered_cb.setChecked(ordered)
self.variable_changed.emit()
class WelcomeDialog(QDialog):
"""
A welcome widget shown at startup presenting a series
of buttons (actions) for a beginner to choose from.
"""
triggered = Signal(QAction)
def __init__(self, *args, **kwargs):
showAtStartup = kwargs.pop("showAtStartup", True)
feedbackUrl = kwargs.pop("feedbackUrl", "")
super().__init__(*args, **kwargs)
self.__triggeredAction = None
self.__showAtStartupCheck = None
self.__mainLayout = None
self.__feedbackUrl = None
self.__feedbackLabel = None
self.setupUi()
self.setFeedbackUrl(feedbackUrl)
self.setShowAtStartup(showAtStartup)
def setupUi(self):
self.setLayout(QVBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
self.__mainLayout = QVBoxLayout()
self.__mainLayout.setContentsMargins(0, 40, 0, 40)
self.__mainLayout.setSpacing(65)
self.layout().addLayout(self.__mainLayout)
self.setStyleSheet(WELCOME_WIDGET_BUTTON_STYLE)
bottom_bar = QWidget(objectName="bottom-bar")
bottom_bar_layout = QHBoxLayout()
bottom_bar_layout.setContentsMargins(20, 10, 20, 10)
bottom_bar.setLayout(bottom_bar_layout)
bottom_bar.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Maximum)
self.__showAtStartupCheck = QCheckBox(
self.tr("Show at startup"), bottom_bar, checked=False
)
self.__feedbackLabel = QLabel(
textInteractionFlags=Qt.TextBrowserInteraction,
openExternalLinks=True,
visible=False,
)
bottom_bar_layout.addWidget(
self.__showAtStartupCheck, alignment=Qt.AlignVCenter | Qt.AlignLeft
)
bottom_bar_layout.addWidget(
self.__feedbackLabel, alignment=Qt.AlignVCenter | Qt.AlignRight
)
self.layout().addWidget(bottom_bar, alignment=Qt.AlignBottom,
stretch=1)
self.setSizeGripEnabled(False)
self.setFixedSize(620, 390)
def setShowAtStartup(self, show):
"""
Set the 'Show at startup' check box state.
"""
if self.__showAtStartupCheck.isChecked() != show:
self.__showAtStartupCheck.setChecked(show)
def showAtStartup(self):
"""
Return the 'Show at startup' check box state.
"""
return self.__showAtStartupCheck.isChecked()
def setFeedbackUrl(self, url):
# type: (str) -> None
"""
Set an 'feedback' url. When set a link is displayed in the bottom row.
"""
self.__feedbackUrl = url
if url:
text = self.tr("Help us improve!")
self.__feedbackLabel.setText(
'<a href="{url}">{text}</a>'.format(url=url, text=escape(text))
)
else:
self.__feedbackLabel.setText("")
self.__feedbackLabel.setVisible(bool(url))
def addRow(self, actions, background="light-orange"):
"""Add a row with `actions`.
"""
count = self.__mainLayout.count()
self.insertRow(count, actions, background)
def insertRow(self, index, actions, background="light-orange"):
"""Insert a row with `actions` at `index`.
"""
widget = QWidget(objectName="icon-row")
layout = QHBoxLayout()
layout.setContentsMargins(40, 0, 40, 0)
layout.setSpacing(65)
widget.setLayout(layout)
self.__mainLayout.insertWidget(index, widget, stretch=10,
alignment=Qt.AlignCenter)
for i, action in enumerate(actions):
self.insertAction(index, i, action, background)
def insertAction(self, row, index, action,
background="light-orange"):
"""Insert `action` in `row` in position `index`.
"""
button = self.createButton(action, background)
self.insertButton(row, index, button)
def insertButton(self, row, index, button):
"""Insert `button` in `row` in position `index`.
"""
item = self.__mainLayout.itemAt(row)
layout = item.widget().layout()
layout.insertWidget(index, button)
button.triggered.connect(self.__on_actionTriggered)
def createButton(self, action, background="light-orange"):
"""Create a tool button for action.
"""
button = WelcomeActionButton(self)
button.setDefaultAction(action)
button.setText(action.iconText())
button.setIcon(decorate_welcome_icon(action.icon(), background))
button.setToolTip(action.toolTip())
button.setFixedSize(100, 100)
button.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
button.setVisible(action.isVisible())
font = QFont(button.font())
font.setPointSize(13)
button.setFont(font)
return button
def buttonAt(self, i, j):
"""Return the button at i-t row and j-th column.
"""
item = self.__mainLayout.itemAt(i)
row = item.widget()
item = row.layout().itemAt(j)
return item.widget()
def triggeredAction(self):
"""Return the action that was triggered by the user.
"""
return self.__triggeredAction
def showEvent(self, event):
# Clear the triggered action before show.
self.__triggeredAction = None
super().showEvent(event)
def __on_actionTriggered(self, action):
"""Called when the button action is triggered.
"""
self.triggered.emit(action)
self.__triggeredAction = action
class AddonManagerWidget(QWidget):
statechanged = Signal()
def __init__(self, parent=None, **kwargs):
super(AddonManagerWidget, self).__init__(parent, **kwargs)
self.__items = []
self.setLayout(QVBoxLayout())
self.__header = QLabel(
wordWrap=True,
textFormat=Qt.RichText
)
self.__search = QLineEdit(
placeholderText=self.tr("Filter")
)
self.__only_trusted = QCheckBox(
self.tr("Show only trusted add-ons"),
)
topline = QHBoxLayout()
topline.addWidget(self.__search)
topline.addWidget(self.__only_trusted)
self.layout().addLayout(topline)
self.__only_trusted.setChecked(True)
self.show_only_trusted = True
self.__only_trusted.stateChanged.connect(self._show_only_trusted_changed)
self.__view = view = QTreeView(
rootIsDecorated=False,
editTriggers=QTreeView.NoEditTriggers,
selectionMode=QTreeView.SingleSelection,
alternatingRowColors=True
)
self.__view.setItemDelegateForColumn(0, TristateCheckItemDelegate())
self.layout().addWidget(view)
self.__model = model = QStandardItemModel()
model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"])
model.dataChanged.connect(self.__data_changed)
self.__proxy = proxy = SortFilterProxyTrusted(
filterKeyColumn=1,
filterCaseSensitivity=Qt.CaseInsensitive
)
proxy.setSourceModel(model)
self.__search.textChanged.connect(proxy.setFilterFixedString)
view.setModel(proxy)
view.selectionModel().selectionChanged.connect(
self.__update_details
)
header = self.__view.header()
header.setSectionResizeMode(0, QHeaderView.Fixed)
header.setSectionResizeMode(2, QHeaderView.ResizeToContents)
self.__details = QTextBrowser(
frameShape=QTextBrowser.NoFrame,
readOnly=True,
lineWrapMode=QTextBrowser.WidgetWidth,
openExternalLinks=True,
)
self.__details.setWordWrapMode(QTextOption.WordWrap)
palette = QPalette(self.palette())
palette.setColor(QPalette.Base, Qt.transparent)
self.__details.setPalette(palette)
self.layout().addWidget(self.__details)
def _show_only_trusted_changed(self):
self.__proxy.set_show_only_trusted(self.__only_trusted.isChecked())
def set_items(self, items):
self.__items = items
model = self.__model
model.clear()
model.setHorizontalHeaderLabels(["", "Name", "Version", "Action"])
for item in items:
if isinstance(item, Installed):
installed = True
ins, dist = item
name = dist.project_name
summary = get_dist_meta(dist).get("Summary", "")
version = ins.version if ins is not None else dist.version
else:
installed = False
(ins,) = item
dist = None
name = ins.name
summary = ins.summary
version = ins.version
updatable = is_updatable(item)
item1 = QStandardItem()
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable |
(Qt.ItemIsTristate if updatable else 0))
if installed and updatable:
item1.setCheckState(Qt.PartiallyChecked)
elif installed:
item1.setCheckState(Qt.Checked)
else:
item1.setCheckState(Qt.Unchecked)
item2 = QStandardItem(cleanup(name))
item2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item2.setToolTip(summary)
item2.setData(item, Qt.UserRole)
if updatable:
version = "{} < {}".format(dist.version, ins.version)
item3 = QStandardItem(version)
item3.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item4 = QStandardItem()
item4.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
model.appendRow([item1, item2, item3, item4])
self.__view.resizeColumnToContents(0)
self.__view.setColumnWidth(
1, max(150, self.__view.sizeHintForColumn(1)))
self.__view.setColumnWidth(
2, max(150, self.__view.sizeHintForColumn(2)))
if self.__items:
self.__view.selectionModel().select(
self.__view.model().index(0, 0),
QItemSelectionModel.Select | QItemSelectionModel.Rows
)
def item_state(self):
steps = []
for i, item in enumerate(self.__items):
modelitem = self.__model.item(i, 0)
state = modelitem.checkState()
if modelitem.flags() & Qt.ItemIsTristate and state == Qt.Checked:
steps.append((Upgrade, item))
elif isinstance(item, Available) and state == Qt.Checked:
steps.append((Install, item))
elif isinstance(item, Installed) and state == Qt.Unchecked:
steps.append((Uninstall, item))
return steps
def __selected_row(self):
indices = self.__view.selectedIndexes()
if indices:
proxy = self.__view.model()
indices = [proxy.mapToSource(index) for index in indices]
return indices[0].row()
else:
return -1
def set_install_projects(self, names):
"""Mark for installation the add-ons that match any of names"""
model = self.__model
for row in range(model.rowCount()):
item = model.item(row, 1)
if item.text() in names:
model.item(row, 0).setCheckState(Qt.Checked)
def __data_changed(self, topleft, bottomright):
rows = range(topleft.row(), bottomright.row() + 1)
for i in rows:
modelitem = self.__model.item(i, 0)
actionitem = self.__model.item(i, 3)
item = self.__items[i]
state = modelitem.checkState()
flags = modelitem.flags()
if flags & Qt.ItemIsTristate and state == Qt.Checked:
actionitem.setText("Update")
elif isinstance(item, Available) and state == Qt.Checked:
actionitem.setText("Install")
elif isinstance(item, Installed) and state == Qt.Unchecked:
actionitem.setText("Uninstall")
else:
actionitem.setText("")
self.statechanged.emit()
def __update_details(self):
index = self.__selected_row()
if index == -1:
self.__details.setText("")
else:
item = self.__model.item(index, 1)
item = item.data(Qt.UserRole)
assert isinstance(item, (Installed, Available))
text = self._detailed_text(item)
self.__details.setText(text)
def _detailed_text(self, item):
if isinstance(item, Installed):
remote, dist = item
if remote is None:
meta = get_dist_meta(dist)
description = meta.get("Description") or meta.get('Summary')
else:
description = remote.description
else:
description = item[0].description
if docutils is not None:
try:
html = docutils.core.publish_string(
trim(description),
writer_name="html",
settings_overrides={
"output-encoding": "utf-8",
# "embed-stylesheet": False,
# "stylesheet": [],
# "stylesheet_path": []
}
).decode("utf-8")
except docutils.utils.SystemMessage:
html = "<pre>{}<pre>".format(escape(description))
except Exception:
html = "<pre>{}<pre>".format(escape(description))
else:
html = "<pre>{}<pre>".format(escape(description))
return html
def sizeHint(self):
return QSize(480, 420)
def _setup_gui(self):
grid = QGridLayout()
box = gui.widgetBox(self.controlArea, "Scoring Methods", grid)
yake_cb = gui.comboBox(
self.controlArea, self, "yake_lang_index", items=YAKE_LANGUAGES,
callback=self.__on_yake_lang_changed
)
rake_cb = gui.comboBox(
self.controlArea, self, "rake_lang_index", items=RAKE_LANGUAGES,
callback=self.__on_rake_lang_changed
)
embedding_cb = gui.comboBox(
self.controlArea, self, "embedding_lang_index",
items=EMBEDDING_LANGUAGES, callback=self.__on_emb_lang_changed
)
for i, (method_name, _) in enumerate(ScoringMethods.ITEMS):
check_box = QCheckBox(method_name, self)
check_box.setChecked(method_name in self.selected_scoring_methods)
check_box.stateChanged.connect(
lambda state, name=method_name:
self.__on_scoring_method_state_changed(state, name)
)
box.layout().addWidget(check_box, i, 0)
if method_name == ScoringMethods.YAKE:
box.layout().addWidget(yake_cb, i, 1)
if method_name == ScoringMethods.RAKE:
box.layout().addWidget(rake_cb, i, 1)
if method_name == ScoringMethods.EMBEDDING:
box.layout().addWidget(embedding_cb, i, 1)
box = gui.vBox(self.controlArea, "Aggregation")
gui.comboBox(
box, self, "agg_method", items=AggregationMethods.ITEMS,
callback=self.update_scores
)
box = gui.vBox(self.buttonsArea, "Select Words")
grid = QGridLayout()
grid.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(grid)
self.__sel_method_buttons = QButtonGroup()
for method, label in enumerate(SelectionMethods.ITEMS):
button = QRadioButton(label)
button.setChecked(method == self.sel_method)
grid.addWidget(button, method, 0)
self.__sel_method_buttons.addButton(button, method)
self.__sel_method_buttons.buttonClicked[int].connect(
self._set_selection_method
)
spin = gui.spin(
box, self, "n_selected", 1, 999, addToLayout=False,
callback=lambda: self._set_selection_method(
SelectionMethods.N_BEST)
)
grid.addWidget(spin, 3, 1)
gui.rubber(self.controlArea)
gui.auto_send(self.buttonsArea, self, "auto_apply")
self.__filter_line_edit = QLineEdit(
textChanged=self.__on_filter_changed,
placeholderText="Filter..."
)
self.mainArea.layout().addWidget(self.__filter_line_edit)
def select_manual():
self._set_selection_method(SelectionMethods.MANUAL)
self.view = KeywordsTableView()
self.view.pressedAny.connect(select_manual)
self.view.horizontalHeader().setSortIndicator(*self.DEFAULT_SORTING)
self.view.horizontalHeader().sectionClicked.connect(
self.__on_horizontal_header_clicked)
self.mainArea.layout().addWidget(self.view)
proxy = SortFilterProxyModel()
proxy.setFilterKeyColumn(0)
proxy.setFilterCaseSensitivity(False)
self.view.setModel(proxy)
self.view.model().setSourceModel(self.model)
self.view.selectionModel().selectionChanged.connect(
self.__on_selection_changed
)
class EditOBAUI(QWidget):
def __init__(self, oba, parent):
super(EditOBAUI, self).__init__()
self.parent = parent
self.oba = oba
self.setLayout(QVBoxLayout(self))
self.layout().setAlignment(Qt.AlignCenter)
# Init Name text control
self._nameControl = LineEdit('Name', self)
self._nameControl.setText(self.oba.name)
self._nameControl.kb.connect(self.showOSK)
# Init Output Pin dropdown control
self._outputPinControlLabel = QLabel('Output Pin', self)
self._outputPinControl = QComboBox(self)
for _pin in self.parent.availablePins():
self._outputPinControl.addItem(str(_pin))
for _i in range(self._outputPinControl.count()):
if self._outputPinControl.itemText(_i) == str(self.oba.outputPin):
self._outputPinControl.setCurrentIndex(_i)
break
# Init Momentary checkbox control and set value
self._momentaryControl = QCheckBox('Momentary', self)
self._momentaryControl.setChecked(self.oba.momentary)
# Init Enabled checkbox control and set value
self._enabledControl = QCheckBox('Enabled', self)
self._enabledControl.setChecked(self.oba.enabled)
# Init Icon dropdown control
self._iconControlLabel = QLabel('Icon Path', self)
self._iconControl = QComboBox(self)
for _key in Config.icons['oba'].keys():
icon = Config.icon('oba', _key)
self._iconControl.addItem(icon['name'], _key)
self._iconControl.setItemIcon(self._iconControl.count() - 1,
QIcon(icon['path']))
for _i in range(self._iconControl.count()):
# Set current index if matching icon attribute
if self.oba.icon is not None and self._iconControl.itemData(
_i) == self.oba.icon:
self._iconControl.setCurrentIndex(_i)
break
# Init Save button
self._saveBtn = QPushButton('Save', self)
self._saveBtn.clicked.connect(self.__saveBtnAction)
# Init cancel button
self._cancelBtn = QPushButton('Cancel', self)
self._cancelBtn.clicked.connect(self.__cancel)
# Assign control layout
_layout = [['_nameControl'],
['_outputPinControlLabel', '_outputPinControl'],
['_momentaryControl', '_enabledControl'],
['_iconControlLabel', '_iconControl'],
['_saveBtn', '_cancelBtn']]
for _list in _layout:
_panel = QWidget(self)
_panel.setLayout(QHBoxLayout(_panel))
_panel.layout().setAlignment(Qt.AlignCenter)
_panel.layout().setSpacing(20)
for _control in _list:
_panel.layout().addWidget(eval('self.%s' % _control))
self.layout().addWidget(_panel)
def __saveBtnAction(self):
self.oba.name = self._nameControl.text()
self.oba.outputPin = int(self._outputPinControl.currentText())
self.oba.enabled = self._enabledControl.isChecked()
self.oba.icon = self._iconControl.currentData()
self.oba.momentary = self._momentaryControl.isChecked()
self.parent.obas.save()
self.parent.loadUI('config_oba')
def __cancel(self):
self.parent.loadUI('config_oba')
def showOSK(self):
self.window().dock.show()
self.window().osk.rWidget = self._nameControl
class NormalizationModule(SingleMethodModule):
Porter, Snowball, WordNet, UDPipe = range(4)
Methods = {Porter: PorterStemmer,
Snowball: SnowballStemmer,
WordNet: WordNetLemmatizer,
UDPipe: UDPipeLemmatizer}
DEFAULT_METHOD = Porter
DEFAULT_LANGUAGE = "English"
DEFAULT_USE_TOKE = False
def __init__(self, parent=None, **kwargs):
super().__init__(parent, **kwargs)
self.__snowball_lang = self.DEFAULT_LANGUAGE
self.__udpipe_lang = self.DEFAULT_LANGUAGE
self.__use_tokenizer = self.DEFAULT_USE_TOKE
self.__combo_sbl = ComboBox(
self, SnowballStemmer.supported_languages,
self.__snowball_lang, self.__set_snowball_lang
)
self.__combo_udl = UDPipeComboBox(
self, self.__udpipe_lang, self.DEFAULT_LANGUAGE,
self.__set_udpipe_lang
)
self.__check_use = QCheckBox("UDPipe tokenizer",
checked=self.DEFAULT_USE_TOKE)
self.__check_use.clicked.connect(self.__set_use_tokenizer)
label = QLabel("Language:")
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.layout().addWidget(label, self.Snowball, 1)
self.layout().addWidget(self.__combo_sbl, self.Snowball, 2)
label = QLabel("Language:")
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.layout().addWidget(label, self.UDPipe, 1)
self.layout().addWidget(self.__combo_udl, self.UDPipe, 2)
self.layout().addWidget(self.__check_use, self.UDPipe, 3)
self.layout().setColumnStretch(2, 1)
self.__enable_udpipe()
def __enable_udpipe(self):
enable = bool(self.__combo_udl.items)
layout = self.layout() # type: QGridLayout
for i in range(4):
layout.itemAtPosition(self.UDPipe, i).widget().setEnabled(enable)
if self.method == self.UDPipe and not enable:
self._set_method(self.Porter)
def setParameters(self, params: Dict):
super().setParameters(params)
snowball_lang = params.get("snowball_language", self.DEFAULT_LANGUAGE)
self.__set_snowball_lang(snowball_lang)
udpipe_lang = params.get("udpipe_language", self.DEFAULT_LANGUAGE)
self.__set_udpipe_lang(udpipe_lang)
use_tokenizer = params.get("udpipe_tokenizer", self.DEFAULT_USE_TOKE)
self.__set_use_tokenizer(use_tokenizer)
def _set_method(self, method: int):
super()._set_method(method)
self.__enable_udpipe()
def __set_snowball_lang(self, language: str):
if self.__snowball_lang != language:
self.__snowball_lang = language
self.__combo_sbl.setCurrentText(language)
self.changed.emit()
if self.method == self.Snowball:
self.edited.emit()
def __set_udpipe_lang(self, language: str):
if self.__udpipe_lang != language:
self.__udpipe_lang = language
self.__combo_udl.setCurrentText(language)
self.changed.emit()
if self.method == self.UDPipe:
self.edited.emit()
def __set_use_tokenizer(self, use: bool):
if self.__use_tokenizer != use:
self.__use_tokenizer = use
self.__check_use.setChecked(use)
self.changed.emit()
if self.method == self.UDPipe:
self.edited.emit()
def parameters(self) -> Dict:
params = super().parameters()
params.update({"snowball_language": self.__snowball_lang,
"udpipe_language": self.__udpipe_lang,
"udpipe_tokenizer": self.__use_tokenizer})
return params
@staticmethod
def createinstance(params: Dict) -> BaseNormalizer:
method = params.get("method", NormalizationModule.DEFAULT_METHOD)
args = {}
def_lang = NormalizationModule.DEFAULT_LANGUAGE
if method == NormalizationModule.Snowball:
args = {"language": params.get("snowball_language", def_lang)}
elif method == NormalizationModule.UDPipe:
def_use = NormalizationModule.DEFAULT_USE_TOKE
args = {"language": params.get("udpipe_language", def_lang),
"use_tokenizer": params.get("udpipe_tokenizer", def_use)}
return NormalizationModule.Methods[method](**args)
def __repr__(self):
text = super().__repr__()
if self.method == self.Snowball:
text = f"{text} ({self.__snowball_lang})"
elif self.method == self.UDPipe:
text = f"{text} ({self.__udpipe_lang}, " \
f"Tokenize: {['No', 'Yes'][self.__use_tokenizer]})"
return text