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

KEGG Pathways widget code style fixes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _bioinformatics/widgets/OWKEGGPathwayBrowser.py

    r1733 r1739  
    1010import sys 
    1111import gc 
     12import webbrowser 
     13import threading 
     14from functools import partial 
    1215from collections import defaultdict 
    13 import webbrowser 
     16from operator import add 
     17 
     18from PyQt4.QtGui import ( 
     19    QTreeWidget, QTreeWidgetItem, QItemSelectionModel, QSplitter, 
     20    QAction, QMenu, QGraphicsView, QGraphicsScene, QFont, 
     21    QBrush, QColor, QPen, QTransform, QPainter, QPainterPath, 
     22    QGraphicsItem, QGraphicsPathItem, QGraphicsPixmapItem, QPixmap 
     23) 
     24 
     25from PyQt4.QtCore import ( 
     26    Qt, QObject, QMetaObject, QTimer, Q_ARG, QRectF, SIGNAL 
     27) 
    1428 
    1529import Orange 
    16 import orange 
     30 
    1731from Orange.orng import orngMisc, orngServerFiles 
    1832from Orange.orng.orngDataCaching import data_hints 
     33 
    1934from Orange.OrangeWidgets import OWGUI 
    2035from Orange.OrangeWidgets.OWWidget import * 
     
    2742 
    2843if USE_THREADING: 
    29     import threading 
    30     from functools import partial 
     44 
    3145    def threading_queued_invoke(qobj, func): 
    3246        def safe_wrapper(*args, **kwargs): 
    33             QMetaObject.invokeMethod(qobj, "queuedInvoke",  
    34                                      Qt.QueuedConnection,  
     47            QMetaObject.invokeMethod(qobj, "queuedInvoke", 
     48                                     Qt.QueuedConnection, 
    3549                                     Q_ARG("PyQt_PyObject", 
    3650                                           partial(func, *args, **kwargs))) 
    3751        return safe_wrapper 
    38      
     52 
     53 
    3954def split_and_strip(string, sep=None): 
    4055    return [s.strip() for s in string.split(sep)] 
    4156 
     57 
     58def path_from_graphics(graphics): 
     59    """ 
     60    Return a constructed `QPainterPath` for a KEGG pathway graphics 
     61    element. 
     62 
     63    """ 
     64    path = QPainterPath() 
     65    x, y, w, h = [int(graphics.get(c, 0)) for c in 
     66                  ["x", "y", "width", "height"]] 
     67    type = graphics.get("type", "rectangle") 
     68    if type == "rectangle": 
     69        path.addRect(QRectF(x - w / 2, y - h / 2, w, h)) 
     70    elif type == "roundrectangle": 
     71        path.addRoundedRect(QRectF(x - w / 2, y - h / 2, w, h), 10, 10) 
     72    elif type == "circle": 
     73        path.addEllipse(QRectF(x - w / 2, y - h / 2, w, h)) 
     74    else: 
     75        ValueError("Unknown graphcis type %r." % type) 
     76    return path 
     77 
     78 
    4279class EntryGraphicsItem(QGraphicsPathItem): 
     80    """ 
     81    An Graphics Item with actions for an overlay of a KEGG pathway image. 
     82    """ 
    4383    def __init__(self, graphics, *args): 
    4484        QGraphicsPathItem.__init__(self, *args) 
    45         path = QPainterPath() 
    46         x, y, w, h = [int(graphics.get(c, 0)) for c in ["x", "y", "width", "height"]] 
    47         type = graphics.get("type", "rectangle") 
    48         if type == "rectangle": 
    49             path.addRect(QRectF(x - w/2, y - h/2, w, h)) 
    50         elif type == "roundrectangle": 
    51             path.addRoundedRect(QRectF(x - w/2, y - h/2, w, h), 10, 10) 
    52         elif type == "circle": 
    53             path.addEllipse(QRectF(x - w/2, y - h/2, w, h)) 
    54              
     85        path = path_from_graphics(graphics) 
    5586        self.setPath(path) 
    5687        self.setAcceptHoverEvents(True) 
    5788        self._actions = [] 
    5889        self.link = None 
    59          
     90 
    6091    def hoverEnterEvent(self, event): 
    6192        self.setBrush(QBrush(QColor(0, 100, 0, 100))) 
    62          
     93 
    6394    def hoverLeaveEvent(self, event): 
    6495        self.setBrush(QBrush(Qt.NoBrush)) 
    65          
     96 
    6697    def contextMenuEvent(self, event): 
    6798        if self._actions: 
     
    70101                menu.addAction(action) 
    71102            menu.popup(event.screenPos()) 
    72              
     103 
    73104    def itemChange(self, change, value): 
    74105        if change == QGraphicsItem.ItemSelectedHasChanged: 
    75106            self.setPen(QPen(Qt.red if self.isSelected() else Qt.blue, 2)) 
    76              
     107 
    77108        return QGraphicsPathItem.itemChange(self, change, value) 
    78              
     109 
     110 
    79111class GraphicsPathwayItem(QGraphicsPixmapItem): 
     112    """ 
     113    A Graphics Item displaying a KEGG Pathway image with optional 
     114    marked objects. 
     115 
     116    """ 
    80117    def __init__(self, pathway, objects, *args, **kwargs): 
    81118        QGraphicsPixmapItem.__init__(self, *args) 
    82119        self.setTransformationMode(Qt.SmoothTransformation) 
    83120        self.setPathway(pathway) 
    84         self.setMarkedObjects(objects, name_mapper=kwargs.get("name_mapper", {})) 
    85          
     121        self.setMarkedObjects(objects, 
     122                              name_mapper=kwargs.get("name_mapper", {})) 
     123 
    86124    def setPathway(self, pathway): 
     125        """ 
     126        Set pathway 
     127        """ 
    87128        self.pathway = pathway 
    88129        if pathway: 
     
    92133            self._pixmap = QPixmap() 
    93134        self.setPixmap(self._pixmap) 
    94          
     135 
    95136    def setMarkedObjects(self, objects, name_mapper={}): 
    96137        for entry in self.pathway.entries() if self.pathway else []: 
     
    100141            contained_objects = [obj for obj in objects if obj in entry.name] 
    101142            item = EntryGraphicsItem(graphics, self, self.scene()) 
    102             item.setToolTip(self.tooltip(entry, contained_objects, name_mapper)) 
     143            item.setToolTip(self.tooltip(entry, contained_objects, 
     144                                         name_mapper)) 
    103145            item._actions = self.actions(entry, contained_objects) 
    104146            item.marked_objects = contained_objects 
     
    106148                item.setPen(QPen(Qt.blue, 2)) 
    107149                item.setFlag(QGraphicsItem.ItemIsSelectable, True) 
    108      
     150 
    109151    def actions(self, entry, marked_objects=[]): 
    110152        actions = [] 
     
    114156            org = set([s.split(":")[0] for s in marked_objects]).pop() 
    115157            genes = [s.split(":")[-1] for s in marked_objects] 
    116             address = "http://www.genome.jp/dbget-bin/www_bget?" + "+".join([org] + genes) 
    117             QObject.connect(action, SIGNAL("triggered()"), lambda toggled=False, address=address: webbrowser.open(address)) 
     158            address = ("http://www.genome.jp/dbget-bin/www_bget?" + 
     159                       "+".join([org] + genes)) 
     160            action.connect(action, 
     161                           SIGNAL("triggered()"), 
     162                           lambda toggled=False, address=address: 
     163                               webbrowser.open(address)) 
    118164            actions.append(action) 
    119165        elif hasattr(entry, "link"): 
    120166            action = QAction("View %s on KEGG website" % str(type), None) 
    121             QObject.connect(action, SIGNAL("triggered()"), lambda toggled=False, address=entry.link: webbrowser.open(address)) 
     167            action.connect(action, 
     168                           SIGNAL("triggered()"), 
     169                           lambda toggled=False, address=entry.link: \ 
     170                               webbrowser.open(address)) 
    122171            actions.append(action) 
    123172        return actions 
    124      
     173 
    125174    def tooltip(self, entry, objects, name_mapper={}): 
    126175        names = [obj for obj in objects if obj in entry.name] 
    127176        names = [name_mapper.get(name, name) for name in names] 
    128         text = "<p>%s</p>" % (entry.name[:16] + " ..." if len(entry.name) > 20 else entry.name) 
     177        text = entry.name[:16] + " ..." if len(entry.name) > 20 else entry.name 
     178        text = "<p>%s</p>" % text 
    129179        if names: 
    130180            text += "<br>".join(names) 
    131181        return text 
    132      
     182 
    133183    def contextMenuEvent(self, event): 
    134184        self._menu = menu = QMenu() 
    135185        action = menu.addAction("View this pathway on KEGG website") 
    136         address ="http://www.kegg.jp/kegg-bin/show_pathway?%s%s" % (self.pathway.org, self.pathway.number) 
    137         QObject.connect(action, SIGNAL("triggered()"), lambda : webbrowser.open(address)) 
     186        address = ("http://www.kegg.jp/kegg-bin/show_pathway?%s%s" % 
     187                   (self.pathway.org, self.pathway.number)) 
     188        action.connect(action, SIGNAL("triggered()"), 
     189                       lambda: webbrowser.open(address)) 
    138190        menu.popup(event.screenPos()) 
     191 
    139192 
    140193class PathwayView(QGraphicsView): 
     
    142195        QGraphicsView.__init__(self, *args) 
    143196        self.master = master 
    144          
     197 
    145198        self.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) 
    146199        self.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) 
    147          
     200 
    148201        self.setRenderHints(QPainter.Antialiasing) 
    149202        scene = QGraphicsScene(self) 
    150         self.pixmapGraphicsItem = QGraphicsPixmapItem(None, scene)  
     203        self.pixmapGraphicsItem = QGraphicsPixmapItem(None, scene) 
    151204        self.setScene(scene) 
    152          
     205 
    153206        self.setMouseTracking(True) 
    154207        self.viewport().setMouseTracking(True) 
    155          
     208 
    156209        self.setFocusPolicy(Qt.WheelFocus) 
    157          
     210 
    158211    def SetPathway(self, pathway=None, objects=[]): 
    159212        self.scene().clear() 
    160213        self.pathway = pathway 
    161214        self.objects = objects 
    162         self.pathwayItem = GraphicsPathwayItem(pathway, objects, None, self.scene(), name_mapper=getattr(self.master, "uniqueGenesDict", {})) 
     215        self.pathwayItem = GraphicsPathwayItem( 
     216            pathway, objects, None, 
     217            name_mapper=getattr(self.master, "uniqueGenesDict", {}) 
     218        ) 
     219 
     220        self.scene().addItem(self.pathwayItem) 
    163221        self.scene().setSceneRect(self.pathwayItem.boundingRect()) 
    164222        self.updateTransform() 
    165      
     223 
    166224    def resizeEvent(self, event): 
    167225        self.updateTransform() 
    168226        return QGraphicsView.resizeEvent(self, event) 
    169              
     227 
    170228    def updateTransform(self): 
    171229        if self.master.autoResize: 
    172             self.fitInView(self.scene().sceneRect().adjusted(-1, -1, 1, 1), Qt.KeepAspectRatio) 
     230            self.fitInView(self.scene().sceneRect().adjusted(-1, -1, 1, 1), 
     231                           Qt.KeepAspectRatio) 
    173232        else: 
    174233            self.setTransform(QTransform()) 
    175              
     234 
    176235    def paintEvent(self, event): 
    177236        QGraphicsView.paintEvent(self, event) 
     
    181240            font.setPointSize(15) 
    182241            painter.setFont(font) 
    183             painter.drawText(self.viewport().geometry(), Qt.AlignCenter, self._userMessage) 
     242            painter.drawText(self.viewport().geometry(), Qt.AlignCenter, 
     243                             self._userMessage) 
    184244            painter.end() 
    185          
    186      
     245 
     246 
    187247class OWKEGGPathwayBrowser(OWWidget): 
    188     settingsList = ["organismIndex", "geneAttrIndex", "autoCommit", "autoResize", "useReference", "useAttrNames", "caseSensitive", "showOrthology"] 
    189     contextHandlers = {"":DomainContextHandler("",[ContextField("organismIndex", DomainContextHandler.Required + DomainContextHandler.IncludeMetaAttributes), 
    190                                                    ContextField("geneAttrIndex", DomainContextHandler.Required + DomainContextHandler.IncludeMetaAttributes), 
    191                                                    ContextField("useAttrNames", DomainContextHandler.Required + DomainContextHandler.IncludeMetaAttributes)])} 
     248    settingsList = ["organismIndex", "geneAttrIndex", "autoCommit", 
     249                    "autoResize", "useReference", "useAttrNames", 
     250                    "caseSensitive", "showOrthology"] 
     251 
     252    contextHandlers = { 
     253        "": DomainContextHandler( 
     254            "", 
     255            [ContextField("organismIndex", 
     256                          DomainContextHandler.Required + 
     257                          DomainContextHandler.IncludeMetaAttributes), 
     258             ContextField("geneAttrIndex", 
     259                          DomainContextHandler.Required + 
     260                          DomainContextHandler.IncludeMetaAttributes), 
     261             ContextField("useAttrNames", 
     262                          DomainContextHandler.Required + 
     263                          DomainContextHandler.IncludeMetaAttributes)] 
     264        ) 
     265    } 
     266 
    192267    def __init__(self, parent=None, signalManager=None, name="KEGG Pathways"): 
    193268        OWWidget.__init__(self, parent, signalManager, name, wantGraph=True) 
    194         self.inputs = [("Examples", ExampleTable, self.SetData), ("Reference", ExampleTable, self.SetRefData)] 
    195         self.outputs = [("Selected Examples", ExampleTable), ("Unselected Examples", ExampleTable)] 
     269        self.inputs = [("Examples", Orange.data.Table, self.SetData), 
     270                       ("Reference", Orange.data.Table, self.SetRefData)] 
     271        self.outputs = [("Selected Examples", Orange.data.Table), 
     272                        ("Unselected Examples", Orange.data.Table)] 
    196273        self.organismIndex = 0 
    197274        self.geneAttrIndex = 0 
     
    208285        box = OWGUI.widgetBox(self.controlArea, "Info") 
    209286        self.infoLabel = OWGUI.widgetLabel(box, "No data on input\n") 
    210          
    211         self.allOrganismCodes = {}  
    212          
     287 
     288        self.allOrganismCodes = {} 
     289 
    213290        self.organismCodes = [] 
    214          
     291 
     292        # Organism selection. 
    215293        box = OWGUI.widgetBox(self.controlArea, "Organism") 
    216         self.organismComboBox = cb = OWGUI.comboBox(box, self, 
    217                                 "organismIndex",  
    218                                 items=[], 
    219                                 callback=self.OrganismSelectionCallback,  
    220                                 addSpace=True, 
    221                                 debuggingEnabled=0) 
    222          
     294        self.organismComboBox = OWGUI.comboBox( 
     295            box, self, "organismIndex", 
     296            items=[], 
     297            callback=self.OrganismSelectionCallback, 
     298            addSpace=True, 
     299            debuggingEnabled=0, 
     300            tooltip="Select the organism of the input genes") 
     301 
    223302        self.signalManager.freeze(self).push() 
    224          
     303 
     304        # Selection of genes attribute 
    225305        box = OWGUI.widgetBox(self.controlArea, "Gene attribute") 
    226306        self.geneAttrCombo = OWGUI.comboBox(box, self, "geneAttrIndex", 
    227307                                            callback=self.Update) 
    228          
     308 
    229309        OWGUI.checkBox(box, self, "useAttrNames", 
    230                        "Use variable names",  
     310                       "Use variable names", 
    231311                       disables=[(-1, self.geneAttrCombo)], 
    232312                       callback=self.UseAttrNamesCallback) 
    233          
     313 
    234314        self.geneAttrCombo.setDisabled(bool(self.useAttrNames)) 
    235          
     315 
    236316        OWGUI.separator(self.controlArea) 
    237          
     317 
    238318        OWGUI.checkBox(self.controlArea, self, "useReference", 
    239319                       "From signal", 
    240320                       box="Reference", 
    241321                       callback=self.Update) 
    242          
     322 
    243323        OWGUI.separator(self.controlArea) 
    244324 
     
    247327                       box="Orthology", 
    248328                       callback=self.UpdateListView) 
    249          
     329 
    250330        OWGUI.checkBox(self.controlArea, self, "autoResize", 
    251331                       "Resize to fit", 
    252332                       box="Image", 
    253333                       callback=self.UpdatePathwayViewTransform) 
    254          
     334 
    255335        box = OWGUI.widgetBox(self.controlArea, "Cache Control") 
    256          
    257         OWGUI.button(box, self, "Clear cache",  
     336 
     337        OWGUI.button(box, self, "Clear cache", 
    258338                     callback=self.ClearCache, 
    259339                     tooltip="Clear all locally cached KEGG data.") 
    260          
     340 
    261341        OWGUI.separator(self.controlArea) 
    262342 
     
    265345        OWGUI.button(box, self, "Commit", callback=self.Commit, default=True) 
    266346        OWGUI.rubber(self.controlArea) 
    267          
     347 
    268348        spliter = QSplitter(Qt.Vertical, self.mainArea) 
    269349        self.pathwayView = PathwayView(self, spliter) 
     
    272352        self.listView = QTreeWidget(spliter) 
    273353        spliter.addWidget(self.listView) 
    274          
     354 
    275355        self.listView.setAllColumnsShowFocus(1) 
    276356        self.listView.setColumnCount(4) 
    277         self.listView.setHeaderLabels(["Pathway", "P value",  
     357        self.listView.setHeaderLabels(["Pathway", "P value", 
    278358                                       "Genes", "Reference"]) 
    279359 
    280         self.listView.setSelectionMode(QAbstractItemView.SingleSelection) 
    281              
     360        self.listView.setSelectionMode(QTreeWidget.SingleSelection) 
     361 
    282362        self.listView.setSortingEnabled(True) 
    283          
     363 
    284364        self.listView.setMaximumHeight(200) 
    285          
     365 
    286366        self.connect(self.listView, 
    287367                     SIGNAL("itemSelectionChanged()"), 
    288368                     self.UpdatePathwayView) 
    289          
     369 
    290370        self.connect(self.graphButton, 
    291371                     SIGNAL("clicked()"), 
    292372                     self.saveGraph) 
    293          
     373 
    294374        self.ctrlPressed = False 
    295375        self.selectedObjects = defaultdict(list) 
    296376        self.data = None 
    297377        self.refData = None 
    298          
     378 
    299379        self.resize(800, 600) 
    300          
     380 
    301381        self.connect(self, 
    302382                     SIGNAL("widgetStateChanged(QString, int, QString)"), 
    303383                     self.onStateChange) 
    304          
     384 
    305385        self.has_new_data = False 
    306386        self.has_new_reference_set = False 
    307          
     387 
    308388        self.setEnabled(False) 
    309389        QTimer.singleShot(100, self.UpdateOrganismComboBox) 
    310390 
    311391    def UpdateOrganismComboBox(self): 
    312         # First try to import suds 
     392        # First try to import slumber 
    313393        try: 
    314394            import slumber 
     
    349429            self.organismCodes = [code for code, desc in codes] 
    350430            self.organismComboBox.addItems(items) 
    351  
    352431        finally: 
    353432            self.setEnabled(True) 
     
    369448        self.pathwayView.SetPathway(None) 
    370449        self.selectedObjects = defaultdict(list) 
    371          
     450 
    372451    def SetData(self, data=None): 
    373452        self.closeContext() 
     
    382461                    self.organismIndex = self.organismCodes.index(code) 
    383462                except Exception, ex: 
    384 #                    self.log.exception(self, level=self.log.INFO) 
    385463                    print ex, taxid 
    386              
    387             self.useAttrNames = data_hints.get_hint(data, "genesinrows", self.useAttrNames) 
    388              
     464 
     465            self.useAttrNames = data_hints.get_hint(data, "genesinrows", 
     466                                                    self.useAttrNames) 
     467 
    389468            self.openContext("", data) 
    390469        else: 
    391470            self.Clear() 
    392              
     471 
    393472        self.has_new_data = True 
    394473 
     
    396475        self.refData = data 
    397476        self.has_new_reference_set = True 
    398          
     477 
    399478    def handleNewSignals(self): 
    400479        if self.has_new_data or (self.has_new_reference_set and \ 
    401480                                 self.useReference): 
    402481            self.Update() 
    403              
     482 
    404483            self.has_new_data = False 
    405484            self.has_new_reference_set = False 
    406          
     485 
    407486    def UseAttrNamesCallback(self): 
    408487        self.Update() 
     
    410489    def OrganismSelectionCallback(self): 
    411490        self.Update() 
    412          
     491 
    413492    def SetGeneAttrCombo(self): 
    414         self.geneAttrCandidates = self.data.domain.attributes + \ 
     493        self.geneAttrCandidates = self.data.domain.variables + \ 
    415494                                  self.data.domain.getmetas().values() 
    416         self.geneAttrCandidates = filter(lambda v:v.varType in [orange.VarTypes.Discrete, 
    417                                                                 orange.VarTypes.String], 
    418                                          self.geneAttrCandidates) 
     495        self.geneAttrCandidates = filter( 
     496            lambda v: isinstance(v, (Orange.feature.Discrete, 
     497                                     Orange.feature.String)), 
     498            self.geneAttrCandidates) 
     499 
    419500        self.geneAttrCombo.clear() 
    420          
    421         self.geneAttrCombo.addItems([var.name for var in self.geneAttrCandidates]) 
     501 
     502        self.geneAttrCombo.addItems([var.name for var in 
     503                                     self.geneAttrCandidates]) 
    422504 
    423505    def UpdateListView(self): 
     
    438520 
    439521        org_code = self.organismCodes[min(self.organismIndex, 
    440                                           len(self.organismCodes)-1)] 
     522                                          len(self.organismCodes) - 1)] 
    441523 
    442524        if self.showOrthology: 
     
    448530                num = koEntry.title[:5] if koEntry.title else None 
    449531                if num in path_ids: 
    450                     return [koEntry] + reduce(lambda li, c:li + _walkCollect(c), [child for child in koEntry.entries], []) 
     532                    return ([koEntry] + 
     533                            reduce(lambda li, c: li + _walkCollect(c), 
     534                                   [child for child in koEntry.entries], 
     535                                   [])) 
    451536                else: 
    452537                    c = reduce(lambda li, c: li + _walkCollect(c), 
    453                                [child for child in koEntry.entries], []) 
     538                               [child for child in koEntry.entries], 
     539                               []) 
    454540                    return c + (c and [koEntry] or []) 
    455541 
    456542            allClasses = reduce(lambda li1, li2: li1 + li2, 
    457                                 [_walkCollect(c) for c in self.koOrthology], []) 
     543                                [_walkCollect(c) for c in self.koOrthology], 
     544                                []) 
    458545 
    459546            def _walkCreate(koEntry, lvItem): 
     
    515602        for i in range(4): 
    516603            self.listView.resizeColumnToContents(i) 
    517              
     604 
    518605        if self.bestPValueItem: 
    519             self.listView.selectionModel().select(self.listView.indexFromItem(self.bestPValueItem), QItemSelectionModel.ClearAndSelect) 
     606            index = self.listView.indexFromItem(self.bestPValueItem) 
     607            self.listView.selectionModel().select( 
     608                index, QItemSelectionModel.ClearAndSelect 
     609            ) 
    520610 
    521611    def UpdatePathwayView(self): 
    522612        items = self.listView.selectedItems() 
    523          
     613 
    524614        if len(items) > 0: 
    525615            item = items[0] 
    526616        else: 
    527617            item = None 
    528              
     618 
    529619        self.selectedObjects = defaultdict(list) 
    530620        self.Commit() 
     
    533623            self.pathwayView.SetPathway(None) 
    534624            return 
    535          
     625 
    536626        if USE_THREADING: 
    537627            result = {} 
     628 
    538629            def call(pathway_id): 
    539630                result["pathway"] = p = obiKEGG.KEGGPathway(pathway_id) 
    540                 p._get_kgml() # makes sure the kgml file is downloaded 
    541                 p._get_image_filename() # makes sure the image is downloaded 
    542                  
     631                p._get_kgml()  # makes sure the kgml file is downloaded 
     632                p._get_image_filename()  # makes sure the image is downloaded 
     633 
    543634            self.setEnabled(False) 
    544635            try: 
    545                 thread = threading.Thread(None, 
    546                                           call, 
     636                thread = threading.Thread(None, call, 
    547637                                          name="get_kgml_and_image", 
    548638                                          args=(item.pathway_id,)) 
     
    559649        else: 
    560650            self.pathway = obiKEGG.KEGGPathway(item.pathway_id) 
    561              
    562         self.pathwayView.SetPathway(self.pathway, self.pathways.get(item.pathway_id, [[]])[0]) 
    563              
     651 
     652        self.pathwayView.SetPathway(self.pathway, 
     653                                    self.pathways.get(item.pathway_id, [[]])[0]) 
     654 
    564655    def UpdatePathwayViewTransform(self): 
    565656        self.pathwayView.updateTransform() 
    566          
     657 
    567658    def Update(self): 
    568659        if not self.data: 
     
    574665            genes = [str(v.name).strip() for v in self.data.domain.attributes] 
    575666        elif self.geneAttrCandidates: 
    576             geneAttr = self.geneAttrCandidates[min(self.geneAttrIndex, len(self.geneAttrCandidates)-1)] 
    577             genes = [str(e[geneAttr]) for e in self.data if not e[geneAttr].isSpecial()] 
     667            geneAttr = self.geneAttrCandidates[min(self.geneAttrIndex, 
     668                                                   len(self.geneAttrCandidates) - 1)] 
     669            genes = [str(e[geneAttr]) for e in self.data 
     670                     if not e[geneAttr].isSpecial()] 
    578671            if any("," in gene for gene in genes): 
    579                 genes = reduce(list.__add__, (split_and_strip(gene, ",") for gene in genes), []) 
    580                 self.information(0, "Separators detected in input gene names. Assuming multiple genes per instance.") 
     672                genes = reduce(add, (split_and_strip(gene, ",") 
     673                                     for gene in genes), 
     674                               []) 
     675                self.information(0, 
     676                                 "Separators detected in input gene names. " 
     677                                 "Assuming multiple genes per instance.") 
    581678        else: 
    582679            self.error(0, "Cannot extract gene names from input") 
    583680            genes = [] 
    584         org_code = self.organismCodes[min(self.organismIndex, len(self.organismCodes)-1)] 
    585          
     681        org_code = self.organismCodes[min(self.organismIndex, 
     682                                          len(self.organismCodes) - 1)] 
     683 
    586684        if USE_THREADING: 
    587685            result = {} 
     686 
    588687            def callable(*args, **kwargs): 
    589688                result["org"] = org = obiKEGG.KEGGOrganism(org_code) 
    590689                # Make sure genes are cached for global reference set 
    591690                result["genes"] = org.genes.keys() 
    592                  
     691 
    593692            self.setEnabled(False) 
    594693            try: 
     
    602701            finally: 
    603702                self.setEnabled(True) 
    604              
     703 
    605704            if "org" in result: 
    606705                org = result["org"] 
     
    609708        else: 
    610709            org = obiKEGG.KEGGOrganism(org_code) 
    611          
    612         uniqueGenes, conflicting, unknown = org.get_unique_gene_ids(set(genes), self.caseSensitive) 
     710 
     711        uniqueGenes, _, _ = org.get_unique_gene_ids(set(genes), 
     712                                                    self.caseSensitive) 
    613713        genesCount = len(set(genes)) 
    614         self.infoLabel.setText("%i unique gene names on input\n%i (%.1f%%) genes names matched" % (genesCount, len(uniqueGenes), 100.0*len(uniqueGenes)/genesCount if genes else 0.0))   
    615          
     714        self.infoLabel.setText("%i unique gene names on input\n%i (%.1f%%) " 
     715                               "genes names matched" % 
     716                               (genesCount, len(uniqueGenes), 
     717                                100.0 * len(uniqueGenes) / genesCount if genes else 0.0)) 
     718 
    616719        self.information(1) 
    617720        if self.useReference and self.refData: 
     
    619722                reference = [str(v.name).strip() for v in self.refData] 
    620723            else: 
    621                 geneAttr = self.geneAttrCandidates[min(self.geneAttrIndex, len(self.geneAttrCandidates)-1)] 
    622                 reference = [str(e[geneAttr]) for e in self.refData if not e[geneAttr].isSpecial()] 
     724                geneAttr = self.geneAttrCandidates[min(self.geneAttrIndex, 
     725                                                       len(self.geneAttrCandidates) - 1)] 
     726                reference = [str(e[geneAttr]) for e in self.refData 
     727                             if not e[geneAttr].isSpecial()] 
    623728                if any("," in gene for gene in reference): 
    624                     reference = reduce(list.__add__, (split_and_strip(gene, ",") for gene in reference), []) 
    625                     self.information(1, "Separators detected in reference gene names. Assuming multiple genes per example.") 
    626             uniqueRefGenes, conflicting, unknown = org.get_unique_gene_ids(set(reference), self.caseSensitive) 
     729                    reference = reduce(add, (split_and_strip(gene, ",") 
     730                                             for gene in reference), 
     731                                       []) 
     732                    self.information(1, 
     733                                     "Separators detected in reference gene " 
     734                                     "names. Assuming multiple genes per " 
     735                                     "example.") 
     736            uniqueRefGenes, _, _ = org.get_unique_gene_ids(set(reference), 
     737                                                           self.caseSensitive) 
    627738            self.referenceGenes = reference = uniqueRefGenes.keys() 
    628739        else: 
     
    630741        self.uniqueGenesDict = uniqueGenes 
    631742        self.genes = uniqueGenes.keys() 
    632         self.revUniqueGenesDict = dict([(val, key) for key, val in self.uniqueGenesDict.items()]) 
    633          
     743        self.revUniqueGenesDict = dict([(val, key) for key, val in 
     744                                        self.uniqueGenesDict.items()]) 
     745 
    634746        taxid = obiKEGG.to_taxid(org.org_code) 
    635         r_tax_map = dict((v,k) for k, v in obiKEGG.KEGGGenome.TAXID_MAP.items()) 
     747        r_tax_map = dict((v, k) for k, v in 
     748                         obiKEGG.KEGGGenome.TAXID_MAP.items()) 
    636749        if taxid in r_tax_map: 
    637750            taxid = r_tax_map[taxid] 
    638              
     751 
    639752        with orngServerFiles.DownloadProgress.setredirect(self.progressBarSet): 
    640753            orngServerFiles.update(obiGeneSets.sfdomain, "index.pck") 
    641             kegg_gs_collections = list(obiGeneSets.collections((("KEGG", "pathways"), taxid))) 
    642          
     754            kegg_gs_collections = \ 
     755                list(obiGeneSets.collections((("KEGG", "pathways"), taxid))) 
     756 
    643757        if USE_THREADING: 
    644758            result = {} 
     759 
    645760            def callable(*args, **kwargs): 
    646761#                result["result"] = org.get_enriched_pathways(*args, **kwargs) 
    647762                result["result"] = pathway_enrichment(*args, **kwargs) 
    648              
     763 
    649764            self.setEnabled(False) 
    650765            try: 
    651                 thread = threading.Thread(None, callable, 
    652                                           name="get_enriched_pathways", 
    653                                           args=(kegg_gs_collections, 
    654                                                 self.genes,  
    655                                                 reference), 
    656                                           kwargs={"callback":  
    657                                                   threading_queued_invoke(self, 
    658                                                   lambda value:self.progressBarSet(value))} 
    659                                           ) 
    660                  
     766                thread = threading.Thread( 
     767                    None, callable, 
     768                    name="get_enriched_pathways", 
     769                    args=(kegg_gs_collections, 
     770                          self.genes, 
     771                          reference), 
     772                    kwargs={"callback": 
     773                            threading_queued_invoke( 
     774                                self, 
     775                                lambda value: self.progressBarSet(value))} 
     776                ) 
     777 
    661778                thread.start() 
    662779                while thread.is_alive(): 
     
    665782            finally: 
    666783                self.setEnabled(True) 
    667                  
     784 
    668785            if "result" in result: 
    669786                self.pathways = result["result"] 
    670787            else: 
    671788                raise Exception('Could not get enriched pathways') 
    672              
    673              
    674         else: 
    675             self.pathways = org.get_enriched_pathways(self.genes, reference, 
    676                                                       callback=lambda value: self.progressBarSet(value)) 
    677          
     789 
     790        else: 
     791            self.pathways = org.get_enriched_pathways( 
     792                self.genes, reference, 
     793                callback=self.progressBarSet 
     794            ) 
     795 
    678796        self.org = org 
    679797        if not self.pathways: 
     
    681799        else: 
    682800            self.warning(0) 
    683          
     801 
    684802        self.UpdateListView() 
    685803        pb.finish() 
    686      
    687  
    688     def SelectObjects(self, objs): 
    689         if (not self.selectedObjects or self.ctrlPressed) and not objs: 
    690             return 
    691         if self.ctrlPressed: 
    692             for id, graphics in objs: 
    693                 graphics = tuple(sorted(graphics.items())) 
    694                 if id in self.selectedObjects[graphics]: 
    695                     self.selectedObjects[graphics].pop(self.selectedObjects[graphics].index(id)) 
    696                     if not self.selectedObjects[graphics]: 
    697                         del self.selectedObjects[graphics] 
    698                 else: 
    699                     self.selectedObjects[graphics].append(id) 
    700         else: 
    701             self.selectedObjects.clear() 
    702             for id, graphics in objs: 
    703                 graphics = tuple(sorted(graphics.items())) 
    704                 self.selectedObjects[graphics].append(id) 
    705         if self.autoCommit: 
    706             self.Commit() 
    707              
    708804 
    709805    def Commit(self): 
    710806        if self.data: 
    711807            selectedItems = self.pathwayView.scene().selectedItems() 
    712             selectedGenes = reduce(set.union, [item.marked_objects for item in selectedItems], set()) 
    713              
     808            selectedGenes = reduce(set.union, [item.marked_objects 
     809                                               for item in selectedItems], 
     810                                   set()) 
     811 
    714812            if self.useAttrNames: 
    715                 selectedVars = [self.data.domain[self.uniqueGenesDict[gene]] for gene in selectedGenes] 
    716                 newDomain = orange.Domain(selectedVars ,0) 
    717                 data = orange.ExampleTable(newDomain, self.data) 
     813                selectedVars = [self.data.domain[self.uniqueGenesDict[gene]] 
     814                                for gene in selectedGenes] 
     815                newDomain = Orange.data.Domain(selectedVars, 0) 
     816                data = Orange.data.Table(newDomain, self.data) 
    718817                self.send("Selected Examples", data) 
    719818            elif self.geneAttrCandidates: 
    720                 geneAttr = self.geneAttrCandidates[min(self.geneAttrIndex, len(self.geneAttrCandidates)-1)] 
     819                geneAttr = self.geneAttrCandidates[min(self.geneAttrIndex, 
     820                                                       len(self.geneAttrCandidates) - 1)] 
    721821                selectedExamples = [] 
    722822                otherExamples = [] 
    723823                for ex in self.data: 
    724                     names = [self.revUniqueGenesDict.get(name, None) for name in split_and_strip(str(ex[geneAttr]), ",")] 
     824                    names = [self.revUniqueGenesDict.get(name, None) 
     825                             for name in split_and_strip(str(ex[geneAttr]), ",")] 
    725826                    if any(name and name in selectedGenes for name in names): 
    726827                        selectedExamples.append(ex) 
    727828                    else: 
    728829                        otherExamples.append(ex) 
    729                          
     830 
    730831                if selectedExamples: 
    731                     selectedExamples = orange.ExampleTable(selectedExamples) 
     832                    selectedExamples = Orange.data.Table(selectedExamples) 
    732833                else: 
    733834                    selectedExamples = None 
    734                      
     835 
    735836                if otherExamples: 
    736                     otherExamples = orange.ExampleTable(otherExamples) 
     837                    otherExamples = Orange.data.Table(otherExamples) 
    737838                else: 
    738839                    otherExamples = None 
    739                      
     840 
    740841                self.send("Selected Examples", selectedExamples) 
    741842                self.send("Unselected Examples", otherExamples) 
     
    743844            self.send("Selected Examples", None) 
    744845            self.send("Unselected Examples", None) 
    745          
     846 
    746847    def ClearCache(self): 
    747848        from ..obiKEGG import caching 
     
    749850            caching.clear_cache() 
    750851        except Exception, ex: 
    751             QMessageBox.warning(self, "Cache clear",  
    752                 ex.args[0]) 
    753              
    754          
    755     def keyPressEvent(self, key): 
    756         if key.key()==Qt.Key_Control: 
    757             self.ctrlPressed=True 
    758         else: 
    759             OWWidget.keyPressEvent(self, key) 
    760  
    761     def keyReleaseEvent(self, key): 
    762         if key.key()==Qt.Key_Control: 
    763             self.ctrlPressed=False 
    764         else: 
    765             OWWidget.keyReleaseEvent(self, key) 
    766              
     852            QMessageBox.warning(self, "Cache clear", ex.args[0]) 
     853 
    767854    def onStateChange(self, stateType, id, text): 
    768855        if stateType == "Warning": 
    769856            self.pathwayView._userMessage = text 
    770857            self.pathwayView.viewport().update() 
    771              
     858 
    772859    def saveGraph(self): 
    773860        from Orange.OrangeWidgets.OWDlgs import OWChooseImageSizeDlg 
     
    788875 
    789876    def onDeleteWidget(self): 
    790         """ Called before the widget is removed from the canvas. 
     877        """ 
     878        Called before the widget is removed from the canvas. 
    791879        """ 
    792880        self.org = None 
    793881        gc.collect()  # Force collection 
    794          
    795     def UpdateToLatestPathways(self): 
    796         pass         
    797            
     882 
     883 
    798884from .. import obiProb 
     885 
    799886 
    800887def pathway_enrichment(genesets, genes, reference, prob=None, callback=None): 
     
    803890    if prob is None: 
    804891        prob = obiProb.Hypergeometric() 
    805          
     892 
    806893    for i, gs in enumerate(genesets): 
    807894        cluster = gs.genes.intersection(genes) 
     
    817904        if callback is not None: 
    818905            callback(100.0 * i / len(genesets)) 
    819      
     906 
    820907    # FDR correction 
    821908    p_values = obiProb.FDR(p_values) 
    822      
    823     return dict([(id, (genes, p_val, len(ref))) \ 
    824                  for (id, genes, ref), p_val in zip(result_sets, p_values)] 
    825                 ) 
     909 
     910    return dict([(id, (genes, p_val, len(ref))) 
     911                 for (id, genes, ref), p_val in zip(result_sets, p_values)]) 
     912 
    826913 
    827914if __name__ == "__main__": 
    828915    app = QApplication(sys.argv) 
    829     data = orange.ExampleTable("brown-selected.tab") 
     916    data = Orange.data.Table("brown-selected.tab") 
    830917    w = OWKEGGPathwayBrowser() 
    831918    w.UpdateOrganismComboBox() 
    832919    w.show() 
    833     w.SetData(orange.ExampleTable(data[:])) 
     920    w.SetData(Orange.data.Table(data[:])) 
    834921    QTimer.singleShot(10, w.handleNewSignals) 
    835922 
Note: See TracChangeset for help on using the changeset viewer.