Changeset 1615:8506076ec2e7 in orange-bioinformatics


Ignore:
Timestamp:
05/09/12 12:20:49 (2 years ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Added PIPAx api interface.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • obiDicty.py

    r1565 r1615  
    708708 
    709709        return et 
     710 
     711 
     712class PIPAx(PIPA): 
     713    """`PIPAx <http://pipa.biolab.si/?page_id=23>` api interface. 
     714    """ 
     715 
     716    API_ADDRESS = "https://pipa.biolab.si/pipax/api.py" 
     717 
     718    def __init__(self, address=API_ADDRESS, buffer=None, 
     719                 username=None, password=None): 
     720        self.address = address 
     721        self.db = DBInterface(address) 
     722        self.buffer = buffer 
     723        self.username = username 
     724        self.password = password 
     725 
     726    def genomes(self, reload=False, bufver="0"): 
     727        """Return a list of available genomes as a list of 
     728        (genome_id, genome_name) tuples. 
     729 
     730        >>> pipax.genomes() 
     731        [('dd', 'Dictyostelium discoideum'), ('dp', 'Dictyostelium purpureum')] 
     732 
     733        """ 
     734        data = {"action": "genomes"} 
     735        res, _ = self.sq("", data=data, reload=reload, bufver=bufver) 
     736        return [tuple(r) for r in res] 
     737 
     738    def mappings(self, reload=False, bufver="0"): 
     739        """Return a dictionary of {unique_id: dictionary_of_annotations} 
     740        where the keys for dictionary_of_annotations are 
     741        ["id", data_id", "data_name", "genomes_id"] 
     742 
     743        >>> mappings = pipax.mappings() 
     744 
     745        """ 
     746        data = self.add_auth({"action": "mappings"}) 
     747        res, legend = self.sq("", data=data, reload=reload, 
     748                              bufferkey=bufferkeypipa, 
     749                              bufver=bufver) 
     750 
     751        return dict((sa[0], dict(zip(legend[1:], sa[1:]))) for sa in res) 
     752 
     753    def result_types(self, reload=False, bufver="0"): 
     754        """Return a list of available result type templates. 
     755        """ 
     756        data = {"action": "results_templates"} 
     757        res, _ = self.sq("", data=data, reload=reload, bufver=bufver) 
     758        return sorted(tuple(a) for a in res) 
     759 
     760    def results_list(self, rtype, reload=False, bufver="0"): 
     761        """Return a list of available results for a result type template 
     762        `rtype` (a key from the `result_types` return value). 
     763 
     764        """ 
     765        data = {"action": "results", 
     766                "results_templates_id": rtype} 
     767        data = self.add_auth(data) 
     768        res, legend = self.sq("", data=data, reload=reload, 
     769                              bufferkey=bufferkeypipa, 
     770                              bufver=bufver) 
     771        # index by unique_id (last column) 
     772        res = splitTableOnColumn(res, -1) 
     773        return dict((id, dict(zip(legend, line[0]))) \ 
     774                    for id, line in res.items()) 
     775 
     776    def download_key_function(self): 
     777        data = self.add_auth({"action": "download", 
     778                              "ids": "$MULTI$"} 
     779                                ) 
     780        keynamingfn, _ = self.downloadMulti_bufcommand_replace_multi("", 
     781                         data=data, chunk=100, bufferkey=bufferkeypipa, 
     782                         transformfn=None) 
     783        return keynamingfn 
     784 
     785    def get_data(self, ids=None, result_type=None, 
     786                 exclude_constant_labels=False, average=median, 
     787                 callback=None, bufver="0", transform=None, 
     788                 allowed_labels=None): 
     789        """ 
     790        Get data in a single example table with labels of individual 
     791        attributes set to annotations for query and post-processing 
     792        instructions. 
     793 
     794        :param ids: If `result_type` is specified then this must 
     795            be a list of  `unique_id`s or (id, data_id) tuples as 
     796            returned by `mappings`. Else the `ids` must be a list 
     797            of `unique_id`s as returned by `results_list`. 
     798        :type ids: list 
     799 
     800        :param result_type: Result template type id as returned by 
     801             `result_types`. Not specified by default (see `ids`.) 
     802        :type result_type: str 
     803 
     804        :param exclude_constant_labels: If a label has the same value 
     805            in whole example table, remove it. 
     806        :type exclude_constant_labels: bool 
     807 
     808        :param average: Function used for combining multiple reading of 
     809            the same spot on a chip. If None, no averaging is done. 
     810            Function should take a list of floats and return an "averaged" 
     811            float (default `median`). 
     812        :type average: function 
     813 
     814        """ 
     815 
     816        def optcb(): 
     817            if callback: 
     818                callback() 
     819 
     820        cbc = CallBack(len(ids), optcb, callbacks=10) 
     821 
     822        if result_type is not None: 
     823            res_list = self.results_list(result_type, reload=reload, 
     824                                         bufver=bufver) 
     825            # Map (data_id, mapping_id) to unique_id 
     826            res_types_to_unique_id = \ 
     827                dict(((annot["data_id"], annot["mappings_id"]), 
     828                      annot["unique_id"]) \ 
     829                     for annot in res_list.values()) 
     830 
     831            mappings = self.mappings(reload=reload, bufver=bufver) 
     832 
     833            def id_map(mappings_unique_id): 
     834                cbc() 
     835                if isinstance(mappings_unique_id, tuple): 
     836                    data_id, mappings_id = mappings_unique_id 
     837                else: 
     838                    annot = mappings[mappings_unique_id] 
     839                    data_id = annot["data_id"] 
     840                    mappings_id = annot["id"] 
     841                return res_types_to_unique_id[data_id, mappings_id] 
     842 
     843            ids = map(id_map, ids) 
     844        else: 
     845            result_type_set = set(id.rsplit("_", 1)[-1] for id in ids) 
     846            if len(result_type_set) != 1: 
     847                raise ValueError("""\ 
     848Can only retrieve a single result_template_type at a time""" 
     849) 
     850            result_type = result_type_set.pop() 
     851            res_list = self.results_list(result_type, reload=reload, 
     852                                         bufver=bufver) 
     853 
     854        read = {} 
     855        for a, b in res_list.items(): 
     856            read[a] = b.items() 
     857 
     858        cbc.end() 
     859 
     860        download_func = lambda x: self.download(x, reload=reload, 
     861                                                bufver=bufver) 
     862 
     863        cbc = CallBack(len(ids) + 3, optcb, 
     864                       callbacks=99 - 20) 
     865        et = self.exampleTables(ids, spotmap={}, callback=cbc, annots=read, 
     866                            exclude_constant_labels=exclude_constant_labels, 
     867                            chipfn=download_func, 
     868                            allowed_labels=allowed_labels) 
     869        cbc.end() 
     870 
     871        cbc = CallBack(2, optcb, callbacks=10) 
     872 
     873        #transformation is performed prior to averaging 
     874        if transform != None: 
     875            transformValues(et, fn=transform)  # in place transform 
     876            cbc() 
     877 
     878        #if average function is given, use it to join same spotids 
     879        if average != None: 
     880            et = averageAttributes(et, fn=average) 
     881            cbc() 
     882 
     883        cbc.end() 
     884 
     885        return et 
     886 
     887    def download(self, result_ids, reload=False, bufver="0"): 
     888        data = {"action": "download", "ids": "$MULTI$"} 
     889        data = self.add_auth(data) 
     890        antss = self.downloadMulti("", result_ids, data=data, chunk=10, 
     891                                   bufferkey=bufferkeypipa, bufreload=reload, 
     892                                   bufver=bufver) 
     893        for a, legend in antss: 
     894            yield a 
     895 
     896    def downloadMulti(self, command, ids, data=None, chunk=100, 
     897                      transformfn=None, bufferkey=None, separatefn=None, 
     898                      bufreload=False, bufver="0"): 
     899        """ 
     900        Downloads multiple results at once. 
     901        Results in the same order as in ids. 
     902 
     903        Bufferkey transforms command and data into buffer key. 
     904        bufver is a function returning buffer version for a given id. if 
     905            a string is given, use it for all ids 
     906        """ 
     907 
     908        sids = split(ids, chunk) 
     909 
     910        bufverfn = None 
     911        if isinstance(bufver, basestring): 
     912            bufverfn = lambda x: bufver 
     913        else: 
     914            bufverfn = bufver 
     915 
     916        bufcommand, replace_multi = \ 
     917                self.downloadMulti_bufcommand_replace_multi(command, 
     918                                data=data, chunk=chunk, bufferkey=bufferkey, 
     919                                transformfn=transformfn 
     920                                ) 
     921 
     922        for i, sidp in enumerate(sids): 
     923 
     924            buffered = [] 
     925            unbuffered = [] 
     926 
     927            for a in sidp: 
     928                if self.inBuffer(bufcommand(a)) == bufverfn(a) and \ 
     929                        bufreload == False: 
     930                    buffered.append(a) 
     931                else: 
     932                    unbuffered.append(a) 
     933 
     934            res = [] 
     935            legend = [] 
     936 
     937            if len(unbuffered) > 0: 
     938                com1, d1 = replace_multi(command, data, ",".join(unbuffered)) 
     939                # get unbuffered part 
     940                res, legend = self.sq(com1, data=d1, buffer=False) 
     941            else: 
     942                # get legend from buffer also 
     943                legend = self.fromBuffer(bufcommand(buffered[0]))[0] 
     944 
     945            legend = ["gene_id", "value"] 
     946            genes = nth(res, 0)[1:] 
     947 
     948            antss = {} 
     949            for i, cid in enumerate(unbuffered): 
     950                col = i + 1 
     951                vals = nth(res, col) 
     952                antss[cid] = [[a, b] for a, b in zip(genes, vals) if b != "?"] 
     953 
     954            #here save buffer 
     955            for a, b in antss.items(): 
     956                self.toBuffer(bufcommand(a), [legend] + b, bufverfn(a), 
     957                              autocommit=False) 
     958            self.bufferCommit() 
     959 
     960            #get buffered from the buffer 
     961            antssb = dict([(b, self.fromBuffer(bufcommand(b))[1:]) \ 
     962                           for b in buffered]) 
     963            antss.update(antssb) 
     964 
     965            #put results in order 
     966            for ci in sidp: 
     967                yield antss[ci], legend 
     968 
    710969 
    711970class DictyExpress(DBCommon): 
Note: See TracChangeset for help on using the changeset viewer.