aboutsummaryrefslogtreecommitdiff
path: root/gn3/computations/datasets.py
blob: b405e551904791369780634baace50b351c13dc1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
"""module contains the code all related to datasets"""
import json
from unittest import mock
from math import ceil
from collections import defaultdict

from typing import Optional
from typing import List

from dataclasses import dataclass
from MySQLdb import escape_string  # type: ignore

import requests
from gn3.settings import GN2_BASE_URL


def retrieve_trait_sample_data(dataset,
                               trait_name: str,
                               group_species_id=None,) -> List:
    """given the dataset id and trait_name fetch the\
    sample_name,value from the dataset"""

    # should pass the db as arg all  do a setup

    (dataset_name, dataset_id, dataset_type) = (dataset.get("name"), dataset.get(
        "id"), dataset.get("type"))

    dataset_query = get_query_for_dataset_sample(dataset_type)
    results = []
    sample_query_values = {
        "Publish": (trait_name, dataset_id),
        "Geno": (group_species_id, trait_name, dataset_name),
        "ProbeSet": (trait_name, dataset_name)
    }

    if dataset_query:
        formatted_query = dataset_query % sample_query_values[dataset_type]
        results = fetch_from_db_sample_data(formatted_query, mock.Mock())

    return results


def fetch_from_db_sample_data(formatted_query: str, database_instance) -> List:
    """this is the function that does the actual fetching of\
    results from the database"""
    try:
        cursor = database_instance.cursor()
        cursor.execute(formatted_query)
        results = cursor.fetchall()

    except Exception as error:
        raise error

    cursor.close()

    return results


def get_query_for_dataset_sample(dataset_type) -> Optional[str]:
    """this functions contains querys for\
    getting sample data from the db depending in
    dataset"""
    dataset_query = {}

    pheno_query = """
                SELECT
                        Strain.Name, PublishData.value, PublishSE.error,NStrain.count, Strain.Name2
                FROM
                        (PublishData, Strain, PublishXRef, PublishFreeze)
                left join PublishSE on
                        (PublishSE.DataId = PublishData.Id AND PublishSE.StrainId = PublishData.StrainId)
                left join NStrain on
                        (NStrain.DataId = PublishData.Id AND
                        NStrain.StrainId = PublishData.StrainId)
                WHERE
                        PublishXRef.InbredSetId = PublishFreeze.InbredSetId AND
                        PublishData.Id = PublishXRef.DataId AND PublishXRef.Id = %s AND
                        PublishFreeze.Id = %s AND PublishData.StrainId = Strain.Id
                Order BY
                        Strain.Name
                """
    geno_query = """
                SELECT
                        Strain.Name, GenoData.value, GenoSE.error, "N/A", Strain.Name2
                FROM
                        (GenoData, GenoFreeze, Strain, Geno, GenoXRef)
                left join GenoSE on
                        (GenoSE.DataId = GenoData.Id AND GenoSE.StrainId = GenoData.StrainId)
                WHERE
                        Geno.SpeciesId = %s AND Geno.Name = %s AND GenoXRef.GenoId = Geno.Id AND
                        GenoXRef.GenoFreezeId = GenoFreeze.Id AND
                        GenoFreeze.Name = %s AND
                        GenoXRef.DataId = GenoData.Id AND
                        GenoData.StrainId = Strain.Id
                Order BY
                        Strain.Name
                """

    probeset_query = """
                SELECT
                        Strain.Name, ProbeSetData.value, ProbeSetSE.error, NStrain.count, Strain.Name2
                FROM
                        (ProbeSetData, ProbeSetFreeze,
                         Strain, ProbeSet, ProbeSetXRef)
                left join ProbeSetSE on
                        (ProbeSetSE.DataId = ProbeSetData.Id AND ProbeSetSE.StrainId = ProbeSetData.StrainId)
                left join NStrain on
                        (NStrain.DataId = ProbeSetData.Id AND
                        NStrain.StrainId = ProbeSetData.StrainId)
                WHERE
                        ProbeSet.Name = '%s' AND ProbeSetXRef.ProbeSetId = ProbeSet.Id AND
                        ProbeSetXRef.ProbeSetFreezeId = ProbeSetFreeze.Id AND
                        ProbeSetFreeze.Name = '%s' AND
                        ProbeSetXRef.DataId = ProbeSetData.Id AND
                        ProbeSetData.StrainId = Strain.Id
                Order BY
                        Strain.Name
                """

    dataset_query["Publish"] = pheno_query
    dataset_query["Geno"] = geno_query
    dataset_query["ProbeSet"] = probeset_query

    return dataset_query.get(dataset_type)


@dataclass
class Dataset:
    """class for creating datasets"""
    name: Optional[str] = None
    dataset_type: Optional[str] = None
    dataset_id: int = -1


def create_mrna_tissue_dataset(dataset_name, dataset_type):
    """an mrna assay is a quantitative assessment(assay) associated\
    with an mrna trait.This used to be called probeset,but that term\
    only referes specifically to the afffymetrix platform and is\
    far too speficified"""

    return Dataset(name=dataset_name, dataset_type=dataset_type)


def dataset_type_getter(dataset_name, redis_instance=None) -> Optional[str]:
    """given the dataset name fetch the type\
    of the dataset this in turn  enables fetching\
    the creation of the correct object could utilize\
    redis for the case"""

    results = redis_instance.get(dataset_name, None)

    if results:
        return results

    return fetch_dataset_type_from_gn2_api(dataset_name)


