Attachment 'PSI-MI.py'

from xml.sax import make_parser
from xml.sax.handler import ContentHandler
import sys
import string
import re

from InteractionRecord import InteractionRecord

class PSI_MI_Scanner(ContentHandler):
    def __init__(self,consumer):
        self._consumer = consumer
        self.interactors = {}
        self.interactions = []
        
        self._list = None
        self._section = None
        self._element = None

        self._cgexp = re.compile('CG\d+')
        self._fbexp = re.compile('FBgn\d+')
        
    def startElement(self,name,attributes):
        if name in ['interactorList','interactionList']:
            self._list = name
            return
        if self._list is None:
            return

        if self._list == 'interactorList':
            self._startInteractorElement(name,attributes)
        if self._list == 'interactionList':
            self._startInteractionElement(name,attributes)

    def characters(self,content):
        if self._list == 'interactorList':
            self._interactorCharacters(name,attributes)
        if self._list == 'interactionList':
            self._interactionCharacters(name,attributes)
            
    def endElement(self,name):
        if name in ['interactorList','interactionList']:
            self._list = None
            return
        if self._list is None:
            return
        
        if self._list == 'interactorList':
            self._endInteractorElement(name,attributes)
        if self._list == 'interactionList':
            self._endInteractionElement(name,attributes)
            
    def endDocument(self):
##        nodes = {}
##        for node in self.nodes:
##            nodes[node['ID']] = node
##        self.storage_obj.nodes = nodes
##        self.storage_obj.edges = self.edges

        
    def _startInteractorElement(self,name,attributes):
        if name == 'interactor':
            self.cur_interactor = Interactor()
            self.cur_interactor.id = attributes['id']
            self.cur_interactor.alias = {}
            self._section = name
            return
        if name == 'organism':
            self.cur_interactor.organism = attributes['ncbiTaxId']
            self._section = name
        if name == 'interactionType':
            self._section = name
        if name in ['fullName','shortLabel']
            self._element = name
            
        if name == 'secondaryRef' and self._section == 'interactor':
            self.cur_interactor.alias[attributes['db']] = attributes['id']
               
    def _interactorCharacters(self,content):
        if self._element == 'fullName':
            if self._section == 'interactor':
                cg = self._cgexp.match(content)
                fb = self._fbexp.match(content)
                if cg is not None:
                    self.cur_interactor.cg = cg.group()
                if fb is not None:
                    self.cur_interactor.fb = fb.group()
            if self._section == 'interactorType':
                self.cur_interactor.type = content
            if self._section == 'organism':
                self.cur_interactor.organism = content
                    
    def _endInteractorElement(self,name,attributes):
        if name == 'interactor':
            self._interactors[self.cur_interactor.id] = self.cur_interactor
            self._section = None
        if name in ['interactionType','organism']:
            self._section = None
        if name in ['fullName','shortLabel','primaryRef','secondaryRef']
            self._element = None
            
            
    def _startInteractionElement(self,name,attributes):
        if name == 'interaction':
            self._cur_interaction = InteractionRecord()
            self._cur_interaction.id = attributes['id']
            self._section = name
##        if name in ['experimentList','participantList',:
##            self._section = name
                    
    def _endInteractionElement(self,name,attributes):
        
        if name == 'interactor':
            
        if name == 'node':
            self.nodes.append(self.node_data)
            self.node_data = {}
        elif name == 'edge':
            self.edges.append(self.edge_data)
            self.edge_data = {}
        if self.el_stack:  self.el_stack.pop()
            

        if name == 'fullName':
            # check last 2 in stack to see what type of fullName
            # e.g. organism->name->fullName or interactor->name->fullName
            parent = element_stack[-2]
            if parent == 
            interactor = Interactor()
            interactors.id = attributes['id']
            self.interactors[interactors.id] = interactor
            stack_name = name            
            
        if name == 'interaction':
            interactionself.edge_data['exp'] = []
            self.edge_data['PMID'] = []
            self.edge_data['from'] = attributes['from']
            self.edge_data['to'] = attributes['to']
            stack_name = name
            
        if name == 'feature':
            if self.el_stack[0]=='node':
                if string.find(attributes['name'],'GI')==0:
                    self.node_data['NCBI_ID'] = int(attributes['name'][3:])
                elif string.find(attributes['name'],'SWP')==0:
                    self.node_data['SWP_ID'] = attributes['name'][4:]
            stack_name = name

        if name == 'att': # each type of 'att' is handled differently when vals or src encountered
            stack_name = attributes['name']

        if name == 'val':  stack_name = name
        if name == 'src':  stack_name = name
                    
        if stack_name:  self.element_stack.append(stack_name)
                     






class Interactor: pass

def parseNetwork(file,handler=ContentHandler):
    storage_obj = DataStorage()
    parser = make_parser()
    parser.setContentHandler(handler(storage_obj))
    parser.parse(file)
    return storage_obj.nodes,storage_obj.edges

You are not allowed to view this page.