Changeset 11430:f9e572f80f4e in orange


Ignore:
Timestamp:
04/02/13 12:22:37 (13 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Edit Domain widget code style fix.

Empty and trailing line whitespace.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeWidgets/Data/OWEditDomain.py

    r11096 r11430  
    1515import Orange 
    1616 
     17 
    1718def is_discrete(var): 
    1819    return isinstance(var, Orange.feature.Discrete) 
    1920 
     21 
    2022def is_continuous(var): 
    2123    return isinstance(var, Orange.feature.Continuous) 
    2224 
     25 
    2326def get_qualified(module, name): 
    24     """Return a qualified module member ``name`` inside the named  
     27    """Return a qualified module member ``name`` inside the named 
    2528    ``module``. 
    26      
     29 
    2730    The module (or package) first gets imported and the name 
    2831    is retrieved from the module's global namespace. 
    29       
     32 
    3033    """ 
    3134    # see __import__.__doc__ for why 'fromlist' is used 
     
    3336    return getattr(module, name) 
    3437 
     38 
    3539def variable_description(var): 
    3640    """Return a variable descriptor. 
    37      
    38     A descriptor is a hashable tuple which should uniquely define  
    39     the variable i.e. (module, type_name, variable_name,  
     41 
     42    A descriptor is a hashable tuple which should uniquely define 
     43    the variable i.e. (module, type_name, variable_name, 
    4044    any_kwargs, sorted-attributes-items). 
    41      
     45 
    4246    """ 
    4347    var_type = type(var) 
     
    4549        return (var_type.__module__, 
    4650                var_type.__name__, 
    47                 var.name,  
    48                 (("values", tuple(var.values)),),  
     51                var.name, 
     52                (("values", tuple(var.values)),), 
    4953                tuple(sorted(var.attributes.items()))) 
    5054    else: 
    5155        return (var_type.__module__, 
    5256                var_type.__name__, 
    53                 var.name,  
    54                 (),  
     57                var.name, 
     58                (), 
    5559                tuple(sorted(var.attributes.items()))) 
    5660 
     61 
    5762def variable_from_description(description): 
    58     """Construct a variable from its description 
    59     (:ref:`variable_description`). 
    60      
     63    """Construct a variable from its description (see 
     64    :func:`variable_description`). 
     65 
    6166    """ 
    6267    module, type_name, name, kwargs, attrs = description 
     
    6469        type = get_qualified(module, type_name) 
    6570    except (ImportError, AttributeError), ex: 
    66         raise ValueError("""Invalid descriptor type '{}.{}\ 
    67         """.format(module, type_name)) 
    68          
     71        raise ValueError("Invalid descriptor type '{}.{}" 
     72                         "".format(module, type_name)) 
     73 
    6974    var = type(name, **dict(list(kwargs))) 
    7075    var.attributes.update(attrs) 
    7176    return var 
    72      
     77 
    7378from PyQt4 import QtCore, QtGui 
    7479 
    7580QtCore.Slot = QtCore.pyqtSlot 
    7681QtCore.Signal = QtCore.pyqtSignal 
     82 
    7783 
    7884class PyStandardItem(QStandardItem): 
    7985    def __lt__(self, other): 
    8086        return id(self) < id(other) 
    81      
     87 
     88 
    8289class DictItemsModel(QStandardItemModel): 
    8390    """A Qt Item Model class displaying the contents of a python 
    8491    dictionary. 
    85      
     92 
    8693    """ 
    8794    # Implement a proper model with in-place editing. 
     
    9198        self.setHorizontalHeaderLabels(["Key", "Value"]) 
    9299        self.set_dict(dict) 
    93          
     100 
    94101    def set_dict(self, dict): 
    95102        self._dict = dict 
     
    102109            value_item.setFlags(value_item.flags() | Qt.ItemIsEditable) 
    103110            self.appendRow([key_item, value_item]) 
    104              
     111 
    105112    def get_dict(self): 
    106113        dict = {} 
     
    111118        return dict 
    112119 
     120 
    113121class VariableEditor(QWidget): 
    114122    """An editor widget for a variable. 
    115      
     123 
    116124    Can edit the variable name, and its attributes dictionary. 
    117       
     125 
    118126    """ 
    119127    def __init__(self, parent=None): 
    120128        QWidget.__init__(self, parent) 
    121129        self.setup_gui() 
    122          
     130 
    123131    def setup_gui(self): 
    124132        layout = QVBoxLayout() 
    125133        self.setLayout(layout) 
    126          
     134 
    127135        self.main_form = QFormLayout() 
    128136        self.main_form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) 
    129137        layout.addLayout(self.main_form) 
    130          
     138 
    131139        self._setup_gui_name() 
    132140        self._setup_gui_labels() 
    133          
     141 
    134142    def _setup_gui_name(self): 
    135143        self.name_edit = QLineEdit() 
    136144        self.main_form.addRow("Name", self.name_edit) 
    137145        self.name_edit.editingFinished.connect(self.on_name_changed) 
    138          
     146 
    139147    def _setup_gui_labels(self): 
    140148        vlayout = QVBoxLayout() 
    141149        vlayout.setContentsMargins(0, 0, 0, 0) 
    142150        vlayout.setSpacing(1) 
    143          
     151 
    144152        self.labels_edit = QTreeView() 
    145153        self.labels_edit.setEditTriggers(QTreeView.CurrentChanged) 
    146154        self.labels_edit.setRootIsDecorated(False) 
    147          
     155 
    148156        self.labels_model = DictItemsModel() 
    149157        self.labels_edit.setModel(self.labels_model) 
    150          
     158 
    151159        self.labels_edit.selectionModel().selectionChanged.connect(\ 
    152160                                    self.on_label_selection_changed) 
    153          
     161 
    154162        # Necessary signals to know when the labels change 
    155163        self.labels_model.dataChanged.connect(self.on_labels_changed) 
    156164        self.labels_model.rowsInserted.connect(self.on_labels_changed) 
    157165        self.labels_model.rowsRemoved.connect(self.on_labels_changed) 
    158          
     166 
    159167        vlayout.addWidget(self.labels_edit) 
    160168        hlayout = QHBoxLayout() 
     
    172180                        enabled=False, 
    173181                        shortcut=QKeySequence(QKeySequence.Delete)) 
    174          
     182 
    175183        button_size = OWGUI.toolButtonSizeHint() 
    176184        button_size = QSize(button_size, button_size) 
    177          
     185 
    178186        button = QToolButton(self) 
    179187        button.setFixedSize(button_size) 
    180188        button.setDefaultAction(self.add_label_action) 
    181189        hlayout.addWidget(button) 
    182          
     190 
    183191        button = QToolButton(self) 
    184192        button.setFixedSize(button_size) 
     
    187195        hlayout.addStretch(10) 
    188196        vlayout.addLayout(hlayout) 
    189          
     197 
    190198        self.main_form.addRow("Labels", vlayout) 
    191          
     199 
    192200    def set_data(self, var): 
    193201        """Set the variable to edit. 
     
    195203        self.clear() 
    196204        self.var = var 
    197          
     205 
    198206        if var is not None: 
    199207            self.name_edit.setText(var.name) 
     
    203211            self.add_label_action.setEnabled(False) 
    204212            self.remove_label_action.setEnabled(False) 
    205              
     213 
    206214    def get_data(self): 
    207215        """Retrieve the modified variable. 
     
    209217        name = str(self.name_edit.text()) 
    210218        labels = self.labels_model.get_dict() 
    211          
    212         # Is the variable actually changed.  
     219 
     220        # Is the variable actually changed. 
    213221        if not self.is_same(): 
    214222            var = type(self.var)(name) 
     
    217225        else: 
    218226            var = self.var 
    219          
     227 
    220228        return var 
    221      
     229 
    222230    def is_same(self): 
    223         """Is the current model state the same as the input.  
     231        """Is the current model state the same as the input. 
    224232        """ 
    225233        name = str(self.name_edit.text()) 
    226234        labels = self.labels_model.get_dict() 
    227          
     235 
    228236        return self.var and name == self.var.name and labels == self.var.attributes 
    229              
     237 
    230238    def clear(self): 
    231239        """Clear the editor state. 
     
    234242        self.name_edit.setText("") 
    235243        self.labels_model.set_dict({}) 
    236          
     244 
    237245    def maybe_commit(self): 
    238246        if not self.is_same(): 
    239247            self.commit() 
    240              
     248 
    241249    def commit(self): 
    242250        """Emit a ``variable_changed()`` signal. 
    243251        """ 
    244252        self.emit(SIGNAL("variable_changed()")) 
    245          
     253 
    246254    @QtCore.Slot() 
    247255    def on_name_changed(self): 
    248256        self.maybe_commit() 
    249          
     257 
    250258    @QtCore.Slot() 
    251259    def on_labels_changed(self, *args): 
    252260        self.maybe_commit() 
    253          
     261 
    254262    @QtCore.Slot() 
    255263    def on_add_label(self): 
     
    258266        index = self.labels_model.index(row, 0) 
    259267        self.labels_edit.edit(index) 
    260          
     268 
    261269    @QtCore.Slot() 
    262270    def on_remove_label(self): 
     
    265273            row = rows[0] 
    266274            self.labels_model.removeRow(row.row()) 
    267      
     275 
    268276    @QtCore.Slot() 
    269277    def on_label_selection_changed(self): 
    270278        selected = self.labels_edit.selectionModel().selectedRows() 
    271279        self.remove_label_action.setEnabled(bool(len(selected))) 
    272          
    273          
     280 
     281 
    274282class DiscreteVariableEditor(VariableEditor): 
    275283    """An editor widget for editing a discrete variable. 
    276      
     284 
    277285    Extends the :class:`VariableEditor` to enable editing of 
    278286    variables values. 
    279      
     287 
    280288    """ 
    281289    def setup_gui(self): 
    282290        layout = QVBoxLayout() 
    283291        self.setLayout(layout) 
    284          
     292 
    285293        self.main_form = QFormLayout() 
    286294        self.main_form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) 
    287295        layout.addLayout(self.main_form) 
    288          
     296 
    289297        self._setup_gui_name() 
    290298        self._setup_gui_values() 
    291299        self._setup_gui_labels() 
    292          
     300 
    293301    def _setup_gui_values(self): 
    294302        self.values_edit = QListView() 
     
    297305                                        Qt.ItemIsEnabled | Qt.ItemIsEditable) 
    298306        self.values_edit.setModel(self.values_model) 
    299          
     307 
    300308        self.values_model.dataChanged.connect(self.on_values_changed) 
    301309        self.main_form.addRow("Values", self.values_edit) 
     
    309317            for v in var.values: 
    310318                self.values_model.append(v) 
    311                  
     319 
    312320    def get_data(self): 
    313321        """Retrieve the modified variable 
     
    316324        labels = self.labels_model.get_dict() 
    317325        values = map(str, self.values_model) 
    318          
     326 
    319327        if not self.is_same(): 
    320328            var = type(self.var)(name, values=values) 
     
    323331        else: 
    324332            var = self.var 
    325              
     333 
    326334        return var 
    327              
     335 
    328336    def is_same(self): 
    329         """Is the current model state the same as the input.  
     337        """Is the current model state the same as the input. 
    330338        """ 
    331339        values = map(str, self.values_model) 
    332340        return VariableEditor.is_same(self) and self.var.values == values 
    333      
     341 
    334342    def clear(self): 
    335343        """Clear the model state. 
     
    337345        VariableEditor.clear(self) 
    338346        self.values_model.wrap([]) 
    339          
     347 
    340348    @QtCore.Slot() 
    341349    def on_values_changed(self): 
    342350        self.maybe_commit() 
    343          
    344          
     351 
     352 
    345353class ContinuousVariableEditor(VariableEditor): 
    346     #TODO: enable editing of number_of_decimals, scientific format ... 
    347     pass  
     354    # TODO: enable editing of number_of_decimals, scientific format ... 
     355    pass 
    348356 
    349357 
    350358class OWEditDomain(OWWidget): 
    351     contextHandlers = {"": DomainContextHandler("", ["domain_change_hints", "selected_index"])} 
     359    contextHandlers = { 
     360        "": DomainContextHandler( 
     361            "", 
     362            ["domain_change_hints", "selected_index"] 
     363        ) 
     364    } 
    352365    settingsList = ["auto_commit"] 
    353      
     366 
    354367    def __init__(self, parent=None, signalManager=None, title="Edit Domain"): 
    355368        OWWidget.__init__(self, parent, signalManager, title) 
    356          
     369 
    357370        self.inputs = [("Data", Orange.data.Table, self.set_data)] 
    358371        self.outputs = [("Data", Orange.data.Table)] 
    359          
     372 
    360373        # Settings 
    361          
     374 
    362375        # Domain change hints maps from input variables description to 
    363376        # the modified variables description as returned by 
     
    367380        self.auto_commit = False 
    368381        self.changed_flag = False 
    369          
     382 
    370383        self.loadSettings() 
    371          
     384 
    372385        ##### 
    373386        # GUI 
    374387        ##### 
    375      
     388 
    376389        # The list of domain's variables. 
    377390        box = OWGUI.widgetBox(self.controlArea, "Domain Features") 
    378391        self.domain_view = QListView() 
    379392        self.domain_view.setSelectionMode(QListView.SingleSelection) 
    380          
     393 
    381394        self.domain_model = VariableListModel() 
    382          
     395 
    383396        self.domain_view.setModel(self.domain_model) 
    384          
     397 
    385398        self.connect(self.domain_view.selectionModel(), 
    386399                     SIGNAL("selectionChanged(QItemSelection, QItemSelection)"), 
    387400                     self.on_selection_changed) 
    388          
     401 
    389402        box.layout().addWidget(self.domain_view) 
    390          
     403 
    391404        # A stack for variable editor widgets. 
    392405        box = OWGUI.widgetBox(self.mainArea, "Edit Feature") 
    393406        self.editor_stack = QStackedWidget() 
    394407        box.layout().addWidget(self.editor_stack) 
    395          
    396          
     408 
    397409        box = OWGUI.widgetBox(self.controlArea, "Reset") 
    398          
     410 
    399411        OWGUI.button(box, self, "Reset selected", 
    400412                     callback=self.reset_selected, 
    401413                     tooltip="Reset changes made to the selected feature" 
    402414                     ) 
    403          
     415 
    404416        OWGUI.button(box, self, "Reset all", 
    405417                     callback=self.reset_all, 
    406418                     tooltip="Reset all changes made to the domain" 
    407419                     ) 
    408          
     420 
    409421        box = OWGUI.widgetBox(self.controlArea, "Commit") 
    410          
     422 
    411423        b = OWGUI.button(box, self, "&Commit", 
    412424                         callback=self.commit, 
    413425                         tooltip="Commit the data with the changed domain", 
    414426                         ) 
    415          
     427 
    416428        cb = OWGUI.checkBox(box, self, "auto_commit", 
    417429                            label="Commit automatically", 
    418430                            tooltip="Commit the changed domain on any change", 
    419431                            callback=self.commit_if) 
    420          
     432 
    421433        OWGUI.setStopper(self, b, cb, "changed_flag", 
    422434                         callback=self.commit) 
    423          
     435 
    424436        self._editor_cache = {} 
    425          
     437 
    426438        self.resize(600, 500) 
    427          
     439 
    428440    def clear(self): 
    429441        """Clear the widget state. 
     
    433445        self.domain_change_hints = {} 
    434446        self.clear_editor() 
    435          
     447 
    436448    def clear_editor(self): 
    437449        """Clear the current editor widget 
     
    442454                               self.on_variable_changed) 
    443455            current.set_data(None) 
    444          
     456 
    445457    def set_data(self, data=None): 
    446458        self.closeContext("") 
     
    451463            all_vars = list(input_domain.variables) + \ 
    452464                       input_domain.getmetas().values() 
    453              
     465 
    454466            self.openContext("", data) 
    455              
     467 
    456468            edited_vars = [] 
    457              
    458             # Apply any saved transformations as listed in  
     469 
     470            # Apply any saved transformations as listed in 
    459471            # `domain_change_hints` 
    460               
     472 
    461473            for var in all_vars: 
    462474                desc = variable_description(var) 
     
    468480#                        print ex 
    469481                        new = None 
    470                          
     482 
    471483                    if new is not None: 
    472484                        # Make sure orange's domain transformations will work. 
     
    474486                        new.get_value_from = Orange.core.ClassifierFromVar(whichVar=var) 
    475487                        var = new 
    476                          
     488 
    477489                edited_vars.append(var) 
    478              
     490 
    479491            self.all_vars = all_vars 
    480492            self.input_domain = input_domain 
    481              
     493 
    482494            # Sets the model to display in the 'Domain Features' view 
    483495            self.domain_model[:] = edited_vars 
    484              
     496 
    485497            # Try to restore the variable selection 
    486498            index = self.selected_index 
     
    489501            if index >= 0: 
    490502                self.select_variable(index) 
    491          
     503 
    492504            self.changed_flag = True 
    493505            self.commit_if() 
     
    495507            # To force send None on output 
    496508            self.commit() 
    497              
     509 
    498510    def on_selection_changed(self, *args): 
    499         """When selection in 'Domain Features' view changes.  
     511        """When selection in 'Domain Features' view changes. 
    500512        """ 
    501513        i = self.selected_var_index() 
     
    503515            self.open_editor(i) 
    504516            self.selected_index = i 
    505          
     517 
    506518    def selected_var_index(self): 
    507         """Return the selected row in 'Domain Features' view or None  
     519        """Return the selected row in 'Domain Features' view or None 
    508520        if no row is selected. 
    509          
     521 
    510522        """ 
    511523        rows = self.domain_view.selectionModel().selectedRows() 
     
    514526        else: 
    515527            return None 
    516          
     528 
    517529    def select_variable(self, index): 
    518530        """Select the variable with ``index`` in the 'Domain Features' 
    519531        view. 
    520          
     532 
    521533        """ 
    522534        sel_model = self.domain_view.selectionModel() 
    523535        sel_model.select(self.domain_model.index(index, 0), 
    524536                         QItemSelectionModel.ClearAndSelect) 
    525          
     537 
    526538    def open_editor(self, index): 
    527539        """Open the editor for variable at ``index`` and move it 
    528540        to the top if the stack. 
    529          
     541 
    530542        """ 
    531543        # First remove and clear the current editor if any 
    532544        self.clear_editor() 
    533              
     545 
    534546        var = self.domain_model[index] 
    535          
     547 
    536548        editor = self.editor_for_variable(var) 
    537549        editor.set_data(var) 
    538550        self.edited_variable_index = index 
    539          
     551 
    540552        QObject.connect(editor, SIGNAL("variable_changed()"), 
    541553                        self.on_variable_changed) 
    542554        self.editor_stack.setCurrentWidget(editor) 
    543      
     555 
    544556    def editor_for_variable(self, var): 
    545557        """Return the editor for ``var``'s variable type. 
    546          
     558 
    547559        The editors are cached and reused by type. 
    548            
     560 
    549561        """ 
    550562        editor = None 
     
    555567        else: 
    556568            editor = VariableEditor 
    557              
     569 
    558570        if type(var) not in self._editor_cache: 
    559571            editor = editor() 
    560572            self._editor_cache[type(var)] = editor 
    561573            self.editor_stack.addWidget(editor) 
    562              
     574 
    563575        return self._editor_cache[type(var)] 
    564      
     576 
    565577    def on_variable_changed(self): 
    566578        """When the user edited the current variable in editor. 
     
    569581        editor = self.editor_stack.currentWidget() 
    570582        new_var = editor.get_data() 
    571          
     583 
    572584        # Replace the variable in the 'Domain Features' view/model 
    573585        self.domain_model[self.edited_variable_index] = new_var 
    574586        old_var = self.all_vars[self.edited_variable_index] 
    575          
     587 
    576588        # Store the transformation hint. 
    577589        self.domain_change_hints[variable_description(old_var)] = \ 
     
    581593        new_var.source_variable = old_var 
    582594        new_var.get_value_from = Orange.core.ClassifierFromVar(whichVar=old_var) 
    583          
     595 
    584596        self.commit_if() 
    585           
     597 
    586598    def reset_all(self): 
    587599        """Reset all variables to the input state. 
     
    595607            self.select_variable(self.selected_index) 
    596608            self.commit_if() 
    597              
     609 
    598610    def reset_selected(self): 
    599611        """Reset the currently selected variable to its original 
    600612        state. 
    601            
     613 
    602614        """ 
    603615        if self.data is not None: 
     
    606618            if desc in self.domain_change_hints: 
    607619                del self.domain_change_hints[desc] 
    608              
     620 
    609621            # To invalidate stored hints 
    610622            self.closeContext("") 
    611623            self.openContext("", self.data) 
    612              
     624 
    613625            self.domain_model[self.selected_index] = var 
    614626            self.editor_stack.currentWidget().set_data(var) 
    615627            self.commit_if() 
    616              
     628 
    617629    def commit_if(self): 
    618630        if self.auto_commit: 
     
    620632        else: 
    621633            self.changed_flag = True 
    622          
     634 
    623635    def commit(self): 
    624         """Commit the changed data to output.  
     636        """Commit the changed data to output. 
    625637        """ 
    626638        new_data = None 
     
    632644                class_var = variables[-1] 
    633645                variables = variables[:-1] 
    634              
    635             new_metas = new_vars[len(self.input_domain.variables) :] 
     646 
     647            new_metas = new_vars[len(self.input_domain.variables):] 
    636648            new_domain = Orange.data.Domain(variables, class_var) 
    637              
     649 
    638650            # Assumes getmetas().items() order has not changed. 
    639651            # TODO: store metaids in set_data method 
    640             for (mid, _), new in zip(self.input_domain.getmetas().items(),  
     652            for (mid, _), new in zip(self.input_domain.getmetas().items(), 
    641653                                       new_metas): 
    642654                new_domain.addmeta(mid, new) 
    643                  
     655 
    644656            new_data = Orange.data.Table(new_domain, self.data) 
    645          
     657 
    646658        self.send("Data", new_data) 
    647659        self.changed_flag = False 
    648              
    649          
     660 
     661 
    650662def main(): 
    651663    import sys 
     
    660672    w.saveSettings() 
    661673    return rval 
    662          
     674 
    663675if __name__ == "__main__": 
    664676    import sys 
    665677    sys.exit(main()) 
    666      
Note: See TracChangeset for help on using the changeset viewer.