def fetch_dataset_type_from_gn2_api(dataset_name):
    """this function is only called when the\
    the redis is empty and does have the specificied\
    dataset_type"""
    # should only run once

    dataset_structure = {}

    map_dataset_to_new_type = {
        "Phenotypes": "Publish",
        "Genotypes": "Geno",
        "MrnaTypes": "ProbeSet"
    }

    data = json.loads(requests.get(
        GN2_BASE_URL + "/api/v_pre1/gen_dropdown", timeout=5).content)
    _name = dataset_name
    for species in data['datasets']:
        for group in data['datasets'][species]:
            for dataset_type in data['datasets'][species][group]:
                for dataset in data['datasets'][species][group][dataset_type]:
                    # assumes  the first is dataset_short_name
                    short_dataset_name = next(
                        item for item in dataset if item != "None" and item is not None)

                    dataset_structure[short_dataset_name] = map_dataset_to_new_type.get(
                        dataset_type, "MrnaTypes")
    return dataset_structure


def dataset_creator_store(dataset_type):
    """function contains key value pairs for\
    the function need to be called to create\
    each dataset_type"""

    dataset_obj = {
        "ProbeSet": create_mrna_tissue_dataset
    }

    return dataset_obj[dataset_type]


def create_dataset(dataset_type=None, dataset_name: str = None):
    """function for creating new dataset  temp not implemented"""
    if dataset_type is None:
        dataset_type = dataset_type_getter(dataset_name)

    dataset_creator = dataset_creator_store(dataset_type)
    results = dataset_creator(
        dataset_name=dataset_name, dataset_type=dataset_type)
    return results


def fetch_dataset_sample_id(samplelist: List, database, species: str) -> dict:
    """fetch the strain ids from the db only if\
    it is in the samplelist"""
    # xtodo create an in clause for samplelist

    strain_query = """
        SELECT Strain.Name, Strain.Id FROM Strain, Species
        WHERE Strain.Name IN {}
        and Strain.SpeciesId=Species.Id
        and Species.name = '{}'
        """

    database_cursor = database.cursor()
    database_cursor.execute(strain_query.format(samplelist, species))

    results = database_cursor.fetchall()

    return dict(results)


def divide_into_chunks(the_list, number_chunks):
    """Divides a list into approximately number_chunks
    >>> divide_into_chunks([1, 2, 7, 3, 22, 8, 5, 22, 333], 3)
    [[1, 2, 7], [3, 22, 8], [5, 22, 333]]"""

    length = len(the_list)
    if length == 0:
        return [[]]

    if length <= number_chunks:
        number_chunks = length
    chunk_size = int(ceil(length/number_chunks))
    chunks = []

    for counter in range(0, length, chunk_size):
        chunks.append(the_list[counter:counter+chunk_size])
    return chunks


def escape(string_):
    """function escape sql value"""
    return escape_string(string_).decode('utf8')


def mescape(*items) -> List:
    """multiple escape for query values"""

    return [escape_string(str(item)).decode('utf8') for item in items]


def get_traits_data(sample_ids, database_instance, dataset_name, dataset_type):
    """function to fetch trait data"""
    # MySQL limits the number of tables that can be used in a join to 61,
    # so we break the sample ids into smaller chunks
    # Postgres doesn't have that limit, so we can get rid of this after we transition

    _trait_data = defaultdict(list)
    chunk_size = 61
    number_chunks = int(ceil(len(sample_ids) / chunk_size))
    for sample_ids_step in divide_into_chunks(sample_ids, number_chunks):
        if dataset_type == "Publish":
            full_dataset_type = "Phenotype"
        else:
            full_dataset_type = dataset_type
        temp = ['T%s.value' % item for item in sample_ids_step]

        if dataset_type == "Publish":
            query = "SELECT {}XRef.Id,".format(escape(dataset_type))

        else:
            query = "SELECT {}.Name,".format(escape(full_dataset_type))

        query += ', '.join(temp)
        query += ' FROM ({}, {}XRef, {}Freeze) '.format(*mescape(full_dataset_type,
                                                                 dataset_type,
                                                                 dataset_type))
        for item in sample_ids_step:

            query += """
                    left join {}Data as T{} on T{}.Id = {}XRef.DataId
                    and T{}.StrainId={}\n
                    """.format(*mescape(dataset_type, item,
                                        item, dataset_type, item, item))

        if dataset_type == "Publish":
            query += """
                        WHERE {}XRef.{}FreezeId = {}Freeze.Id
                        and {}Freeze.Name = '{}'
                        and {}.Id = {}XRef.{}Id
                        order by {}.Id
                        """.format(*mescape(dataset_type, dataset_type,
                                            dataset_type, dataset_type,
                                            dataset_name, full_dataset_type,
                                            dataset_type, dataset_type,
                                            full_dataset_type))

        else:
            query += """
                        WHERE {}XRef.{}FreezeId = {}Freeze.Id
                        and {}Freeze.Name = '{}'
                        and {}.Id = {}XRef.{}Id
                        order by {}.Id
                        """.format(*mescape(dataset_type, dataset_type,
                                            dataset_type, dataset_type,
                                            dataset_name, dataset_type,
                                            dataset_type, dataset_type,
                                            full_dataset_type))

        _results = fetch_from_db_sample_data(query, database_instance)
    return {}