class OWRank(OWWidget):
name = "Rank"
description = "Rank and filter data features by their relevance."
icon = "icons/Rank.svg"
priority = 1102
buttons_area_orientation = Qt.Vertical
inputs = [("Data", Table, "setData"),
("Scorer", score.Scorer, "set_learner", widget.Multiple)]
outputs = [("Reduced Data", Table, widget.Default), ("Scores", Table)]
SelectNone, SelectAll, SelectManual, SelectNBest = range(4)
cls_default_selected = Setting({"Gain Ratio", "Gini Decrease"})
reg_default_selected = Setting({"Univariate Linear Regression", "RReliefF"})
selectMethod = Setting(SelectNBest)
nSelected = Setting(5)
auto_apply = Setting(True)
# Header state for discrete/continuous/no_class scores
headerState = Setting([None, None, None])
settings_version = 1
settingsHandler = DomainContextHandler()
selected_rows = ContextSetting([])
gain = inf_gain = gini = anova = chi2 = ulr = relief = rrelief = fcbc = True
_score_vars = ["gain", "inf_gain", "gini", "anova", "chi2", "relief",
"fcbc", "ulr", "rrelief"]
class Warning(OWWidget.Warning):
no_target_var = Msg("Data does not have a target variable")
class Error(OWWidget.Error):
invalid_type = Msg("Cannot handle target variable type {}")
inadequate_learner = Msg("{}")
def __init__(self):
super().__init__()
self.measure_scores = None
self.update_scores = True
self.usefulAttributes = []
self.learners = {}
self.labels = []
self.out_domain_desc = None
self.all_measures = SCORES
self.selectedMeasures = dict([(m.name, True) for m
in self.all_measures])
# Discrete (0) or continuous (1) class mode
self.rankMode = 0
self.data = None
self.discMeasures = [m for m in self.all_measures if
issubclass(DiscreteVariable, m.score.class_type)]
self.contMeasures = [m for m in self.all_measures if
issubclass(ContinuousVariable, m.score.class_type)]
self.score_checks = []
self.cls_scoring_box = gui.vBox(None, "Scoring for Classification")
self.reg_scoring_box = gui.vBox(None, "Scoring for Regression")
boxes = [self.cls_scoring_box] * 7 + [self.reg_scoring_box] * 2
for _score, var, box in zip(SCORES, self._score_vars, boxes):
check = gui.checkBox(
box, self, var, label=_score.name,
callback=lambda val=_score: self.measuresSelectionChanged(val))
self.score_checks.append(check)
self.score_stack = QStackedWidget(self)
self.score_stack.addWidget(self.cls_scoring_box)
self.score_stack.addWidget(self.reg_scoring_box)
self.score_stack.addWidget(QWidget())
self.controlArea.layout().addWidget(self.score_stack)
gui.rubber(self.controlArea)
selMethBox = gui.vBox(
self.controlArea, "Select Attributes", addSpace=True)
grid = QGridLayout()
grid.setContentsMargins(6, 0, 6, 0)
self.selectButtons = QButtonGroup()
self.selectButtons.buttonClicked[int].connect(self.setSelectMethod)
def button(text, buttonid, toolTip=None):
b = QRadioButton(text)
self.selectButtons.addButton(b, buttonid)
if toolTip is not None:
b.setToolTip(toolTip)
return b
b1 = button(self.tr("None"), OWRank.SelectNone)
b2 = button(self.tr("All"), OWRank.SelectAll)
b3 = button(self.tr("Manual"), OWRank.SelectManual)
b4 = button(self.tr("Best ranked:"), OWRank.SelectNBest)
s = gui.spin(selMethBox, self, "nSelected", 1, 100,
callback=self.nSelectedChanged)
grid.addWidget(b1, 0, 0)
grid.addWidget(b2, 1, 0)
grid.addWidget(b3, 2, 0)
grid.addWidget(b4, 3, 0)
grid.addWidget(s, 3, 1)
self.selectButtons.button(self.selectMethod).setChecked(True)
selMethBox.layout().addLayout(grid)
gui.auto_commit(selMethBox, self, "auto_apply", "Send", box=False)
# Discrete, continuous and no_class table views are stacked
self.ranksViewStack = QStackedLayout()
self.mainArea.layout().addLayout(self.ranksViewStack)
self.discRanksView = QTableView()
self.ranksViewStack.addWidget(self.discRanksView)
self.discRanksView.setSelectionBehavior(QTableView.SelectRows)
self.discRanksView.setSelectionMode(QTableView.MultiSelection)
self.discRanksView.setSortingEnabled(True)
self.discRanksLabels = ["#"] + [m.shortname for m in self.discMeasures]
self.discRanksModel = QStandardItemModel(self)
self.discRanksModel.setHorizontalHeaderLabels(self.discRanksLabels)
self.discRanksProxyModel = MySortProxyModel(self)
self.discRanksProxyModel.setSourceModel(self.discRanksModel)
self.discRanksView.setModel(self.discRanksProxyModel)
self.discRanksView.setColumnWidth(0, 20)
self.discRanksView.selectionModel().selectionChanged.connect(
self.commit
)
self.discRanksView.pressed.connect(self.onSelectItem)
self.discRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick
)
self.discRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem
)
if self.headerState[0] is not None:
self.discRanksView.horizontalHeader().restoreState(
self.headerState[0])
self.contRanksView = QTableView()
self.ranksViewStack.addWidget(self.contRanksView)
self.contRanksView.setSelectionBehavior(QTableView.SelectRows)
self.contRanksView.setSelectionMode(QTableView.MultiSelection)
self.contRanksView.setSortingEnabled(True)
self.contRanksLabels = ["#"] + [m.shortname for m in self.contMeasures]
self.contRanksModel = QStandardItemModel(self)
self.contRanksModel.setHorizontalHeaderLabels(self.contRanksLabels)
self.contRanksProxyModel = MySortProxyModel(self)
self.contRanksProxyModel.setSourceModel(self.contRanksModel)
self.contRanksView.setModel(self.contRanksProxyModel)
self.contRanksView.setColumnWidth(0, 20)
self.contRanksView.selectionModel().selectionChanged.connect(
self.commit
)
self.contRanksView.pressed.connect(self.onSelectItem)
self.contRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick
)
self.contRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem
)
if self.headerState[1] is not None:
self.contRanksView.horizontalHeader().restoreState(
self.headerState[1])
self.noClassRanksView = QTableView()
self.ranksViewStack.addWidget(self.noClassRanksView)
self.noClassRanksView.setSelectionBehavior(QTableView.SelectRows)
self.noClassRanksView.setSelectionMode(QTableView.MultiSelection)
self.noClassRanksView.setSortingEnabled(True)
self.noClassRanksLabels = ["#"]
self.noClassRanksModel = QStandardItemModel(self)
self.noClassRanksModel.setHorizontalHeaderLabels(self.noClassRanksLabels)
self.noClassRanksProxyModel = MySortProxyModel(self)
self.noClassRanksProxyModel.setSourceModel(self.noClassRanksModel)
self.noClassRanksView.setModel(self.noClassRanksProxyModel)
self.noClassRanksView.setColumnWidth(0, 20)
self.noClassRanksView.selectionModel().selectionChanged.connect(
self.commit
)
self.noClassRanksView.pressed.connect(self.onSelectItem)
self.noClassRanksView.horizontalHeader().sectionClicked.connect(
self.headerClick
)
self.noClassRanksView.verticalHeader().sectionClicked.connect(
self.onSelectItem
)
if self.headerState[2] is not None:
self.noClassRanksView.horizontalHeader().restoreState(
self.headerState[2])
# Switch the current view to Discrete
self.switchRanksMode(0)
self.resetInternals()
self.updateDelegates()
self.updateVisibleScoreColumns()
self.resize(690, 500)
self.measure_scores = table((len(self.measures), 0), None)
def switchRanksMode(self, index):
"""
Switch between discrete/continuous/no_class mode
"""
self.rankMode = index
self.ranksViewStack.setCurrentIndex(index)
if index == 0:
self.ranksView = self.discRanksView
self.ranksModel = self.discRanksModel
self.ranksProxyModel = self.discRanksProxyModel
self.measures = self.discMeasures
self.selected_checks = self.cls_default_selected
self.reg_scoring_box.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.cls_scoring_box.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
elif index == 1:
self.ranksView = self.contRanksView
self.ranksModel = self.contRanksModel
self.ranksProxyModel = self.contRanksProxyModel
self.measures = self.contMeasures
self.selected_checks = self.reg_default_selected
self.cls_scoring_box.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.reg_scoring_box.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
else:
self.ranksView = self.noClassRanksView
self.ranksModel = self.noClassRanksModel
self.ranksProxyModel = self.noClassRanksProxyModel
self.measures = []
self.selected_checks = set()
self.reg_scoring_box.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
self.cls_scoring_box.setSizePolicy(QSizePolicy.Ignored,
QSizePolicy.Ignored)
shape = (len(self.measures) + len(self.learners), 0)
self.measure_scores = table(shape, None)
self.update_scores = False
for check, score in zip(self.score_checks, SCORES):
check.setChecked(score.name in self.selected_checks)
self.update_scores = True
self.score_stack.setCurrentIndex(index)
self.updateVisibleScoreColumns()
@check_sql_input
def setData(self, data):
self.closeContext()
self.clear_messages()
self.resetInternals()
self.data = data
self.switchRanksMode(0)
if self.data is not None:
domain = self.data.domain
attrs = domain.attributes
self.usefulAttributes = [attr for attr in attrs
if attr.is_discrete or attr.is_continuous]
if domain.has_continuous_class:
self.switchRanksMode(1)
elif not domain.class_var:
self.Warning.no_target_var()
self.switchRanksMode(2)
elif not domain.has_discrete_class:
self.Error.invalid_type(type(domain.class_var).__name__)
if issparse(self.data.X): # keep only measures supporting sparse data
self.measures = [m for m in self.measures
if m.score.supports_sparse_data]
self.ranksModel.setRowCount(len(attrs))
for i, a in enumerate(attrs):
if a.is_discrete:
v = len(a.values)
else:
v = "C"
item = ScoreValueItem()
item.setData(v, Qt.DisplayRole)
self.ranksModel.setItem(i, 0, item)
item = QStandardItem(a.name)
item.setData(gui.attributeIconDict[a], Qt.DecorationRole)
self.ranksModel.setVerticalHeaderItem(i, item)
shape = (len(self.measures) + len(self.learners), len(attrs))
self.measure_scores = table(shape, None)
self.updateScores()
else:
self.send("Scores", None)
self.selected_rows = []
self.openContext(data)
self.selectMethodChanged()
self.commit()
def get_selection(self):
selection = self.ranksView.selectionModel().selection()
return list(set(ind.row() for ind in selection.indexes()))
def set_learner(self, learner, lid=None):
if learner is None and lid is not None:
del self.learners[lid]
elif learner is not None:
self.learners[lid] = score_meta(
learner.name,
learner.name,
learner
)
attrs_len = 0 if not self.data else len(self.data.domain.attributes)
shape = (len(self.learners), attrs_len)
self.measure_scores = self.measure_scores[:len(self.measures)]
self.measure_scores += table(shape, None)
self.contRanksModel.setHorizontalHeaderLabels(self.contRanksLabels)
self.discRanksModel.setHorizontalHeaderLabels(self.discRanksLabels)
self.noClassRanksModel.setHorizontalHeaderLabels(
self.noClassRanksLabels)
measures_mask = [False] * len(self.measures)
measures_mask += [True for _ in self.learners]
self.updateScores(measures_mask)
self.commit()
def updateScores(self, measuresMask=None):
"""
Update the current computed scores.
If `measuresMask` is given it must be an list of bool values
indicating what measures should be recomputed.
"""
if not self.data:
return
if self.data.has_missing():
self.information("Missing values have been imputed.")
measures = self.measures + [v for k, v in self.learners.items()]
if measuresMask is None:
# Update all selected measures
measuresMask = [self.selectedMeasures.get(m.name)
for m in self.measures]
measuresMask = measuresMask + [v.name for k, v in
self.learners.items()]
data = self.data
learner_col = len(self.measures)
if len(measuresMask) <= len(self.measures) or \
measuresMask[len(self.measures)]:
self.labels = []
self.Error.inadequate_learner.clear()
self.setStatusMessage("Running")
with self.progressBar():
n_measure_update = len([x for x in measuresMask if x is not False])
count = 0
for index, (meas, mask) in enumerate(zip(measures, measuresMask)):
if not mask:
continue
self.progressBarSet(90 * count / n_measure_update)
count += 1
if index < len(self.measures):
estimator = meas.score()
try:
self.measure_scores[index] = estimator(data)
except ValueError:
self.measure_scores[index] = []
for attr in data.domain.attributes:
try:
self.measure_scores[index].append(
estimator(data, attr))
except ValueError:
self.measure_scores[index].append(None)
else:
learner = meas.score
if isinstance(learner, Learner) and \
not learner.check_learner_adequacy(self.data.domain):
self.Error.inadequate_learner(
learner.learner_adequacy_err_msg)
scores = table((1, len(data.domain.attributes)))
else:
scores = meas.score.score_data(data)
for i, row in enumerate(scores):
self.labels.append(meas.shortname + str(i + 1))
if len(self.measure_scores) > learner_col:
self.measure_scores[learner_col] = row
else:
self.measure_scores.append(row)
learner_col += 1
self.progressBarSet(90)
self.contRanksModel.setHorizontalHeaderLabels(
self.contRanksLabels + self.labels
)
self.discRanksModel.setHorizontalHeaderLabels(
self.discRanksLabels + self.labels
)
self.noClassRanksModel.setHorizontalHeaderLabels(
self.noClassRanksLabels + self.labels
)
self.updateRankModel(measuresMask)
self.ranksProxyModel.invalidate()
self.selectMethodChanged()
self.send("Scores", self.create_scores_table(self.labels))
self.setStatusMessage("")
def updateRankModel(self, measuresMask):
"""
Update the rankModel.
"""
values = []
diff = len(self.measure_scores) - len(measuresMask)
if len(measuresMask):
measuresMask += [measuresMask[-1]] * diff
for i in range(self.ranksModel.columnCount() - 1,
len(self.measure_scores), -1):
self.ranksModel.removeColumn(i)
for i, (scores, m) in enumerate(zip(self.measure_scores, measuresMask)):
if not m and self.ranksModel.item(0, i + 1):
values.append([])
continue
values_one = []
for j, _score in enumerate(scores):
values_one.append(_score)
item = self.ranksModel.item(j, i + 1)
if not item:
item = ScoreValueItem()
self.ranksModel.setItem(j, i + 1, item)
item.setData(_score, Qt.DisplayRole)
values.append(values_one)
for i, (vals, m) in enumerate(zip(values, measuresMask)):
if not m:
continue
valid_vals = [v for v in vals if v is not None]
if valid_vals:
vmin, vmax = min(valid_vals), max(valid_vals)
for j, v in enumerate(vals):
if v is not None:
# Set the bar ratio role for i-th measure.
ratio = float((v - vmin) / ((vmax - vmin) or 1))
item = self.ranksModel.item(j, i + 1)
item.setData(ratio, gui.BarRatioRole)
self.ranksView.setColumnWidth(0, 20)
self.ranksView.resizeRowsToContents()
def resetInternals(self):
self.data = None
self.usefulAttributes = []
self.ranksModel.setRowCount(0)
def onSelectItem(self, index):
"""
Called when the user selects/unselects an item in the table view.
"""
self.selectMethod = OWRank.SelectManual # Manual
self.selectButtons.button(self.selectMethod).setChecked(True)
self.commit()
def setSelectMethod(self, method):
if self.selectMethod != method:
self.selectMethod = method
self.selectButtons.button(method).setChecked(True)
self.selectMethodChanged()
def selectMethodChanged(self):
self.autoSelection()
self.ranksView.setFocus()
def nSelectedChanged(self):
self.selectMethod = OWRank.SelectNBest
self.selectButtons.button(self.selectMethod).setChecked(True)
self.selectMethodChanged()
def autoSelection(self):
selModel = self.ranksView.selectionModel()
rowCount = self.ranksModel.rowCount()
columnCount = self.ranksModel.columnCount()
model = self.ranksProxyModel
if self.selectMethod == OWRank.SelectNone:
selection = QItemSelection()
elif self.selectMethod == OWRank.SelectAll:
selection = QItemSelection(
model.index(0, 0),
model.index(rowCount - 1, columnCount - 1)
)
elif self.selectMethod == OWRank.SelectNBest:
nSelected = min(self.nSelected, rowCount)
selection = QItemSelection(
model.index(0, 0),
model.index(nSelected - 1, columnCount - 1)
)
else:
selection = QItemSelection()
if len(self.selected_rows):
selection = QItemSelection()
for row in self.selected_rows:
selection.append(QItemSelectionRange(
model.index(row, 0), model.index(row, columnCount - 1)))
selModel.select(selection, QItemSelectionModel.ClearAndSelect)
def headerClick(self, index):
if index >= 1 and self.selectMethod == OWRank.SelectNBest:
# Reselect the top ranked attributes
self.autoSelection()
# Store the header states
disc = bytes(self.discRanksView.horizontalHeader().saveState())
cont = bytes(self.contRanksView.horizontalHeader().saveState())
no_class = bytes(self.noClassRanksView.horizontalHeader().saveState())
self.headerState = [disc, cont, no_class]
def measuresSelectionChanged(self, measure):
"""Measure selection has changed. Update column visibility.
"""
checked = self.selectedMeasures[measure.name]
self.selectedMeasures[measure.name] = not checked
if not checked:
self.selected_checks.add(measure.name)
elif measure.name in self.selected_checks:
self.selected_checks.remove(measure.name)
measures_mask = [False] * len(self.measures)
measures_mask += [False for _ in self.learners]
# Update scores for shown column if they are not yet computed.
if measure in self.measures and self.measure_scores:
index = self.measures.index(measure)
if all(s is None for s in self.measure_scores[index]):
measures_mask[index] = True
if self.update_scores:
self.updateScores(measures_mask)
self.updateVisibleScoreColumns()
def updateVisibleScoreColumns(self):
"""
Update the visible columns of the scores view.
"""
for i, measure in enumerate(self.measures):
shown = self.selectedMeasures.get(measure.name)
self.ranksView.setColumnHidden(i + 1, not shown)
self.ranksView.setColumnWidth(i + 1, 100)
index = self.ranksView.horizontalHeader().sortIndicatorSection()
if self.ranksView.isColumnHidden(index):
self.headerState[self.rankMode] = None
if self.headerState[self.rankMode] is None:
def get_sort_by_col(measures, selected_measures):
cols = [i + 1 for i, m in enumerate(measures) if
m.name in selected_measures]
return cols[0] if cols else len(measures) + 1
col = get_sort_by_col(self.measures, self.selected_checks)
self.ranksView.sortByColumn(col, Qt.DescendingOrder)
self.autoSelection()
def updateDelegates(self):
self.contRanksView.setItemDelegate(gui.ColoredBarItemDelegate(self))
self.discRanksView.setItemDelegate(gui.ColoredBarItemDelegate(self))
self.noClassRanksView.setItemDelegate(gui.ColoredBarItemDelegate(self))
def send_report(self):
if not self.data:
return
self.report_domain("Input", self.data.domain)
self.report_table("Ranks", self.ranksView, num_format="{:.3f}")
if self.out_domain_desc is not None:
self.report_items("Output", self.out_domain_desc)
def commit(self):
self.selected_rows = self.get_selection()
if self.data and len(self.data.domain.attributes) == len(
self.selected_rows):
self.selectMethod = OWRank.SelectAll
self.selectButtons.button(self.selectMethod).setChecked(True)
selected = self.selectedAttrs()
if not self.data or not selected:
self.send("Reduced Data", None)
self.out_domain_desc = None
else:
data = Table(Domain(selected, self.data.domain.class_var,
self.data.domain.metas), self.data)
self.send("Reduced Data", data)
self.out_domain_desc = report.describe_domain(data.domain)
def selectedAttrs(self):
if self.data:
inds = self.ranksView.selectionModel().selectedRows(0)
source = self.ranksProxyModel.mapToSource
inds = map(source, inds)
inds = [ind.row() for ind in inds]
return [self.data.domain.attributes[i] for i in inds]
else:
return []
def create_scores_table(self, labels):
indices = [i for i, m in enumerate(self.measures)
if self.selectedMeasures.get(m.name, False)]
measures = [s.name for s in self.measures if
self.selectedMeasures.get(s.name, False)]
measures += [label for label in labels]
if not measures:
return None
features = [ContinuousVariable(s) for s in measures]
metas = [StringVariable("Feature name")]
domain = Domain(features, metas=metas)
scores = np.array([row for i, row in enumerate(self.measure_scores)
if i in indices or i >= len(self.measures)]).T
feature_names = np.array([a.name for a in self.data.domain.attributes])
# Reshape to 2d array as Table does not like 1d arrays
feature_names = feature_names[:, None]
new_table = Table(domain, scores, metas=feature_names)
new_table.name = "Feature Scores"
return new_table
@classmethod
def migrate_settings(cls, settings, version):
if not version:
# Before fc5caa1e1d716607f1f5c4e0b0be265c23280fa0
# headerState had length 2
headerState = settings.get("headerState", None)
if headerState is not None and \
isinstance(headerState, tuple) and \
len(headerState) < 3:
headerState = (list(headerState) + [None] * 3)[:3]
settings["headerState"] = headerState
class OWImportImages(widget.OWWidget):
name = "Import Images"
description = "Import images from a directory(s)"
icon = "icons/ImportImages.svg"
priority = 110
outputs = [("Data", Orange.data.Table)]
#: list of recent paths
recent_paths = settings.Setting([]) # type: List[RecentPath]
currentPath = settings.Setting(None)
want_main_area = False
resizing_enabled = False
Modality = Qt.ApplicationModal
# Modality = Qt.WindowModal
MaxRecentItems = 20
def __init__(self):
super().__init__()
#: widget's runtime state
self.__state = State.NoState
self.data = None
self._n_image_categories = 0
self._n_image_data = 0
self._n_skipped = 0
self.__invalidated = False
self.__pendingTask = None
vbox = gui.vBox(self.controlArea)
hbox = gui.hBox(vbox)
self.recent_cb = QComboBox(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=16,
acceptDrops=True)
self.recent_cb.installEventFilter(self)
self.recent_cb.activated[int].connect(self.__onRecentActivated)
icons = standard_icons(self)
browseaction = QAction(
"Open/Load Images",
self,
iconText="\N{HORIZONTAL ELLIPSIS}",
icon=icons.dir_open_icon,
toolTip="Select a directory from which to load the images")
browseaction.triggered.connect(self.__runOpenDialog)
reloadaction = QAction("Reload",
self,
icon=icons.reload_icon,
toolTip="Reload current image set")
reloadaction.triggered.connect(self.reload)
self.__actions = namespace(
browse=browseaction,
reload=reloadaction,
)
browsebutton = QPushButton(browseaction.iconText(),
icon=browseaction.icon(),
toolTip=browseaction.toolTip(),
clicked=browseaction.trigger)
reloadbutton = QPushButton(
reloadaction.iconText(),
icon=reloadaction.icon(),
clicked=reloadaction.trigger,
default=True,
)
hbox.layout().addWidget(self.recent_cb)
hbox.layout().addWidget(browsebutton)
hbox.layout().addWidget(reloadbutton)
self.addActions([browseaction, reloadaction])
reloadaction.changed.connect(
lambda: reloadbutton.setEnabled(reloadaction.isEnabled()))
box = gui.vBox(vbox, "Info")
self.infostack = QStackedWidget()
self.info_area = QLabel(text="No image set selected", wordWrap=True)
self.progress_widget = QProgressBar(minimum=0, maximum=0)
self.cancel_button = QPushButton(
"Cancel",
icon=icons.cancel_icon,
)
self.cancel_button.clicked.connect(self.cancel)
w = QWidget()
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
hlayout = QHBoxLayout()
hlayout.setContentsMargins(0, 0, 0, 0)
hlayout.addWidget(self.progress_widget)
hlayout.addWidget(self.cancel_button)
vlayout.addLayout(hlayout)
self.pathlabel = TextLabel()
self.pathlabel.setTextElideMode(Qt.ElideMiddle)
self.pathlabel.setAttribute(Qt.WA_MacSmallSize)
vlayout.addWidget(self.pathlabel)
w.setLayout(vlayout)
self.infostack.addWidget(self.info_area)
self.infostack.addWidget(w)
box.layout().addWidget(self.infostack)
self.__initRecentItemsModel()
self.__invalidated = True
self.__executor = ThreadExecutor(self)
QApplication.postEvent(self, QEvent(RuntimeEvent.Init))
def __initRecentItemsModel(self):
if self.currentPath is not None and \
not os.path.isdir(self.currentPath):
self.currentPath = None
recent_paths = []
for item in self.recent_paths:
if os.path.isdir(item.abspath):
recent_paths.append(item)
recent_paths = recent_paths[:OWImportImages.MaxRecentItems]
recent_model = self.recent_cb.model()
for pathitem in recent_paths:
item = RecentPath_asqstandarditem(pathitem)
recent_model.appendRow(item)
self.recent_paths = recent_paths
if self.currentPath is not None and \
os.path.isdir(self.currentPath) and self.recent_paths and \
os.path.samefile(self.currentPath, self.recent_paths[0].abspath):
self.recent_cb.setCurrentIndex(0)
else:
self.currentPath = None
self.recent_cb.setCurrentIndex(-1)
self.__actions.reload.setEnabled(self.currentPath is not None)
def customEvent(self, event):
"""Reimplemented."""
if event.type() == RuntimeEvent.Init:
if self.__invalidated:
try:
self.start()
finally:
self.__invalidated = False
super().customEvent(event)
def __runOpenDialog(self):
startdir = os.path.expanduser("~/")
if self.recent_paths:
startdir = os.path.dirname(self.recent_paths[0].abspath)
if OWImportImages.Modality == Qt.WindowModal:
dlg = QFileDialog(
self,
"Select Top Level Directory",
startdir,
acceptMode=QFileDialog.AcceptOpen,
modal=True,
)
dlg.setFileMode(QFileDialog.Directory)
dlg.setOption(QFileDialog.ShowDirsOnly)
dlg.setDirectory(startdir)
dlg.setAttribute(Qt.WA_DeleteOnClose)
@dlg.accepted.connect
def on_accepted():
dirpath = dlg.selectedFiles()
if dirpath:
self.setCurrentPath(dirpath[0])
self.start()
dlg.open()
else:
dirpath = QFileDialog.getExistingDirectory(
self, "Select Top Level Directory", startdir)
if dirpath:
self.setCurrentPath(dirpath)
self.start()
def __onRecentActivated(self, index):
item = self.recent_cb.itemData(index)
if item is None:
return
assert isinstance(item, RecentPath)
self.setCurrentPath(item.abspath)
self.start()
def __updateInfo(self):
if self.__state == State.NoState:
text = "No image set selected"
elif self.__state == State.Processing:
text = "Processing"
elif self.__state == State.Done:
nvalid = self._n_image_data
ncategories = self._n_image_categories
n_skipped = self._n_skipped
if ncategories < 2:
text = "{} image{}".format(nvalid, "s" if nvalid != 1 else "")
else:
text = "{} images / {} categories".format(nvalid, ncategories)
if n_skipped > 0:
text = text + ", {} skipped".format(n_skipped)
elif self.__state == State.Cancelled:
text = "Cancelled"
elif self.__state == State.Error:
text = "Error state"
else:
assert False
self.info_area.setText(text)
if self.__state == State.Processing:
self.infostack.setCurrentIndex(1)
else:
self.infostack.setCurrentIndex(0)
def setCurrentPath(self, path):
"""
Set the current root image path to path
If the path does not exists or is not a directory the current path
is left unchanged
Parameters
----------
path : str
New root import path.
Returns
-------
status : bool
True if the current root import path was successfully
changed to path.
"""
if self.currentPath is not None and path is not None and \
os.path.isdir(self.currentPath) and os.path.isdir(path) and \
os.path.samefile(self.currentPath, path):
return True
success = True
error = None
if path is not None:
if not os.path.exists(path):
error = "'{}' does not exist".format(path)
path = None
success = False
elif not os.path.isdir(path):
error = "'{}' is not a directory".format(path)
path = None
success = False
if error is not None:
self.error(error)
warnings.warn(error, UserWarning, stacklevel=3)
else:
self.error()
if path is not None:
newindex = self.addRecentPath(path)
self.recent_cb.setCurrentIndex(newindex)
if newindex >= 0:
self.currentPath = path
else:
self.currentPath = None
else:
self.currentPath = None
self.__actions.reload.setEnabled(self.currentPath is not None)
if self.__state == State.Processing:
self.cancel()
return success
def addRecentPath(self, path):
"""
Prepend a path entry to the list of recent paths
If an entry with the same path already exists in the recent path
list it is moved to the first place
Parameters
----------
path : str
"""
existing = None
for pathitem in self.recent_paths:
try:
if os.path.samefile(pathitem.abspath, path):
existing = pathitem
break
except FileNotFoundError:
# file not found if the `pathitem.abspath` no longer exists
pass
model = self.recent_cb.model()
if existing is not None:
selected_index = self.recent_paths.index(existing)
assert model.item(selected_index).data(Qt.UserRole) is existing
self.recent_paths.remove(existing)
row = model.takeRow(selected_index)
self.recent_paths.insert(0, existing)
model.insertRow(0, row)
else:
item = RecentPath(path, None, None)
self.recent_paths.insert(0, item)
model.insertRow(0, RecentPath_asqstandarditem(item))
return 0
def __setRuntimeState(self, state):
assert state in State
self.setBlocking(state == State.Processing)
message = ""
if state == State.Processing:
assert self.__state in [
State.Done, State.NoState, State.Error, State.Cancelled
]
message = "Processing"
elif state == State.Done:
assert self.__state == State.Processing
elif state == State.Cancelled:
assert self.__state == State.Processing
message = "Cancelled"
elif state == State.Error:
message = "Error during processing"
elif state == State.NoState:
message = ""
else:
assert False
self.__state = state
if self.__state == State.Processing:
self.infostack.setCurrentIndex(1)
else:
self.infostack.setCurrentIndex(0)
self.setStatusMessage(message)
self.__updateInfo()
def reload(self):
"""
Restart the image scan task
"""
if self.__state == State.Processing:
self.cancel()
self.data = None
self.start()
def start(self):
"""
Start/execute the image indexing operation
"""
self.error()
self.__invalidated = False
if self.currentPath is None:
return
if self.__state == State.Processing:
assert self.__pendingTask is not None
log.info("Starting a new task while one is in progress. "
"Cancel the existing task (dir:'{}')".format(
self.__pendingTask.startdir))
self.cancel()
startdir = self.currentPath
self.__setRuntimeState(State.Processing)
report_progress = methodinvoke(self, "__onReportProgress", (object, ))
task = ImportImages(report_progress=report_progress)
# collect the task state in one convenient place
self.__pendingTask = taskstate = namespace(
task=task,
startdir=startdir,
future=None,
watcher=None,
cancelled=False,
cancel=None,
)
def cancel():
# Cancel the task and disconnect
if taskstate.future.cancel():
pass
else:
taskstate.task.cancelled = True
taskstate.cancelled = True
try:
taskstate.future.result(timeout=3)
except UserInterruptError:
pass
except TimeoutError:
log.info("The task did not stop in in a timely manner")
taskstate.watcher.finished.disconnect(self.__onRunFinished)
taskstate.cancel = cancel
def run_image_scan_task_interupt():
try:
return task(startdir)
except UserInterruptError:
# Suppress interrupt errors, so they are not logged
return
taskstate.future = self.__executor.submit(run_image_scan_task_interupt)
taskstate.watcher = FutureWatcher(taskstate.future)
taskstate.watcher.finished.connect(self.__onRunFinished)
@Slot()
def __onRunFinished(self):
assert QThread.currentThread() is self.thread()
assert self.__state == State.Processing
assert self.__pendingTask is not None
assert self.sender() is self.__pendingTask.watcher
assert self.__pendingTask.future.done()
task = self.__pendingTask
self.__pendingTask = None
try:
data, n_skipped = task.future.result()
except Exception:
sys.excepthook(*sys.exc_info())
state = State.Error
data = None
n_skipped = 0
self.error(traceback.format_exc())
else:
state = State.Done
self.error()
if data:
self._n_image_data = len(data)
self._n_image_categories = len(data.domain.class_var.values)\
if data.domain.class_var else 0
self.data = data
self._n_skipped = n_skipped
self.__setRuntimeState(state)
self.commit()
def cancel(self):
"""
Cancel current pending task (if any).
"""
if self.__state == State.Processing:
assert self.__pendingTask is not None
self.__pendingTask.cancel()
self.__pendingTask = None
self.__setRuntimeState(State.Cancelled)
@Slot(object)
def __onReportProgress(self, arg):
# report on scan progress from a worker thread
# arg must be a namespace(count: int, lastpath: str)
assert QThread.currentThread() is self.thread()
if self.__state == State.Processing:
self.pathlabel.setText(prettyfypath(arg.lastpath))
def commit(self):
"""
Commit a Table from the collected image meta data.
"""
self.send("Data", self.data)
def onDeleteWidget(self):
self.cancel()
self.__executor.shutdown(wait=True)
self.__invalidated = False
def eventFilter(self, receiver, event):
# re-implemented from QWidget
# intercept and process drag drop events on the recent directory
# selection combo box
def dirpath(event):
# type: (QDropEvent) -> Optional[str]
"""Return the directory from a QDropEvent."""
data = event.mimeData()
urls = data.urls()
if len(urls) == 1:
url = urls[0]
path = url.toLocalFile()
if os.path.isdir(path):
return path
return None
if receiver is self.recent_cb and \
event.type() in {QEvent.DragEnter, QEvent.DragMove,
QEvent.Drop}:
assert isinstance(event, QDropEvent)
path = dirpath(event)
if path is not None and event.possibleActions() & Qt.LinkAction:
event.setDropAction(Qt.LinkAction)
event.accept()
if event.type() == QEvent.Drop:
self.setCurrentPath(path)
self.start()
else:
event.ignore()
return True
return super().eventFilter(receiver, event)
class OWImportImages(widget.OWWidget):
name = "Import Images"
description = "Import images from a directory(s)"
icon = "icons/ImportImages.svg"
priority = 110
outputs = [("Data", Orange.data.Table)]
#: list of recent paths
recent_paths = settings.Setting([]) # type: List[RecentPath]
want_main_area = False
resizing_enabled = False
Modality = Qt.ApplicationModal
# Modality = Qt.WindowModal
MaxRecentItems = 20
def __init__(self):
super().__init__()
#: widget's runtime state
self.__state = State.NoState
self.data = None
self._n_image_categories = 0
self._n_image_data = 0
self._n_skipped = 0
self.__invalidated = False
self.__pendingTask = None
vbox = gui.vBox(self.controlArea)
hbox = gui.hBox(vbox)
self.recent_cb = QComboBox(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=16,
acceptDrops=True
)
self.recent_cb.installEventFilter(self)
self.recent_cb.activated[int].connect(self.__onRecentActivated)
icons = standard_icons(self)
browseaction = QAction(
"Open/Load Images", self,
iconText="\N{HORIZONTAL ELLIPSIS}",
icon=icons.dir_open_icon,
toolTip="Select a directory from which to load the images"
)
browseaction.triggered.connect(self.__runOpenDialog)
reloadaction = QAction(
"Reload", self,
icon=icons.reload_icon,
toolTip="Reload current image set"
)
reloadaction.triggered.connect(self.reload)
self.__actions = namespace(
browse=browseaction,
reload=reloadaction,
)
browsebutton = QPushButton(
browseaction.iconText(),
icon=browseaction.icon(),
toolTip=browseaction.toolTip(),
clicked=browseaction.trigger
)
reloadbutton = QPushButton(
reloadaction.iconText(),
icon=reloadaction.icon(),
clicked=reloadaction.trigger,
default=True,
)
hbox.layout().addWidget(self.recent_cb)
hbox.layout().addWidget(browsebutton)
hbox.layout().addWidget(reloadbutton)
self.addActions([browseaction, reloadaction])
reloadaction.changed.connect(
lambda: reloadbutton.setEnabled(reloadaction.isEnabled())
)
box = gui.vBox(vbox, "Info")
self.infostack = QStackedWidget()
self.info_area = QLabel(
text="No image set selected",
wordWrap=True
)
self.progress_widget = QProgressBar(
minimum=0, maximum=0
)
self.cancel_button = QPushButton(
"Cancel", icon=icons.cancel_icon,
)
self.cancel_button.clicked.connect(self.cancel)
w = QWidget()
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
hlayout = QHBoxLayout()
hlayout.setContentsMargins(0, 0, 0, 0)
hlayout.addWidget(self.progress_widget)
hlayout.addWidget(self.cancel_button)
vlayout.addLayout(hlayout)
self.pathlabel = TextLabel()
self.pathlabel.setTextElideMode(Qt.ElideMiddle)
self.pathlabel.setAttribute(Qt.WA_MacSmallSize)
vlayout.addWidget(self.pathlabel)
w.setLayout(vlayout)
self.infostack.addWidget(self.info_area)
self.infostack.addWidget(w)
box.layout().addWidget(self.infostack)
self.__initRecentItemsModel()
self.__invalidated = True
self.__executor = ThreadExecutor(self)
QApplication.postEvent(self, QEvent(RuntimeEvent.Init))
def __initRecentItemsModel(self):
self._relocate_recent_files()
recent_paths = []
for item in self.recent_paths:
recent_paths.append(item)
recent_paths = recent_paths[:OWImportImages.MaxRecentItems]
recent_model = self.recent_cb.model()
recent_model.clear()
for pathitem in recent_paths:
item = RecentPath_asqstandarditem(pathitem)
recent_model.appendRow(item)
self.recent_paths = recent_paths
if self.recent_paths and os.path.isdir(self.recent_paths[0].abspath):
self.recent_cb.setCurrentIndex(0)
self.__actions.reload.setEnabled(True)
else:
self.recent_cb.setCurrentIndex(-1)
self.__actions.reload.setEnabled(False)
def customEvent(self, event):
"""Reimplemented."""
if event.type() == RuntimeEvent.Init:
if self.__invalidated:
try:
self.start()
finally:
self.__invalidated = False
super().customEvent(event)
def __runOpenDialog(self):
startdir = os.path.expanduser("~/")
if self.recent_paths:
startdir = os.path.dirname(self.recent_paths[0].abspath)
if OWImportImages.Modality == Qt.WindowModal:
dlg = QFileDialog(
self, "Select Top Level Directory", startdir,
acceptMode=QFileDialog.AcceptOpen,
modal=True,
)
dlg.setFileMode(QFileDialog.Directory)
dlg.setOption(QFileDialog.ShowDirsOnly)
dlg.setDirectory(startdir)
dlg.setAttribute(Qt.WA_DeleteOnClose)
@dlg.accepted.connect
def on_accepted():
dirpath = dlg.selectedFiles()
if dirpath:
self.setCurrentPath(dirpath[0])
self.start()
dlg.open()
else:
dirpath = QFileDialog.getExistingDirectory(
self, "Select Top Level Directory", startdir
)
if dirpath:
self.setCurrentPath(dirpath)
self.start()
def __onRecentActivated(self, index):
item = self.recent_cb.itemData(index)
if item is None:
return
assert isinstance(item, RecentPath)
self.setCurrentPath(item.abspath)
self.start()
def __updateInfo(self):
if self.__state == State.NoState:
text = "No image set selected"
elif self.__state == State.Processing:
text = "Processing"
elif self.__state == State.Done:
nvalid = self._n_image_data
ncategories = self._n_image_categories
n_skipped = self._n_skipped
if ncategories < 2:
text = "{} image{}".format(nvalid, "s" if nvalid != 1 else "")
else:
text = "{} images / {} categories".format(nvalid, ncategories)
if n_skipped > 0:
text = text + ", {} skipped".format(n_skipped)
elif self.__state == State.Cancelled:
text = "Cancelled"
elif self.__state == State.Error:
text = "Error state"
else:
assert False
self.info_area.setText(text)
if self.__state == State.Processing:
self.infostack.setCurrentIndex(1)
else:
self.infostack.setCurrentIndex(0)
def setCurrentPath(self, path):
"""
Set the current root image path to path
If the path does not exists or is not a directory the current path
is left unchanged
Parameters
----------
path : str
New root import path.
Returns
-------
status : bool
True if the current root import path was successfully
changed to path.
"""
if self.recent_paths and path is not None and \
os.path.isdir(self.recent_paths[0].abspath) and os.path.isdir(path) \
and os.path.samefile(os.path.isdir(self.recent_paths[0].abspath), path):
return True
success = True
error = None
if path is not None:
if not os.path.exists(path):
error = "'{}' does not exist".format(path)
path = None
success = False
elif not os.path.isdir(path):
error = "'{}' is not a directory".format(path)
path = None
success = False
if error is not None:
self.error(error)
warnings.warn(error, UserWarning, stacklevel=3)
else:
self.error()
if path is not None:
newindex = self.addRecentPath(path)
self.recent_cb.setCurrentIndex(newindex)
self.__actions.reload.setEnabled(len(self.recent_paths) > 0)
if self.__state == State.Processing:
self.cancel()
return success
def _search_paths(self):
basedir = self.workflowEnv().get("basedir", None)
if basedir is None:
return []
return [("basedir", basedir)]
def addRecentPath(self, path):
"""
Prepend a path entry to the list of recent paths
If an entry with the same path already exists in the recent path
list it is moved to the first place
Parameters
----------
path : str
"""
existing = None
for pathitem in self.recent_paths:
try:
if os.path.samefile(pathitem.abspath, path):
existing = pathitem
break
except FileNotFoundError:
# file not found if the `pathitem.abspath` no longer exists
pass
model = self.recent_cb.model()
if existing is not None:
selected_index = self.recent_paths.index(existing)
assert model.item(selected_index).data(Qt.UserRole) is existing
self.recent_paths.remove(existing)
row = model.takeRow(selected_index)
self.recent_paths.insert(0, existing)
model.insertRow(0, row)
else:
item = RecentPath.create(path, self._search_paths())
self.recent_paths.insert(0, item)
model.insertRow(0, RecentPath_asqstandarditem(item))
return 0
def __setRuntimeState(self, state):
assert state in State
self.setBlocking(state == State.Processing)
message = ""
if state == State.Processing:
assert self.__state in [State.Done,
State.NoState,
State.Error,
State.Cancelled]
message = "Processing"
elif state == State.Done:
assert self.__state == State.Processing
elif state == State.Cancelled:
assert self.__state == State.Processing
message = "Cancelled"
elif state == State.Error:
message = "Error during processing"
elif state == State.NoState:
message = ""
else:
assert False
self.__state = state
if self.__state == State.Processing:
self.infostack.setCurrentIndex(1)
else:
self.infostack.setCurrentIndex(0)
self.setStatusMessage(message)
self.__updateInfo()
def reload(self):
"""
Restart the image scan task
"""
if self.__state == State.Processing:
self.cancel()
self.data = None
self.start()
def start(self):
"""
Start/execute the image indexing operation
"""
self.error()
self.__invalidated = False
if not self.recent_paths:
return
if self.__state == State.Processing:
assert self.__pendingTask is not None
log.info("Starting a new task while one is in progress. "
"Cancel the existing task (dir:'{}')"
.format(self.__pendingTask.startdir))
self.cancel()
startdir = self.recent_paths[0].abspath
self.__setRuntimeState(State.Processing)
report_progress = methodinvoke(
self, "__onReportProgress", (object,))
task = ImportImages(report_progress=report_progress)
# collect the task state in one convenient place
self.__pendingTask = taskstate = namespace(
task=task,
startdir=startdir,
future=None,
watcher=None,
cancelled=False,
cancel=None,
)
def cancel():
# Cancel the task and disconnect
if taskstate.future.cancel():
pass
else:
taskstate.task.cancelled = True
taskstate.cancelled = True
try:
taskstate.future.result(timeout=3)
except UserInterruptError:
pass
except TimeoutError:
log.info("The task did not stop in in a timely manner")
taskstate.watcher.finished.disconnect(self.__onRunFinished)
taskstate.cancel = cancel
def run_image_scan_task_interupt():
try:
return task(startdir)
except UserInterruptError:
# Suppress interrupt errors, so they are not logged
return
taskstate.future = self.__executor.submit(run_image_scan_task_interupt)
taskstate.watcher = FutureWatcher(taskstate.future)
taskstate.watcher.finished.connect(self.__onRunFinished)
@Slot()
def __onRunFinished(self):
assert QThread.currentThread() is self.thread()
assert self.__state == State.Processing
assert self.__pendingTask is not None
assert self.sender() is self.__pendingTask.watcher
assert self.__pendingTask.future.done()
task = self.__pendingTask
self.__pendingTask = None
try:
data, n_skipped = task.future.result()
except Exception:
sys.excepthook(*sys.exc_info())
state = State.Error
data = None
n_skipped = 0
self.error(traceback.format_exc())
else:
state = State.Done
self.error()
if data:
self._n_image_data = len(data)
self._n_image_categories = len(data.domain.class_var.values)\
if data.domain.class_var else 0
else:
self._n_image_data, self._n_image_categories = 0, 0
self.data = data
self._n_skipped = n_skipped
self.__setRuntimeState(state)
self.commit()
def cancel(self):
"""
Cancel current pending task (if any).
"""
if self.__state == State.Processing:
assert self.__pendingTask is not None
self.__pendingTask.cancel()
self.__pendingTask = None
self.__setRuntimeState(State.Cancelled)
@Slot(object)
def __onReportProgress(self, arg):
# report on scan progress from a worker thread
# arg must be a namespace(count: int, lastpath: str)
assert QThread.currentThread() is self.thread()
if self.__state == State.Processing:
self.pathlabel.setText(prettyfypath(arg.lastpath))
def commit(self):
"""
Commit a Table from the collected image meta data.
"""
self.send("Data", self.data)
def onDeleteWidget(self):
self.cancel()
self.__executor.shutdown(wait=True)
self.__invalidated = False
def eventFilter(self, receiver, event):
# re-implemented from QWidget
# intercept and process drag drop events on the recent directory
# selection combo box
def dirpath(event):
# type: (QDropEvent) -> Optional[str]
"""Return the directory from a QDropEvent."""
data = event.mimeData()
urls = data.urls()
if len(urls) == 1:
url = urls[0]
path = url.toLocalFile()
if path.endswith("/"):
path = path[:-1] # remove last /
if os.path.isdir(path):
return path
return None
if receiver is self.recent_cb and \
event.type() in {QEvent.DragEnter, QEvent.DragMove,
QEvent.Drop}:
assert isinstance(event, QDropEvent)
path = dirpath(event)
if path is not None and event.possibleActions() & Qt.LinkAction:
event.setDropAction(Qt.LinkAction)
event.accept()
if event.type() == QEvent.Drop:
self.setCurrentPath(path)
self.start()
else:
event.ignore()
return True
return super().eventFilter(receiver, event)
def _relocate_recent_files(self):
search_paths = self._search_paths()
rec = []
for recent in self.recent_paths:
kwargs = dict(
title=recent.title, sheet=recent.sheet,
file_format=recent.file_format)
resolved = recent.resolve(search_paths)
if resolved is not None:
rec.append(
RecentPath.create(resolved.abspath, search_paths, **kwargs))
else:
rec.append(recent)
# change the list in-place for the case the widgets wraps this list
self.recent_paths[:] = rec
def workflowEnvChanged(self, key, value, oldvalue):
"""
Function called when environment changes (e.g. while saving the scheme)
It make sure that all environment connected values are modified
(e.g. relative file paths are changed)
"""
self.__initRecentItemsModel()
class PagedWidget(QFrame):
class Page(SimpleNamespace):
icon = ... # type: QIcon
text = ... # type: str
toolTip = ... # type: str
widget = ... # type: QWidget
class TabView(LinearIconView):
def __init__(self, *args, focusPolicy=Qt.TabFocus, **kwargs):
super().__init__(*args, focusPolicy=focusPolicy, **kwargs)
def viewOptions(self):
# type: () -> QStyleOptionViewItem
option = super().viewOptions()
# by default items in views are active only if the view is focused
if self.isActiveWindow():
option.state |= QStyle.State_Active
return option
def selectionCommand(self, index, event=None):
# type: (QModelIndex, QEvent) -> QItemSelectionModel.SelectionFlags
command = super().selectionCommand(index, event)
if not index.isValid():
# Prevent deselection on click/drag in an empty view part
return QItemSelectionModel.NoUpdate
else:
# Prevent deselect on click + ctrl modifier
return command & ~QItemSelectionModel.Deselect
class TabViewDelegate(QStyledItemDelegate):
def sizeHint(self, option, index):
# type: (QStyleOptionViewItem, QModelIndex) -> QSize
sh = super().sizeHint(option, index)
widget = option.widget
if isinstance(widget, PagedWidget.TabView):
if widget.flow() == QListView.TopToBottom:
return sh.expandedTo(QSize(82, 100))
else:
return sh.expandedTo(QSize(100, 82))
else:
return sh
def initStyleOption(self, option, index):
# type: (QStyleOptionViewItem, QModelIndex) -> None
super().initStyleOption(option, index)
widget = option.widget
if isinstance(widget, PagedWidget.TabView):
# extend the item rect to cover the whole viewport
# (probably not a good idea).
if widget.flow() == QListView.TopToBottom:
option.rect.setLeft(0)
option.rect.setRight(widget.viewport().width())
else:
option.rect.setTop(0)
option.rect.setBottom(widget.viewport().height())
if option.state & QStyle.State_Selected:
# make sure the selection highlights cover the whole area
option.showDecorationSelected = True
#: Signal emitted when the current displayed widget changes
currentIndexChanged = Signal(int)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__pages = [] # type: List[PagedWidget.Page]
self.__currentIndex = -1
self.setContentsMargins(0, 0, 0, 0)
self.setLayout(QHBoxLayout())
self.layout().setContentsMargins(0, 0, 0, 0)
self.layout().setSpacing(0)
self.__tabview = PagedWidget.TabView(
viewMode=QListView.IconMode,
flow=QListView.TopToBottom,
editTriggers=QListView.NoEditTriggers,
uniformItemSizes=True,
horizontalScrollBarPolicy=Qt.ScrollBarAlwaysOff)
self.__tabview.setAttribute(Qt.WA_LayoutUsesWidgetRect)
self.__tabview.setContentsMargins(0, 0, 0, 0)
self.__tabview.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.__tabview.setItemDelegate(PagedWidget.TabViewDelegate())
self.__tabview.setModel(QStandardItemModel(self))
self.__tabview.selectionModel().selectionChanged.connect(
self.__on_activated, Qt.UniqueConnection)
iconsize = self.style().pixelMetric(QStyle.PM_LargeIconSize) * 3 // 2
self.__tabview.setIconSize(QSize(iconsize, iconsize))
self.__tabview.setAttribute(Qt.WA_MacShowFocusRect, False)
self.__stack = QStackedWidget(objectName="contents")
self.__stack.setContentsMargins(0, 0, 0, 0)
self.__stack.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.layout().addWidget(self.__tabview)
self.layout().addWidget(self.__stack)
def currentIndex(self):
# type: () -> int
return self.__currentIndex
def setCurrentIndex(self, index):
# type: (int) -> None
assert index < self.count()
if self.__currentIndex != index:
self.__currentIndex = index
if index < 0:
self.__tabview.selectionModel().clearSelection()
else:
self.__tabview.selectionModel().select(
self.__tabview.model().index(index, 0),
QItemSelectionModel.ClearAndSelect)
self.__stack.setCurrentIndex(index)
self.currentIndexChanged.emit(index)
def count(self):
# type: () -> int
return len(self.__pages)
def addPage(self, icon, text, widget):
# type: (QIcon, str, QWidget) -> int
return self.insertPage(len(self.__pages), icon, text, widget)
def insertPage(self, index, icon, text, widget):
# type: (int, QIcon, str, QWidget) -> int
if not 0 <= index < self.count():
index = self.count()
page = PagedWidget.Page(icon=QIcon(icon),
text=text,
toolTip="",
widget=widget)
item = QStandardItem()
item.setIcon(icon)
item.setText(text)
self.__pages.insert(index, page)
self.__tabview.model().insertRow(index, item)
self.__stack.insertWidget(index, page.widget)
if len(self.__pages) == 1:
self.setCurrentIndex(0)
elif index <= self.__currentIndex:
self.__currentIndex += 1
return index
def removePage(self, index):
# type: (int) -> None
if 0 <= index < len(self.__pages):
page = self.__pages[index]
model = self.__tabview.model() # type: QStandardItemModel
currentIndex = self.__currentIndex
if index < currentIndex:
newCurrent = currentIndex - 1
else:
newCurrent = currentIndex
selmodel = self.__tabview.selectionModel()
selmodel.selectionChanged.disconnect(self.__on_activated)
model.removeRow(index)
del self.__pages[index]
self.__stack.removeWidget(page.widget)
selmodel.selectionChanged.connect(self.__on_activated,
Qt.UniqueConnection)
self.setCurrentIndex(newCurrent)
def widget(self, index):
# type: (int) -> QWidget
return self.__pages[index].widget
def setPageEnabled(self, index, enabled):
# type: (int, bool) -> None
item = self.__tabview.model().item(index) # type: QStandardItem
if item is not None:
flags = item.flags()
if enabled:
flags = flags | Qt.ItemIsEnabled | Qt.ItemIsSelectable
else:
flags = flags & ~(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setFlags(flags)
def isPageEnabled(self, index):
# type: (int) -> bool
item = self.__tabview.model().item(index)
return bool(item.flags() & Qt.ItemIsEnabled)
def setPageToolTip(self, index, toolTip):
# type: (int, str) -> None
if 0 <= index < self.count():
model = self.__tabview.model() # type: QStandardItemModel
item = model.item(index, 0)
item.setToolTip(toolTip)
def pageToolTip(self, index):
model = self.__tabview.model() # type: QStandardItemModel
return model.item(index, 0).toolTip()
def __on_activated(self, selected, deselected):
indexes = selected.indexes()
if len(indexes) == 1:
self.setCurrentIndex(indexes[0].row())
elif len(indexes) == 0:
self.setCurrentIndex(-1)
else:
assert False, "Invalid selection mode"
class OWImportDocuments(widget.OWWidget):
name = "Import Documents"
description = "Import text documents from folders."
icon = "icons/ImportDocuments.svg"
priority = 110
class Outputs:
data = Output("Corpus", Corpus)
skipped_documents = Output("Skipped documents", Table)
LOCAL_FILE, URL = range(2)
source = settings.Setting(LOCAL_FILE)
#: list of recent paths
recent_paths: List[RecentPath] = settings.Setting([])
currentPath: Optional[str] = settings.Setting(None)
recent_urls: List[str] = settings.Setting([])
want_main_area = False
resizing_enabled = False
Modality = Qt.ApplicationModal
MaxRecentItems = 20
class Warning(widget.OWWidget.Warning):
read_error = widget.Msg("{} couldn't be read.")
def __init__(self):
super().__init__()
#: widget's runtime state
self.__state = State.NoState
self.corpus = None
self.n_text_categories = 0
self.n_text_data = 0
self.skipped_documents = []
self.__invalidated = False
self.__pendingTask = None
layout = QGridLayout()
layout.setSpacing(4)
gui.widgetBox(self.controlArea, orientation=layout, box='Source')
source_box = gui.radioButtons(None, self, "source", box=True,
callback=self.start, addToLayout=False)
rb_button = gui.appendRadioButton(source_box, "Folder:",
addToLayout=False)
layout.addWidget(rb_button, 0, 0, Qt.AlignVCenter)
box = gui.hBox(None, addToLayout=False, margin=0)
box.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
self.recent_cb = QComboBox(
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon,
minimumContentsLength=16,
acceptDrops=True
)
self.recent_cb.installEventFilter(self)
self.recent_cb.activated[int].connect(self.__onRecentActivated)
browseaction = QAction(
"Open/Load Documents", self,
iconText="\N{HORIZONTAL ELLIPSIS}",
icon=self.style().standardIcon(QStyle.SP_DirOpenIcon),
toolTip="Select a folder from which to load the documents"
)
browseaction.triggered.connect(self.__runOpenDialog)
reloadaction = QAction(
"Reload", self,
icon=self.style().standardIcon(QStyle.SP_BrowserReload),
toolTip="Reload current document set"
)
reloadaction.triggered.connect(self.reload)
self.__actions = namespace(
browse=browseaction,
reload=reloadaction,
)
browsebutton = QPushButton(
browseaction.iconText(),
icon=browseaction.icon(),
toolTip=browseaction.toolTip(),
clicked=browseaction.trigger,
default=False,
autoDefault=False,
)
reloadbutton = QPushButton(
reloadaction.iconText(),
icon=reloadaction.icon(),
clicked=reloadaction.trigger,
default=False,
autoDefault=False,
)
box.layout().addWidget(self.recent_cb)
layout.addWidget(box, 0, 1)
layout.addWidget(browsebutton, 0, 2)
layout.addWidget(reloadbutton, 0, 3)
rb_button = gui.appendRadioButton(source_box, "URL:", addToLayout=False)
layout.addWidget(rb_button, 3, 0, Qt.AlignVCenter)
self.url_combo = url_combo = QComboBox()
url_model = PyListModel()
url_model.wrap(self.recent_urls)
url_combo.setLineEdit(LineEditSelectOnFocus())
url_combo.setModel(url_model)
url_combo.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed)
url_combo.setEditable(True)
url_combo.setInsertPolicy(url_combo.InsertAtTop)
url_edit = url_combo.lineEdit()
l, t, r, b = url_edit.getTextMargins()
url_edit.setTextMargins(l + 5, t, r, b)
layout.addWidget(url_combo, 3, 1, 1, 3)
url_combo.activated.connect(self._url_set)
# whit completer we set that combo box is case sensitive when
# matching the history
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseSensitive)
url_combo.setCompleter(completer)
self.addActions([browseaction, reloadaction])
reloadaction.changed.connect(
lambda: reloadbutton.setEnabled(reloadaction.isEnabled())
)
box = gui.vBox(self.controlArea, "Info")
self.infostack = QStackedWidget()
self.info_area = QLabel(
text="No document set selected",
wordWrap=True
)
self.progress_widget = QProgressBar(
minimum=0, maximum=100
)
self.cancel_button = QPushButton(
"Cancel",
icon=self.style().standardIcon(QStyle.SP_DialogCancelButton),
default=False,
autoDefault=False,
)
self.cancel_button.clicked.connect(self.cancel)
w = QWidget()
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
hlayout = QHBoxLayout()
hlayout.setContentsMargins(0, 0, 0, 0)
hlayout.addWidget(self.progress_widget)
hlayout.addWidget(self.cancel_button)
vlayout.addLayout(hlayout)
self.pathlabel = TextLabel()
self.pathlabel.setTextElideMode(Qt.ElideMiddle)
self.pathlabel.setAttribute(Qt.WA_MacSmallSize)
vlayout.addWidget(self.pathlabel)
w.setLayout(vlayout)
self.infostack.addWidget(self.info_area)
self.infostack.addWidget(w)
box.layout().addWidget(self.infostack)
self.__initRecentItemsModel()
self.__invalidated = True
self.__executor = ThreadExecutor(self)
QApplication.postEvent(self, QEvent(RuntimeEvent.Init))
def _url_set(self):
url = self.url_combo.currentText()
pos = self.recent_urls.index(url)
url = url.strip()
if not urlparse(url).scheme:
url = "http://" + url
self.url_combo.setItemText(pos, url)
self.recent_urls[pos] = url
self.source = self.URL
self.start()
def __initRecentItemsModel(self):
if self.currentPath is not None and \
not os.path.isdir(self.currentPath):
self.currentPath = None
recent_paths = []
for item in self.recent_paths:
if os.path.isdir(item.abspath):
recent_paths.append(item)
recent_paths = recent_paths[:OWImportDocuments.MaxRecentItems]
recent_model = self.recent_cb.model()
for pathitem in recent_paths:
item = RecentPath_asqstandarditem(pathitem)
recent_model.appendRow(item)
self.recent_paths = recent_paths
if self.currentPath is not None and \
os.path.isdir(self.currentPath) and self.recent_paths and \
os.path.samefile(self.currentPath, self.recent_paths[0].abspath):
self.recent_cb.setCurrentIndex(0)
else:
self.currentPath = None
self.recent_cb.setCurrentIndex(-1)
self.__actions.reload.setEnabled(self.currentPath is not None)
def customEvent(self, event):
"""Reimplemented."""
if event.type() == RuntimeEvent.Init:
if self.__invalidated:
try:
self.start()
finally:
self.__invalidated = False
super().customEvent(event)
def __runOpenDialog(self):
startdir = os.path.expanduser("~/")
if self.recent_paths:
startdir = os.path.dirname(self.recent_paths[0].abspath)
caption = "Select Top Level Folder"
if OWImportDocuments.Modality == Qt.WindowModal:
dlg = QFileDialog(
self, caption, startdir,
acceptMode=QFileDialog.AcceptOpen,
modal=True,
)
dlg.setFileMode(QFileDialog.Directory)
dlg.setOption(QFileDialog.ShowDirsOnly)
dlg.setDirectory(startdir)
dlg.setAttribute(Qt.WA_DeleteOnClose)
@dlg.accepted.connect
def on_accepted():
dirpath = dlg.selectedFiles()
if dirpath:
self.setCurrentPath(dirpath[0])
self.start()
dlg.open()
else:
dirpath = QFileDialog.getExistingDirectory(
self, caption, startdir
)
if dirpath:
self.setCurrentPath(dirpath)
self.start()
def __onRecentActivated(self, index):
item = self.recent_cb.itemData(index)
if item is None:
return
assert isinstance(item, RecentPath)
self.setCurrentPath(item.abspath)
self.start()
def __updateInfo(self):
if self.__state == State.NoState:
text = "No document set selected"
elif self.__state == State.Processing:
text = "Processing"
elif self.__state == State.Done:
nvalid = self.n_text_data
ncategories = self.n_text_categories
n_skipped = len(self.skipped_documents)
if ncategories < 2:
text = "{} document{}".format(nvalid, "s" if nvalid != 1 else "")
else:
text = "{} documents / {} categories".format(nvalid, ncategories)
if n_skipped > 0:
text = text + ", {} skipped".format(n_skipped)
elif self.__state == State.Cancelled:
text = "Cancelled"
elif self.__state == State.Error:
text = "Error state"
else:
assert False
self.info_area.setText(text)
if self.__state == State.Processing:
self.infostack.setCurrentIndex(1)
else:
self.infostack.setCurrentIndex(0)
def setCurrentPath(self, path):
"""
Set the current root text path to path
If the path does not exists or is not a directory the current path
is left unchanged
Parameters
----------
path : str
New root import path.
Returns
-------
status : bool
True if the current root import path was successfully
changed to path.
"""
if self.currentPath is not None and path is not None and \
os.path.isdir(self.currentPath) and os.path.isdir(path) and \
os.path.samefile(self.currentPath, path) and \
self.source == self.LOCAL_FILE:
return True
success = True
error = None
if path is not None:
if not os.path.exists(path):
error = "'{}' does not exist".format(path)
path = None
success = False
elif not os.path.isdir(path):
error = "'{}' is not a folder".format(path)
path = None
success = False
if error is not None:
self.error(error)
warnings.warn(error, UserWarning, stacklevel=3)
else:
self.error()
if path is not None:
newindex = self.addRecentPath(path)
self.recent_cb.setCurrentIndex(newindex)
if newindex >= 0:
self.currentPath = path
else:
self.currentPath = None
else:
self.currentPath = None
self.__actions.reload.setEnabled(self.currentPath is not None)
if self.__state == State.Processing:
self.cancel()
self.source = self.LOCAL_FILE
return success
def addRecentPath(self, path):
"""
Prepend a path entry to the list of recent paths
If an entry with the same path already exists in the recent path
list it is moved to the first place
Parameters
----------
path : str
"""
existing = None
for pathitem in self.recent_paths:
try:
if os.path.samefile(pathitem.abspath, path):
existing = pathitem
break
except FileNotFoundError:
# file not found if the `pathitem.abspath` no longer exists
pass
model = self.recent_cb.model()
if existing is not None:
selected_index = self.recent_paths.index(existing)
assert model.item(selected_index).data(Qt.UserRole) is existing
self.recent_paths.remove(existing)
row = model.takeRow(selected_index)
self.recent_paths.insert(0, existing)
model.insertRow(0, row)
else:
item = RecentPath(path, None, None)
self.recent_paths.insert(0, item)
model.insertRow(0, RecentPath_asqstandarditem(item))
return 0
def __setRuntimeState(self, state):
assert state in State
self.setBlocking(state == State.Processing)
message = ""
if state == State.Processing:
assert self.__state in [State.Done,
State.NoState,
State.Error,
State.Cancelled]
message = "Processing"
elif state == State.Done:
assert self.__state == State.Processing
elif state == State.Cancelled:
assert self.__state == State.Processing
message = "Cancelled"
elif state == State.Error:
message = "Error during processing"
elif state == State.NoState:
message = ""
else:
assert False
self.__state = state
if self.__state == State.Processing:
self.infostack.setCurrentIndex(1)
else:
self.infostack.setCurrentIndex(0)
self.setStatusMessage(message)
self.__updateInfo()
def reload(self):
"""
Restart the text scan task
"""
if self.__state == State.Processing:
self.cancel()
self.source = self.LOCAL_FILE
self.corpus = None
self.start()
def start(self):
"""
Start/execute the text indexing operation
"""
self.error()
self.Warning.clear()
self.progress_widget.setValue(0)
self.__invalidated = False
startdir = self.currentPath if self.source == self.LOCAL_FILE \
else self.url_combo.currentText().strip()
if not startdir:
return
if self.__state == State.Processing:
assert self.__pendingTask is not None
log.info("Starting a new task while one is in progress. "
"Cancel the existing task (dir:'{}')"
.format(self.__pendingTask.startdir))
self.cancel()
self.__setRuntimeState(State.Processing)
report_progress = methodinvoke(
self, "__onReportProgress", (object,))
task = ImportDocuments(startdir, self.source == self.URL,
report_progress=report_progress)
# collect the task state in one convenient place
self.__pendingTask = taskstate = namespace(
task=task,
startdir=startdir,
future=None,
watcher=None,
cancelled=False,
cancel=None,
)
def cancel():
# Cancel the task and disconnect
if taskstate.future.cancel():
pass
else:
taskstate.task.cancelled = True
taskstate.cancelled = True
try:
taskstate.future.result(timeout=0)
except UserInterruptError:
pass
except TimeoutError:
log.info("The task did not stop in in a timely manner")
taskstate.watcher.finished.disconnect(self.__onRunFinished)
taskstate.cancel = cancel
def run_text_scan_task_interupt():
try:
return task.run()
except UserInterruptError:
# Suppress interrupt errors, so they are not logged
return
taskstate.future = self.__executor.submit(run_text_scan_task_interupt)
taskstate.watcher = FutureWatcher(taskstate.future)
taskstate.watcher.finished.connect(self.__onRunFinished)
@Slot()
def __onRunFinished(self):
assert QThread.currentThread() is self.thread()
assert self.__state == State.Processing
assert self.__pendingTask is not None
assert self.sender() is self.__pendingTask.watcher
assert self.__pendingTask.future.done()
task = self.__pendingTask
self.__pendingTask = None
corpus, errors = None, []
try:
corpus, errors = task.future.result()
except NoDocumentsException:
state = State.Error
self.error("Folder contains no readable files.")
except Exception:
sys.excepthook(*sys.exc_info())
state = State.Error
self.error(traceback.format_exc())
else:
state = State.Done
self.error()
if corpus:
self.n_text_data = len(corpus)
self.n_text_categories = len(corpus.domain.class_var.values)\
if corpus.domain.class_var else 0
self.corpus = corpus
if self.corpus:
self.corpus.name = "Documents"
self.skipped_documents = errors
if len(errors):
self.Warning.read_error(
"Some files" if len(errors) > 1 else "One file"
)
self.__setRuntimeState(state)
self.commit()
def cancel(self):
"""
Cancel current pending task (if any).
"""
if self.__state == State.Processing:
assert self.__pendingTask is not None
self.__pendingTask.cancel()
self.__pendingTask = None
self.__setRuntimeState(State.Cancelled)
@Slot(object)
def __onReportProgress(self, arg):
# report on scan progress from a worker thread
# arg must be a namespace(count: int, lastpath: str)
assert QThread.currentThread() is self.thread()
if self.__state == State.Processing:
self.pathlabel.setText(prettifypath(arg.lastpath))
self.progress_widget.setValue(int(100 * arg.progress))
def commit(self):
"""
Create and commit a Corpus from the collected text meta data.
"""
self.Outputs.data.send(self.corpus)
if self.skipped_documents:
skipped_table = (
Table.from_list(
SKIPPED_DOMAIN,
[[x, os.path.join(self.currentPath, x)]
for x in self.skipped_documents]
)
)
skipped_table.name = "Skipped documents"
else:
skipped_table = None
self.Outputs.skipped_documents.send(skipped_table)
def onDeleteWidget(self):
self.cancel()
self.__executor.shutdown(wait=True)
self.__invalidated = False
def eventFilter(self, receiver, event):
# re-implemented from QWidget
# intercept and process drag drop events on the recent directory
# selection combo box
def dirpath(event):
# type: (QDropEvent) -> Optional[str]
"""Return the directory from a QDropEvent."""
data = event.mimeData()
urls = data.urls()
if len(urls) == 1:
url = urls[0]
path = url.toLocalFile()
if os.path.isdir(path):
return path
return None
if receiver is self.recent_cb and \
event.type() in {QEvent.DragEnter, QEvent.DragMove,
QEvent.Drop}:
assert isinstance(event, QDropEvent)
path = dirpath(event)
if path is not None and event.possibleActions() & Qt.LinkAction:
event.setDropAction(Qt.LinkAction)
event.accept()
if event.type() == QEvent.Drop:
self.setCurrentPath(path)
self.start()
else:
event.ignore()
return True
return super().eventFilter(receiver, event)
def send_report(self):
if not self.currentPath:
return
items = [('Path', self.currentPath),
('Number of documents', self.n_text_data)]
if self.n_text_categories:
items += [('Categories', self.n_text_categories)]
if self.skipped_documents:
items += [('Number of skipped', len(self.skipped_documents))]
self.report_items(items, )
