Changeset 1887:b0dce8ef683c in orange-bioinformatics


Ignore:
Timestamp:
10/14/13 14:59:54 (6 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Fixes for obiGeneAtlas.

Location:
orangecontrib/bio
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • orangecontrib/bio/obiGeneAtlas.py

    r1873 r1887  
    1919from __future__ import absolute_import 
    2020 
    21 import os, shelve, sys 
     21import os 
     22import shelve 
    2223from collections import defaultdict, namedtuple 
    23 from contextlib import closing 
    24  
    25 from Orange.orng import orngServerFiles 
     24from contextlib import closing, contextmanager 
     25 
    2626from Orange.utils import serverfiles 
    2727 
     
    4444    """ Return a open cache instance (a shelve object). 
    4545    """ 
    46     if not os.path.exists(orngServerFiles.localpath("GeneAtlas")): 
     46    if not os.path.exists(serverfiles.localpath("GeneAtlas")): 
    4747        try: 
    48             os.makedirs(orngServerFiles.localpath("GeneAtlas")) 
     48            os.makedirs(serverfiles.localpath("GeneAtlas")) 
    4949        except OSError: 
    5050            pass 
    51     cache = shelve.open(orngServerFiles.localpath("GeneAtlas", name)) 
     51    cache = shelve.open(serverfiles.localpath("GeneAtlas", name)) 
    5252    if cache.get(name + "__CACHE_VERSION__", None) == CACHE_VERSION: 
    5353        return cache 
    5454    else: 
    5555        cache.close() 
    56         cache = shelve.open(orngServerFiles.localpath("GeneAtlas", name), "n") 
     56        cache = shelve.open(serverfiles.localpath("GeneAtlas", name), "n") 
    5757        cache[name + "__CACHE_VERSION__"] = CACHE_VERSION 
    5858        return cache 
     
    152152    """ 
    153153    taxid = to_taxid(organism) 
    154     matcher = obiGene.matcher([obiGene.GMEnsembl(taxid), 
    155                                obiGene.GMNCBI(taxid)]) 
     154    matcher = obiGene.matcher( 
     155      [obiGene.GMEnsembl(taxid), 
     156       [obiGene.GMEnsembl(taxid), 
     157        obiGene.GMNCBI(taxid)]] 
     158    ) 
    156159    matcher.set_targets(obiGene.EnsembleGeneInfo(taxid).keys()) 
    157160    return matcher 
     
    159162from Orange.utils import lru_cache 
    160163 
     164 
    161165@lru_cache(maxsize=3) 
    162 def _cached_default_gene_matcher(organism):  
     166def _cached_default_gene_matcher(organism): 
    163167    return default_gene_matcher(organism) 
    164168     
     
    179183    Example :: 
    180184     
    181         >>> get_atlas_summary(["RUNX1"], "Homo sapiens") 
     185        >>> get_atlas_summary(["ENSG00000159216"], "Homo sapiens") 
    182186        ({u'RUNX1': ... 
    183187         
     
    330334 
    331335class GeneExpressionAtlasConenction(object): 
    332     """ A connection to Gene Expression Atlas database. 
    333     """ 
    334     DEFAULT_ADDRESS = "http://www.ebi.ac.uk:80/gxa/" 
    335     DEFAULT_CACHE = orngServerFiles.localpath("GeneAtlas", "GeneAtlasConnectionCache.shelve") 
     336    """ 
     337    A connection to Gene Expression Atlas database. 
     338 
     339    :param address: 
     340        Address of the GXA server (default: http://www.ebi.ac.uk/gxa/api/deprecated). 
     341    :param timeout: 
     342        Socket timeout (default 30). 
     343    :param cache: 
     344        A dict like object to use as a cache. 
     345 
     346    """ 
     347    DEFAULT_ADDRESS = "http://www.ebi.ac.uk/gxa/api/deprecated" 
     348    DEFAULT_CACHE = serverfiles.localpath( 
     349        "GeneAtlas", "GeneAtlasConnectionCache.shelve") 
     350 
    336351    def __init__(self, address=None, timeout=30, cache=None): 
    337         """ Initialize the conenction. 
    338          
    339         :param address: Address of the server. 
    340         :param timeout: Socket timeout. 
    341         :param cache : A dict like object to use as a cache. 
    342          
    343         """ 
     352 
    344353        self.address = address if address is not None else self.DEFAULT_ADDRESS 
    345354        self.timeout = timeout 
    346355        self.cache = cache if cache is not None else self.DEFAULT_CACHE 
    347      
     356 
    348357    def query(self, condition, format="json", start=None, rows=None, indent=False): 
    349         url = self.address + "api/vx?" + condition.rest() 
     358        url = self.address + "?" + condition.rest() 
    350359        if start is not None and rows is not None: 
    351360            url += "&start={0}&rows={1}".format(start, rows) 
     
    359368        else: 
    360369            return urllib2.urlopen(url) 
    361         return response 
    362      
     370 
    363371    def _query_cached(self, url, format): 
    364372        if self.cache is not None: 
    365             with self.open_cache() as cache: 
    366                 cached = url in cache 
    367              
    368             if not cached: 
    369                 response = urllib2.urlopen(url) 
    370                 contents = response.read() 
    371                 # Test if the contents is a valid json or xml string (some  
    372                 # times the stream just stops in the middle, so this makes 
    373                 # sure we don't cache an invalid response 
    374                 # TODO: what about errors (e.g. 'cannot handle the 
    375                 # query in a timely fashion' 
    376                 if format == "json": 
    377                     parse_json(StringIO(contents)) 
    378                 else: 
    379                     parse_xml(StringIO(contents)) 
    380                      
    381                 with self.open_cache() as cache: 
    382                     cache[url] = contents 
     373            with self.open_cache("r") as cache: 
     374                if url in cache: 
     375                    return StringIO(cache[url]) 
     376 
     377            response = urllib2.urlopen(url) 
     378            contents = response.read() 
     379            # Test if the contents is a valid json or xml string (some 
     380            # times the stream just stops in the middle, so this makes 
     381            # sure we don't cache an invalid response 
     382            # TODO: what about errors (e.g. 'cannot handle the 
     383            # query in a timely fashion' 
     384            if format == "json": 
     385                parse_json(StringIO(contents)) 
    383386            else: 
    384                 with self.open_cache() as cache: 
    385                     contents = cache[url] 
     387                parse_xml(StringIO(contents)) 
     388 
     389            with self.open_cache("w") as cache: 
     390                cache[url] = contents 
     391 
    386392            return StringIO(contents) 
    387393        else: 
    388394            return urllib2.urlopen(url) 
    389          
    390     def open_cache(self): 
     395 
     396    def open_cache(self, flag="r"): 
     397        """ 
     398        Return a context manager for a dict like object. 
     399        """ 
    391400        if isinstance(self.cache, basestring): 
    392             return closing(shelve.open(self.cache)) 
    393         elif hasattr(self.cache, "close"): 
    394             return closing(self.cache) 
    395         elif self.cache is None: 
    396             return fake_closing({}) 
     401            try: 
     402                return closing(_open_shelve(self.cache, flag)) 
     403            except Exception: 
     404                return fake_closing({}) 
    397405        else: 
    398406            return fake_closing(self.cache) 
    399          
    400          
    401 from contextlib import contextmanager 
     407 
     408 
     409def _open_shelve(filename, flag="r"): 
     410    dirname = os.path.dirname(filename) 
     411    if not os.path.isdir(dirname): 
     412        os.makedirs(dirname) 
     413    exists = os.path.exists(filename) 
     414    if flag in ["r", "w"] and not exists: 
     415        # needs to be created first 
     416        # XXX: Race condition 
     417        s = shelve.open(filename, "c") 
     418        s.close() 
     419 
     420    return shelve.open(filename, flag) 
     421 
     422 
    402423@contextmanager 
    403424def fake_closing(obj): 
  • orangecontrib/bio/widgets/OWGeneAtlasTissueExpression.py

    r1874 r1887  
    454454    app = QApplication(sys.argv) 
    455455    w = OWGeneAtlasTissueExpression() 
    456     data = Orange.data.Table("RUNX1.tab") 
     456 
     457    data = Orange.data.Table( 
     458        Orange.data.Domain([Orange.feature.String("Gene")], None), 
     459        [["RUNX1"]] 
     460    ) 
     461 
    457462    w.show() 
    458463    w.set_data(data) 
Note: See TracChangeset for help on using the changeset viewer.