Changeset 1712:bcd52ead3d93 in orange-bioinformatics


Ignore:
Timestamp:
08/21/12 15:06:38 (20 months ago)
Author:
markotoplak
Branch:
default
Message:

Classes for storing gene set data moved to Orange.bio.geneset. obiGeneSets adapted to make new pickled classes.

Location:
_bioinformatics
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • _bioinformatics/obiGO.py

    r1682 r1712  
    624624 
    625625        path = os.path.join(orngServerFiles.localpath("GO"), file) 
     626 
    626627        if not os.path.exists(path): 
     628            sf = orngServerFiles.ServerFiles() 
     629            available = sf.listfiles("GO") 
     630            if file not in available: 
     631                from . import obiKEGG2 
     632                raise obiKEGG2.OrganismNotFoundError(org + str(code)) 
    627633            orngServerFiles.download("GO", file) 
     634 
    628635        return cls(path, ontology=ontology, genematcher=genematcher, progressCallback=progressCallback) 
    629636     
  • _bioinformatics/obiGeneSets.py

    r1707 r1712  
    2323    return [ a[n] for a in l] 
    2424 
    25 class GeneSet(object): 
    26  
    27     def __init__(self, genes=None, name=None, id=None, \ 
    28         description=None, link=None, organism=None, hierarchy=None, pair=None): 
    29         """ 
    30         pair can be (id, listofgenes) - it is used before anything else. 
    31         """ 
    32         if genes == None: 
    33             genes = [] 
    34  
    35         self.hierarchy = hierarchy 
    36         self.genes = set(genes) 
    37         self.name = name 
    38         self.id = id 
    39         self.description = description 
    40         self.link = link 
    41         self.organism = organism 
    42  
    43         if pair: 
    44             self.id, self.genes = pair[0], set(pair[1]) 
    45  
    46     """ 
    47     the following functions are needed for sets of gene sets to be able 
    48     to assess equality 
    49     """ 
    50  
    51     def __hash__(self): 
    52         return self.id.__hash__() + self.name.__hash__() 
    53  
    54     def __eq__(self, other): 
    55         if isinstance(other, self.__class__): 
    56             return self.__dict__ == other.__dict__ 
    57         else: 
    58             return False 
    59  
    60     def __ne__(self, other): 
    61         return not self.__eq__(other) 
    62  
    63     def size(self): 
    64         return len(self.genes) 
    65  
    66     def cname(self, source=True, name=True): 
    67         """ Constructs a gene set name with the hierarchy. """ 
    68         oname = self.id 
    69         if source and self.hierarchy: 
    70             oname = "[ " + ", ".join(self.hierarchy) + " ] " + oname 
    71         if name and self.name: 
    72             oname = oname + " " + self.name 
    73         return oname 
    74  
    75     def to_odict(self, source=True, name=True): 
    76         """ 
    77         Returns a pair (id, listofgenes), like in old format. 
    78         """ 
    79         return self.cname(source=source, name=name), self.genes 
    80  
    81     def __repr__(self): 
    82         return "GeneSet(" + ", ".join( [  
    83             "id=" + str(self.id), 
    84             "genes=" + str(self.genes), 
    85             "name=" + str(self.name), 
    86             "link=" + str(self.link), 
    87             "hierarchy=" + str(self.hierarchy) 
    88         ]) + ")" 
    89  
    90 class GeneSetIDException(Exception): 
    91     pass 
    92  
    93 class GeneSets(set): 
    94      
    95     def __init__(self, input=None): 
    96         """ 
    97         odict are genesets in old dict format. 
    98         gs are genesets in new format 
    99         """ 
    100         if input != None and len(input) > 0: 
    101             self.update(input) 
    102  
    103     def update(self, input): 
    104         from . import obiGeneSets 
    105         if isinstance(input, obiGeneSets.GeneSets): 
    106             super(GeneSets, self).update(input) 
    107         elif hasattr(input, "items"): 
    108             for i, g in input.items(): 
    109                 self.add(obiGeneSets.GeneSet(pair=(i, g))) 
    110         else: 
    111             for i in input: 
    112                 if isinstance(i, obiGeneSets.GeneSet): 
    113                     self.add(i) 
    114                 else: 
    115                     i, g = i 
    116                     self.add(obiGeneSets.GeneSet(pair=(i, g))) 
    117  
    118     def to_odict(self): 
    119         """ Return gene sets in old dictionary format. """ 
    120         return dict(gs.to_odict() for gs in self) 
    121  
    122     def set_hierarchy(self, hierarchy): 
    123         """ Sets hierarchy for all gene sets """ 
    124         for gs in self: 
    125             gs.hierarchy = hierarchy 
    126  
    127     def __repr__(self): 
    128         return "GeneSets(" + set.__repr__(self) + ")" 
    129  
    130     def common_org(self): 
    131         """ Returns the common organism. """ 
    132         if len(self) == 0: 
    133             raise GenesetRegException("Empty gene sets.") 
    134  
    135         organisms = set(a.organism for a in self) 
    136  
    137         try: 
    138             return only_option(organisms) 
    139         except: 
    140             raise GenesetRegException("multiple organisms: " + str(organisms)) 
    141  
    142     def hierarchies(self): 
    143         """ Returns all hierachies """ 
    144         if len(self) == 0: 
    145             raise GenesetRegException("Empty gene sets.") 
    146         return set(a.hierarchy for a in self) 
    147  
    148     def common_hierarchy(self): 
    149         hierarchies = self.hierarchies() 
    150  
    151         def common_hierarchy1(hierarchies): 
    152             def hier(l): return set(map(lambda x: x[:currentl], hierarchies)) 
    153             currentl = max(map(len, hierarchies)) 
    154             while len(hier(currentl)) > 1: 
    155                 currentl -= 1 
    156             return only_option(hier(currentl)) 
    157  
    158         return common_hierarchy1(hierarchies) 
    159  
    160     def split_by_hierarchy(self): 
    161         """ Splits gene sets by hierarchies. """ 
    162         from . import obiGeneSets 
    163         hd = dict((h,obiGeneSets.GeneSets()) for h in  self.hierarchies()) 
    164         for gs in self: 
    165             hd[gs.hierarchy].add(gs) 
    166         return hd.values() 
     25from Orange.bio.geneset import GeneSet, GeneSets, GenesetRegException 
    16726 
    16827def goGeneSets(org): 
    16928    """Returns gene sets from GO.""" 
    170     from . import obiGeneSets 
    171  
    17229    ontology = obiGO.Ontology() 
    17330    annotations = obiGO.Annotations(org, ontology=ontology) 
     
    17936        hier = ("GO", term.namespace) 
    18037        if len(genes) > 0: 
    181             gs = obiGeneSets.GeneSet(id=termn, name=term.name, genes=genes, hierarchy=hier, organism=org, link=link_fmt % termn)  
     38            gs = GeneSet(id=termn, name=term.name, genes=genes, hierarchy=hier, organism=org, link=link_fmt % termn)  
    18239            genesets.append(gs) 
    18340 
    184     return obiGeneSets.GeneSets(genesets) 
     41    return GeneSets(genesets) 
    18542 
    18643def keggGeneSets(org): 
     
    18845    Returns gene sets from KEGG pathways. 
    18946    """ 
    190     from . import obiKEGG2 as obiKEGG, obiGeneSets 
     47    from . import obiKEGG2 as obiKEGG 
    19148     
    19249    kegg = obiKEGG.KEGGOrganism(org) 
     
    19451    genesets = [] 
    19552    for id in kegg.pathways(): 
     53        print id 
    19654        pway = obiKEGG.KEGGPathway(id) 
    19755        hier = ("KEGG","pathways") 
    198         gs = obiGeneSets.GeneSet(id=id, 
     56        gs = GeneSet(id=id, 
    19957                                 name=pway.title, 
    20058                                 genes=kegg.get_genes_by_pathway(id), 
     
    20462        genesets.append(gs) 
    20563 
    206     return obiGeneSets.GeneSets(genesets) 
     64    return GeneSets(genesets) 
    20765 
    20866def omimGeneSets(): 
     
    24199    go_sets = obimiRNA.filter_GO(go_sets, annotations, treshold=treshold) 
    242100     
    243     from . import obiGeneSets as gs 
    244101    link_fmt = "http://amigo.geneontology.org/cgi-bin/amigo/term-details.cgi?term=%s" 
    245     gsets = [gs.GeneSet(id=key, name=ontology[key].name, genes=value, hierarchy=("miRNA", "go_sets",), 
     102    gsets = [GeneSet(id=key, name=ontology[key].name, genes=value, hierarchy=("miRNA", "go_sets",), 
    246103                        organism=org, link=link_fmt % key) for key, value in go_sets.items()] 
    247     gset = gs.GeneSets(gsets) 
     104    gset = GeneSets(gsets) 
    248105    return gset 
    249106 
     
    257114    """ 
    258115 
    259     from . import obiGeneSets 
    260  
    261116    def hline(s): 
    262117        tabs = [tab.strip() for tab in s.split("\t")] 
    263         return obiGeneSets.GeneSet(id=tabs[0], description=tabs[1], 
     118        return GeneSet(id=tabs[0], description=tabs[1], 
    264119                                   hierarchy=(name,), genes=tabs[2:]) 
    265120 
     
    272127        return [fn(l) for l in lines if l] 
    273128 
    274     return obiGeneSets.GeneSets(handleNELines(contents, hline)) 
     129    return GeneSets(handleNELines(contents, hline)) 
    275130 
    276131""" 
     
    299154    """ Returns gene set availability index for some folder. """ 
    300155    pass 
    301  
    302 class GenesetRegException(Exception): pass 
    303  
    304 def only_option(a): 
    305     if len(a) == 1: 
    306         return list(a)[0] 
    307     else: 
    308         raise Exception() 
    309156 
    310157def filename(hierarchy, organism): 
     
    380227        os.remove(tfname) 
    381228 
    382 def register_local(genesets): 
     229def _register_local(genesets): 
    383230    """ Registers using the common hierarchy and organism. """ 
    384231    pth = local_path() 
     
    394241 
    395242def pickle_temp(obj): 
    396     """ Pickle a file to a temporary file returns its name """ 
     243    """ Pickle a file to a temporary file and returns its name """ 
    397244    fd,tfname = tempfile.mkstemp() 
    398245    os.close(fd) 
     
    402249    return tfname 
    403250 
    404 def register_serverfiles(genesets, serverFiles): 
     251def _register_serverfiles(genesets, serverFiles): 
    405252    """ Registers using the common hierarchy and organism. """ 
    406253    org = genesets.common_org() 
     
    429276    """ 
    430277    if serverFiles == None: 
    431         register_local(genesets) 
     278        _register_local(genesets) 
    432279    else: 
    433         register_serverfiles(genesets, serverFiles) 
     280        _register_serverfiles(genesets, serverFiles) 
    434281 
    435282def build_hierarchy_dict(files): 
     
    443290def load_local(hierarchy, organism): 
    444291    files = map(lambda x: x[:2], list_local()) 
    445  
    446292    hierd = build_hierarchy_dict(files) 
    447293 
     
    455301    files = map(lambda x: x[:2], list_serverfiles()) 
    456302    hierd = build_hierarchy_dict(files) 
    457  
    458303    out = GeneSets() 
    459304    for (h, o) in [ files[i] for i in hierd[(hierarchy, organism)]]: 
     
    464309 
    465310def load(hierarchy, organism): 
    466     """ First try to load from the local registred folder, then 
    467     from the server files. """ 
     311    """ First try to load from the local registred folder. If the file 
     312    is not available, load it from the server files. """ 
    468313    ret = load_local(hierarchy, organism) 
    469     ret.update(load_serverfiles(hierarchy, organism)) 
     314    if len(ret) == 0: 
     315        ret.update(load_serverfiles(hierarchy, organism)) 
    470316    return ret 
    471317 
     
    476322    hierarchy is a tuple also. 
    477323    """ 
    478     from . import obiGeneSets 
    479     result = obiGeneSets.GeneSets() 
     324    result = GeneSets() 
    480325 
    481326    for collection in args: 
     
    506351    orngServerFiles.update_local_files() 
    507352 
    508     genesetsfn = [ keggGeneSets, goGeneSets, miRNAGeneSets] 
     353    from . import obiKEGG2 as obiKEGG 
     354 
     355    #genesetsfn = [ keggGeneSets, goGeneSets, miRNAGeneSets] 
     356    genesetsfn = [ goGeneSets, miRNAGeneSets] 
    509357    organisms = obiTaxonomy.common_taxids() 
    510358    for fn in genesetsfn: 
    511359        for org in organisms: 
    512         #for org in [ "9606" ]: 
    513             print "Uploading ORG", org, fn 
    514360            try: 
     361                print "Uploading ORG", org, fn 
    515362                genesets = fn(org).split_by_hierarchy() 
    516363                for gs in genesets: 
    517364                    print "registering", gs.common_hierarchy() 
    518                     register_serverfiles(gs, rsf) 
     365                    #register(gs, rsf) #server files 
     366                    register(gs) 
    519367                    print "successful", gs.common_hierarchy() 
    520             except Exception, e: 
    521                 print "Not successful" 
     368            except (obiKEGG.OrganismNotFoundError, GenesetRegException): 
     369                print "organism not found", org 
     370 
    522371 
    523372if __name__ == "__main__": 
    524373    rsf = orngServerFiles.ServerFiles(username=sys.argv[1], password=sys.argv[2]) 
    525374    upload_genesets(rsf) 
     375    pass 
  • _bioinformatics/obiKEGG2/__init__.py

    r1636 r1712  
    4747from .. import obiProb 
    4848from Orange.utils import deprecated_keywords, deprecated_attribute 
     49 
     50class OrganismNotFoundError(Exception): pass 
    4951 
    5052class Organism(object): 
     
    193195            return genome[name].entry_key 
    194196        except KeyError: 
    195             raise ValueError("Organism with name='%s' not found in KEGG." % name) 
     197            raise OrganismNotFoundError(name) 
    196198         
    197199    @classmethod 
  • _bioinformatics/obiKEGG2/caching.py

    r1636 r1712  
    2323    def __exit__(self, *args): 
    2424        pass 
    25      
    2625 
    2726class Sqlite3Store(Store, UserDict.DictMixin): 
     
    2928        self.filename = filename 
    3029        self.con = sqlite3.connect(filename) 
     30        #self.con = sqlite3.connect(":memory:") 
    3131        self.con.execute(""" 
    3232        CREATE TABLE IF NOT EXISTS cache  
  • _bioinformatics/widgets/OWKEGGPathwayBrowser.py

    r1701 r1712  
    88from __future__ import absolute_import, with_statement  
    99 
     10if __name__ == "__main__":  
     11    __package__ = "Orange.bio.widgets" 
     12 
    1013import sys 
    1114from collections import defaultdict 
    1215import webbrowser 
    1316 
     17import Orange 
    1418import orange 
    1519from Orange.orng import orngMisc, orngServerFiles 
Note: See TracChangeset for help on using the changeset viewer.