Create class: Add widget

Author: janezd

Orange/widgets/data/owcreateclass.py

@@ -0,0 +1,231 @@
+import numpy as np
+
+from AnyQt.QtWidgets import QGridLayout, QLabel, QLineEdit, QSizePolicy
+from AnyQt.QtCore import QSize, Qt
+
+from Orange.data import StringVariable, DiscreteVariable, Domain
+from Orange.data.table import Table
+from Orange.preprocess.transformation import Transformation
+from Orange.widgets import gui, widget
+from Orange.widgets.settings import DomainContextHandler, ContextSetting
+from Orange.widgets.utils.itemmodels import DomainModel
+from Orange.widgets.widget import Msg
+
+
+class ValueFromSubstring(Transformation):
+    def __init__(self, variable, values):
+        super().__init__(variable)
+        self.values = values
+
+    def transform(self, c):
+        c = c.flatten()
+        res = np.empty(len(c))
+        for i, val in enumerate(c):
+            for res[i], pattern in enumerate(self.values):
+                if pattern in val:
+                    break
+            else:
+                res[i] = np.nan
+        return res
+
+
+class OWCreateClass(widget.OWWidget):
+    name = "Create class"
+    description = "Create class attribute from a string attribute"
+    icon = "icons/CreateClass.svg"
+    category = "Data"
+    keywords = ["data"]
+
+    inputs = [("Data", Table, "set_data")]
+    outputs = [("Data", Table)]
+
+    want_main_area = False
+
+    settingsHandler = DomainContextHandler()
+    attribute = ContextSetting(None)
+
+    class Warning(widget.OWWidget.Warning):
+        no_string_variables = Msg("No string variables.")
+
+    def __init__(self):
+        super().__init__()
+        self.data = None
+        self.rules = [["C1", ""], ["C2", ""]]
+        self.line_edits = []
+        self.remove_buttons = []
+        self.counts = []
+        self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum)
+
+        box = gui.hBox(self.controlArea)
+        gui.widgetLabel(box, "Class from column: ", addSpace=12)
+        gui.comboBox(
+            box, self, "attribute", callback=self.apply,
+            model=DomainModel(valid_types=StringVariable),
+            sizePolicy=(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed))
+
+        self.rules_box = rules_box = QGridLayout()
+        self.controlArea.layout().addLayout(self.rules_box)
+        self.add_button = gui.button(None, self, "+", flat=True,
+                                     callback=self.add_row,
+                                     minimumSize=QSize(12, 20))
+        self.rules_box.setColumnMinimumWidth(1, 80)
+        self.rules_box.setColumnMinimumWidth(0, 10)
+        self.rules_box.setColumnStretch(0, 1)
+        self.rules_box.setColumnStretch(1, 1)
+        self.rules_box.setColumnStretch(2, 100)
+        rules_box.addWidget(QLabel("Name"), 0, 1)
+        rules_box.addWidget(QLabel("Pattern"), 0, 2)
+        rules_box.addWidget(QLabel("#Instances"), 0, 3, 1, 2)
+        self.update_rules()
+
+        box = gui.hBox(self.controlArea)
+        gui.rubber(box)
+        gui.button(box, self, "Apply", autoDefault=False, callback=self.apply)
+
+    def retrieveSpecificSettings(self):
+        self.rules = list(self.current_context.rules)
+        self.update_rules()
+
+    def storeSpecificSettings(self):
+        self.current_context.rules = tuple(self.rules)
+
+    def rules_to_edits(self):
+        for editr, textr in zip(self.line_edits, self.rules):
+            for edit, text in zip(editr, textr):
+                edit.setText(text)
+
+    def edits_to_rule(self):
+        self.rules = [[edit.text() for edit in row] for row in self.line_edits]
+
+    def set_data(self, data):
+        # We don't reset the rules before opening new context, thus keeping the
+        # existing rules. This makes sense within a lifetime of a widget, and
+        # it doesn't extend past it.
+        self.closeContext()
+        self.data = data
+        model = self.controls.attribute.model()
+        model.set_domain(data and data.domain)
+        self.Warning.no_string_variables(shown=data is not None and not model)
+        if not model:
+            self.attribute = None
+            self.send("Data", None)
+            return
+        self.attribute = model[0]
+        self.openContext(data)
+        self.update_rules()
+
+    def update_rules(self):
+        self.adjust_n_rule_rows()
+        self.rules_to_edits()
+        self.update_counts()
+
+    def adjust_n_rule_rows(self):
+        def _add_line():
+            self.line_edits.append([])
+            n_lines = len(self.line_edits)
+            for coli in range(1, 3):
+                edit = QLineEdit()
+                self.line_edits[-1].append(edit)
+                self.rules_box.addWidget(edit, n_lines, coli)
+                edit.textChanged.connect(self.sync_edit)
+            button = gui.button(
+                None, self, label='×', flat=True, height=20,
+                styleSheet='* {font-size: 16pt; color: silver}'
+                           '*:hover {color: black}',
+                callback=self.remove_row)
+            button.setMinimumSize(QSize(12, 20))
+            self.remove_buttons.append(button)
+            self.rules_box.addWidget(button, n_lines, 0)
+            self.counts.append([])
+            for coli in range(3, 5):
+                label = QLabel(alignment=Qt.AlignRight if coli == 3
+                               else Qt.AlignLeft)
+                self.counts[-1].append(label)
+                self.rules_box.addWidget(label, n_lines, coli)
+
+        def _remove_line():
+            for edit in self.line_edits.pop():
+                edit.deleteLater()
+            self.remove_buttons.pop().deleteLater()
+            for label in self.counts.pop():
+                label.deleteLater()
+
+        def _fix_tab_order():
+            prev = None
+            for row, rule in zip(self.line_edits, self.rules):
+                for col_idx, edit in enumerate(row):
+                    edit.row, edit.col_idx = rule, col_idx
+                    if prev is not None:
+                        self.setTabOrder(prev, edit)
+                    prev = edit
+
+        n = len(self.rules)
+        while n > len(self.line_edits):
+            _add_line()
+        while len(self.line_edits) > n:
+            _remove_line()
+        self.rules_box.addWidget(self.add_button, len(self.rules) + 1, 0)
+        _fix_tab_order()
+
+    def add_row(self):
+        self.rules.append(["", ""])
+        self.adjust_n_rule_rows()
+
+    def remove_row(self):
+        remove_idx = self.remove_buttons.index(self.sender())
+        del self.rules[remove_idx]
+        self.update_rules()
+
+    def sync_edit(self, text):
+        edit = self.sender()
+        edit.row[edit.col_idx] = text
+        self.update_counts()
+
+    def update_counts(self):
+        if not self.attribute:
+            for label_row in self.counts:
+                for label in label_row:
+                    label.setText("")
+            return
+        data = [str(x) for x in self.data[:, self.attribute]]
+        remaining = data.copy()
+        for (lab_match, lab_all), (_, pattern) in zip(self.counts, self.rules):
+            new_remaining = [x for x in remaining if pattern not in x]
+            n_matched = len(remaining) - len(new_remaining)
+            n_match_in_all = sum(pattern in x for x in data)
+            lab_match.setText("{}".format(n_matched) if remaining else "")
+            lab_all.setText("({})".format(n_match_in_all)
+                            if remaining and n_match_in_all != n_matched
+                            else "")
+            remaining = new_remaining
+
+    def apply(self):
+        if not self.data:
+            return
+        domain = self.data.domain
+        names, patterns = \
+            zip(*((name.strip(), pattern)
+                  for name, pattern in self.rules if name.strip()))
+        new_class = DiscreteVariable(
+            "class", names,
+            compute_value=ValueFromSubstring(self.attribute, patterns))
+        new_domain = Domain(domain.attributes, new_class,
+                            domain.metas + domain.class_vars)
+        new_data = Table(new_domain, self.data)
+        self.send("Data", new_data)
+
+
+def main():
+    import sys
+    from AnyQt.QtWidgets import QApplication
+
+    a = QApplication(sys.argv)
+    table = Table("zoo")
+    ow = OWCreateClass()
+    ow.show()
+    ow.set_data(table)
+    a.exec()
+    ow.saveSettings()
+
+if __name__ == "__main__":
+    main()