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))
class OWFeatureConstructor(OWWidget):
name = "Feature Constructor"
description = "Construct new features (data columns) from a set of " \
"existing features in the input data set."
icon = "icons/FeatureConstructor.svg"
inputs = [("Data", Orange.data.Table, "setData")]
outputs = [("Data", Orange.data.Table)]
want_main_area = False
settingsHandler = FeatureConstructorSettingsHandler()
descriptors = ContextSetting([])
currentIndex = ContextSetting(-1)
EDITORS = [
(ContinuousDescriptor, ContinuousFeatureEditor),
(DiscreteDescriptor, DiscreteFeatureEditor),
(StringDescriptor, StringFeatureEditor)
]
class Error(OWWidget.Error):
more_values_needed = Msg("Discrete feature {} needs more values.")
invalid_expressions = Msg("Invalid expressions: {}.")
def __init__(self):
super().__init__()
self.data = None
self.editors = {}
box = gui.vBox(self.controlArea, "Variable Definitions")
toplayout = QHBoxLayout()
toplayout.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(toplayout)
self.editorstack = QStackedWidget(
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
)
for descclass, editorclass in self.EDITORS:
editor = editorclass()
editor.featureChanged.connect(self._on_modified)
self.editors[descclass] = editor
self.editorstack.addWidget(editor)
self.editorstack.setEnabled(False)
buttonlayout = QVBoxLayout(spacing=10)
buttonlayout.setContentsMargins(0, 0, 0, 0)
self.addbutton = QPushButton(
"New", toolTip="Create a new variable",
minimumWidth=120,
shortcut=QKeySequence.New
)
def unique_name(fmt, reserved):
candidates = (fmt.format(i) for i in count(1))
return next(c for c in candidates if c not in reserved)
def reserved_names():
varnames = []
if self.data is not None:
varnames = [var.name for var in
self.data.domain.variables + self.data.domain.metas]
varnames += [desc.name for desc in self.featuremodel]
return set(varnames)
def generate_newname(fmt):
return unique_name(fmt, reserved_names())
menu = QMenu(self.addbutton)
cont = menu.addAction("Continuous")
cont.triggered.connect(
lambda: self.addFeature(
ContinuousDescriptor(generate_newname("X{}"), "", 3))
)
disc = menu.addAction("Discrete")
disc.triggered.connect(
lambda: self.addFeature(
DiscreteDescriptor(generate_newname("D{}"), "",
("A", "B"), -1, False))
)
string = menu.addAction("String")
string.triggered.connect(
lambda: self.addFeature(
StringDescriptor(generate_newname("S{}"), ""))
)
menu.addSeparator()
self.duplicateaction = menu.addAction("Duplicate Selected Variable")
self.duplicateaction.triggered.connect(self.duplicateFeature)
self.duplicateaction.setEnabled(False)
self.addbutton.setMenu(menu)
self.removebutton = QPushButton(
"Remove", toolTip="Remove selected variable",
minimumWidth=120,
shortcut=QKeySequence.Delete
)
self.removebutton.clicked.connect(self.removeSelectedFeature)
buttonlayout.addWidget(self.addbutton)
buttonlayout.addWidget(self.removebutton)
buttonlayout.addStretch(10)
toplayout.addLayout(buttonlayout, 0)
toplayout.addWidget(self.editorstack, 10)
# Layout for the list view
layout = QVBoxLayout(spacing=1, margin=0)
self.featuremodel = DescriptorModel(parent=self)
self.featureview = QListView(
minimumWidth=200,
sizePolicy=QSizePolicy(QSizePolicy.Minimum,
QSizePolicy.MinimumExpanding)
)
self.featureview.setItemDelegate(FeatureItemDelegate(self))
self.featureview.setModel(self.featuremodel)
self.featureview.selectionModel().selectionChanged.connect(
self._on_selectedVariableChanged
)
layout.addWidget(self.featureview)
box.layout().addLayout(layout, 1)
box = gui.hBox(self.controlArea)
box.layout().addWidget(self.report_button)
self.report_button.setMinimumWidth(180)
gui.rubber(box)
commit = gui.button(box, self, "Send", callback=self.apply,
default=True)
commit.setMinimumWidth(180)
def setCurrentIndex(self, index):
index = min(index, len(self.featuremodel) - 1)
self.currentIndex = index
if index >= 0:
itemmodels.select_row(self.featureview, index)
desc = self.featuremodel[min(index, len(self.featuremodel) - 1)]
editor = self.editors[type(desc)]
self.editorstack.setCurrentWidget(editor)
editor.setEditorData(desc, self.data.domain if self.data else None)
self.editorstack.setEnabled(index >= 0)
self.duplicateaction.setEnabled(index >= 0)
self.removebutton.setEnabled(index >= 0)
def _on_selectedVariableChanged(self, selected, *_):
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
else:
self.setCurrentIndex(-1)
def _on_modified(self):
if self.currentIndex >= 0:
editor = self.editorstack.currentWidget()
self.featuremodel[self.currentIndex] = editor.editorData()
self.descriptors = list(self.featuremodel)
def setDescriptors(self, descriptors):
"""
Set a list of variable descriptors to edit.
"""
self.descriptors = descriptors
self.featuremodel[:] = list(self.descriptors)
@check_sql_input
def setData(self, data=None):
"""Set the input dataset."""
self.closeContext()
self.data = data
if self.data is not None:
descriptors = list(self.descriptors)
currindex = self.currentIndex
self.descriptors = []
self.currentIndex = -1
self.openContext(data)
if descriptors != self.descriptors or \
self.currentIndex != currindex:
# disconnect from the selection model while reseting the model
selmodel = self.featureview.selectionModel()
selmodel.selectionChanged.disconnect(
self._on_selectedVariableChanged)
self.featuremodel[:] = list(self.descriptors)
self.setCurrentIndex(self.currentIndex)
selmodel.selectionChanged.connect(
self._on_selectedVariableChanged)
self.editorstack.setEnabled(self.currentIndex >= 0)
def handleNewSignals(self):
if self.data is not None:
self.apply()
else:
self.send("Data", None)
def addFeature(self, descriptor):
self.featuremodel.append(descriptor)
self.setCurrentIndex(len(self.featuremodel) - 1)
editor = self.editorstack.currentWidget()
editor.nameedit.setFocus()
editor.nameedit.selectAll()
def removeFeature(self, index):
del self.featuremodel[index]
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
elif index is None and len(self.featuremodel) > 0:
# Deleting the last item clears selection
self.setCurrentIndex(len(self.featuremodel) - 1)
def removeSelectedFeature(self):
if self.currentIndex >= 0:
self.removeFeature(self.currentIndex)
def duplicateFeature(self):
desc = self.featuremodel[self.currentIndex]
self.addFeature(copy.deepcopy(desc))
def check_attrs_values(self, attr, data):
for i in range(len(data)):
for var in attr:
if not math.isnan(data[i, var]) \
and int(data[i, var]) >= len(var.values):
return var.name
return None
def _validate_descriptors(self, desc):
def validate(source):
try:
return validate_exp(ast.parse(source, mode="eval"))
except Exception:
return False
final = []
invalid = []
for d in desc:
if validate(d.expression):
final.append(d)
else:
final.append(d._replace(expression=""))
invalid.append(d)
if invalid:
self.Error.invalid_expressions(", ".join(s.name for s in invalid))
return final
def apply(self):
self.Error.clear()
if self.data is None:
return
desc = list(self.featuremodel)
desc = self._validate_descriptors(desc)
source_vars = tuple(self.data.domain) + self.data.domain.metas
new_variables = construct_variables(desc, source_vars)
attrs = [var for var in new_variables if var.is_primitive()]
metas = [var for var in new_variables if not var.is_primitive()]
new_domain = Orange.data.Domain(
self.data.domain.attributes + tuple(attrs),
self.data.domain.class_vars,
metas=self.data.domain.metas + tuple(metas)
)
try:
data = Orange.data.Table(new_domain, self.data)
except Exception as err:
log = logging.getLogger(__name__)
log.error("", exc_info=True)
self.error("".join(format_exception_only(type(err), err)).rstrip())
return
disc_attrs_not_ok = self.check_attrs_values(
[var for var in attrs if var.is_discrete], data)
if disc_attrs_not_ok:
self.Error.more_values_needed(disc_attrs_not_ok)
return
self.send("Data", data)
def send_report(self):
items = OrderedDict()
for feature in self.featuremodel:
if isinstance(feature, DiscreteDescriptor):
items[feature.name] = "{} (discrete with values {}{})".format(
feature.expression, feature.values,
"; ordered" * feature.ordered)
elif isinstance(feature, ContinuousDescriptor):
items[feature.name] = "{} (numeric)".format(feature.expression)
else:
items[feature.name] = "{} (text)".format(feature.expression)
self.report_items(
report.plural("Constructed feature{s}", len(items)), items)
class OWFeatureConstructor(OWWidget):
name = "Feature Constructor"
description = "Construct new features (data columns) from a set of " \
"existing features in the input data set."
icon = "icons/FeatureConstructor.svg"
class Inputs:
data = Input("Data", Orange.data.Table)
class Outputs:
data = Output("Data", Orange.data.Table)
want_main_area = False
settingsHandler = FeatureConstructorHandler()
descriptors = ContextSetting([])
currentIndex = ContextSetting(-1)
EDITORS = [
(ContinuousDescriptor, ContinuousFeatureEditor),
(DiscreteDescriptor, DiscreteFeatureEditor),
(StringDescriptor, StringFeatureEditor)
]
class Error(OWWidget.Error):
more_values_needed = Msg("Categorical feature {} needs more values.")
invalid_expressions = Msg("Invalid expressions: {}.")
def __init__(self):
super().__init__()
self.data = None
self.editors = {}
box = gui.vBox(self.controlArea, "Variable Definitions")
toplayout = QHBoxLayout()
toplayout.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(toplayout)
self.editorstack = QStackedWidget(
sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
)
for descclass, editorclass in self.EDITORS:
editor = editorclass()
editor.featureChanged.connect(self._on_modified)
self.editors[descclass] = editor
self.editorstack.addWidget(editor)
self.editorstack.setEnabled(False)
buttonlayout = QVBoxLayout(spacing=10)
buttonlayout.setContentsMargins(0, 0, 0, 0)
self.addbutton = QPushButton(
"New", toolTip="Create a new variable",
minimumWidth=120,
shortcut=QKeySequence.New
)
def unique_name(fmt, reserved):
candidates = (fmt.format(i) for i in count(1))
return next(c for c in candidates if c not in reserved)
def reserved_names():
varnames = []
if self.data is not None:
varnames = [var.name for var in
self.data.domain.variables + self.data.domain.metas]
varnames += [desc.name for desc in self.featuremodel]
return set(varnames)
def generate_newname(fmt):
return unique_name(fmt, reserved_names())
menu = QMenu(self.addbutton)
cont = menu.addAction("Numeric")
cont.triggered.connect(
lambda: self.addFeature(
ContinuousDescriptor(generate_newname("X{}"), "", 3))
)
disc = menu.addAction("Categorical")
disc.triggered.connect(
lambda: self.addFeature(
DiscreteDescriptor(generate_newname("D{}"), "",
("A", "B"), -1, False))
)
string = menu.addAction("Text")
string.triggered.connect(
lambda: self.addFeature(
StringDescriptor(generate_newname("S{}"), ""))
)
menu.addSeparator()
self.duplicateaction = menu.addAction("Duplicate Selected Variable")
self.duplicateaction.triggered.connect(self.duplicateFeature)
self.duplicateaction.setEnabled(False)
self.addbutton.setMenu(menu)
self.removebutton = QPushButton(
"Remove", toolTip="Remove selected variable",
minimumWidth=120,
shortcut=QKeySequence.Delete
)
self.removebutton.clicked.connect(self.removeSelectedFeature)
buttonlayout.addWidget(self.addbutton)
buttonlayout.addWidget(self.removebutton)
buttonlayout.addStretch(10)
toplayout.addLayout(buttonlayout, 0)
toplayout.addWidget(self.editorstack, 10)
# Layout for the list view
layout = QVBoxLayout(spacing=1, margin=0)
self.featuremodel = DescriptorModel(parent=self)
self.featureview = QListView(
minimumWidth=200,
sizePolicy=QSizePolicy(QSizePolicy.Minimum,
QSizePolicy.MinimumExpanding)
)
self.featureview.setItemDelegate(FeatureItemDelegate(self))
self.featureview.setModel(self.featuremodel)
self.featureview.selectionModel().selectionChanged.connect(
self._on_selectedVariableChanged
)
layout.addWidget(self.featureview)
box.layout().addLayout(layout, 1)
box = gui.hBox(self.controlArea)
gui.rubber(box)
commit = gui.button(box, self, "Send", callback=self.apply,
default=True)
commit.setMinimumWidth(180)
def setCurrentIndex(self, index):
index = min(index, len(self.featuremodel) - 1)
self.currentIndex = index
if index >= 0:
itemmodels.select_row(self.featureview, index)
desc = self.featuremodel[min(index, len(self.featuremodel) - 1)]
editor = self.editors[type(desc)]
self.editorstack.setCurrentWidget(editor)
editor.setEditorData(desc, self.data.domain if self.data else None)
self.editorstack.setEnabled(index >= 0)
self.duplicateaction.setEnabled(index >= 0)
self.removebutton.setEnabled(index >= 0)
def _on_selectedVariableChanged(self, selected, *_):
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
else:
self.setCurrentIndex(-1)
def _on_modified(self):
if self.currentIndex >= 0:
editor = self.editorstack.currentWidget()
self.featuremodel[self.currentIndex] = editor.editorData()
self.descriptors = list(self.featuremodel)
def setDescriptors(self, descriptors):
"""
Set a list of variable descriptors to edit.
"""
self.descriptors = descriptors
self.featuremodel[:] = list(self.descriptors)
@Inputs.data
@check_sql_input
def setData(self, data=None):
"""Set the input dataset."""
self.closeContext()
self.data = data
if self.data is not None:
descriptors = list(self.descriptors)
currindex = self.currentIndex
self.descriptors = []
self.currentIndex = -1
self.openContext(data)
if descriptors != self.descriptors or \
self.currentIndex != currindex:
# disconnect from the selection model while reseting the model
selmodel = self.featureview.selectionModel()
selmodel.selectionChanged.disconnect(
self._on_selectedVariableChanged)
self.featuremodel[:] = list(self.descriptors)
self.setCurrentIndex(self.currentIndex)
selmodel.selectionChanged.connect(
self._on_selectedVariableChanged)
self.editorstack.setEnabled(self.currentIndex >= 0)
def handleNewSignals(self):
if self.data is not None:
self.apply()
else:
self.Outputs.data.send(None)
def addFeature(self, descriptor):
self.featuremodel.append(descriptor)
self.setCurrentIndex(len(self.featuremodel) - 1)
editor = self.editorstack.currentWidget()
editor.nameedit.setFocus()
editor.nameedit.selectAll()
def removeFeature(self, index):
del self.featuremodel[index]
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
elif index is None and len(self.featuremodel) > 0:
# Deleting the last item clears selection
self.setCurrentIndex(len(self.featuremodel) - 1)
def removeSelectedFeature(self):
if self.currentIndex >= 0:
self.removeFeature(self.currentIndex)
def duplicateFeature(self):
desc = self.featuremodel[self.currentIndex]
self.addFeature(copy.deepcopy(desc))
def check_attrs_values(self, attr, data):
for i in range(len(data)):
for var in attr:
if not math.isnan(data[i, var]) \
and int(data[i, var]) >= len(var.values):
return var.name
return None
def _validate_descriptors(self, desc):
def validate(source):
try:
return validate_exp(ast.parse(source, mode="eval"))
except Exception:
return False
final = []
invalid = []
for d in desc:
if validate(d.expression):
final.append(d)
else:
final.append(d._replace(expression=""))
invalid.append(d)
if invalid:
self.Error.invalid_expressions(", ".join(s.name for s in invalid))
return final
def apply(self):
self.Error.clear()
if self.data is None:
return
desc = list(self.featuremodel)
desc = self._validate_descriptors(desc)
source_vars = self.data.domain.variables + self.data.domain.metas
new_variables = construct_variables(desc, source_vars)
attrs = [var for var in new_variables if var.is_primitive()]
metas = [var for var in new_variables if not var.is_primitive()]
new_domain = Orange.data.Domain(
self.data.domain.attributes + tuple(attrs),
self.data.domain.class_vars,
metas=self.data.domain.metas + tuple(metas)
)
try:
data = self.data.transform(new_domain)
except Exception as err:
log = logging.getLogger(__name__)
log.error("", exc_info=True)
self.error("".join(format_exception_only(type(err), err)).rstrip())
return
disc_attrs_not_ok = self.check_attrs_values(
[var for var in attrs if var.is_discrete], data)
if disc_attrs_not_ok:
self.Error.more_values_needed(disc_attrs_not_ok)
return
self.Outputs.data.send(data)
def send_report(self):
items = OrderedDict()
for feature in self.featuremodel:
if isinstance(feature, DiscreteDescriptor):
items[feature.name] = "{} (categorical with values {}{})".format(
feature.expression, feature.values,
"; ordered" * feature.ordered)
elif isinstance(feature, ContinuousDescriptor):
items[feature.name] = "{} (numeric)".format(feature.expression)
else:
items[feature.name] = "{} (text)".format(feature.expression)
self.report_items(
report.plural("Constructed feature{s}", len(items)), items)
class OWSplitInstancesWidget(OWWidget):
"""
Widget for splitting instances.
If we have dataset with "quantity" column we can multiply that row
number of times it is present fo r example:
Name | product | quantity
John | icecream | 3
Lisa | pie | 2
Will be transformed to:
Name | product
John | icecream
John | icecream
John | icecream
Lisa | pie
Lisa | pie
"""
# Widget's name as displayed in the canvas
name = "Split instances"
# Short widget description
description = "Lets the user input a number"
# An icon resource file path for this widget
# (a path relative to the module where this widget is defined)
icon = "../img/icon.svg"
category = "Data"
class Inputs:
"""Input fields definition"""
data = Input("Data", Table)
class Outputs:
"""Output fields definition"""
data = Output("Data", Table)
def __init__(self):
self.data = None
# List of all features (model for ComboBox)
self.features = itemmodels.VariableListModel(
["Select Feature"], parent=self)
box = gui.vBox(self.controlArea, "Select ")
self.features_widget = QComboBox(
self.controlArea,
minimumContentsLength=16,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLengthWithIcon,
sizePolicy=QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
)
self.features_widget.setModel(self.features)
self.features_widget.currentIndexChanged.connect(self.feature_changed)
self.button = QPushButton("Split")
self.button.clicked.connect(self.split)
self.button.setEnabled(False)
box.layout().addWidget(self.features_widget)
box.layout().addWidget(self.button)
@Inputs.data
def set_data(self, data: Table):
"""
Handler for input data
:param data: Input Orange Table
:return: None
"""
self.data = data
self.features[:] = ["Select Feature"]
if self.data \
and self.data.domain is not None \
and not self.data.domain.empty():
self.features[:] += [
var for var in self.data.domain.variables
if self.is_integer_col(var)
] # only integer columns may be quantity columns
def selected_col(self)->Optional(str):
"""
Get selected feature value
:return: Selected feature name r None if Nothing selected
"""
index = self.features_widget.currentIndex()
if index < 1:
return None
return self.features[index]
def feature_changed(self):
"""
Handler for changed selected feature value in ComboBox
:return: None
"""
if self.selected_col():
self.button.setEnabled(True)
else:
self.button.setEnabled(False)
def handleNewSignals(self):
if self.data is None:
self.Outputs.data.send(None)
else:
self.feature_changed()
def split(self):
"""
Function for splitting provided data
:return: None
"""
col = self.selected_col().name
# all columns except quantity
without_count_col = tuple(
var for var in self.data.domain.variables
if var.name != col
)
# domain without quantit column
new_domain = Domain(
without_count_col,
self.data.domain.class_vars,
self.data.domain.metas
)
res = Table.from_domain(
new_domain
)
for row in self.data:
res.append(Instance(new_domain, row))
rows_added = 1
if not np.isnan(row[col]):
while rows_added < row[col]:
res.append(Instance(new_domain, row))
rows_added += 1
self.Outputs.data.send(res)
def is_integer_col(self, name: str)->bool:
"""
Check if provided column is integer
:param name: column name
:return: is column integer or not
"""
if not isinstance(self.data.domain[name], ContinuousVariable):
return False
return all([
np.isnan(row[name]) # we count NaN columns as qty 1
or np.equal(np.mod(row[name], 1), 0) # check that column is integer
for row in self.data
])
class OWImpute(OWWidget):
name = "Impute"
description = "Impute missing values in the data table."
icon = "icons/Impute.svg"
priority = 2130
keywords = ["substitute", "missing"]
class Inputs:
data = Input("Data", Orange.data.Table)
learner = Input("Learner", Learner)
class Outputs:
data = Output("Data", Orange.data.Table)
class Error(OWWidget.Error):
imputation_failed = Msg("Imputation failed for '{}'")
model_based_imputer_sparse = \
Msg("Model based imputer does not work for sparse data")
class Warning(OWWidget.Warning):
cant_handle_var = Msg("Default method can not handle '{}'")
settingsHandler = settings.DomainContextHandler()
_default_method_index = settings.Setting(int(Method.Leave)) # type: int
# Per-variable imputation state (synced in storeSpecificSettings)
_variable_imputation_state = settings.ContextSetting(
{}) # type: VariableState
autocommit = settings.Setting(True)
default_numeric = settings.Setting("")
default_time = settings.Setting(0)
want_main_area = False
resizing_enabled = False
def __init__(self):
super().__init__()
self.data = None # type: Optional[Orange.data.Table]
self.learner = None # type: Optional[Learner]
self.default_learner = SimpleTreeLearner(min_instances=10,
max_depth=10)
self.modified = False
self.executor = qconcurrent.ThreadExecutor(self)
self.__task = None
main_layout = QVBoxLayout()
main_layout.setContentsMargins(10, 10, 10, 10)
self.controlArea.layout().addLayout(main_layout)
box = gui.vBox(None, "Default Method")
main_layout.addWidget(box)
box_layout = QGridLayout()
box_layout.setSpacing(8)
box.layout().addLayout(box_layout)
button_group = QButtonGroup()
button_group.buttonClicked[int].connect(self.set_default_method)
for i, (method, _) in enumerate(list(METHODS.items())[1:-1]):
imputer = self.create_imputer(method)
button = QRadioButton(imputer.name)
button.setChecked(method == self.default_method_index)
button_group.addButton(button, method)
box_layout.addWidget(button, i % 3, i // 3)
def set_default_time(datetime):
datetime = datetime.toSecsSinceEpoch()
if datetime != self.default_time:
self.default_time = datetime
if self.default_method_index == Method.Default:
self._invalidate()
hlayout = QHBoxLayout()
box.layout().addLayout(hlayout)
button = QRadioButton("Fixed values; numeric variables:")
button_group.addButton(button, Method.Default)
button.setChecked(Method.Default == self.default_method_index)
hlayout.addWidget(button)
locale = QLocale()
locale.setNumberOptions(locale.NumberOption.RejectGroupSeparator)
validator = QDoubleValidator()
validator.setLocale(locale)
self.numeric_value_widget = le = gui.lineEdit(
None,
self,
"default_numeric",
validator=validator,
alignment=Qt.AlignRight,
callback=self._invalidate,
enabled=self.default_method_index == Method.Default)
hlayout.addWidget(le)
hlayout.addWidget(QLabel(", time:"))
self.time_widget = gui.DateTimeEditWCalendarTime(self)
self.time_widget.setEnabled(
self.default_method_index == Method.Default)
self.time_widget.setKeyboardTracking(False)
self.time_widget.setContentsMargins(0, 0, 0, 0)
self.time_widget.set_datetime(
QDateTime.fromSecsSinceEpoch(self.default_time))
self.connect_control(
"default_time", lambda value: self.time_widget.set_datetime(
QDateTime.fromSecsSinceEpoch(value)))
self.time_widget.dateTimeChanged.connect(set_default_time)
hlayout.addWidget(self.time_widget)
self.default_button_group = button_group
box = QGroupBox(title=self.tr("Individual Attribute Settings"),
flat=False)
main_layout.addWidget(box)
horizontal_layout = QHBoxLayout(box)
main_layout.addWidget(box)
self.varview = ListViewSearch(
selectionMode=QListView.ExtendedSelection, uniformItemSizes=True)
self.varview.setItemDelegate(DisplayFormatDelegate())
self.varmodel = itemmodels.VariableListModel()
self.varview.setModel(self.varmodel)
self.varview.selectionModel().selectionChanged.connect(
self._on_var_selection_changed)
self.selection = self.varview.selectionModel()
horizontal_layout.addWidget(self.varview)
vertical_layout = QVBoxLayout(margin=0)
self.methods_container = QWidget(enabled=False)
method_layout = QVBoxLayout(margin=0)
self.methods_container.setLayout(method_layout)
button_group = QButtonGroup()
for method in Method:
imputer = self.create_imputer(method)
button = QRadioButton(text=imputer.name)
button_group.addButton(button, method)
method_layout.addWidget(button)
self.value_combo = QComboBox(
minimumContentsLength=8,
sizeAdjustPolicy=QComboBox.AdjustToMinimumContentsLength,
activated=self._on_value_selected)
self.value_double = QDoubleSpinBox(
editingFinished=self._on_value_selected,
minimum=-1000.,
maximum=1000.,
singleStep=.1,
decimals=3,
)
self.value_stack = value_stack = QStackedWidget()
value_stack.addWidget(self.value_combo)
value_stack.addWidget(self.value_double)
method_layout.addWidget(value_stack)
button_group.buttonClicked[int].connect(
self.set_method_for_current_selection)
self.reset_button = QPushButton(
"Restore All to Default",
enabled=False,
default=False,
autoDefault=False,
clicked=self.reset_variable_state,
)
vertical_layout.addWidget(self.methods_container)
vertical_layout.addStretch(2)
vertical_layout.addWidget(self.reset_button)
horizontal_layout.addLayout(vertical_layout)
self.variable_button_group = button_group
box = gui.auto_apply(self.controlArea, self, "autocommit")
box.button.setFixedWidth(180)
box.layout().insertStretch(0)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
def create_imputer(self, method, *args):
# type: (Method, ...) -> impute.BaseImputeMethod
if method == Method.Model:
if self.learner is not None:
return impute.Model(self.learner)
else:
return impute.Model(self.default_learner)
elif method == Method.AsAboveSoBelow:
assert self.default_method_index != Method.AsAboveSoBelow
default = self.create_imputer(Method(self.default_method_index))
m = AsDefault()
m.method = default
return m
elif method == Method.Default and not args: # global default values
if self.default_numeric == "":
default_num = np.nan
else:
default_num, ok = QLocale().toDouble(self.default_numeric)
if not ok:
default_num = np.nan
return impute.FixedValueByType(default_continuous=default_num,
default_time=self.default_time
or np.nan)
else:
return METHODS[method](*args)
@property
def default_method_index(self):
return self._default_method_index
@default_method_index.setter
def default_method_index(self, index):
if self._default_method_index != index:
assert index != Method.AsAboveSoBelow
self._default_method_index = index
self.default_button_group.button(index).setChecked(True)
self.time_widget.setEnabled(index == Method.Default)
self.numeric_value_widget.setEnabled(index == Method.Default)
# update variable view
self.update_varview()
self._invalidate()
def set_default_method(self, index):
"""Set the current selected default imputation method.
"""
self.default_method_index = index
@Inputs.data
@check_sql_input
def set_data(self, data):
self.cancel()
self.closeContext()
self.varmodel[:] = []
self._variable_imputation_state = {} # type: VariableState
self.modified = False
self.data = data
if data is not None:
self.varmodel[:] = data.domain.variables
self.openContext(data.domain)
# restore per variable imputation state
self._restore_state(self._variable_imputation_state)
self.reset_button.setEnabled(len(self.varmodel) > 0)
summary = len(data) if data else self.info.NoInput
details = format_summary_details(data) if data else ""
self.info.set_input_summary(summary, details)
self.update_varview()
self.unconditional_commit()
@Inputs.learner
def set_learner(self, learner):
self.cancel()
self.learner = learner or self.default_learner
imputer = self.create_imputer(Method.Model)
button = self.default_button_group.button(Method.Model)
button.setText(imputer.name)
variable_button = self.variable_button_group.button(Method.Model)
variable_button.setText(imputer.name)
if learner is not None:
self.default_method_index = Method.Model
self.update_varview()
self.commit()
def get_method_for_column(self, column_index):
# type: (int) -> impute.BaseImputeMethod
"""
Return the imputation method for column by its index.
"""
assert 0 <= column_index < len(self.varmodel)
idx = self.varmodel.index(column_index, 0)
state = idx.data(StateRole)
if state is None:
state = (Method.AsAboveSoBelow, ())
return self.create_imputer(state[0], *state[1])
def _invalidate(self):
self.modified = True
if self.__task is not None:
self.cancel()
self.commit()
def commit(self):
self.cancel()
self.warning()
self.Error.imputation_failed.clear()
self.Error.model_based_imputer_sparse.clear()
summary = len(self.data) if self.data else self.info.NoOutput
detail = format_summary_details(self.data) if self.data else ""
self.info.set_output_summary(summary, detail)
if not self.data or not self.varmodel.rowCount():
self.Outputs.data.send(self.data)
self.modified = False
return
data = self.data
impute_state = [(i, var, self.get_method_for_column(i))
for i, var in enumerate(self.varmodel)]
# normalize to the effective method bypasing AsDefault
impute_state = [(i, var, m.method if isinstance(m, AsDefault) else m)
for i, var, m in impute_state]
def impute_one(method, var, data):
# type: (impute.BaseImputeMethod, Variable, Table) -> Any
# Readability counts, pylint: disable=no-else-raise
if isinstance(method, impute.Model) and data.is_sparse():
raise SparseNotSupported()
elif isinstance(method, impute.DropInstances):
return RowMask(method(data, var))
elif not method.supports_variable(var):
raise VariableNotSupported(var)
else:
return method(data, var)
futures = []
for _, var, method in impute_state:
f = self.executor.submit(impute_one, copy.deepcopy(method), var,
data)
futures.append(f)
w = qconcurrent.FutureSetWatcher(futures)
w.doneAll.connect(self.__commit_finish)
w.progressChanged.connect(self.__progress_changed)
self.__task = Task(futures, w)
self.progressBarInit()
self.setInvalidated(True)
@Slot()
def __commit_finish(self):
assert QThread.currentThread() is self.thread()
assert self.__task is not None
futures = self.__task.futures
assert len(futures) == len(self.varmodel)
assert self.data is not None
def get_variable(variable, future, drop_mask) \
-> Optional[List[Orange.data.Variable]]:
# Returns a (potentially empty) list of variables,
# or None on failure that should interrupt the imputation
assert future.done()
try:
res = future.result()
except SparseNotSupported:
self.Error.model_based_imputer_sparse()
return [] # None?
except VariableNotSupported:
self.Warning.cant_handle_var(variable.name)
return []
except Exception: # pylint: disable=broad-except
log = logging.getLogger(__name__)
log.info("Error for %s", variable.name, exc_info=True)
self.Error.imputation_failed(variable.name)
return None
if isinstance(res, RowMask):
drop_mask |= res.mask
newvar = variable
else:
newvar = res
if isinstance(newvar, Orange.data.Variable):
newvar = [newvar]
return newvar
def create_data(attributes, class_vars):
domain = Orange.data.Domain(attributes, class_vars,
self.data.domain.metas)
try:
return self.data.from_table(domain, self.data[~drop_mask])
except Exception: # pylint: disable=broad-except
log = logging.getLogger(__name__)
log.info("Error", exc_info=True)
self.Error.imputation_failed("Unknown")
return None
self.__task = None
self.setInvalidated(False)
self.progressBarFinished()
attributes = []
class_vars = []
drop_mask = np.zeros(len(self.data), bool)
for i, (var, fut) in enumerate(zip(self.varmodel, futures)):
newvar = get_variable(var, fut, drop_mask)
if newvar is None:
data = None
break
if i < len(self.data.domain.attributes):
attributes.extend(newvar)
else:
class_vars.extend(newvar)
else:
data = create_data(attributes, class_vars)
self.Outputs.data.send(data)
self.modified = False
summary = len(data) if data else self.info.NoOutput
details = format_summary_details(data) if data else ""
self.info.set_output_summary(summary, details)
@Slot(int, int)
def __progress_changed(self, n, d):
assert QThread.currentThread() is self.thread()
assert self.__task is not None
self.progressBarSet(100. * n / d)
def cancel(self):
self.__cancel(wait=False)
def __cancel(self, wait=False):
if self.__task is not None:
task, self.__task = self.__task, None
task.cancel()
task.watcher.doneAll.disconnect(self.__commit_finish)
task.watcher.progressChanged.disconnect(self.__progress_changed)
if wait:
concurrent.futures.wait(task.futures)
task.watcher.flush()
self.progressBarFinished()
self.setInvalidated(False)
def onDeleteWidget(self):
self.__cancel(wait=True)
super().onDeleteWidget()
def send_report(self):
specific = []
for i, var in enumerate(self.varmodel):
method = self.get_method_for_column(i)
if not isinstance(method, AsDefault):
specific.append("{} ({})".format(var.name, str(method)))
default = self.create_imputer(Method.AsAboveSoBelow)
if specific:
self.report_items((("Default method", default.name),
("Specific imputers", ", ".join(specific))))
else:
self.report_items((("Method", default.name), ))
def _on_var_selection_changed(self):
# Method is well documented, splitting it is not needed for readability,
# thus pylint: disable=too-many-branches
indexes = self.selection.selectedIndexes()
self.methods_container.setEnabled(len(indexes) > 0)
defmethod = (Method.AsAboveSoBelow, ())
methods = [index.data(StateRole) for index in indexes]
methods = [m if m is not None else defmethod for m in methods]
methods = set(methods)
selected_vars = [self.varmodel[index.row()] for index in indexes]
has_discrete = any(var.is_discrete for var in selected_vars)
fixed_value = None
value_stack_enabled = False
current_value_widget = None
if len(methods) == 1:
method_type, parameters = methods.pop()
for m in Method:
if method_type == m:
self.variable_button_group.button(m).setChecked(True)
if method_type == Method.Default:
(fixed_value, ) = parameters
elif self.variable_button_group.checkedButton() is not None:
# Uncheck the current button
self.variable_button_group.setExclusive(False)
self.variable_button_group.checkedButton().setChecked(False)
self.variable_button_group.setExclusive(True)
assert self.variable_button_group.checkedButton() is None
# Update variable methods GUI enabled state based on selection.
for method in Method:
# use a default constructed imputer to query support
imputer = self.create_imputer(method)
enabled = all(
imputer.supports_variable(var) for var in selected_vars)
button = self.variable_button_group.button(method)
button.setEnabled(enabled)
# Update the "Value" edit GUI.
if not has_discrete:
# no discrete variables -> allow mass edit for all (continuous vars)
value_stack_enabled = True
current_value_widget = self.value_double
elif len(selected_vars) == 1:
# single discrete var -> enable and fill the values combo
value_stack_enabled = True
current_value_widget = self.value_combo
self.value_combo.clear()
self.value_combo.addItems(selected_vars[0].values)
else:
# mixed type selection -> disable
value_stack_enabled = False
current_value_widget = None
self.variable_button_group.button(Method.Default).setEnabled(False)
self.value_stack.setEnabled(value_stack_enabled)
if current_value_widget is not None:
self.value_stack.setCurrentWidget(current_value_widget)
if fixed_value is not None:
# set current value
if current_value_widget is self.value_combo:
self.value_combo.setCurrentIndex(fixed_value)
elif current_value_widget is self.value_double:
self.value_double.setValue(fixed_value)
else:
assert False
def set_method_for_current_selection(self, method_index):
# type: (Method) -> None
indexes = self.selection.selectedIndexes()
self.set_method_for_indexes(indexes, method_index)
def set_method_for_indexes(self, indexes, method_index):
# type: (List[QModelIndex], Method) -> None
if method_index == Method.AsAboveSoBelow:
for index in indexes:
self.varmodel.setData(index, None, StateRole)
elif method_index == Method.Default:
current = self.value_stack.currentWidget()
if current is self.value_combo:
value = self.value_combo.currentIndex()
else:
value = self.value_double.value()
for index in indexes:
state = (int(Method.Default), (value, ))
self.varmodel.setData(index, state, StateRole)
else:
state = (int(method_index), ())
for index in indexes:
self.varmodel.setData(index, state, StateRole)
self.update_varview(indexes)
self._invalidate()
def update_varview(self, indexes=None):
if indexes is None:
indexes = map(self.varmodel.index, range(len(self.varmodel)))
for index in indexes:
self.varmodel.setData(index,
self.get_method_for_column(index.row()),
DisplayMethodRole)
def _on_value_selected(self):
# The fixed 'Value' in the widget has been changed by the user.
self.variable_button_group.button(Method.Default).setChecked(True)
self.set_method_for_current_selection(Method.Default)
def reset_variable_state(self):
indexes = list(map(self.varmodel.index, range(len(self.varmodel))))
self.set_method_for_indexes(indexes, Method.AsAboveSoBelow)
self.variable_button_group.button(
Method.AsAboveSoBelow).setChecked(True)
def _store_state(self):
# type: () -> VariableState
"""
Save the current variable imputation state
"""
state = {} # type: VariableState
for i, var in enumerate(self.varmodel):
index = self.varmodel.index(i)
m = index.data(StateRole)
if m is not None:
state[var_key(var)] = m
return state
def _restore_state(self, state):
# type: (VariableState) -> None
"""
Restore the variable imputation state from the saved state
"""
def check(state):
# check if state is a proper State
if isinstance(state, tuple) and len(state) == 2:
m, p = state
if isinstance(m, int) and isinstance(p, tuple) and \
0 <= m < len(Method):
return True
return False
for i, var in enumerate(self.varmodel):
m = state.get(var_key(var), None)
if check(m):
self.varmodel.setData(self.varmodel.index(i), m, StateRole)
def storeSpecificSettings(self):
self._variable_imputation_state = self._store_state()
super().storeSpecificSettings()
class SignInForm(QDialog):
def __init__(self, flags, *args, **kwargs):
super().__init__(flags, *args, **kwargs)
self.cm: CredentialManager = CredentialManager(CREDENTIAL_MANAGER_SERVICE)
self.setWindowTitle('Sign in')
self.setFixedSize(400, 250)
self.server_cb_label = QLabel('Server *')
self.server_cb = QComboBox(self)
self.server_cb.addItems(RESOLWE_URLS)
self.server_cb.setEditable(True)
self.username_label = QLabel('Username *')
self.username_line_edit = QLineEdit(self)
self.username_line_edit.setPlaceholderText('Enter correct username')
self.username_line_edit.returnPressed.connect(self.sign_in)
self.username_line_edit.textChanged.connect(self.handle_sign_in_btn)
self.password_label = QLabel('Password *')
self.password_line_edit = QLineEdit(self)
self.password_line_edit.setPlaceholderText('Enter correct password')
self.password_line_edit.returnPressed.connect(self.sign_in)
self.password_line_edit.textChanged.connect(self.handle_sign_in_btn)
self.password_line_edit.setEchoMode(QLineEdit.Password)
self.sign_in_btn = QPushButton('Sign in', self)
self.sign_in_btn.setDisabled(True)
self.sign_in_btn.clicked.connect(self.sign_in)
self.error_msg = QLabel('Unable to log in with provided credentials.')
self.error_msg.setStyleSheet('color:red')
self.error_msg.hide()
layout = QVBoxLayout(self)
layout.addWidget(self.server_cb_label)
layout.addWidget(self.server_cb)
layout.addWidget(self.username_label)
layout.addWidget(self.username_line_edit)
layout.addWidget(self.password_label)
layout.addWidget(self.password_line_edit)
layout.addWidget(self.error_msg)
layout.addStretch()
layout.addWidget(self.sign_in_btn)
self.resolwe_instance = None
def handle_sign_in_btn(self):
self.sign_in_btn.setEnabled(
True if self.username_line_edit.text() and self.password_line_edit.text() else False
)
def sign_in(self):
self.server_cb_label.setStyleSheet(None)
self.username_label.setStyleSheet(None)
self.password_label.setStyleSheet(None)
self.error_msg.hide()
server = self.server_cb.currentText()
username = self.cm.username if self.cm.username else self.username_line_edit.text()
password = self.cm.password if self.cm.password else self.password_line_edit.text()
if not server:
self.server_cb_label.setStyleSheet('color:red')
return
if not username:
self.username_label.setStyleSheet('color:red')
return
if not password:
self.password_label.setStyleSheet('color:red')
return
try:
self.resolwe_instance = connect(username, password, url=server)
except ResolweAuthException:
self.error_msg.show()
return
self.cm.username = username
self.cm.password = password
self.accept()
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))
class OWFeatureConstructor(OWWidget):
name = "特征构造器(Feature Constructor)"
description = "用输入数据集中的现有特征构造新特征。"
icon = "icons/FeatureConstructor.svg"
keywords = ['tezheng', 'gouzao', 'tezhenggouzao']
category = "数据(Data)"
icon = "icons/FeatureConstructor.svg"
class Inputs:
data = Input("数据(Data)", Orange.data.Table, replaces=['Data'])
class Outputs:
data = Output("数据(Data)", Orange.data.Table, replaces=['Data'])
want_main_area = False
settingsHandler = FeatureConstructorHandler()
descriptors = ContextSetting([])
currentIndex = ContextSetting(-1)
expressions_with_values = ContextSetting(False)
settings_version = 2
EDITORS = [(ContinuousDescriptor, ContinuousFeatureEditor),
(DateTimeDescriptor, DateTimeFeatureEditor),
(DiscreteDescriptor, DiscreteFeatureEditor),
(StringDescriptor, StringFeatureEditor)]
class Error(OWWidget.Error):
more_values_needed = Msg("Categorical feature {} needs more values.")
invalid_expressions = Msg("Invalid expressions: {}.")
class Warning(OWWidget.Warning):
renamed_var = Msg("Recently added variable has been renamed, "
"to avoid duplicates.\n")
def __init__(self):
super().__init__()
self.data = None
self.editors = {}
box = gui.vBox(self.controlArea, "变量定义")
toplayout = QHBoxLayout()
toplayout.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(toplayout)
self.editorstack = QStackedWidget(sizePolicy=QSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding))
for descclass, editorclass in self.EDITORS:
editor = editorclass()
editor.featureChanged.connect(self._on_modified)
self.editors[descclass] = editor
self.editorstack.addWidget(editor)
self.editorstack.setEnabled(False)
buttonlayout = QVBoxLayout(spacing=10)
buttonlayout.setContentsMargins(0, 0, 0, 0)
self.addbutton = QPushButton("新建",
toolTip="Create a new variable",
minimumWidth=120,
shortcut=QKeySequence.New)
def unique_name(fmt, reserved):
candidates = (fmt.format(i) for i in count(1))
return next(c for c in candidates if c not in reserved)
def generate_newname(fmt):
return unique_name(fmt, self.reserved_names())
menu = QMenu(self.addbutton)
cont = menu.addAction("数值数据")
cont.triggered.connect(lambda: self.addFeature(
ContinuousDescriptor(generate_newname("X{}"), "", 3)))
disc = menu.addAction("分类数据")
disc.triggered.connect(lambda: self.addFeature(
DiscreteDescriptor(generate_newname("D{}"), "", (), False)))
string = menu.addAction("文本")
string.triggered.connect(lambda: self.addFeature(
StringDescriptor(generate_newname("S{}"), "")))
datetime = menu.addAction("日期/时间")
datetime.triggered.connect(lambda: self.addFeature(
DateTimeDescriptor(generate_newname("T{}"), "")))
menu.addSeparator()
self.duplicateaction = menu.addAction("复制选中变量")
self.duplicateaction.triggered.connect(self.duplicateFeature)
self.duplicateaction.setEnabled(False)
self.addbutton.setMenu(menu)
self.removebutton = QPushButton("删除",
toolTip="删除选中变量",
minimumWidth=120,
shortcut=QKeySequence.Delete)
self.removebutton.clicked.connect(self.removeSelectedFeature)
buttonlayout.addWidget(self.addbutton)
buttonlayout.addWidget(self.removebutton)
buttonlayout.addStretch(10)
toplayout.addLayout(buttonlayout, 0)
toplayout.addWidget(self.editorstack, 10)
# Layout for the list view
layout = QVBoxLayout(spacing=1, margin=0)
self.featuremodel = DescriptorModel(parent=self)
self.featureview = QListView(minimumWidth=200,
minimumHeight=50,
sizePolicy=QSizePolicy(
QSizePolicy.Minimum,
QSizePolicy.MinimumExpanding))
self.featureview.setItemDelegate(FeatureItemDelegate(self))
self.featureview.setModel(self.featuremodel)
self.featureview.selectionModel().selectionChanged.connect(
self._on_selectedVariableChanged)
layout.addWidget(self.featureview)
box.layout().addLayout(layout, 1)
self.fix_button = gui.button(self.buttonsArea,
self,
"Upgrade Expressions",
callback=self.fix_expressions)
self.fix_button.setHidden(True)
gui.button(self.buttonsArea,
self,
"Send",
callback=self.apply,
default=True)
def setCurrentIndex(self, index):
index = min(index, len(self.featuremodel) - 1)
self.currentIndex = index
if index >= 0:
itemmodels.select_row(self.featureview, index)
desc = self.featuremodel[min(index, len(self.featuremodel) - 1)]
editor = self.editors[type(desc)]
self.editorstack.setCurrentWidget(editor)
editor.setEditorData(desc, self.data.domain if self.data else None)
self.editorstack.setEnabled(index >= 0)
self.duplicateaction.setEnabled(index >= 0)
self.removebutton.setEnabled(index >= 0)
def _on_selectedVariableChanged(self, selected, *_):
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
else:
self.setCurrentIndex(-1)
def _on_modified(self):
if self.currentIndex >= 0:
self.Warning.clear()
editor = self.editorstack.currentWidget()
proposed = editor.editorData().name
uniq = get_unique_names(self.reserved_names(self.currentIndex),
proposed)
feature = editor.editorData()
if editor.editorData().name != uniq:
self.Warning.renamed_var()
feature = feature.__class__(uniq, *feature[1:])
self.featuremodel[self.currentIndex] = feature
self.descriptors = list(self.featuremodel)
def setDescriptors(self, descriptors):
"""
Set a list of variable descriptors to edit.
"""
self.descriptors = descriptors
self.featuremodel[:] = list(self.descriptors)
def reserved_names(self, idx_=None):
varnames = []
if self.data is not None:
varnames = [
var.name
for var in self.data.domain.variables + self.data.domain.metas
]
varnames += [
desc.name for idx, desc in enumerate(self.featuremodel)
if idx != idx_
]
return set(varnames)
@Inputs.data
@check_sql_input
def setData(self, data=None):
"""Set the input dataset."""
self.closeContext()
self.data = data
self.expressions_with_values = False
self.descriptors = []
self.currentIndex = -1
if self.data is not None:
self.openContext(data)
# disconnect from the selection model while reseting the model
selmodel = self.featureview.selectionModel()
selmodel.selectionChanged.disconnect(self._on_selectedVariableChanged)
self.featuremodel[:] = list(self.descriptors)
self.setCurrentIndex(self.currentIndex)
selmodel.selectionChanged.connect(self._on_selectedVariableChanged)
self.fix_button.setHidden(not self.expressions_with_values)
self.editorstack.setEnabled(self.currentIndex >= 0)
def handleNewSignals(self):
if self.data is not None:
self.apply()
else:
self.Outputs.data.send(None)
self.fix_button.setHidden(True)
def addFeature(self, descriptor):
self.featuremodel.append(descriptor)
self.setCurrentIndex(len(self.featuremodel) - 1)
editor = self.editorstack.currentWidget()
editor.nameedit.setFocus()
editor.nameedit.selectAll()
def removeFeature(self, index):
del self.featuremodel[index]
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
elif index is None and self.featuremodel.rowCount():
# Deleting the last item clears selection
self.setCurrentIndex(self.featuremodel.rowCount() - 1)
def removeSelectedFeature(self):
if self.currentIndex >= 0:
self.removeFeature(self.currentIndex)
def duplicateFeature(self):
desc = self.featuremodel[self.currentIndex]
self.addFeature(copy.deepcopy(desc))
@staticmethod
def check_attrs_values(attr, data):
for i in range(len(data)):
for var in attr:
if not math.isnan(data[i, var]) \
and int(data[i, var]) >= len(var.values):
return var.name
return None
def _validate_descriptors(self, desc):
def validate(source):
try:
return validate_exp(ast.parse(source, mode="eval"))
# ast.parse can return arbitrary errors, not only SyntaxError
# pylint: disable=broad-except
except Exception:
return False
final = []
invalid = []
for d in desc:
if validate(d.expression):
final.append(d)
else:
final.append(d._replace(expression=""))
invalid.append(d)
if invalid:
self.Error.invalid_expressions(", ".join(s.name for s in invalid))
return final
def apply(self):
def report_error(err):
log = logging.getLogger(__name__)
log.error("", exc_info=True)
self.error("".join(format_exception_only(type(err), err)).rstrip())
self.Error.clear()
if self.data is None:
return
desc = list(self.featuremodel)
desc = self._validate_descriptors(desc)
try:
new_variables = construct_variables(desc, self.data,
self.expressions_with_values)
# user's expression can contain arbitrary errors
except Exception as err: # pylint: disable=broad-except
report_error(err)
return
attrs = [var for var in new_variables if var.is_primitive()]
metas = [var for var in new_variables if not var.is_primitive()]
new_domain = Orange.data.Domain(
self.data.domain.attributes + tuple(attrs),
self.data.domain.class_vars,
metas=self.data.domain.metas + tuple(metas))
try:
for variable in new_variables:
variable.compute_value.mask_exceptions = False
data = self.data.transform(new_domain)
# user's expression can contain arbitrary errors
# pylint: disable=broad-except
except Exception as err:
report_error(err)
return
finally:
for variable in new_variables:
variable.compute_value.mask_exceptions = True
disc_attrs_not_ok = self.check_attrs_values(
[var for var in attrs if var.is_discrete], data)
if disc_attrs_not_ok:
self.Error.more_values_needed(disc_attrs_not_ok)
return
self.Outputs.data.send(data)
def send_report(self):
items = OrderedDict()
for feature in self.featuremodel:
if isinstance(feature, DiscreteDescriptor):
desc = "categorical"
if feature.values:
desc += " with values " \
+ ", ".join(f"'{val}'" for val in feature.values)
if feature.ordered:
desc += "; ordered"
elif isinstance(feature, ContinuousDescriptor):
desc = "numeric"
elif isinstance(feature, DateTimeDescriptor):
desc = "date/time"
else:
desc = "text"
items[feature.name] = f"{feature.expression} ({desc})"
self.report_items(report.plural("Constructed feature{s}", len(items)),
items)
def fix_expressions(self):
dlg = QMessageBox(
QMessageBox.Question, "Fix Expressions",
"This widget's behaviour has changed. Values of categorical "
"variables are now inserted as their textual representations "
"(strings); previously they appeared as integer numbers, with an "
"attribute '.value' that contained the text.\n\n"
"The widget currently runs in compatibility mode. After "
"expressions are updated, manually check for their correctness.")
dlg.addButton("Update", QMessageBox.ApplyRole)
dlg.addButton("Cancel", QMessageBox.RejectRole)
if dlg.exec() == QMessageBox.RejectRole:
return
def fixer(mo):
var = domain[mo.group(2)]
if mo.group(3) == ".value": # uses string; remove `.value`
return "".join(mo.group(1, 2, 4))
# Uses ints: get them by indexing
return mo.group(1) + "{" + \
", ".join(f"'{val}': {i}"
for i, val in enumerate(var.values)) + \
f"}}[{var.name}]" + mo.group(4)
domain = self.data.domain
disc_vars = "|".join(f"{var.name}"
for var in chain(domain.variables, domain.metas)
if var.is_discrete)
expr = re.compile(r"(^|\W)(" + disc_vars + r")(\.value)?(\W|$)")
self.descriptors[:] = [
descriptor._replace(
expression=expr.sub(fixer, descriptor.expression))
for descriptor in self.descriptors
]
self.expressions_with_values = False
self.fix_button.hide()
index = self.currentIndex
self.featuremodel[:] = list(self.descriptors)
self.setCurrentIndex(index)
self.apply()
@classmethod
def migrate_context(cls, context, version):
if version is None or version < 2:
used_vars = set(
chain(*(
freevars(ast.parse(descriptor.expression, mode="eval"), [])
for descriptor in context.values["descriptors"]
if descriptor.expression)))
disc_vars = {
name
for (name, vtype) in chain(context.attributes.items(),
context.metas.items()) if vtype == 1
}
if used_vars & disc_vars:
context.values["expressions_with_values"] = True
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
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)
browseaction = QAction(
"Open/Load Documents", self,
iconText="\N{HORIZONTAL ELLIPSIS}",
icon=self.style().standardIcon(QStyle.SP_DirOpenIcon),
toolTip="选中一个文件夹以载入文档"
)
browseaction.triggered.connect(self.__runOpenDialog)
reloadaction = QAction(
"重载", self,
icon=self.style().standardIcon(QStyle.SP_BrowserReload),
toolTip="重载当前文档集"
)
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, "信息")
self.infostack = QStackedWidget()
self.info_area = QLabel(
text="没有选中文档",
wordWrap=True
)
self.progress_widget = QProgressBar(
minimum=0, maximum=100
)
self.cancel_button = QPushButton(
"取消",
icon=self.style().standardIcon(QStyle.SP_DialogCancelButton),
)
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 __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))
class OWFeatureConstructor(OWWidget):
name = "Feature Constructor"
description = "Construct new features (data columns) from a set of " \
"existing features in the input dataset."
icon = "icons/FeatureConstructor.svg"
keywords = ['function', 'lambda']
class Inputs:
data = Input("Data", Orange.data.Table)
class Outputs:
data = Output("Data", Orange.data.Table)
want_main_area = False
settingsHandler = FeatureConstructorHandler()
descriptors = ContextSetting([])
currentIndex = ContextSetting(-1)
EDITORS = [(ContinuousDescriptor, ContinuousFeatureEditor),
(DateTimeDescriptor, DateTimeFeatureEditor),
(DiscreteDescriptor, DiscreteFeatureEditor),
(StringDescriptor, StringFeatureEditor)]
class Error(OWWidget.Error):
more_values_needed = Msg("Categorical feature {} needs more values.")
invalid_expressions = Msg("Invalid expressions: {}.")
class Warning(OWWidget.Warning):
renamed_var = Msg("Recently added variable has been renamed, "
"to avoid duplicates.\n")
def __init__(self):
super().__init__()
self.data = None
self.editors = {}
box = gui.vBox(self.controlArea, "Variable Definitions")
toplayout = QHBoxLayout()
toplayout.setContentsMargins(0, 0, 0, 0)
box.layout().addLayout(toplayout)
self.editorstack = QStackedWidget(sizePolicy=QSizePolicy(
QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding))
for descclass, editorclass in self.EDITORS:
editor = editorclass()
editor.featureChanged.connect(self._on_modified)
self.editors[descclass] = editor
self.editorstack.addWidget(editor)
self.editorstack.setEnabled(False)
buttonlayout = QVBoxLayout(spacing=10)
buttonlayout.setContentsMargins(0, 0, 0, 0)
self.addbutton = QPushButton("New",
toolTip="Create a new variable",
minimumWidth=120,
shortcut=QKeySequence.New)
def unique_name(fmt, reserved):
candidates = (fmt.format(i) for i in count(1))
return next(c for c in candidates if c not in reserved)
def generate_newname(fmt):
return unique_name(fmt, self.reserved_names())
menu = QMenu(self.addbutton)
cont = menu.addAction("Numeric")
cont.triggered.connect(lambda: self.addFeature(
ContinuousDescriptor(generate_newname("X{}"), "", 3)))
disc = menu.addAction("Categorical")
disc.triggered.connect(lambda: self.addFeature(
DiscreteDescriptor(generate_newname("D{}"), "", (), False)))
string = menu.addAction("Text")
string.triggered.connect(lambda: self.addFeature(
StringDescriptor(generate_newname("S{}"), "")))
datetime = menu.addAction("Date/Time")
datetime.triggered.connect(lambda: self.addFeature(
DateTimeDescriptor(generate_newname("T{}"), "")))
menu.addSeparator()
self.duplicateaction = menu.addAction("Duplicate Selected Variable")
self.duplicateaction.triggered.connect(self.duplicateFeature)
self.duplicateaction.setEnabled(False)
self.addbutton.setMenu(menu)
self.removebutton = QPushButton("Remove",
toolTip="Remove selected variable",
minimumWidth=120,
shortcut=QKeySequence.Delete)
self.removebutton.clicked.connect(self.removeSelectedFeature)
buttonlayout.addWidget(self.addbutton)
buttonlayout.addWidget(self.removebutton)
buttonlayout.addStretch(10)
toplayout.addLayout(buttonlayout, 0)
toplayout.addWidget(self.editorstack, 10)
# Layout for the list view
layout = QVBoxLayout(spacing=1, margin=0)
self.featuremodel = DescriptorModel(parent=self)
self.featureview = QListView(minimumWidth=200,
minimumHeight=50,
sizePolicy=QSizePolicy(
QSizePolicy.Minimum,
QSizePolicy.MinimumExpanding))
self.featureview.setItemDelegate(FeatureItemDelegate(self))
self.featureview.setModel(self.featuremodel)
self.featureview.selectionModel().selectionChanged.connect(
self._on_selectedVariableChanged)
self.info.set_input_summary(self.info.NoInput)
self.info.set_output_summary(self.info.NoOutput)
layout.addWidget(self.featureview)
box.layout().addLayout(layout, 1)
gui.button(self.buttonsArea,
self,
"Send",
callback=self.apply,
default=True)
def setCurrentIndex(self, index):
index = min(index, len(self.featuremodel) - 1)
self.currentIndex = index
if index >= 0:
itemmodels.select_row(self.featureview, index)
desc = self.featuremodel[min(index, len(self.featuremodel) - 1)]
editor = self.editors[type(desc)]
self.editorstack.setCurrentWidget(editor)
editor.setEditorData(desc, self.data.domain if self.data else None)
self.editorstack.setEnabled(index >= 0)
self.duplicateaction.setEnabled(index >= 0)
self.removebutton.setEnabled(index >= 0)
def _on_selectedVariableChanged(self, selected, *_):
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
else:
self.setCurrentIndex(-1)
def _on_modified(self):
if self.currentIndex >= 0:
self.Warning.clear()
editor = self.editorstack.currentWidget()
proposed = editor.editorData().name
unique = get_unique_names(self.reserved_names(self.currentIndex),
proposed)
feature = editor.editorData()
if editor.editorData().name != unique:
self.Warning.renamed_var()
feature = feature.__class__(unique, *feature[1:])
self.featuremodel[self.currentIndex] = feature
self.descriptors = list(self.featuremodel)
def setDescriptors(self, descriptors):
"""
Set a list of variable descriptors to edit.
"""
self.descriptors = descriptors
self.featuremodel[:] = list(self.descriptors)
def reserved_names(self, idx_=None):
varnames = []
if self.data is not None:
varnames = [
var.name
for var in self.data.domain.variables + self.data.domain.metas
]
varnames += [
desc.name for idx, desc in enumerate(self.featuremodel)
if idx != idx_
]
return set(varnames)
@Inputs.data
@check_sql_input
def setData(self, data=None):
"""Set the input dataset."""
self.closeContext()
self.data = data
self.info.set_input_summary(self.info.NoInput)
if self.data is not None:
descriptors = list(self.descriptors)
currindex = self.currentIndex
self.descriptors = []
self.currentIndex = -1
self.openContext(data)
self.info.set_input_summary(len(data),
format_summary_details(data))
if descriptors != self.descriptors or \
self.currentIndex != currindex:
# disconnect from the selection model while reseting the model
selmodel = self.featureview.selectionModel()
selmodel.selectionChanged.disconnect(
self._on_selectedVariableChanged)
self.featuremodel[:] = list(self.descriptors)
self.setCurrentIndex(self.currentIndex)
selmodel.selectionChanged.connect(
self._on_selectedVariableChanged)
self.editorstack.setEnabled(self.currentIndex >= 0)
def handleNewSignals(self):
if self.data is not None:
self.apply()
else:
self.info.set_output_summary(self.info.NoOutput)
self.Outputs.data.send(None)
def addFeature(self, descriptor):
self.featuremodel.append(descriptor)
self.setCurrentIndex(len(self.featuremodel) - 1)
editor = self.editorstack.currentWidget()
editor.nameedit.setFocus()
editor.nameedit.selectAll()
def removeFeature(self, index):
del self.featuremodel[index]
index = selected_row(self.featureview)
if index is not None:
self.setCurrentIndex(index)
elif index is None and self.featuremodel.rowCount():
# Deleting the last item clears selection
self.setCurrentIndex(self.featuremodel.rowCount() - 1)
def removeSelectedFeature(self):
if self.currentIndex >= 0:
self.removeFeature(self.currentIndex)
def duplicateFeature(self):
desc = self.featuremodel[self.currentIndex]
self.addFeature(copy.deepcopy(desc))
@staticmethod
def check_attrs_values(attr, data):
for i in range(len(data)):
for var in attr:
if not math.isnan(data[i, var]) \
and int(data[i, var]) >= len(var.values):
return var.name
return None
def _validate_descriptors(self, desc):
def validate(source):
try:
return validate_exp(ast.parse(source, mode="eval"))
# ast.parse can return arbitrary errors, not only SyntaxError
# pylint: disable=broad-except
except Exception:
return False
final = []
invalid = []
for d in desc:
if validate(d.expression):
final.append(d)
else:
final.append(d._replace(expression=""))
invalid.append(d)
if invalid:
self.Error.invalid_expressions(", ".join(s.name for s in invalid))
return final
def apply(self):
def report_error(err):
log = logging.getLogger(__name__)
log.error("", exc_info=True)
self.error("".join(format_exception_only(type(err), err)).rstrip())
self.Error.clear()
if self.data is None:
return
desc = list(self.featuremodel)
desc = self._validate_descriptors(desc)
try:
new_variables = construct_variables(desc, self.data)
# user's expression can contain arbitrary errors
except Exception as err: # pylint: disable=broad-except
report_error(err)
return
attrs = [var for var in new_variables if var.is_primitive()]
metas = [var for var in new_variables if not var.is_primitive()]
new_domain = Orange.data.Domain(
self.data.domain.attributes + tuple(attrs),
self.data.domain.class_vars,
metas=self.data.domain.metas + tuple(metas))
try:
for variable in new_variables:
variable.compute_value.mask_exceptions = False
data = self.data.transform(new_domain)
# user's expression can contain arbitrary errors
# pylint: disable=broad-except
except Exception as err:
report_error(err)
return
finally:
for variable in new_variables:
variable.compute_value.mask_exceptions = True
disc_attrs_not_ok = self.check_attrs_values(
[var for var in attrs if var.is_discrete], data)
if disc_attrs_not_ok:
self.Error.more_values_needed(disc_attrs_not_ok)
return
self.info.set_output_summary(len(data), format_summary_details(data))
self.Outputs.data.send(data)
def send_report(self):
items = OrderedDict()
for feature in self.featuremodel:
if isinstance(feature, DiscreteDescriptor):
items[
feature.name] = "{} (categorical with values {}{})".format(
feature.expression, feature.values,
"; ordered" * feature.ordered)
elif isinstance(feature, ContinuousDescriptor):
items[feature.name] = "{} (numeric)".format(feature.expression)
elif isinstance(feature, DateTimeDescriptor):
items[feature.name] = "{} (date/time)".format(
feature.expression)
else:
items[feature.name] = "{} (text)".format(feature.expression)
self.report_items(report.plural("Constructed feature{s}", len(items)),
items)
