Changeset 1512:c4a1ed0a9f8a in orange-bioinformatics


Ignore:
Timestamp:
11/24/11 18:19:41 (2 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
9fee7eb457efbd66b9686240e3b6f6c5a4dfb7f8
Message:

Added STRINGNonCommercial class.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • obiPPI.py

    r1508 r1512  
    2121from obiTaxonomy import pickled_cache 
    2222 
    23 from Orange.misc import lru_cache 
     23from Orange.misc import lru_cache, ConsoleProgressBar 
    2424 
    2525import sqlite3 
     
    456456from functools import partial 
    457457 
     458from obiGeneMania import wget, copyfileobj 
     459 
     460def chainiter(iterable): 
     461    for sub_iter in iterable: 
     462        for obj in sub_iter: 
     463            yield obj 
     464 
     465def chunks(iter, chunk_size=1000): 
     466    chunk = [] 
     467    i = 0 
     468    for obj in iter: 
     469        chunk.append(obj) 
     470        if len(chunk) == chunk_size: 
     471            yield chunk 
     472            chunk = [] 
     473    if chunk: 
     474        # The remaining items if any 
     475        yield chunk 
     476     
    458477STRINGInteraction = namedtuple("STRINGInteraciton", 
    459478        ["protein_id1", "protein_id2", "combined_score", "mode", 
     
    485504    table `aliases`: 
    486505        - `protein_id: id (text) 
    487         - `alias`: protein alias (text)  
     506        - `alias`: protein alias (text) 
     507        - `source`: protein alias source (text) 
    488508         
    489509    """ 
    490510    DOMAIN = "PPI" 
    491511    FILENAME = "string-protein.sqlite" 
    492     VERSION = "1.0" 
     512    VERSION = "2.0" 
    493513     
    494514    # Mapping from obiTaxonomy.common_taxids() to taxids in STRING. 
     
    508528        self.db = sqlite3.connect(self.filename) 
    509529         
     530    @classmethod 
     531    def common_taxids(cls): 
     532        common = obiTaxonomy.common_taxids() 
     533        common = [cls.TAXID_MAP.get(id, id) for id in common] 
     534        return filter(None, common) 
     535     
    510536    def organisms(self): 
    511537        """ Return all organism taxids contained in this database. 
     
    542568        res = cur.fetchall() 
    543569        return [r[0] for r in res] 
     570     
     571    def synonyms_with_source(self, id): 
     572        """ Return a list of synonyms for primary `id` along  
     573        with its source as reported by STRING  
     574        (proteins.aliases.{version}.txt file) 
     575         
     576        """ 
     577        cur = self.db.execute("""\ 
     578            select alias, source 
     579            from aliases 
     580            where protein_id=? 
     581            """, (id,)) 
     582        return cur.fetchall() 
    544583     
    545584    def all_edges(self, taxid=None): 
     
    622661        """ 
    623662        dir = orngServerFiles.localpath("PPI") 
    624          
    625         def download(address, dir): 
    626             stream = urllib2.urlopen(address) 
    627             basename = posixpath.basename(address) 
    628             tmpfilename = os.path.join(dir, basename + ".part") 
    629             tmpfile = open(tmpfilename, "wb") 
    630             shutil.copyfileobj(stream, tmpfile) 
    631             tmpfile.close() 
    632             os.rename(tmpfilename, os.path.join(dir, basename)) 
    633         base_url = "http://www.string-db.org/newstring_download/" #protein.links.v9.0.txt.gz 
     663 
     664        base_url = "http://www.string-db.org/newstring_download/" 
    634665        links = base_url + "protein.links.{version}.txt.gz" 
    635666        actions = base_url + "protein.actions.{version}.txt.gz" 
    636667        aliases = base_url + "protein.aliases.{version}.txt.gz" 
    637668         
    638         download(links.format(version=version), dir) 
    639         download(actions.format(version=version), dir) 
    640         download(aliases.format(version=version), dir) 
     669        wget(links.format(version=version), dir, progress=True) 
     670        wget(actions.format(version=version), dir, progress=True) 
     671        wget(aliases.format(version=version), dir, progress=True) 
    641672         
    642673        links_filename = os.path.join(dir, "protein.links.{version}.txt".format(version=version)) 
    643         actions_filename = os.path.join(dir, "protein.links.{version}.txt".format(version=version)) 
     674        actions_filename = os.path.join(dir, "protein.actions.{version}.txt".format(version=version)) 
    644675        aliases_filename = os.path.join(dir, "protein.aliases.{version}.txt".format(version=version)) 
    645          
    646         from orngMisc import ConsoleProgressBar 
    647676         
    648677        progress = ConsoleProgressBar("Extracting files:") 
     
    654683        actions_file = gzip.GzipFile(actions_filename + ".gz", "rb") 
    655684        shutil.copyfileobj(actions_file, open(actions_filename, "wb")) 
    656         actions_file = open(actions_filename, "rb") 
    657 #         
     685         
    658686        progress(90.0) 
    659687        aliases_file = gzip.GzipFile(aliases_filename + ".gz", "rb") 
    660688        shutil.copyfileobj(aliases_file, open(aliases_filename, "wb")) 
    661         aliases_file = open(aliases_filename, "rb") 
    662689        progress.finish() 
    663690         
     
    691718        aliases_file = open(aliases_filename, "rb") 
    692719         
    693         from orngMisc import ConsoleProgressBar 
    694          
    695         progress = ConsoleProgressBar("Processing links file:") 
     720        progress = ConsoleProgressBar("Processing links:") 
    696721        progress(0.0) 
    697722        filesize = os.stat(links_filename).st_size 
     
    700725            taxids = set(taxids) 
    701726        else: 
    702             taxids = [cls.TAXID_MAP.get(id, id) for id in obiTaxonomy.common_taxids()] 
    703             taxids = set(filter(None, taxids)) 
     727            taxids = set(cls.common_taxids()) 
    704728                         
    705729        con = sqlite3.connect(orngServerFiles.localpath(cls.DOMAIN, cls.FILENAME)) 
     730         
    706731        with con: 
    707732            con.execute("drop table if exists links") 
     
    713738            con.execute("create table proteins (protein_id text, taxid text)") 
    714739            con.execute("create table actions (protein_id1 text, protein_id2 text, mode text, action text, score int)") 
    715             con.execute("create table aliases (protein_id text, alias text)") 
     740            con.execute("create table aliases (protein_id text, alias text, source text)") 
    716741             
    717742            header = links_file.readline() # read the header 
     
    723748                links = [] 
    724749                i = 0 
     750                split = str.split 
    725751                for p1, p2, score in reader: 
    726                     taxid1 = p1.split(".", 1)[0] 
    727                     taxid2 = p2.split(".", 1)[0] 
    728                     if taxid1 in taxids and taxid2 in taxids: 
     752                    if split(p1, ".", 1)[0] in taxids and split(p2, ".", 1)[0] in taxids: 
    729753                        links.append((intern(p1), intern(p2), int(score))) 
    730754                        if len(links) == chunk_size: 
     
    739763            for chunk in read_links(reader): 
    740764                con.executemany("insert into links values (?, ?, ?)", chunk) 
    741                  
    742             con.commit() 
    743765             
    744766            progress.finish() 
     
    758780             
    759781            con.executemany("insert into proteins values (?, ?)", protein_taxids(proteins)) 
    760      
    761             con.commit() 
     782             
    762783            progress.finish() 
    763784             
     
    771792                actions = [] 
    772793                i = 0 
     794                split = str.split 
    773795                for p1, p2, mode, action, a_is_acting, score in reader: 
    774                     taxid1 = p1.split(".", 1)[0] 
    775                     taxid2 = p2.split(".", 1)[0] 
    776                     if taxid1 in taxids and taxid2 in taxids: 
     796                    if split(p1, ".", 1)[0] in taxids and split(p2, ".", 1)[0] in taxids: 
    777797                        actions.append((intern(p1), intern(p2), mode, action, int(score))) 
    778798                    i += 1 
     
    783803             
    784804            con.executemany("insert into actions values (?, ?, ?, ?, ?)", read_actions(reader)) 
    785             con.commit() 
     805             
    786806            progress.finish() 
    787807             
     
    796816                for taxid, name, alias, source in reader: 
    797817                    if taxid in taxids: 
    798                         yield ".".join([taxid, name]), alias.decode("utf-8", errors="ignore") 
     818                        yield (".".join([taxid, name]),  
     819                               alias.decode("utf-8", errors="ignore"),  
     820                               source.decode("utf-8", errors="ignore"), 
     821                               ) 
    799822                    i += 1 
    800823                    if i % 1000 == 0: 
    801824                        progress(100.0 * aliases_file.tell() / filesize) 
    802825                         
    803             con.executemany("insert into aliases values (?, ?)", read_aliases(reader)) 
     826            con.executemany("insert into aliases values (?, ?, ?)", read_aliases(reader)) 
     827             
     828            progress.finish() 
    804829 
    805830            print "Indexing the database" 
     
    829854                    on aliases (alias)""") 
    830855             
     856            con.executescript(""" 
     857                DROP TABLE IF EXISTS version; 
     858                 
     859                CREATE TABLE version ( 
     860                     string_version text, 
     861                     api_version text 
     862                );""") 
     863             
     864            con.execute(""" 
     865                INSERT INTO version 
     866                VALUES (?, ?)""", (version, cls.VERSION)) 
     867             
    831868        progress.finish() 
     869         
     870 
     871STRINGNonCommercialInteraction = namedtuple("STRINGNonCommercialInteraction", 
     872        ["protein_id1", "protein_id2", "combined_score", "mode", 
     873         "action", "score", "neighborhood", "fusion", "cooccurence",  
     874         "coexpression", "experimental", "database", "textmining" 
     875         ]) 
     876 
     877class STRINGNonCommercial(STRING): 
     878    """ The Creative Commons Attribution-Noncommercial-Share  
     879    Alike licensed part of STRING. 
     880     
     881     
     882    """ 
     883     
     884    DATABASE_SCHEMA = """\ 
     885    DATABASE SCHEMA 
     886    =============== 
     887     
     888    table `evidence`: 
     889        - `protein_id1`: protein id (text) 
     890        - `protein_id2`: protein id (text) 
     891        - `neighborhood`: score (int) 
     892        - `fusion`: score (int) 
     893        - `cooccurence`: score (int) 
     894        - `coexpression`: score (int) 
     895        - `experimental`: score (int) 
     896        - `database`: score (int) 
     897        - `textmining`: score (int) 
     898         
     899    """ 
     900    FILENAME_NC = "string-protein-NC.sqlite" 
     901     
     902    def __init__(self): 
     903        STRING.__init__(self) 
     904        db_nc_file = orngServerFiles.localpath(self.DOMAIN, self.FILENAME_NC) 
     905        db_file = orngServerFiles.localpath(self.DOMAIN, self.FILENAME) 
     906        self.db_nc = sqlite3.connect(db_nc_file) 
     907        self.db_nc.execute("ATTACH DATABASE ? as string", (db_file,)) 
     908         
     909    def edges_annotated(self, id): 
     910        """ Return a list of all edges annotated. 
     911        """ 
     912        edges = STRING.edges_annotated(self, id) 
     913        edges_nc = [] 
     914        for edge in edges: 
     915            id1, id2 = edge.protein_id1, edge.protein_id2 
     916            cur = self.db_nc.execute("""\ 
     917                SELECT neighborhood, fusion, cooccurence, coexpression, 
     918                       experimental, database, textmining 
     919                FROM evidence 
     920                WHERE protein_id1=? AND protein_id2=? 
     921                """, (id1, id2)) 
     922            res = cur.fetchone() 
     923            if res: 
     924                evidence = res 
     925            else: 
     926                evidence = [0] * 7 
     927            edges_nc.append( 
     928                STRINGNonCommercialInteraction(*(tuple(edge) + tuple(evidence))) 
     929            ) 
     930        return edges_nc 
     931         
     932    @classmethod 
     933    def download_data(cls, version, taxids=None): 
     934        import gzip, shutil, csv 
     935         
     936        baseurl = "http://www.string-db.org/newstring_download/" 
     937        links_filename = "protein.links.detailed.{version}.txt.gz".format(version=version) 
     938         
     939        dir = orngServerFiles.localpath(cls.DOMAIN) 
     940        local_filename = os.path.join(dir, links_filename) 
     941          
     942        if not os.path.exists(local_filename): 
     943            wget(baseurl + links_filename, dir, progress=True) 
     944        else: 
     945            print "Already downloaded - skiping" 
     946             
     947        gz = gzip.open(os.path.join(dir, links_filename), "rb") 
     948 
     949        # Strip .gz extension 
     950        links_filename = os.path.join(dir, os.path.splitext(links_filename)[0]) 
     951        if not os.path.exists(links_filename): 
     952            shutil.copyfileobj(gz, open(links_filename)) 
     953         
     954        cls.init_db(version, taxids) 
     955             
     956    @classmethod 
     957    def init_db(cls, version, taxids=None): 
     958        import csv 
     959        dir = orngServerFiles.localpath(cls.DOMAIN) 
     960         
     961        links_filename = "protein.links.detailed.{version}.txt".format(version=version) 
     962        links_filename = os.path.join(dir, links_filename) 
     963         
     964        if taxids: 
     965            taxids = set(taxids) 
     966        else: 
     967            taxids = set(cls.common_taxids()) 
     968         
     969        links_file = open(links_filename, "rb") 
     970         
     971        con = sqlite3.connect(os.path.join(dir, cls.FILENAME_NC)) 
     972        with con: 
     973            con.execute("""\ 
     974                DROP TABLE IF EXISTS evidence 
     975            """) 
     976             
     977            con.execute("""\ 
     978                CREATE TABLE evidence( 
     979                     protein_id1 TEXT, 
     980                     protein_id2 TEXT, 
     981                     neighborhood INTEGER,  
     982                     fusion INTEGER, 
     983                     cooccurence INTEGER, 
     984                     coexpression INTEGER, 
     985                     experimental INTEGER, 
     986                     database INTEGER, 
     987                     textmining INTEGER 
     988                    ) 
     989                """) 
     990             
     991            links = csv.reader(links_file, delimiter=" ") 
     992            links.next() # Read header 
     993            filesize = os.stat(links_filename).st_size 
     994             
     995            progress = ConsoleProgressBar("Processing links file:") 
     996            progress(1.0) 
     997             
     998            def read_links(reader, chunk_size=100000): 
     999                split = str.split 
     1000                for links in chunks(reader, chunk_size): 
     1001                    chunk = [] 
     1002                    for p1, p2, n, f, c, cx, ex, db, t, _ in links: 
     1003                        if split(p1, ".", 1)[0] in taxids and split(p2, ".", 1)[0] in taxids: 
     1004                            chunk.append((intern(p1), intern(p2), n, f, c, cx, ex, db, t)) 
     1005                         
     1006                    progress(100.0 * links_file.tell() / filesize) 
     1007                    if chunk: 
     1008                        yield chunk 
     1009             
     1010            # The links are read in chunks for better performace  
     1011            for chunk in read_links(links): 
     1012                con.executemany(""" 
     1013                    INSERT INTO evidence  
     1014                    VALUES  (?, ?, ?, ?, ?, ?, ?, ?, ?) 
     1015                    """, chunk) 
     1016         
     1017            progress.finish() 
     1018             
     1019            print "Indexing" 
     1020            con.execute("""\ 
     1021                CREATE INDEX IF NOT EXISTS index_evidence 
     1022                    ON evidence (protein_id1, protein_id2) 
     1023            """) 
     1024             
     1025            con.executescript(""" 
     1026                DROP TABLE IF EXISTS version; 
     1027                 
     1028                CREATE TABLE version ( 
     1029                     string_version text, 
     1030                     api_version text 
     1031                ); 
     1032                """) 
     1033             
     1034            con.execute(""" 
     1035                INSERT INTO version 
     1036                VALUES (?, ?)""", (version, cls.VERSION)) 
    8321037         
    8331038         
Note: See TracChangeset for help on using the changeset viewer.