Changeset 1358:9a410c550601 in orange-bioinformatics


Ignore:
Timestamp:
04/01/11 15:06:26 (3 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
bcafebddfecda35dff938c276f3a1f3679039b9f
Message:

Added a new base interface for all protein-protein interaction databases.
Re implemented BioGRID and implemented STRING PPI databases using sqlite as a backend.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • obiPPI.py

    r1040 r1358  
    1 """obiPPI - Protein - protein interactions 
     1"""\ 
     2Protein-protein interactions 
     3============================ 
     4 
     5This is python module for accessing PPI data.   
    26""" 
    37 
    48import os, sys 
    59import xml.dom.minidom as minidom 
     10import warnings 
     11import collections 
     12 
    613import orngServerFiles 
    714 
     
    1017from collections import defaultdict 
    1118 
     19import obiTaxonomy 
    1220from obiTaxonomy import pickled_cache 
    1321 
     22from Orange.misc import lru_cache 
     23import sqlite3 
     24 
     25class PPIDatabase(object): 
     26    """ A general interface for protein-protein interaction database access. 
     27     
     28    An example useage:: 
     29        >>> ppidb = MySuperPPIDatabase() 
     30        >>> ppidb.organisms() # List all organisms (taxids) 
     31        ['... 
     32         
     33        >>> ppidb.ids() # List all protein ids 
     34        ['... 
     35         
     36        >>> ppidb.ids(taxid="9606") # List all human protein ids. 
     37        ['... 
     38         
     39        >>> ppidb.links() # List all links  
     40        [('... 
     41    """ 
     42    def __init__(self): 
     43        pass 
     44     
     45    def organisms(self): 
     46        """ Return all organism taxids contained in this database. 
     47        """ 
     48        raise NotImplementedError 
     49     
     50    def ids(self, taxid=None): 
     51        """ Return a list of all protein ids. If `taxid` is not None limit 
     52        the results to ids from this organism only. 
     53         
     54        """ 
     55        raise NotImplementedError 
     56     
     57    def synonyms(self, id): 
     58        """ Return a list of synonyms for primary `id`. 
     59        """ 
     60        raise NotImplementedError 
     61     
     62    def all_edges(self, taxid=None): 
     63        """ Return a list of all edges. If taxid is not None return the 
     64        edges for this organism only.  
     65         
     66        """ 
     67        raise NotImplementedError 
     68     
     69    def edges(self, id1, id2=None): 
     70        """ Return a list of all edges (a list of 3-tuples (id1, id2, score)). 
     71        """ 
     72        raise NotImplementedError 
     73         
     74    def edges_annotated(self, id=None): 
     75        """ Return a list of all edges annotated 
     76        """ 
     77        raise NotImplementedError 
     78      
     79    def search_id(self, name, taxid=None): 
     80        """ Search the database for protein name. Return a list of matching  
     81        primary ids. Use `taxid` to limit the results to a single organism. 
     82          
     83        """ 
     84        raise NotImplementedError 
     85     
     86    @classmethod 
     87    def download_data(self): 
     88        """ Download the latest PPI data for local work. 
     89        """ 
     90        raise NotImplementedError 
     91     
     92class BioGRID(PPIDatabase): 
     93    """ Access `BioGRID <http://thebiogrid.org>`_ PPI data. 
     94     
     95    Example :: 
     96     
     97        >>> biogrid = BioGRID() 
     98        >>> print biogrid.organism() # Print a list of all organism ncbi taxis in BioGRID 
     99        [u'10090',... 
     100         
     101        >>> print biogrid.ids(taxid="9606") # Print a set of all human protein ids 
     102        [u'110004' 
     103         
     104        >>> print biogrid.synonyms("110004") # Print a list of all synonyms for protein id '110004' as reported by BioGRID 
     105        [u'3803', u'CU464060.2', u'CD158b', u'p58.2', u'CD158B1', u'NKAT6'] 
     106         
     107        >>>  
     108         
     109    """ 
     110     
     111    SCHEMA = [("links", """\ 
     112        biogrid_interaction_id text,  
     113        biogrid_id_interactor_a text, 
     114        biogrid_id_interactor_b text, 
     115        experimental_system text, 
     116        experimental_system_type text, 
     117        author text, 
     118        pubmed_id text, 
     119        throughput text, 
     120        score real, 
     121        modification text, 
     122        phenotypes text, 
     123        qualifications text, 
     124        tags text, 
     125        source_database text 
     126        """), 
     127            ("proteins", """\ 
     128        biogrid_id_interactor text, 
     129        entrez_gene_interactor text, 
     130        systematic_name_interactor text, 
     131        official_symbol_interactor text, 
     132        synonyms_interactor text, 
     133        organism_interactor text, 
     134        """)] 
     135    VERSION = "2.0" 
     136     
     137    # All column names in the tab2 table.  
     138    FIELDS = ['biogrid_interaction_id', 
     139              'entrez_gene_interactor_a', 
     140              'entrez_gene_interactor_b', 
     141              'biogrid_id_interactor_a', 
     142              'biogrid_id_interactor_b', 
     143              'systematic_name_interactor_a', 
     144              'systematic_name_interactor_b', 
     145              'official_symbol_interactor_a', 
     146              'official_symbol_interactor_b', 
     147              'synonyms_interactor_a', 
     148              'synonyms_interactor_b', 
     149              'experimental_system', 
     150              'experimental_system_type', 
     151              'author', 
     152              'pubmed_id', 
     153              'organism_interactor_a', 
     154              'organism_interactor_b', 
     155              'throughput', 
     156              'score', 
     157              'modification', 
     158              'phenotypes', 
     159              'qualifications', 
     160              'tags', 
     161              'source_database' 
     162              ] 
     163     
     164#    BioGRIDInteraction = collections.namedtuple("BioGRIDInteraction", " ".join(SCHEMA[0][1])) 
     165#    BioGRIDInteractor = collections.namedtuple("BioGRIDInteractor", " ".join(SCHEMA[1][1])) 
     166     
     167    DOMAIN = "PPI" 
     168    SERVER_FILE = "BIOGRID-ALL.sqlite" 
     169     
     170    def __init__(self): 
     171        self.filename = orngServerFiles.localpath_download(self.DOMAIN, self.SERVER_FILE) 
     172#        info = orngServerFiles.info(self.DOMAIN, self.SERVER_FILE) 
     173        # assert version matches 
     174        self.db = sqlite3.connect(self.filename) 
     175        self.init_db_index() 
     176 
     177    @lru_cache(1) 
     178    def organisms(self): 
     179        cur = self.db.execute("select distinct organism_interactor from proteins") 
     180        return cur.fetchall() 
     181 
     182    @lru_cache(3) 
     183    def ids(self, taxid=None): 
     184        """ Return a list of all protein ids (biogrid_id_interactors). 
     185        If `taxid` is not None limit the results to ids from this organism 
     186        only. 
     187         
     188        """ 
     189        if taxid is None: 
     190            cur = self.db.execute("""\ 
     191                select biogrid_id_interactor 
     192                from proteins""") 
     193        else: 
     194            cur = self.db.execute("""\ 
     195                select biogrid_id_interactor 
     196                from proteins 
     197                where organism_interactor=?""", (taxid,)) 
     198         
     199        return [t[0] for t in cur.fetchall()] 
     200 
     201    def synonyms(self, id): 
     202        """ Return a list of synonyms for primary `id`. 
     203         
     204        """ 
     205        cur = self.db.execute("""\ 
     206            select entrez_gene_interactor, 
     207                   systematic_name_interactor, 
     208                   official_symbol_interactor, 
     209                   synonyms_interactor 
     210            from proteins 
     211            where biogrid_id_interactor=? 
     212            """, (id,)) 
     213        rec = cur.fetchone() 
     214        synonyms = list(rec[:-1]) + (rec[-1].split("|") if rec[-1] is not None else []) 
     215        return [s for s in synonyms if s is not None] 
     216     
     217    def all_edges(self, taxid=None): 
     218        """ Return a list of all edges. If taxid is not None return the 
     219        edges for this organism only.  
     220         
     221        """ 
     222        if taxid is not None: 
     223            cur = self.db.execute("""\ 
     224                select biogrid_id_interactor_a, biogrid_id_interactor_a, score 
     225                from links left join proteins on  
     226                    biogrid_id_interactor_a=biogrid_id_interactor or 
     227                    biogrid_id_interactor_b=biogrid_id_interactor 
     228                where organism_interactor=? 
     229            """, (taxid,)) 
     230        else: 
     231            cur = self.db.execute("""\ 
     232                select biogrid_id_interactor_a, biogrid_id_interactor_a, score 
     233                from links 
     234            """) 
     235        edges = cur.fetchall() 
     236        return edges 
     237             
     238    def edges(self, id): 
     239        """ Return a list of all interactions where id is a participant 
     240        (a list of 3-tuples (id_a, id_b, score)). 
     241         
     242        """ 
     243         
     244        cur = self.db.execute("""\ 
     245            select biogrid_id_interactor_a, biogrid_id_interactor_b, score 
     246            from links 
     247            where biogrid_id_interactor_a=? or biogrid_id_interactor_b=? 
     248        """, (id, id)) 
     249        return cur.fetchall()  
     250         
     251         
     252    def edges_annotated(self, id): 
     253        """ Return a list of all links 
     254        """ 
     255        cur = self.db.execute("""\ 
     256            select * 
     257            from links 
     258            where biogrid_id_interactor_a=? or biogrid_id_interactor_b=? 
     259        """, (id, id)) 
     260        return cur.fetchall() 
     261     
     262    def search_id(self, name, taxid=None): 
     263        """ Search the database for protein name. Return a list of matching  
     264        primary ids. Use `taxid` to limit the results to a single organism. 
     265          
     266        """ 
     267        if taxid is None: 
     268            self.db.execute("""\ 
     269                select biogrid_id_interactor 
     270                from proteins 
     271                where biogrid_id_interactor=? or 
     272                      entrez_id_interactor=? or 
     273                      systematic_name_interactor=? or 
     274                      official_symbol_interactor=? or 
     275                      synonyms_interactor=? 
     276            """ (id,) * 5) 
     277     
     278    @classmethod 
     279    def download_data(cls, address): 
     280        """ Pass the address of the latest release (the tab2 format). 
     281        """ 
     282        import urllib2, shutil, zipfile 
     283        from StringIO import StringIO 
     284        stream = urllib2.urlopen(address) 
     285        stream = StringIO(stream.read()) 
     286        file = zipfile.ZipFile(stream) 
     287        filename = file.namelist()[0] 
     288        ppi_dir = orngServerFiles.localpath("PPI") 
     289        file.extract(filename, ppi_dir) 
     290        shutil.move(orngServerFiles.localpath("PPI", filename), 
     291                    orngServerFiles.localpath("PPI", "BIOGRID-ALL.tab2")) 
     292        filepath = orngServerFiles.localpath("PPI", "BIOGRID-ALL.tab2") 
     293        cls.init_db(filepath) 
     294        shutil.remove(filepath) 
     295         
     296    @classmethod 
     297    def init_db(cls, filepath): 
     298        """ Initialize the sqlite data base from a BIOGRID-ALL.*tab2.txt file 
     299        format. 
     300         
     301        """ 
     302        dirname = os.path.dirname(filepath) 
     303        lineiter = iter(open(filepath, "rb")) 
     304        headers = lineiter.next() # read the first line 
     305         
     306        con = sqlite3.connect(os.path.join(dirname, "BIOGRID-ALL.sqlite")) 
     307        con.execute("drop table if exists links") # Drop old table 
     308        con.execute("drop table if exists proteins") # Drop old table 
     309         
     310        con.execute("""\ 
     311            create table links ( 
     312                biogrid_interaction_id text,  
     313                biogrid_id_interactor_a text, 
     314                biogrid_id_interactor_b text, 
     315                experimental_system text, 
     316                experimental_system_type text, 
     317                author text, 
     318                pubmed_id text, 
     319                throughput text, 
     320                score real, 
     321                modification text, 
     322                phenotypes text, 
     323                qualifications text, 
     324                tags text, 
     325                source_database text 
     326            )""") 
     327         
     328        con.execute("""\ 
     329            create table proteins ( 
     330                biogrid_id_interactor text, 
     331                entrez_gene_interactor text, 
     332                systematic_name_interactor text, 
     333                official_symbol_interactor text, 
     334                synonyms_interactor text, 
     335                organism_interactor text 
     336            )""") 
     337         
     338        proteins = {} 
     339        nulls = lambda values: [val if val != "-" else None for val in values] 
     340        link_indices = [0, 3, 4, 11, 12, 13, 14, 17, 18, 19, 20, 21, 22, 23] # Values that go in the links table 
     341        interactor_a_indices = [3, 1, 5, 7, 9, 15] # Values that go in the proteins table 
     342        interactor_b_indices = [4, 2, 6, 8, 10, 16] # Values that go in the proteins table 
     343         
     344        def processlinks(file): 
     345            for line in file: 
     346                if line != "\n": 
     347                    fields = nulls(line.strip().split("\t")) 
     348                    yield [fields[i] for i in link_indices] 
     349                    interactor_a = [fields[i] for i in interactor_a_indices] 
     350                    interactor_b = [fields[i] for i in interactor_b_indices] 
     351                    proteins[interactor_a[0]] = interactor_a 
     352                    proteins[interactor_b[0]] = interactor_b 
     353         
     354        con.executemany("""\ 
     355            insert into links values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) 
     356            """, processlinks(lineiter)) 
     357         
     358        con.executemany("""\ 
     359            insert into proteins values (?, ?, ?, ?, ?, ?) 
     360            """, proteins.itervalues()) 
     361        con.commit() 
     362        con.close() 
     363         
     364    def init_db_index(self): 
     365        """ Will create an indexes (if not already pressent) in the database 
     366        for faster searching by primary ids. 
     367         
     368        """ 
     369        self.db.execute("""\ 
     370        create index if not exists index_on_biogrid_id_interactor_a 
     371           on links (biogrid_id_interactor_a) 
     372        """) 
     373        self.db.execute("""\ 
     374        create index if not exists index_on_biogrid_id_interactor_b 
     375           on links (biogrid_id_interactor_b) 
     376        """) 
     377        self.db.execute("""\ 
     378        create index if not exists index_on_biogrid_id_interactor 
     379           on proteins (biogrid_id_interactor) 
     380        """) 
     381         
     382     
     383class STRING(PPIDatabase): 
     384    """ Access `STRING <http://www.string-db.org/>`_ PPI database. 
     385     
     386    Database schema 
     387    --------------- 
     388    table `links`: 
     389        - `protein_id1`: id (text) 
     390        - `protein_id2`: id (text) 
     391        - `score`: combined score (int) 
     392         
     393    table `actions`: 
     394        - `protein_id1`: id (text) 
     395        - `protein_id2`: id (text) 
     396        - `mode`: mode (text) 
     397        - `action`: action type (text) 
     398        - `score`: action score (int) 
     399         
     400    table `proteins`: 
     401        - `protein_id`: protein id in STRING (text) (in the form of {taxid}.{name}) 
     402        - `taxid`: organism taxid (text) 
     403         
     404    table `aliases`: 
     405        - `protein_id: id (text) 
     406        - `alias`: protein alias (text)  
     407         
     408    """ 
     409    DOMAIN = "PPI" 
     410    FILENAME = "string-protein.sqlite" 
     411    VERSION = "1.0" 
     412     
     413    def __init__(self): 
     414        self.filename = orngServerFiles.localpath_download(self.DOMAIN, self.FILENAME) 
     415        self.db = sqlite3.connect(self.filename) 
     416        self.init_db_index() 
     417         
     418    def organisms(self): 
     419        """ Return all organism taxids contained in this database. 
     420        """ 
     421        cur = self.db.execute("select distinct taxid from proteins") 
     422        return [r[0] for r in cur.fetchall()] 
     423     
     424    def ids(self, taxid=None): 
     425        """ Return a list of all protein ids. If `taxid` is not None limit 
     426        the results to ids from this organism only. 
     427         
     428        """ 
     429        if taxid is not None: 
     430            cur = self.db.execute("""\ 
     431                select protein_id 
     432                from proteins 
     433                where taxid=? 
     434                """, (taxid,)) 
     435        else: 
     436            cur = self.db.execute("""\ 
     437                select protein_id 
     438                from proteins 
     439                """) 
     440        return [r[0] for r in cur.fetchall()] 
     441     
     442    def synonyms(self, id): 
     443        """ Return a list of synonyms for primary `id` as reported by STRING (proteins.aliases.{version}.txt file) 
     444        """ 
     445        cur = self.db.execute("""\ 
     446            select alias 
     447            from aliases 
     448            where protein_id=? 
     449            """, (id,)) 
     450        res = cur.fetchall() 
     451        return [r[0] for r in res] 
     452     
     453    def all_edges(self, taxid=None): 
     454        """ Return a list of all edges. If taxid is not None return the 
     455        edges for this organism only. 
     456         
     457        .. note:: This may take some time (and memory). 
     458         
     459        """ 
     460        if taxid is not None: 
     461            cur = self.db.execute("""\ 
     462                select links.protein_id1, links.protein_id2, score 
     463                from links join proteins on 
     464                    links.protein_id1=proteins.protein_id 
     465                where taxid=? 
     466                """, (taxid,)) 
     467        else: 
     468            cur = self.db.execute("""\ 
     469                select protein_id1, protein_id1, score 
     470                from links 
     471                """) 
     472        return cur.fetchall() 
     473         
     474    def edges(self, id): 
     475        """ Return a list of all edges (a list of 3-tuples (id1, id2, score)). 
     476        """ 
     477        cur = self.db.execute("""\ 
     478            select protein_id1, protein_id2, score 
     479            from links 
     480            where protein_id1=? 
     481            """, (id,)) 
     482        return cur.fetchall() 
     483         
     484    def edges_annotated(self, id): 
     485        """ Return a list of all links 
     486        """ 
     487        raise NotImplementedError 
     488     
     489    @classmethod 
     490    def download_data(cls, version, taxids=None): 
     491        """ Download the  PPI data for local work (this may take some time). 
     492        Pass the version of the  STRING release e.g. v8.3. 
     493        The resulting sqlite database will only contain the protein 
     494        interactions for `taxids` (if None all interactions will be present). 
     495         
     496        """ 
     497        dir = orngServerFiles.localpath("PPI") 
     498         
     499        def download(address, dir): 
     500            stream = urllib2.urlopen(address) 
     501            basename = posixpath.basename(address) 
     502            tmpfilename = os.path.join(dir, basename + ".part") 
     503            tmpfile = open(tmpfilename, "wb") 
     504            shutil.copyfileobj(stream, tmpfile) 
     505            tmpfile.close() 
     506            os.rename(tmpfilename, basename) 
     507             
     508        links = "http://www.string-db.org:8080/newstring_download/protein.links.{version}.txt.gz" 
     509        actions = "http://www.string-db.org:8080/newstring_download/protein.actions.{version}.txt.gz" 
     510        aliases = "http://www.string-db.org:8080/newstring_download/protein.aliases.{version}.txt.gz" 
     511         
     512        download(links.format(version=version), dir) 
     513        download(actions.format(version=version), dir) 
     514        download(aliases.format(version=version), dir) 
     515         
     516        links_filename = os.path.join(dir, "protein.links.{version}.txt".format(version=version)) 
     517        actions_filename = os.path.join(dir, "protein.links.{version}.txt".format(version=version)) 
     518        aliases_filename = os.path.join(dir, "protein.aliases.{version}.txt".format(version=version)) 
     519         
     520        from orngMisc import ConsoleProgressBar 
     521         
     522        progress = ConsoleProgressBar("Extracting files:") 
     523        progress(1.0) 
     524        links_file = gzip.GzipFile(links_filename + ".gz", "rb") 
     525        shutil.copyfileobj(links_file, open(links_filename, "wb")) 
     526         
     527        progress(60.0) 
     528        actions_file = gzip.GzipFile(actions_filename + ".gz", "rb") 
     529        shutil.copyfileobj(actions_file, open(actions_filename, "wb")) 
     530        actions_file = open(actions_filename, "rb") 
     531#         
     532        progress(90.0) 
     533        aliases_file = gzip.GzipFile(aliases_filename + ".gz", "rb") 
     534        shutil.copyfileobj(aliases_file, open(aliases_filename, "wb")) 
     535        aliases_file = open(aliases_filename, "rb") 
     536        progress.finish() 
     537         
     538        cls.init_db(version, taxids) 
     539         
     540    @classmethod 
     541    def init_db(cls, version, taxids=None): 
     542        """ Initialize the sqlite3 data base. `version` must contain a 
     543        STRING release version e.g 'v8.3'. If `taxids` is not `None` it 
     544        must contain a list of tax-ids in the STRING database for which 
     545        to extract the interactions for. 
     546         
     547        """ 
     548        def counter(): 
     549            i = 0 
     550            while True: 
     551                yield i 
     552                i += 1 
     553                 
     554        protein_ids = defaultdict(counter().next) 
     555        protein_taxid = {} 
     556 
     557        dir = orngServerFiles.localpath(cls.DOMAIN) 
     558         
     559        links_filename = os.path.join(dir, "protein.links.{version}.txt".format(version=version)) 
     560        actions_filename = os.path.join(dir, "protein.actions.{version}.txt".format(version=version)) 
     561        aliases_filename = os.path.join(dir, "protein.aliases.{version}.txt".format(version=version)) 
     562         
     563        links_file = open(links_filename, "rb") 
     564        actions_file = open(actions_filename, "rb") 
     565        aliases_file = open(aliases_filename, "rb") 
     566         
     567        from orngMisc import ConsoleProgressBar 
     568         
     569        progress = ConsoleProgressBar("Processing links file:") 
     570        progress(0.0) 
     571        filesize = os.stat(links_filename).st_size 
     572         
     573        taxids = set(taxids) if taxids else set(obiTaxonomy.common_taxids()) 
     574                 
     575        con = sqlite3.connect(orngServerFiles.localpath(cls.DOMAIN, cls.FILENAME)) 
     576         
     577        con.execute("drop table if exists links") 
     578        con.execute("drop table if exists proteins") 
     579        con.execute("drop table if exists actions") 
     580        con.execute("drop table if exists aliases") 
     581         
     582        con.execute("create table links (protein_id1 text, protein_id2 text, score int)") 
     583        con.execute("create table proteins (protein_id text, taxid text)") 
     584        con.execute("create table actions (protein_id1 text, protein_id2 text, mode text, action text, score int)") 
     585        con.execute("create table aliases (protein_id text, alias text)") 
     586         
     587        header = links_file.readline() # read the header 
     588         
     589        import csv 
     590        reader = csv.reader(links_file, delimiter=" ") 
     591         
     592        def read_links(reader): 
     593            links = [] 
     594            i = 0 
     595            for p1, p2, score in reader: 
     596                taxid1 = p1.split(".", 1)[0] 
     597                taxid2 = p2.split(".", 1)[0] 
     598                if taxid1 in taxids and taxid2 in taxids: 
     599                    links.append((intern(p1), intern(p2), int(score))) 
     600                i += 1 
     601                if i % 1000 == 0: # Update the progress every 1000 lines 
     602                    progress(100.0 * links_file.tell() / filesize) 
     603            links.sort() 
     604            return links 
     605         
     606        con.executemany("insert into links values (?, ?, ?)", read_links(reader)) 
     607             
     608        con.commit() 
     609         
     610        progress.finish() 
     611         
     612        proteins = [res[0] for res in con.execute("select distinct protein_id1 from links")] 
     613        progress = ConsoleProgressBar("Processing proteins:") 
     614         
     615        def protein_taxids(proteins): 
     616            protein_taxids = [] 
     617            for i, prot in enumerate(proteins): 
     618                taxid = prot.split(".", 1)[0] 
     619                protein_taxids.append((prot, taxid)) 
     620                if i % 1000 == 0: 
     621                    progress(100.0 * i / len(proteins)) 
     622            protein_taxids.sort() 
     623            return protein_taxids 
     624         
     625        con.executemany("insert into proteins values (?, ?)", protein_taxids(proteins)) 
     626 
     627        con.commit() 
     628        progress.finish() 
     629         
     630        filesize = os.stat(actions_filename).st_size 
     631         
     632        actions_file.readline() # read header 
     633         
     634        progress = ConsoleProgressBar("Processing actions:") 
     635        reader = csv.reader(actions_file, delimiter="\t") 
     636        def read_actions(reader): 
     637            actions = [] 
     638            i = 0 
     639            for p1, p2, mode, action, a_is_acting, score in reader: 
     640                taxid1 = p1.split(".", 1)[0] 
     641                taxid2 = p2.split(".", 1)[0] 
     642                if taxid1 in taxids and taxid2 in taxids: 
     643                    actions.append((intern(p1), intern(p2), mode, action, int(score))) 
     644                i += 1 
     645                if i % 1000 == 0: 
     646                    progress(100.0 * actions_file.tell() / filesize) 
     647            actions.sort() 
     648            return actions 
     649         
     650        con.executemany("insert into actions values (?, ?, ?, ?, ?)", read_actions(reader)) 
     651        con.commit() 
     652        progress.finish() 
     653         
     654        filesize = os.stat(aliases_filename).st_size 
     655        aliases_file.readline() # read header 
     656         
     657        progress = ConsoleProgressBar("Processing aliases:") 
     658                         
     659        reader = csv.reader(aliases_file, delimiter="\t") 
     660        def read_aliases(reader): 
     661            i = 0 
     662            for taxid, name, alias, source in reader: 
     663                if taxid in taxids: 
     664                    yield ".".join([taxid, name]), alias 
     665                i += 1 
     666                if i % 1000 == 0: 
     667                    progress(100.0 * aliases_file.tell() / filesize) 
     668                     
     669        con.executemany("insert into aliases values (?, ?)", read_aliases(reader)) 
     670        con.commit() 
     671        progress.finish() 
     672         
     673    def init_db_index(self): 
     674        """ Will create indexes (if not already pressent) in the database 
     675        for faster searching by primary ids. 
     676         
     677        """ 
     678        self.db.execute("""\ 
     679            create index if not exists index_link_protein_id1 
     680                on links (protein_id1)""") 
     681         
     682        self.db.execute("""\ 
     683            create index if not exists index_action_protein_id1 
     684                on actions (protein_id1)""") 
     685         
     686        self.db.execute("""\ 
     687            create index if not exists index_proteins_id 
     688                on proteins (protein_id)""") 
     689         
     690        self.db.execute("""\ 
     691            create index if not exists index_taxids 
     692                on proteins (taxid)""") 
     693         
     694        self.db.execute("""\ 
     695            create index if not exists index_aliases_id 
     696                on aliases (protein_id)""") 
     697         
     698        self.db.execute("""\ 
     699            create index if not exists index_aliases_alias 
     700                on aliases (alias)""") 
     701         
    14702         
    15703class Interaction(object): 
     
    102790    """ An object representing a BioGRID interaction. Each member of this object 
    103791    represents a data from a single column of BIOGRID-ALL.tab file. 
    104     Attributes:: 
     792    Attributes: 
    105793        - *interactor_a*    - BioGRID identifier 
    106794        - *interactor_b*    - BioGRID identifier 
     
    119807            setattr(self, attr, val) 
    120808 
    121 class BioGRID(object): 
     809class _BioGRID_Old(object): 
    122810    """ A BioGRID database interface 
    123811    Example:: 
     
    129817    VERSION = 1 
    130818    def __init__(self, case_insensitive=True): 
     819#        warnings.warn("obiPPi._BioGRID_Old class is deprecated. Use obiPPI.BioGRID") 
    131820        self.case_insensitive = case_insensitive 
    132821        self._case = (lambda name: name.lower()) if self.case_insensitive else (lambda name: name) 
     
    200889    def get_instance(cls): 
    201890        if getattr(cls, "_instance", None) is None: 
    202             cls._instance = BioGRID() 
     891            cls._instance = _BioGRID_Old() 
    203892        return cls._instance 
    204893     
     
    207896    """  
    208897    if name: 
    209         return list(BioGRID.get_instance().get(name, set())) 
     898        return list(_BioGRID_Old.get_instance().get(name, set())) 
    210899    else: 
    211         return BioGRID.get_instance().interactions 
     900        return _BioGRID_Old.get_instance().interactions 
    212901     
    213902def biogrid_proteins(): 
    214903    """ Return all protein names in BioGRID (from INTERACTOR_A, and INTERACTOR_B columns) 
    215904    """ 
    216     return BioGRID.get_instance().proteins() 
     905    return _BioGRID_Old.get_instance().proteins() 
    217906 
    218907 
Note: See TracChangeset for help on using the changeset viewer.