Changeset 1616:6c0bc463ca9b in orange-bioinformatics


Ignore:
Timestamp:
05/09/12 12:22:14 (2 years ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Added new PIPAx widget.

File:
1 copied

Legend:

Unmodified
Added
Removed
  • widgets/OWPIPAx.py

    r1521 r1616  
    11""" 
    2 <name>PIPA</name> 
     2<name>PIPAx</name> 
    33<description>Access data from PIPA RNA-Seq database.</description> 
    44<icon>icons/PIPA.png</icon> 
    5 <priority>30</priority> 
     5<priority>35</priority> 
    66""" 
     7 
     8import Orange 
    79 
    810from OWWidget import * 
     
    1315from collections import defaultdict 
    1416import math 
    15  
    16  
    17 #def pyqtConfigure(object, **kwargs): 
    18 #    if hasattr(object, "pyqtConfigure"): 
    19 #        object.pyqtConfigure(**kwargs) 
    20 #    else: 
    21 #        for name, value in kwargs.items(): 
    22 #            if object.metaObject().indexOfProperty(name) != -1: 
    23 #                object.setProperty(name, value) 
    24 #            elif object.metaObject().indexOfSignal(name) != -1: 
    25 #                object.connect(object. 
     17from datetime import date 
     18 
     19from OWPIPA import (MyTreeWidgetItem, ListItemDelegate, 
     20                    SelectionSetsWidget, SortedListWidget, 
     21                    SelectionByKey) 
     22 
     23try: 
     24    from ast import literal_eval 
     25except ImportError: 
     26    # Compatibility with Python 2.5 
     27    literal_eval = eval 
     28 
    2629 
    2730def tfloat(s): 
     
    3134        return None 
    3235 
     36 
    3337class MyTreeWidgetItem(QTreeWidgetItem): 
    3438 
     
    3842 
    3943    def __contains__(self, text): 
    40         return any(text.upper() in str(self.text(i)).upper() for i in range(self.columnCount()))     
    41   
     44        return any(text.upper() in str(self.text(i)).upper() \ 
     45                   for i in range(self.columnCount())) 
     46 
    4247    def __lt__(self, o1): 
    4348        col = self.par.sortColumn() 
    44         if col in [8,9,10]: #WARNING: hardcoded column numbers 
     49        if col in [8, 9]:  # WARNING: hardcoded column numbers 
    4550            return tfloat(self.text(col)) < tfloat(o1.text(col)) 
    4651        else: 
     
    4853 
    4954 
    50 #set buffer file 
    51 bufferpath = os.path.join(orngEnviron.directoryNames["bufferDir"], "pipa") 
     55# set buffer file 
     56bufferpath = os.path.join(orngEnviron.directoryNames["bufferDir"], "pipax") 
     57 
    5258try: 
    5359    os.makedirs(bufferpath) 
    5460except: 
    5561    pass 
     62 
    5663bufferfile = os.path.join(bufferpath, "database.sq3") 
    5764 
    58 class ListItemDelegate(QStyledItemDelegate): 
    59     def sizeHint(self, option, index): 
    60         size = QStyledItemDelegate.sizeHint(self, option, index) 
    61         size = QSize(size.width(), size.height() + 4) 
    62         return size 
    63  
    64     def createEditor(self, parent, option, index): 
    65         return QLineEdit(parent) 
    66      
    67     def setEditorData(self, editor, index): 
    68         editor.setText(index.data(Qt.DisplayRole).toString()) 
    69          
    70     def setModelData(self, editor, model, index): 
    71 #        print index 
    72         model.setData(index, QVariant(editor.text()), Qt.EditRole) 
    73  
    74 class SelectionSetsWidget(QFrame): 
    75     """ Widget for managing multiple stored item selections  
    76     """ 
    77     def __init__(self, parent): 
    78         QFrame.__init__(self, parent) 
    79         self.setContentsMargins(0, 0, 0, 0) 
    80         layout = QVBoxLayout() 
    81         layout.setContentsMargins(0, 0, 0, 0) 
    82         layout.setSpacing(1) 
    83 #        self._titleLabel = QLabel(self) 
    84 #        self._titleLabel 
    85 #        layout.addWidget(self._titleLabel) 
    86         self._setNameLineEdit = QLineEdit(self) 
    87         layout.addWidget(self._setNameLineEdit) 
    88          
    89         self._setListView = QListView(self) 
    90         self._listModel = QStandardItemModel(self) 
    91         self._proxyModel = QSortFilterProxyModel(self) 
    92         self._proxyModel.setSourceModel(self._listModel) 
    93          
    94         self._setListView.setModel(self._proxyModel) 
    95         self._setListView.setItemDelegate(ListItemDelegate(self)) 
    96          
    97         self.connect(self._setNameLineEdit, SIGNAL("textChanged(QString)"), self._proxyModel.setFilterFixedString) 
    98          
    99         self._completer = QCompleter(self._listModel, self) 
    100          
    101         self._setNameLineEdit.setCompleter(self._completer) 
    102          
    103         self.connect(self._listModel, SIGNAL("itemChanged(QStandardItem *)"), self._onSetNameChange) 
    104         layout.addWidget(self._setListView) 
    105         buttonLayout = QHBoxLayout() 
    106          
    107         self._addAction = QAction("+", self) 
    108         self._updateAction = QAction("Update", self) 
    109         self._removeAction = QAction("-", self) 
    110          
    111         self._addToolButton = QToolButton(self) 
    112         self._updateToolButton = QToolButton(self) 
    113         self._removeToolButton = QToolButton(self) 
    114         self._updateToolButton.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Minimum) 
    115          
    116         self._addToolButton.setDefaultAction(self._addAction) 
    117         self._updateToolButton.setDefaultAction(self._updateAction) 
    118         self._removeToolButton.setDefaultAction(self._removeAction) 
    119           
    120         buttonLayout.addWidget(self._addToolButton) 
    121         buttonLayout.addWidget(self._updateToolButton) 
    122         buttonLayout.addWidget(self._removeToolButton) 
    123          
    124         layout.addLayout(buttonLayout) 
    125         self.setLayout(layout) 
    126          
    127         self.connect(self._addAction, SIGNAL("triggered()"), self.addCurrentSelection) 
    128         self.connect(self._updateAction, SIGNAL("triggered()"), self.updateSelectedSelection) 
    129         self.connect(self._removeAction, SIGNAL("triggered()"), self.removeSelectedSelection) 
    130          
    131         self.connect(self._setListView.selectionModel(), SIGNAL("selectionChanged(QItemSelection, QItemSelection)"), self._onListViewSelectionChanged) 
    132         self.selectionModel = None 
    133         self._selections = [] 
    134          
    135     def sizeHint(self): 
    136         size = QFrame.sizeHint(self) 
    137         return QSize(size.width(), 200) 
    138          
    139     def _onSelectionChanged(self, selected, deselected): 
    140         self.setSelectionModified(True) 
    141          
    142     def _onListViewSelectionChanged(self, selected, deselected): 
    143         try: 
    144             index= self._setListView.selectedIndexes()[0] 
    145         except IndexError: 
    146             return  
    147         self.commitSelection(self._proxyModel.mapToSource(index).row()) 
    148  
    149     def _onSetNameChange(self, item): 
    150         self.selections[item.row()].name = str(item.text()) 
    151                  
    152     def _setButtonStates(self, val): 
    153         self._updateToolButton.setEnabled(val) 
    154          
    155     def setSelectionModel(self, selectionModel): 
    156         if self.selectionModel: 
    157             self.disconnect(self.selectionModel, SIGNAL("selectionChanged(QItemSelection, QItemSelection)", self._onSelectionChanged)) 
    158         self.selectionModel = selectionModel 
    159         self.connect(self.selectionModel, SIGNAL("selectionChanged(QItemSelection, QItemSelection)"), self._onSelectionChanged) 
    160          
    161     def addCurrentSelection(self): 
    162         item = self.addSelection(SelectionByKey(self.selectionModel.selection(), name="New selection", key=(1, 2, 3 ,10))) 
    163         index = self._proxyModel.mapFromSource(item.index()) 
    164         self._setListView.setCurrentIndex(index) 
    165         self._setListView.edit(index) 
    166         self.setSelectionModified(False) 
    167      
    168     def removeSelectedSelection(self): 
    169         i = self._proxyModel.mapToSource(self._setListView.currentIndex()).row() 
    170         self._listModel.takeRow(i) 
    171         del self.selections[i] 
    172      
    173     def updateCurentSelection(self): 
    174         i = self._proxyModel.mapToSource(self._setListView.selectedIndex()).row() 
    175         self.selections[i].setSelection(self.selectionModel.selection()) 
    176         self.setSelectionModified(False) 
    177          
    178     def addSelection(self, selection, name=""): 
    179         self._selections.append(selection) 
    180         item = QStandardItem(selection.name) 
    181         item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled) 
    182         self._listModel.appendRow(item) 
    183         self.setSelectionModified(False) 
    184         return item 
    185          
    186     def updateSelectedSelection(self): 
    187         i = self._proxyModel.mapToSource(self._setListView.currentIndex()).row() 
    188         self.selections[i].setSelection(self.selectionModel.selection()) 
    189         self.setSelectionModified(False) 
    190          
    191     def setSelectionModified(self, val): 
    192         self._selectionModified = val 
    193         self._setButtonStates(val) 
    194         self.emit(SIGNAL("selectionModified(bool)"), bool(val)) 
    195          
    196     def commitSelection(self, index): 
    197         selection = self.selections[index] 
    198         selection.select(self.selectionModel) 
    199          
    200     def setSelections(self, selections): 
    201         self._listModel.clear() 
    202 #        print selections 
    203         for selection in selections: 
    204             self.addSelection(selection) 
    205              
    206     def selections(self): 
    207         return self._selections 
    208      
    209     selections = property(selections, setSelections) 
    210      
    211 class SelectionByKey(object): 
    212     """ An object stores item selection by unique key values  
    213     (works only for row selections in list and table models) 
    214     Example:: 
    215         ## Save selection by unique tuple pairs (DisplayRole of column 1 and 2) 
    216         selection = SelectionsByKey(itemView.selectionModel().selection(), key = (1,2)) 
    217         ... 
    218         ## restore selection (Possibly omitting rows not present in the model)   
    219         selection.select(itemView.selectionModel()) 
    220     """ 
    221      
    222     def __init__(self, itemSelection, name="", key=(0,)): 
    223         self._key = key 
    224         self.name = name 
    225         self._selected_keys = [] 
    226         if itemSelection: 
    227             self.setSelection(itemSelection) 
    228          
    229     def _row_key(self, model, row): 
    230         val = lambda row, col: str(model.data(model.index(row, col), Qt.DisplayRole).toString()) 
    231         return tuple(val(row, col) for col in self._key) 
    232      
    233     def setSelection(self, itemSelection): 
    234         self._selected_keys = [self._row_key(ind.model(), ind.row()) for ind in itemSelection.indexes() if ind.column() == 0] 
    235      
    236     def select(self, selectionModel): 
    237         model = selectionModel.model() 
    238         selected = [] 
    239         selectionModel.clear() 
    240         for i in range(model.rowCount()): 
    241             if self._row_key(model, i) in self._selected_keys: 
    242                 selectionModel.select(model.index(i, 0), QItemSelectionModel.Select | QItemSelectionModel.Rows) 
    243  
    244     def __len__(self): 
    245         return len(self._selected_keys) 
    246                  
    247 class SortedListWidget(QWidget): 
    248     class _MyItemDelegate(QStyledItemDelegate): 
    249         def __init__(self, sortingModel, parent): 
    250             QStyledItemDelegate.__init__(self, parent) 
    251             self.sortingModel = sortingModel 
    252              
    253         def sizeHint(self, option, index): 
    254             size = QStyledItemDelegate.sizeHint(self, option, index) 
    255             return QSize(size.width(), size.height() + 4) 
    256              
    257         def createEditor(self, parent, option, index): 
    258             cb = QComboBox(parent) 
    259             cb.setModel(self.sortingModel) 
    260             cb.showPopup() 
    261             return cb 
    262          
    263         def setEditorData(self, editor, index): 
    264             pass # TODO: sensible default  
    265          
    266         def setModelData(self, editor, model, index): 
    267             text = editor.currentText() 
    268             model.setData(index, QVariant(text)) 
    269      
    270     def __init__(self, *args): 
    271         QWidget.__init__(self, *args) 
    272         self.setContentsMargins(0, 0, 0, 0) 
    273         gridLayout = QGridLayout() 
    274         gridLayout.setContentsMargins(0, 0, 0, 0) 
    275         gridLayout.setSpacing(1) 
    276         self._listView = QListView(self) 
    277         self._listView.setModel(QStandardItemModel(self)) 
    278 #        self._listView.setDragEnabled(True) 
    279         self._listView.setDropIndicatorShown(True) 
    280         self._listView.viewport().setAcceptDrops(True) 
    281         self._listView.setDragDropMode(QAbstractItemView.InternalMove) 
    282         self._listView.setMinimumHeight(100) 
    283          
    284         gridLayout.addWidget(self._listView, 0, 0, 2, 2) 
    285          
    286         vButtonLayout = QVBoxLayout() 
    287          
    288         self._upAction = QAction(QIcon(os.path.join(orngEnviron.widgetDir, "icons/Dlg_up3.png")), "Up", self) 
    289          
    290         self._upButton = QToolButton(self) 
    291         self._upButton.setDefaultAction(self._upAction) 
    292         self._upButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) 
    293  
    294         self._downAction = QAction(QIcon(os.path.join(orngEnviron.widgetDir, "icons/Dlg_down3.png")), "Down", self) 
    295         self._downButton = QToolButton(self) 
    296         self._downButton.setDefaultAction(self._downAction) 
    297         self._downButton.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.MinimumExpanding) 
    298          
    299         vButtonLayout.addWidget(self._upButton) 
    300         vButtonLayout.addWidget(self._downButton) 
    301          
    302         gridLayout.addLayout(vButtonLayout, 0, 2, 2, 1) 
    303          
    304         hButtonLayout = QHBoxLayout() 
    305          
    306         self._addAction = QAction("+", self) 
    307         self._addButton = QToolButton(self) 
    308         self._addButton.setDefaultAction(self._addAction) 
    309          
    310         self._removeAction = QAction("-", self) 
    311         self._removeButton = QToolButton(self) 
    312         self._removeButton.setDefaultAction(self._removeAction) 
    313         hButtonLayout.addWidget(self._addButton) 
    314         hButtonLayout.addWidget(self._removeButton) 
    315         hButtonLayout.addStretch(10) 
    316         gridLayout.addLayout(hButtonLayout, 2, 0, 1, 2) 
    317          
    318         self.setLayout(gridLayout) 
    319          
    320         self.connect(self._addAction, SIGNAL("triggered()"), self._onAddAction) 
    321         self.connect(self._removeAction, SIGNAL("triggered()"), self._onRemoveAction) 
    322         self.connect(self._upAction, SIGNAL("triggered()"), self._onUpAction) 
    323         self.connect(self._downAction, SIGNAL("triggered()"), self._onDownAction) 
    324          
    325     def sizeHint(self): 
    326         size = QWidget.sizeHint(self) 
    327         return QSize(size.width(), 100) 
    328          
    329     def _onAddAction(self): 
    330         item = QStandardItem("") 
    331         item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled) 
    332         self._listView.model().appendRow(item) 
    333         self._listView.setCurrentIndex(item.index()) 
    334         self._listView.edit(item.index())  
    335      
    336     def _onRemoveAction(self): 
    337         current = self._listView.currentIndex() 
    338         self._listView.model().takeRow(current.row()) 
    339      
    340     def _onUpAction(self): 
    341         row = self._listView.currentIndex().row() 
    342         model = self._listView.model() 
    343         if row > 0: 
    344             items = model.takeRow(row) 
    345             model.insertRow(row - 1, items) 
    346             self._listView.setCurrentIndex(model.index(row - 1, 0)) 
    347      
    348     def _onDownAction(self): 
    349         row = self._listView.currentIndex().row() 
    350         model = self._listView.model() 
    351         if row < model.rowCount() and row >= 0: 
    352             items = model.takeRow(row) 
    353             if row == model.rowCount(): 
    354                 model.appendRow(items) 
    355             else: 
    356                 model.insertRow(row + 1, items) 
    357             self._listView.setCurrentIndex(model.index(row + 1, 0)) 
    358      
    359     def setModel(self, model): 
    360         """ Set a model to select items from 
    361         """ 
    362         self._model  = model 
    363         self._listView.setItemDelegate(self._MyItemDelegate(self._model, self)) 
    364          
    365     def addItem(self, *args): 
    366         """ Add a new entry in the list  
    367         """ 
    368         item = QStandardItem(*args) 
    369         item.setFlags(item.flags() ^ Qt.ItemIsDropEnabled) 
    370         self._listView.model().appendRow(item) 
    371          
    372     def setItems(self, items): 
    373         self._listView.model().clear() 
    374         for item in items: 
    375             self.addItem(item) 
    376           
    377     def items(self): 
    378         order = [] 
    379         for row in range(self._listView.model().rowCount()): 
    380              order.append(str(self._listView.model().item(row ,0).text())) 
    381         return order 
    382      
    383     sortingOrder = property(items, setItems) 
    384          
    385      
    386 class OWPIPA(OWWidget): 
    387     settingsList = [ "platform", "selectedExperiments", "server", "buffertime", "excludeconstant", "username", "password","joinreplicates", 
    388                      "selectionSetsWidget.selections", "columnsSortingWidget.sortingOrder", "currentSelection", "log2", "raw", "experimentsHeaderState", "ctypei"] 
    389     def __init__(self, parent=None, signalManager=None, name="PIPA"): 
     65# Mapping from PIPAx.results_list annotation keys to Header names. 
     66HEADER = [("_cached", ""), 
     67          ("data_name", "Name"), 
     68          ("species_name", "Species"), 
     69          ("strain", "Strain"), 
     70          ("Experiment", "Experiment"), 
     71          ("genotype", "Genotype"), 
     72          ("treatment", "Treatment"), 
     73          ("growth", "Growth"), 
     74          ("tp", "Timepoint"), 
     75          ("replicate", "Replicate"), 
     76          ("unique_id", "ID"), 
     77          ("date_rnaseq", "Date RNAseq"), 
     78          ("adapter_type", "Adapter"), 
     79          ("experimenter", "Experimenter"), 
     80          ("band", "Band"), 
     81          ("polya", "Polya"), 
     82          ("primer", "Primer"), 
     83          ("shearing", "Shearing") 
     84          ] 
     85 
     86# Index of unique_id 
     87ID_INDEX = 10 
     88 
     89# Index of 'date_rnaseq' 
     90DATE_INDEX = 11 
     91 
     92SORTING_MODEL_LIST = \ 
     93    ["Strain", "Experiment", "Genotype", 
     94     "Timepoint", "Growth", "Species", 
     95     "ID", "Name", "Replicate"] 
     96 
     97 
     98class OWPIPAx(OWWidget): 
     99    settingsList = ["server", "excludeconstant", "username", "password", 
     100                    "joinreplicates", "selectionSetsWidget.selections", 
     101                    "columnsSortingWidget.sortingOrder", "currentSelection", 
     102                    "log2", "experimentsHeaderState", "rtypei"] 
     103 
     104    def __init__(self, parent=None, signalManager=None, name="PIPAx"): 
    390105        OWWidget.__init__(self, parent, signalManager, name) 
    391106        self.outputs = [("Example table", ExampleTable)] 
    392107 
    393         self.platform = None 
    394108        self.username = "" 
    395109        self.password = "" 
    396110        self.log2 = False 
    397         self.ctypei = 0 
     111        self.rtypei = 0 
    398112 
    399113        self.selectedExperiments = [] 
     
    404118        self.joinreplicates = False 
    405119        self.currentSelection = None 
    406          
    407         self.experimentsHeaderState = {"": False, "Name":False, "Species": False, "Strain": False, "Experiment":False, "Genotype": False, "Treatment": False, 
    408                                        "Growth": False, "Timepoint": False, "Replicate": False, "ID": False} 
    409  
    410         self.exTypes = [] 
    411         self.annots = {} 
     120 
     121        self.experimentsHeaderState = \ 
     122                dict(((name, False) for _, name in HEADER[:ID_INDEX + 1])) 
     123 
     124        self.result_types = [] 
     125        self.mappings = {} 
    412126 
    413127        self.controlArea.setMaximumWidth(250) 
    414128        self.controlArea.setMinimumWidth(250) 
    415129 
    416         OWGUI.button(self.controlArea, self, "Reload", callback=self.Reload) 
    417         OWGUI.button(self.controlArea, self, "Clear cache", callback=self.clear_cache) 
    418          
     130        OWGUI.button(self.controlArea, self, "Reload", 
     131                     callback=self.Reload) 
     132        OWGUI.button(self.controlArea, self, "Clear cache", 
     133                     callback=self.clear_cache) 
     134 
    419135        b = OWGUI.widgetBox(self.controlArea, "Experiment Sets") 
    420136        self.selectionSetsWidget = SelectionSetsWidget(self) 
    421         self.selectionSetsWidget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) 
    422 #        self.controlArea.layout().addWidget(self.selectionSetsWidget) 
     137        self.selectionSetsWidget.setSizePolicy(QSizePolicy.Preferred, 
     138                                               QSizePolicy.Maximum) 
    423139        b.layout().addWidget(self.selectionSetsWidget) 
    424          
     140 
     141        OWGUI.separator(self.controlArea) 
     142 
    425143        b = OWGUI.widgetBox(self.controlArea, "Sort output columns") 
    426144        self.columnsSortingWidget = SortedListWidget(self) 
    427         self.columnsSortingWidget.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) 
    428 #        self.controlArea.layout().addWidget(self.columnsSortingWidget) 
     145        self.columnsSortingWidget.setSizePolicy(QSizePolicy.Preferred, 
     146                                                QSizePolicy.Maximum) 
    429147        b.layout().addWidget(self.columnsSortingWidget) 
    430         self.columnsSortingWidget.setModel(QStringListModel(["Strain", "Experiment", "Genotype", "Timepoint", "Growth", "Species", "Id", "Name"])) 
    431         self.columnsSortingWidget.sortingOrder = ["Strain", "Experiment", "Genotype", "Timepoint"] 
     148        sorting_model = QStringListModel(SORTING_MODEL_LIST) 
     149        self.columnsSortingWidget.setModel(sorting_model) 
     150 
     151        self.columnsSortingWidget.sortingOrder = \ 
     152                ["Strain", "Experiment", "Genotype", "Timepoint"] 
     153 
     154        OWGUI.separator(self.controlArea) 
     155 
     156        box = OWGUI.widgetBox(self.controlArea, 'Expression Type') 
     157        self.expressionTypesCB = OWGUI.comboBox(box, self, "rtypei", 
     158                items=[], 
     159                callback=self.UpdateResultsList) 
     160 
     161        OWGUI.checkBox(self.controlArea, self, "excludeconstant", 
     162                       "Exclude labels with constant values" 
     163                       ) 
     164 
     165        OWGUI.checkBox(self.controlArea, self, "joinreplicates", 
     166                       "Average replicates (use median)" 
     167                       ) 
     168 
     169        OWGUI.checkBox(self.controlArea, self, "log2", 
     170                       "Logarithmic (base 2) transformation" 
     171                       ) 
     172 
     173        self.commit_button = OWGUI.button(self.controlArea, self, "&Commit", 
     174                                          callback=self.Commit) 
     175        self.commit_button.setDisabled(True) 
     176 
    432177        OWGUI.rubber(self.controlArea) 
    433178 
    434         box = OWGUI.widgetBox(self.controlArea, 'Expression Type') 
    435         self.expressionTypesCB = cb = OWGUI.comboBox(box, self, "ctypei", items=[], debuggingEnabled=0, callback=self.UpdateCached) 
    436  
    437  
    438         OWGUI.checkBox(self.controlArea, self, "excludeconstant", "Exclude labels with constant values" ) 
    439         OWGUI.checkBox(self.controlArea, self, "joinreplicates", "Average replicates (use median)" ) 
    440         OWGUI.checkBox(self.controlArea, self, "log2", "Logarithmic (base 2) transformation" ) 
    441  
    442         self.commit_button = OWGUI.button(self.controlArea, self, "&Commit", callback=self.Commit) 
    443         self.commit_button.setDisabled(True) 
    444  
    445         OWGUI.rubber(self.controlArea) 
    446         OWGUI.rubber(self.controlArea) 
    447         OWGUI.rubber(self.controlArea) 
    448         OWGUI.rubber(self.controlArea) 
    449  
    450         box  = OWGUI.widgetBox(self.controlArea, "Authentication") 
    451  
    452         OWGUI.lineEdit(box, self, "username", "Username:", labelWidth=100, orientation='horizontal', callback=self.AuthChanged) 
    453         self.passf = OWGUI.lineEdit(box, self, "password", "Password:", labelWidth=100, orientation='horizontal', callback=self.AuthChanged) 
     179        box = OWGUI.widgetBox(self.controlArea, "Authentication") 
     180 
     181        OWGUI.lineEdit(box, self, "username", "Username:", 
     182                       labelWidth=100, 
     183                       orientation='horizontal', 
     184                       callback=self.AuthChanged) 
     185 
     186        self.passf = OWGUI.lineEdit(box, self, "password", "Password:", 
     187                                    labelWidth=100, 
     188                                    orientation='horizontal', 
     189                                    callback=self.AuthChanged) 
     190 
    454191        self.passf.setEchoMode(QLineEdit.Password) 
    455192 
    456         OWGUI.lineEdit(self.mainArea, self, "searchString", "Search", callbackOnType=True, callback=self.SearchUpdate) 
    457         self.headerLabels = ["", "Name", "Species", "Strain", "Experiment", "Genotype", "Treatment", "Growth", "Timepoint", "Replicate", "ID", 
    458                              "Date RNA", "Adapter", "Who", "Date Rep", "Band", "Amount", "Experimenter","Polya", "Primer", "Shearing", "Unit"] 
     193        OWGUI.lineEdit(self.mainArea, self, "searchString", "Search", 
     194                       callbackOnType=True, 
     195                       callback=self.SearchUpdate) 
     196 
     197        self.headerLabels = [t[1] for t in HEADER] 
     198 
    459199        self.experimentsWidget = QTreeWidget() 
    460200        self.experimentsWidget.setHeaderLabels(self.headerLabels) 
     
    462202        self.experimentsWidget.setRootIsDecorated(False) 
    463203        self.experimentsWidget.setSortingEnabled(True) 
    464         contextEventFilter = OWGUI.VisibleHeaderSectionContextEventFilter(self.experimentsWidget, self.experimentsWidget) 
     204 
     205        contextEventFilter = OWGUI.VisibleHeaderSectionContextEventFilter( 
     206                            self.experimentsWidget, self.experimentsWidget 
     207                            ) 
     208 
    465209        self.experimentsWidget.header().installEventFilter(contextEventFilter) 
    466         self.experimentsWidget.setItemDelegateForColumn(0, OWGUI.IndicatorItemDelegate(self, role=Qt.DisplayRole)) 
     210        self.experimentsWidget.setItemDelegateForColumn(0, 
     211                    OWGUI.IndicatorItemDelegate(self, role=Qt.DisplayRole) 
     212                    ) 
     213 
    467214        self.experimentsWidget.setAlternatingRowColors(True) 
    468          
     215 
    469216        self.connect(self.experimentsWidget.selectionModel(), 
    470                      SIGNAL("selectionChanged(QItemSelection, QItemSelection)"), 
    471                      self.onSelectionChanged) 
    472  
    473         self.selectionSetsWidget.setSelectionModel(self.experimentsWidget.selectionModel()) 
     217                 SIGNAL("selectionChanged(QItemSelection, QItemSelection)"), 
     218                 self.onSelectionChanged) 
     219 
     220        self.selectionSetsWidget.setSelectionModel( 
     221                            self.experimentsWidget.selectionModel() 
     222                            ) 
    474223 
    475224        self.mainArea.layout().addWidget(self.experimentsWidget) 
    476225 
    477226        self.loadSettings() 
    478          
     227 
    479228        self.restoreHeaderState() 
    480          
    481         self.connect(self.experimentsWidget.header(), SIGNAL("geometriesChanged()"), self.saveHeaderState) 
    482          
     229 
     230        self.connect(self.experimentsWidget.header(), 
     231                     SIGNAL("geometriesChanged()"), 
     232                     self.saveHeaderState) 
     233 
    483234        self.dbc = None 
    484235 
     
    487238        QTimer.singleShot(100, self.UpdateExperiments) 
    488239 
    489         self.resize(800, 600)         
    490  
    491     def __updateSelectionList(self, oldList, oldSelection, newList): 
    492         oldList = [oldList[i] for i in oldSelection] 
    493         return [ i for i, new in enumerate(newList) if new in oldList] 
    494      
     240        self.resize(800, 600) 
     241 
    495242    def AuthSet(self): 
    496243        if len(self.username): 
     
    508255 
    509256    def Connect(self): 
    510  
    511257        self.error(1) 
    512258        self.warning(1) 
     
    515261            return x if len(x) else None 
    516262 
    517         self.dbc = obiDicty.PIPA(buffer=self.buffer, username=en(self.username), password=self.password) 
     263        self.dbc = obiDicty.PIPAx(buffer=self.buffer, 
     264                                  username=en(self.username), 
     265                                  password=self.password) 
    518266 
    519267        #check password 
    520268        if en(self.username) != None: 
    521269            try: 
    522                 self.dbc.annotations(reload=True) 
     270                self.dbc.mappings(reload=True) 
    523271            except obiDicty.AuthenticationError: 
    524272                self.error(1, "Wrong username or password") 
     
    528276                import traceback 
    529277                print traceback.format_exc() 
    530                 try: #mable cached? 
    531                     self.dbc.annotations() 
     278                try:  # maybe cached? 
     279                    self.dbc.mappings() 
    532280                    self.warning(1, "Can not access database - using cached data.") 
    533                 except Exception,ex: 
     281                except Exception, ex: 
    534282                    self.dbc = None 
    535283                    self.error(1, "Can not access database.") 
    536284 
    537285    def Reload(self): 
    538         #self.buffer.clear() 
    539286        self.UpdateExperiments(reload=True) 
    540287 
     
    543290        self.Reload() 
    544291 
    545     def ctype(self): 
    546         """ Returns selected experiment type """ 
    547         if self.exTypes: 
    548             return self.exTypes[self.ctypei][0] 
     292    def rtype(self): 
     293        """Return selected result template type """ 
     294        if self.result_types: 
     295            return self.result_types[self.rtypei][0] 
    549296        else: 
    550297            return "-1" 
    551298 
    552299    def UpdateExperimentTypes(self): 
    553         self.signalManager.freeze(self).push() #setFreeze(1) 
    554         try: 
    555             self.expressionTypesCB.clear() 
    556             items = [desc for _,desc,_ in self.exTypes] 
    557             self.expressionTypesCB.addItems(items) 
    558         except IOError: 
    559             pass 
    560         finally: 
    561             self.signalManager.freeze(self).pop() #setFreeze(0) 
    562         self.ctypei = max(0, min(self.ctypei, len(self.exTypes)-1)) 
     300        self.expressionTypesCB.clear() 
     301        items = [desc for _, desc  in self.result_types] 
     302        self.expressionTypesCB.addItems(items) 
     303        self.rtypei = max(0, min(self.rtypei, len(self.result_types) - 1)) 
    563304 
    564305    def UpdateExperiments(self, reload=False): 
    565  
    566         self.chipsl = [] 
    567306        self.experimentsWidget.clear() 
    568307        self.items = [] 
     
    572311        if not self.dbc: 
    573312            self.Connect() 
    574   
    575         annots = {} 
    576         exTypes = [] 
    577          
    578         sucind = False #success indicator for database index 
     313 
     314        mappings = {} 
     315        result_types = [] 
     316        sucind = False  # success indicator for database index 
    579317 
    580318        try: 
    581             annots = self.dbc.annotations(chips, reload=reload) 
    582             exTypes = self.dbc.gene_expression_types(reload=reload) 
     319            mappings = self.dbc.mappings(reload=reload) 
     320            result_types = self.dbc.result_types(reload=reload) 
    583321            sucind = True 
    584322        except Exception, ex: 
    585323            try: 
    586                 annots = self.dbc.annotations() 
    587                 exTypes = self.dbc.gene_expression_types() 
     324                mappings = self.dbc.mappings() 
     325                result_types = self.dbc.result_types() 
    588326                self.warning(0, "Can not access database - using cached data.") 
    589327                sucind = True 
    590             except Exception,ex: 
     328            except Exception, ex: 
    591329                self.error(0, "Can not access database.") 
    592330 
     
    595333            self.error(0) 
    596334 
    597         self.annots = annots 
    598         self.exTypes = exTypes 
    599  
    600         self.UpdateExperimentTypes()  
     335        self.mappings = mappings 
     336        self.result_types = result_types 
     337 
     338        self.UpdateExperimentTypes() 
     339 
     340        results_list = {} 
     341        try: 
     342            results_list = self.dbc.results_list(self.rtype(), reload=reload) 
     343        except Exception, ex: 
     344            try: 
     345                results_list = self.dbc.results_list(self.rtype()) 
     346            except Exception, ex: 
     347                self.error(0, "Can not access database.") 
     348 
     349        self.results_list = results_list 
     350        mappings_key_dict = dict(((m["data_id"], m["id"]), key) \ 
     351                                 for key, m in mappings.items()) 
     352 
     353        def mapping_unique_id(annot): 
     354            """Map annotations dict from results_list to unique 
     355            `mappings` ids. 
     356            """ 
     357            data_id, mappings_id = annot["data_id"], annot["mappings_id"] 
     358            return mappings_key_dict[data_id, mappings_id] 
    601359 
    602360        elements = [] 
    603361        pos = 0 
    604362 
    605         for chip,annot in self.annots.items(): 
     363        for r_id, r_annot in self.results_list.items(): 
    606364            pos += 1 
    607             d = defaultdict(lambda: "?", annot) 
    608             elements.append(["", d["name"], d["species"], d["strain"], d["Experiment"], d["genotype"], d["treatment"], d["growth"], d["tp"], d["replicate"], chip] + \ 
    609                              [d[label.lower().replace(" ", "_")] for label in ["Date RNA", "Adapter", "Who", "Date Rep", "Band", "Amount", "Experimenter", "Polya", "Primer", "Shearing", "Unit"]]) 
    610              
    611 #            self.progressBarSet((100.0 * pos) / len(chips)) 
    612              
    613             el = elements[-1] 
    614             ci = MyTreeWidgetItem(self.experimentsWidget, el) 
     365            d = defaultdict(lambda: "?", r_annot) 
     366            row_items = [""] + [d.get(key, "?") for key, _ in HEADER[1:]] 
     367            date_string = row_items[DATE_INDEX] 
     368            try: 
     369                time_dict = literal_eval(date_string) 
     370            except Exception: 
     371                time_dict = {} 
     372 
     373            if time_dict and "dateUTC" in time_dict and \ 
     374                    "monthUTC" in time_dict and "fullYearUTC" in time_dict: 
     375                date_rna = date(time_dict["fullYearUTC"], 
     376                                time_dict["monthUTC"] + 1,  # Why is month 0 based? 
     377                                time_dict["dateUTC"]) 
     378 
     379                row_items[DATE_INDEX] = date_rna.strftime("%D") 
     380 
     381            row_items[ID_INDEX] = mapping_unique_id(r_annot) 
     382            elements.append(row_items) 
     383 
     384            ci = MyTreeWidgetItem(self.experimentsWidget, row_items) 
    615385 
    616386            self.items.append(ci) 
     
    619389            self.experimentsWidget.resizeColumnToContents(i) 
    620390 
    621         #which is the ok buffer version 
    622         self.wantbufver = lambda x,ad=self.annots: defaultdict(lambda: "?", ad[x])["date"] #FIXME what attribute to use for version? 
     391        # which is the ok buffer version 
     392        # FIXME: what attribute to use for version? 
     393        self.wantbufver = \ 
     394            lambda x, ad=self.results_list: \ 
     395                defaultdict(lambda: "?", ad[x])["date"] 
     396 
     397        self.wantbufver = lambda x: "0" 
    623398 
    624399        self.UpdateCached() 
    625400 
    626401        self.progressBarFinished() 
    627          
     402 
    628403        if self.currentSelection: 
    629404            self.currentSelection.select(self.experimentsWidget.selectionModel()) 
     
    631406        self.handle_commit_button() 
    632407 
     408    def UpdateResultsList(self, reload=False): 
     409        results_list = {} 
     410        try: 
     411            results_list = self.dbc.results_list(self.rtype(), reload=reload) 
     412        except Exception: 
     413            results_list = self.dbc.results_list(self.rtype()) 
     414        self.results_list = results_list 
     415        self.UpdateCached() 
     416 
    633417    def UpdateCached(self): 
    634418        if self.wantbufver and self.dbc: 
    635             fn = self.dbc.chips_keynaming(self.ctype()) 
     419            fn = self.dbc.download_key_function() 
     420            result_id_key = dict(((m["data_id"], m["mappings_id"]), key) \ 
     421                                 for key, m in self.results_list.items()) 
    636422 
    637423            for item in self.items: 
    638424                c = str(item.text(10)) 
    639                 item.setData(0, Qt.DisplayRole, QVariant(" " if self.dbc.inBuffer(fn(c)) == self.wantbufver(c) else "")) 
     425                mapping = self.mappings[c] 
     426                data_id, mappings_id = mapping["data_id"], mapping["id"] 
     427                r_id = result_id_key[data_id, mappings_id] 
     428                # Get the buffered version 
     429                buffered = self.dbc.inBuffer(fn(r_id)) 
     430                value = " " if buffered == self.wantbufver(r_id) else "" 
     431                item.setData(0, Qt.DisplayRole, QVariant(value)) 
    640432 
    641433    def SearchUpdate(self, string=""): 
    642434        for item in self.items: 
    643             item.setHidden(not all(s in item for s in self.searchString.split())) 
     435            item.setHidden(not all(s in item \ 
     436                                   for s in self.searchString.split()) 
     437                           ) 
    644438 
    645439    def Commit(self): 
    646440        if not self.dbc: 
    647441            self.Connect() 
    648         allTables = [] 
    649  
    650         import time 
    651         start = time.time() 
    652  
    653         pb = OWGUI.ProgressBar(self, iterations=1000) 
     442 
     443        pb = OWGUI.ProgressBar(self, iterations=100) 
    654444 
    655445        table = None 
     
    657447        ids = [] 
    658448        for item in self.experimentsWidget.selectedItems(): 
    659             ids += [ str(item.text(10)) ] 
     449            unique_id = str(item.text(10)) 
     450            annots = self.mappings[unique_id] 
     451            ids.append((annots["data_id"], annots["id"])) 
    660452 
    661453        transfn = None 
    662454        if self.log2: 
    663             transfn = lambda x: math.log(x+1.0, 2) 
    664          
    665         keys = {"Strain": "strain", "Genotype": "genotype", "Treatment": "treatment", "Timepoint": "tp", "Growth": "growth", "Replicate": "replicate",  
    666                 "Species": "species", "Name": "name", "Date RNA": "date_rna", "Adapter":"adapter", 
    667                 "Who": "who", "Date Rep": "date_rep", "Band": "band", "Amount": "amount", "Experimenter":"experimenter", 
    668                 "Polya": "polya", "Primer": "primer", "Shearing": "shearing", "Unit": "unit", "Experiment":"Experiment"} 
    669          
     455            transfn = lambda x: math.log(x + 1.0, 2) 
     456 
     457        reverse_header_dict = dict((name, key) for key, name in HEADER) 
     458 
    670459        hview = self.experimentsWidget.header() 
    671         shownHeaders = [label for i, label in list(enumerate(self.headerLabels))[1:] if not hview.isSectionHidden(i)] 
    672         allowed_labels = [keys.get(label, label) for label in shownHeaders] 
    673          
     460        shownHeaders = [label for i, label in \ 
     461                        list(enumerate(self.headerLabels))[1:] \ 
     462                        if not hview.isSectionHidden(i) 
     463                        ] 
     464 
     465        allowed_labels = [reverse_header_dict.get(label, label) \ 
     466                          for label in shownHeaders] 
     467 
    674468        if self.joinreplicates and "id" not in allowed_labels: 
    675469            # need 'id' labels in join_replicates for attribute names 
    676470            allowed_labels.append("id") 
    677          
     471 
    678472        if len(ids): 
    679             table = self.dbc.get_data(ids=ids, callback=pb.advance, exclude_constant_labels=self.excludeconstant, bufver=self.wantbufver, transform=transfn, allowed_labels=allowed_labels, ctype=self.ctype()) 
     473            table = self.dbc.get_data(ids=ids, result_type=self.rtype(), 
     474                          callback=pb.advance, 
     475                          exclude_constant_labels=self.excludeconstant, 
     476#                          bufver=self.wantbufver, 
     477                          transform=transfn, 
     478                          allowed_labels=allowed_labels) 
    680479 
    681480            if self.joinreplicates: 
    682                 table = obiDicty.join_replicates(table, ignorenames=["replicate", "id", "name", "map_stop1"], namefn=None, avg=obiDicty.median) 
    683  
    684             end = int(time.time()-start) 
    685              
     481                table = obiDicty.join_replicates(table, 
     482                    ignorenames=["replicate", "data_id", "mappings_id", 
     483                                 "data_name", "id", "unique_id"], 
     484                    namefn=None, 
     485                    avg=obiDicty.median 
     486                    ) 
    686487 
    687488            # Sort attributes 
    688489            sortOrder = self.columnsSortingWidget.sortingOrder 
    689             # print sortOrder 
    690              
    691             attributes = sorted(table.domain.attributes, key=lambda attr: tuple([attr.attributes.get(keys[name], "") for name in sortOrder])) 
     490 
     491            def sorting_key(attr): 
     492                atts = attr.attributes 
     493                return tuple([atts.get(reverse_header_dict[name], "") \ 
     494                              for name in sortOrder]) 
     495 
     496            attributes = sorted(table.domain.attributes, 
     497                                key=sorting_key) 
     498 
    692499            domain = orange.Domain(attributes, table.domain.classVar) 
    693500            domain.addmetas(table.domain.getmetas()) 
    694501            table = orange.ExampleTable(domain, table) 
    695              
     502 
    696503            from orngDataCaching import data_hints 
    697             data_hints.set_hint(table, "taxid", "352472")  
     504            data_hints.set_hint(table, "taxid", "352472") 
    698505            data_hints.set_hint(table, "genesinrows", False) 
    699              
     506 
    700507            self.send("Example table", table) 
    701508 
     
    706513    def onSelectionChanged(self, selected, deselected): 
    707514        self.handle_commit_button() 
    708          
     515 
    709516    def handle_commit_button(self): 
    710         self.currentSelection = SelectionByKey(self.experimentsWidget.selectionModel().selection(), 
    711                                                key=(1, 2, 3, 10)) 
     517        self.currentSelection = \ 
     518            SelectionByKey(self.experimentsWidget.selectionModel().selection(), 
     519                           key=(1, 2, 3, 10)) 
    712520        self.commit_button.setDisabled(not len(self.currentSelection)) 
    713521 
     
    716524        for i, label in enumerate(self.headerLabels): 
    717525            self.experimentsHeaderState[label] = hview.isSectionHidden(i) 
    718              
     526 
    719527    def restoreHeaderState(self): 
    720528        hview = self.experimentsWidget.header() 
    721         for i, label in enumerate(self.headerLabels):  
    722             hview.setSectionHidden(i, self.experimentsHeaderState.get(label, True)) 
     529        state = self.experimentsHeaderState 
     530        for i, label in enumerate(self.headerLabels): 
     531            hview.setSectionHidden(i, state.get(label, True)) 
    723532            self.experimentsWidget.resizeColumnToContents(i) 
    724              
     533 
    725534if __name__ == "__main__": 
    726     app  = QApplication(sys.argv) 
    727 ##    from pywin.debugger import set_trace 
    728 ##    set_trace() 
     535    app = QApplication(sys.argv) 
    729536    obiDicty.verbose = True 
    730     w = OWPIPA() 
     537    w = OWPIPAx() 
    731538    w.show() 
    732539    app.exec_() 
    733540    w.saveSettings() 
    734              
    735          
Note: See TracChangeset for help on using the changeset viewer.