delete unwanted correlation stuff (#5)

* delete unwanted correlation stuff

* Refactor/clean up correlations (#4)

* initial commit for Refactor/clean-up-correlation

* add python scipy dependency

* initial commit for sample correlation

* initial commit for sample correlation endpoint

* initial commit for integration and unittest

* initial commit for registering  correlation blueprint

* add and modify unittest and integration tests for correlation

* Add compute compute_all_sample_corr   method for correlation

* add scipy to requirement txt file

* add tissue correlation for trait list

* add unittest for tissue correlation

* add lit correlation for trait list

* add unittests for lit correlation for trait list

* modify lit correlarion for trait list

* add unittests for lit correlation for trait list

* add correlation metho  in dynamic url

* add file format for expected structure input  while doing sample correlation

* modify input data structure -> add  trait id

* update tests for sample r correlation

* add compute all lit correlation method

* add endpoint for computing lit_corr

* add unit and integration tests for computing lit corr

* add /api/correlation/tissue_corr/{corr_method} endpoint for tissue correlation

* add unittest and integration tests for tissue correlation

Co-authored-by: BonfaceKilz <bonfacemunyoki@gmail.com>

* update guix scm file

* fix pylint error for correlations api

Co-authored-by: BonfaceKilz <bonfacemunyoki@gmail.com>

1 files changed, 0 insertions, 882 deletions

diff --git a/gn3/base/data_set.py b/gn3/base/data_set.py
deleted file mode 100644
index 01913f2..0000000
--- a/gn3/base/data_set.py
+++ /dev/null
@@ -1,882 +0,0 @@
-
-import json
-import math
-import collections
-import requests
-from redis import Redis
-from flask import g
-from gn3.utility.db_tools import escape
-from gn3.utility.db_tools import mescape
-from gn3.utility.db_tools import create_in_clause
-from gn3.utility.tools import locate_ignore_error
-from gn3.db.calls import fetch1
-from gn3.db.calls import fetchone
-from gn3.db.webqtlDatabaseFunction import retrieve_species
-from gn3.utility import chunks
-
-from gn3.utility import get_group_samplelists
-from gn3.base.species import TheSpecies
-r = Redis()
-
-# should probably move this to its own configuration files
-
-USE_REDIS = True
-
-# todo move to config file
-GN2_BASE_URL = "https://genenetwork.org/"
-
-DS_NAME_MAP = {}
-
-# pylint: disable-all
-#todo file not linted
-# pylint: disable=C0103 
-
-
-
-def create_dataset(dataset_name, dataset_type=None, get_samplelist=True, group_name=None):
-
-    if dataset_name == "Temp":
-        dataset_type = "Temp"
-
-    if dataset_type is None:
-        dataset_type = Dataset_Getter(dataset_name)
-    dataset_ob = DS_NAME_MAP[dataset_type]
-    dataset_class = globals()[dataset_ob]
-
-    if dataset_type == "Temp":
-        results = dataset_class(dataset_name, get_samplelist, group_name)
-
-    else:
-        results = dataset_class(dataset_name, get_samplelist)
-
-    return results
-
-
-class DatasetType:
-    def __init__(self, redis_instance):
-        self.redis_instance = redis_instance
-        self.datasets = {}
-
-        data = self.redis_instance.get("dataset_structure")
-        if data:
-            self.datasets = json.loads(data)
-
-        else:
-
-            try:
-
-                data = json.loads(requests.get(
-                    GN2_BASE_URL + "/api/v_pre1/gen_dropdown", timeout=5).content)
-
-                # todo:Refactor code below n^4 loop
-
-                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]:
-
-                                short_dataset_name = dataset[1]
-                                if dataset_type == "Phenotypes":
-                                    new_type = "Publish"
-
-                                elif dataset_type == "Genotypes":
-                                    new_type = "Geno"
-                                else:
-                                    new_type = "ProbeSet"
-
-                                self.datasets[short_dataset_name] = new_type
-
-            except Exception as e:
-                raise e
-
-            self.redis_instance.set(
-                "dataset_structure", json.dumps(self.datasets))
-
-    def set_dataset_key(self, t, name):
-        """If name is not in the object's dataset dictionary, set it, and update
-    dataset_structure in Redis
-
-    args:
-      t: Type of dataset structure which can be: 'mrna_expr', 'pheno',
-         'other_pheno', 'geno'
-      name: The name of the key to inserted in the datasets dictionary
-
-    """
-
-        sql_query_mapping = {
-            'mrna_expr': ("""SELECT ProbeSetFreeze.Id FROM """ +
-                          """ProbeSetFreeze WHERE ProbeSetFreeze.Name = "{}" """),
-            'pheno': ("""SELECT InfoFiles.GN_AccesionId """ +
-                      """FROM InfoFiles, PublishFreeze, InbredSet """ +
-                      """WHERE InbredSet.Name = '{}' AND """ +
-                      """PublishFreeze.InbredSetId = InbredSet.Id AND """ +
-                      """InfoFiles.InfoPageName = PublishFreeze.Name"""),
-            'other_pheno': ("""SELECT PublishFreeze.Name """ +
-                            """FROM PublishFreeze, InbredSet """ +
-                            """WHERE InbredSet.Name = '{}' AND """ +
-                            """PublishFreeze.InbredSetId = InbredSet.Id"""),
-            'geno':  ("""SELECT GenoFreeze.Id FROM GenoFreeze WHERE """ +
-                      """GenoFreeze.Name = "{}" """)
-        }
-
-        dataset_name_mapping = {
-            "mrna_expr": "ProbeSet",
-            "pheno": "Publish",
-            "other_pheno": "Publish",
-            "geno": "Geno",
-        }
-
-        group_name = name
-        if t in ['pheno', 'other_pheno']:
-            group_name = name.replace("Publish", "")
-
-        results = g.db.execute(
-            sql_query_mapping[t].format(group_name)).fetchone()
-        if results:
-            self.datasets[name] = dataset_name_mapping[t]
-            self.redis_instance.set(
-                "dataset_structure", json.dumps(self.datasets))
-
-            return True
-
-        return None
-
-    def __call__(self, name):
-        if name not in self.datasets:
-            for t in ["mrna_expr", "pheno", "other_pheno", "geno"]:
-
-                if(self.set_dataset_key(t, name)):
-                    # This has side-effects, with the end result being a truth-y value
-                    break
-
-        return self.datasets.get(name, None)
-
-
-# Do the intensive work at  startup one time only
-# could replace the code below
-Dataset_Getter = DatasetType(r)
-
-
-class DatasetGroup:
-    """
-    Each group has multiple datasets; each species has multiple groups.
-
-    For example, Mouse has multiple groups (BXD, BXA, etc), and each group
-    has multiple datasets associated with it.
-
-    """
-
-    def __init__(self, dataset, name=None):
-        """This sets self.group and self.group_id"""
-        if name == None:
-            self.name, self.id, self.genetic_type = fetchone(
-                dataset.query_for_group)
-
-        else:
-            self.name, self.id, self.genetic_type = fetchone(
-                "SELECT InbredSet.Name, InbredSet.Id, InbredSet.GeneticType FROM InbredSet where Name='%s'" % name)
-
-        if self.name == 'BXD300':
-            self.name = "BXD"
-
-        self.f1list = None
-
-        self.parlist = None
-
-        self.get_f1_parent_strains()
-
-        # remove below not used in correlation
-
-        self.mapping_id, self.mapping_names = self.get_mapping_methods()
-
-        self.species = retrieve_species(self.name)
-
-    def get_f1_parent_strains(self):
-        try:
-            # should import ParInfo
-            raise e
-            # NL, 07/27/2010. ParInfo has been moved from webqtlForm.py to webqtlUtil.py;
-            f1, f12, maternal, paternal = webqtlUtil.ParInfo[self.name]
-        except Exception as e:
-            f1 = f12 = maternal = paternal = None
-
-        if f1 and f12:
-            self.f1list = [f1, f12]
-
-        if maternal and paternal:
-            self.parlist = [maternal, paternal]
-
-    def get_mapping_methods(self):
-        mapping_id = g.db.execute(
-            "select MappingMethodId from InbredSet where Name= '%s'" % self.name).fetchone()[0]
-
-        if mapping_id == "1":
-            mapping_names = ["GEMMA", "QTLReaper", "R/qtl"]
-        elif mapping_id == "2":
-            mapping_names = ["GEMMA"]
-
-        elif mapping_id == "3":
-            mapping_names = ["R/qtl"]
-
-        elif mapping_id == "4":
-            mapping_names = ["GEMMA", "PLINK"]
-
-        else:
-            mapping_names = []
-
-        return mapping_id, mapping_names
-
-    def get_samplelist(self):
-        result = None
-        key = "samplelist:v3:" + self.name
-        if USE_REDIS:
-            result = r.get(key)
-
-        if result is not None:
-
-            self.samplelist = json.loads(result)
-
-        else:
-            # logger.debug("Cache not hit")
-            # should enable logger
-            genotype_fn = locate_ignore_error(self.name+".geno", 'genotype')
-            if genotype_fn:
-                self.samplelist = get_group_samplelists.get_samplelist(
-                    "geno", genotype_fn)
-
-            else:
-                self.samplelist = None
-
-            if USE_REDIS:
-                r.set(key, json.dumps(self.samplelist))
-                r.expire(key, 60*5)
-
-
-class DataSet:
-    """
-    DataSet class defines a dataset in webqtl, can be either Microarray,
-    Published phenotype, genotype, or user input dataset(temp)
-
-    """
-
-    def __init__(self, name, get_samplelist=True, group_name=None):
-
-        assert name, "Need a name"
-        self.name = name
-        self.id = None
-        self.shortname = None
-        self.fullname = None
-        self.type = None
-        self.data_scale = None  # ZS: For example log2
-
-        self.setup()
-
-        if self.type == "Temp":  # Need to supply group name as input if temp trait
-            # sets self.group and self.group_id and gets genotype
-            self.group = DatasetGroup(self, name=group_name)
-        else:
-            self.check_confidentiality()
-            self.retrieve_other_names()
-            # sets self.group and self.group_id and gets genotype
-            self.group = DatasetGroup(self)
-            self.accession_id = self.get_accession_id()
-        if get_samplelist == True:
-            self.group.get_samplelist()
-        self.species = TheSpecies(self)
-
-    def get_desc(self):
-        """Gets overridden later, at least for Temp...used by trait's get_given_name"""
-        return None
-
-
-    def get_accession_id(self):
-        if self.type == "Publish":
-            results = g.db.execute("""select InfoFiles.GN_AccesionId from InfoFiles, PublishFreeze, InbredSet where
-                        InbredSet.Name = %s and
-                        PublishFreeze.InbredSetId = InbredSet.Id and
-                        InfoFiles.InfoPageName = PublishFreeze.Name and
-                        PublishFreeze.public > 0 and
-                        PublishFreeze.confidentiality < 1 order by
-                        PublishFreeze.CreateTime desc""", (self.group.name)).fetchone()
-        elif self.type == "Geno":
-            results = g.db.execute("""select InfoFiles.GN_AccesionId from InfoFiles, GenoFreeze, InbredSet where
-                        InbredSet.Name = %s and
-                        GenoFreeze.InbredSetId = InbredSet.Id and
-                        InfoFiles.InfoPageName = GenoFreeze.ShortName and
-                        GenoFreeze.public > 0 and
-                        GenoFreeze.confidentiality < 1 order by
-                        GenoFreeze.CreateTime desc""", (self.group.name)).fetchone()
-        else:
-            results = None
-
-        if results != None:
-            return str(results[0])
-        else:
-            return "None"
-
-    def retrieve_other_names(self):
-        """This method fetches the the dataset names in search_result.
-
-        If the data set name parameter is not found in the 'Name' field of
-        the data set table, check if it is actually the FullName or
-        ShortName instead.
-
-        This is not meant to retrieve the data set info if no name at
-        all is passed.
-
-        """
-
-        try:
-            if self.type == "ProbeSet":
-                query_args = tuple(escape(x) for x in (
-                    self.name,
-                    self.name,
-                    self.name))
-
-                self.id, self.name, self.fullname, self.shortname, self.data_scale, self.tissue = fetch1("""
-    SELECT ProbeSetFreeze.Id, ProbeSetFreeze.Name, ProbeSetFreeze.FullName, ProbeSetFreeze.ShortName, ProbeSetFreeze.DataScale, Tissue.Name
-    FROM ProbeSetFreeze, ProbeFreeze, Tissue
-    WHERE ProbeSetFreeze.ProbeFreezeId = ProbeFreeze.Id
-    AND ProbeFreeze.TissueId = Tissue.Id
-    AND (ProbeSetFreeze.Name = '%s' OR ProbeSetFreeze.FullName = '%s' OR ProbeSetFreeze.ShortName = '%s')
-                """ % (query_args), "/dataset/"+self.name+".json",
-                    lambda r: (r["id"], r["name"], r["full_name"],
-                               r["short_name"], r["data_scale"], r["tissue"])
-                )
-            else:
-                query_args = tuple(escape(x) for x in (
-                    (self.type + "Freeze"),
-                    self.name,
-                    self.name,
-                    self.name))
-
-                self.tissue = "N/A"
-                self.id, self.name, self.fullname, self.shortname = fetchone("""
-                        SELECT Id, Name, FullName, ShortName
-                        FROM %s
-                        WHERE (Name = '%s' OR FullName = '%s' OR ShortName = '%s')
-                    """ % (query_args))
-
-        except TypeError as e:
-            logger.debug(
-                "Dataset {} is not yet available in GeneNetwork.".format(self.name))
-            pass
-
-    def get_trait_data(self, sample_list=None):
-        if sample_list:
-            self.samplelist = sample_list
-        else:
-            self.samplelist = self.group.samplelist
-
-        if self.group.parlist != None and self.group.f1list != None:
-            if (self.group.parlist + self.group.f1list) in self.samplelist:
-                self.samplelist += self.group.parlist + self.group.f1list
-
-        query = """
-            SELECT Strain.Name, Strain.Id FROM Strain, Species
-            WHERE Strain.Name IN {}
-            and Strain.SpeciesId=Species.Id
-            and Species.name = '{}'
-            """.format(create_in_clause(self.samplelist), *mescape(self.group.species))
-        # logger.sql(query)
-        results = dict(g.db.execute(query).fetchall())
-        sample_ids = [results[item] for item in self.samplelist]
-
-        # 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
-        chunk_size = 50
-        number_chunks = int(math.ceil(len(sample_ids) / chunk_size))
-        trait_sample_data = []
-        for sample_ids_step in chunks.divide_into_chunks(sample_ids, number_chunks):
-            if self.type == "Publish":
-                dataset_type = "Phenotype"
-            else:
-                dataset_type = self.type
-            temp = ['T%s.value' % item for item in sample_ids_step]
-            if self.type == "Publish":
-                query = "SELECT {}XRef.Id,".format(escape(self.type))
-            else:
-                query = "SELECT {}.Name,".format(escape(dataset_type))
-            data_start_pos = 1
-            query += ', '.join(temp)
-            query += ' FROM ({}, {}XRef, {}Freeze) '.format(*mescape(dataset_type,
-                                                                     self.type,
-                                                                     self.type))
-
-            for item in sample_ids_step:
-                query += """
-                        left join {}Data as T{} on T{}.Id = {}XRef.DataId
-                        and T{}.StrainId={}\n
-                        """.format(*mescape(self.type, item, item, self.type, item, item))
-
-            if self.type == "Publish":
-                query += """
-                        WHERE {}XRef.InbredSetId = {}Freeze.InbredSetId
-                        and {}Freeze.Name = '{}'
-                        and {}.Id = {}XRef.{}Id
-                        order by {}.Id
-                        """.format(*mescape(self.type, self.type, self.type, self.name,
-                                            dataset_type, self.type, dataset_type, dataset_type))
-            else:
-                query += """
-                        WHERE {}XRef.{}FreezeId = {}Freeze.Id
-                        and {}Freeze.Name = '{}'
-                        and {}.Id = {}XRef.{}Id
-                        order by {}.Id
-                        """.format(*mescape(self.type, self.type, self.type, self.type,
-                                            self.name, dataset_type, self.type, self.type, dataset_type))
-
-            results = g.db.execute(query).fetchall()
-            trait_sample_data.append(results)
-
-        trait_count = len(trait_sample_data[0])
-        self.trait_data = collections.defaultdict(list)
-
-        # put all of the separate data together into a dictionary where the keys are
-        # trait names and values are lists of sample values
-        for trait_counter in range(trait_count):
-            trait_name = trait_sample_data[0][trait_counter][0]
-            for chunk_counter in range(int(number_chunks)):
-                self.trait_data[trait_name] += (
-                    trait_sample_data[chunk_counter][trait_counter][data_start_pos:])
-
-
-class MrnaAssayDataSet(DataSet):
-    '''
-    An mRNA Assay is a quantitative assessment (assay) associated with an mRNA trait
-
-    This used to be called ProbeSet, but that term only refers specifically to the Affymetrix
-    platform and is far too specific.
-
-    '''
-    DS_NAME_MAP['ProbeSet'] = 'MrnaAssayDataSet'
-
-    def setup(self):
-        # Fields in the database table
-        self.search_fields = ['Name',
-                              'Description',
-                              'Probe_Target_Description',
-                              'Symbol',
-                              'Alias',
-                              'GenbankId',
-                              'UniGeneId',
-                              'RefSeq_TranscriptId']
-
-        # Find out what display_fields is
-        self.display_fields = ['name', 'symbol',
-                               'description', 'probe_target_description',
-                               'chr', 'mb',
-                               'alias', 'geneid',
-                               'genbankid', 'unigeneid',
-                               'omim', 'refseq_transcriptid',
-                               'blatseq', 'targetseq',
-                               'chipid', 'comments',
-                               'strand_probe', 'strand_gene',
-                               'proteinid', 'uniprotid',
-                               'probe_set_target_region',
-                               'probe_set_specificity',
-                               'probe_set_blat_score',
-                               'probe_set_blat_mb_start',
-                               'probe_set_blat_mb_end',
-                               'probe_set_strand',
-                               'probe_set_note_by_rw',
-                               'flag']
-
-        # Fields displayed in the search results table header
-        self.header_fields = ['Index',
-                              'Record',
-                              'Symbol',
-                              'Description',
-                              'Location',
-                              'Mean',
-                              'Max LRS',
-                              'Max LRS Location',
-                              'Additive Effect']
-
-        # Todo: Obsolete or rename this field
-        self.type = 'ProbeSet'
-
-        self.query_for_group = '''
-                        SELECT
-                                InbredSet.Name, InbredSet.Id, InbredSet.GeneticType
-                        FROM
-                                InbredSet, ProbeSetFreeze, ProbeFreeze
-                        WHERE
-                                ProbeFreeze.InbredSetId = InbredSet.Id AND
-                                ProbeFreeze.Id = ProbeSetFreeze.ProbeFreezeId AND
-                                ProbeSetFreeze.Name = "%s"
-                ''' % escape(self.name)
-
-    def check_confidentiality(self):
-        return geno_mrna_confidentiality(self)
-
-    def get_trait_info(self, trait_list=None, species=''):
-
-        #  Note: setting trait_list to [] is probably not a great idea.
-        if not trait_list:
-            trait_list = []
-
-        for this_trait in trait_list:
-
-            if not this_trait.haveinfo:
-                this_trait.retrieveInfo(QTL=1)
-
-            if not this_trait.symbol:
-                this_trait.symbol = "N/A"
-
-            # XZ, 12/08/2008: description
-            # XZ, 06/05/2009: Rob asked to add probe target description
-            description_string = str(
-                str(this_trait.description).strip(codecs.BOM_UTF8), 'utf-8')
-            target_string = str(
-                str(this_trait.probe_target_description).strip(codecs.BOM_UTF8), 'utf-8')
-
-            if len(description_string) > 1 and description_string != 'None':
-                description_display = description_string
-            else:
-                description_display = this_trait.symbol
-
-            if (len(description_display) > 1 and description_display != 'N/A' and
-                    len(target_string) > 1 and target_string != 'None'):
-                description_display = description_display + '; ' + target_string.strip()
-
-            # Save it for the jinja2 template
-            this_trait.description_display = description_display
-
-            if this_trait.chr and this_trait.mb:
-                this_trait.location_repr = 'Chr%s: %.6f' % (
-                    this_trait.chr, float(this_trait.mb))
-
-            # Get mean expression value
-            query = (
-                """select ProbeSetXRef.mean from ProbeSetXRef, ProbeSet
-                where ProbeSetXRef.ProbeSetFreezeId = %s and
-                ProbeSet.Id = ProbeSetXRef.ProbeSetId and
-                ProbeSet.Name = '%s'
-            """ % (escape(str(this_trait.dataset.id)),
-                   escape(this_trait.name)))
-
-            #logger.debug("query is:", pf(query))
-            logger.sql(query)
-            result = g.db.execute(query).fetchone()
-
-            mean = result[0] if result else 0
-
-            if mean:
-                this_trait.mean = "%2.3f" % mean
-
-            # LRS and its location
-            this_trait.LRS_score_repr = 'N/A'
-            this_trait.LRS_location_repr = 'N/A'
-
-            # Max LRS and its Locus location
-            if this_trait.lrs and this_trait.locus:
-                query = """
-                    select Geno.Chr, Geno.Mb from Geno, Species
-                    where Species.Name = '{}' and
-                        Geno.Name = '{}' and
-                        Geno.SpeciesId = Species.Id
-                """.format(species, this_trait.locus)
-                logger.sql(query)
-                result = g.db.execute(query).fetchone()
-
-                if result:
-                    lrs_chr, lrs_mb = result
-                    this_trait.LRS_score_repr = '%3.1f' % this_trait.lrs
-                    this_trait.LRS_location_repr = 'Chr%s: %.6f' % (
-                        lrs_chr, float(lrs_mb))
-
-        return trait_list
-
-    def retrieve_sample_data(self, trait):
-        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
-                    """ % (escape(trait), escape(self.name))
-        # logger.sql(query)
-        results = g.db.execute(query).fetchall()
-        #logger.debug("RETRIEVED RESULTS HERE:", results)
-        return results
-
-    def retrieve_genes(self, column_name):
-        query = """
-                    select ProbeSet.Name, ProbeSet.%s
-                    from ProbeSet,ProbeSetXRef
-                    where ProbeSetXRef.ProbeSetFreezeId = %s and
-                    ProbeSetXRef.ProbeSetId=ProbeSet.Id;
-                """ % (column_name, escape(str(self.id)))
-        # logger.sql(query)
-        results = g.db.execute(query).fetchall()
-
-        return dict(results)
-
-
-class TempDataSet(DataSet):
-    '''Temporary user-generated data set'''
-
-    DS_NAME_MAP['Temp'] = 'TempDataSet'
-
-    def setup(self):
-        self.search_fields = ['name',
-                              'description']
-
-        self.display_fields = ['name',
-                               'description']
-
-        self.header_fields = ['Name',
-                              'Description']
-
-        self.type = 'Temp'
-
-        # Need to double check later how these are used
-        self.id = 1
-        self.fullname = 'Temporary Storage'
-        self.shortname = 'Temp'
-
-
-class PhenotypeDataSet(DataSet):
-    DS_NAME_MAP['Publish'] = 'PhenotypeDataSet'
-
-    def setup(self):
-
-        #logger.debug("IS A PHENOTYPEDATASET")
-
-        # Fields in the database table
-        self.search_fields = ['Phenotype.Post_publication_description',
-                              'Phenotype.Pre_publication_description',
-                              'Phenotype.Pre_publication_abbreviation',
-                              'Phenotype.Post_publication_abbreviation',
-                              'PublishXRef.mean',
-                              'Phenotype.Lab_code',
-                              'Publication.PubMed_ID',
-                              'Publication.Abstract',
-                              'Publication.Title',
-                              'Publication.Authors',
-                              'PublishXRef.Id']
-
-        # Figure out what display_fields is
-        self.display_fields = ['name', 'group_code',
-                               'pubmed_id',
-                               'pre_publication_description',
-                               'post_publication_description',
-                               'original_description',
-                               'pre_publication_abbreviation',
-                               'post_publication_abbreviation',
-                               'mean',
-                               'lab_code',
-                               'submitter', 'owner',
-                               'authorized_users',
-                               'authors', 'title',
-                               'abstract', 'journal',
-                               'volume', 'pages',
-                               'month', 'year',
-                               'sequence', 'units', 'comments']
-
-        # Fields displayed in the search results table header
-        self.header_fields = ['Index',
-                              'Record',
-                              'Description',
-                              'Authors',
-                              'Year',
-                              'Max LRS',
-                              'Max LRS Location',
-                              'Additive Effect']
-
-        self.type = 'Publish'
-
-        self.query_for_group = '''
-                            SELECT
-                                    InbredSet.Name, InbredSet.Id, InbredSet.GeneticType
-                            FROM
-                                    InbredSet, PublishFreeze
-                            WHERE
-                                    PublishFreeze.InbredSetId = InbredSet.Id AND
-                                    PublishFreeze.Name = "%s"
-                    ''' % escape(self.name)
-
-    def check_confidentiality(self):
-        # (Urgently?) Need to write this
-        pass
-
-    def get_trait_info(self, trait_list, species=''):
-        for this_trait in trait_list:
-
-            if not this_trait.haveinfo:
-                this_trait.retrieve_info(get_qtl_info=True)
-
-            description = this_trait.post_publication_description
-
-            # If the dataset is confidential and the user has access to confidential
-            # phenotype traits, then display the pre-publication description instead
-            # of the post-publication description
-            if this_trait.confidential:
-                this_trait.description_display = ""
-                continue   # todo for now, because no authorization features
-
-                if not webqtlUtil.has_access_to_confidentail_phenotype_trait(
-                        privilege=self.privilege,
-                        userName=self.userName,
-                        authorized_users=this_trait.authorized_users):
-
-                    description = this_trait.pre_publication_description
-
-            if len(description) > 0:
-                this_trait.description_display = description.strip()
-            else:
-                this_trait.description_display = ""
-
-            if not this_trait.year.isdigit():
-                this_trait.pubmed_text = "N/A"
-            else:
-                this_trait.pubmed_text = this_trait.year
-
-            if this_trait.pubmed_id:
-                this_trait.pubmed_link = webqtlConfig.PUBMEDLINK_URL % this_trait.pubmed_id
-
-            # LRS and its location
-            this_trait.LRS_score_repr = "N/A"
-            this_trait.LRS_location_repr = "N/A"
-
-            if this_trait.lrs:
-                query = """
-                    select Geno.Chr, Geno.Mb from Geno, Species
-                    where Species.Name = '%s' and
-                        Geno.Name = '%s' and
-                        Geno.SpeciesId = Species.Id
-                """ % (species, this_trait.locus)
-
-                result = g.db.execute(query).fetchone()
-
-                if result:
-                    if result[0] and result[1]:
-                        LRS_Chr = result[0]
-                        LRS_Mb = result[1]
-
-                        this_trait.LRS_score_repr = LRS_score_repr = '%3.1f' % this_trait.lrs
-                        this_trait.LRS_location_repr = LRS_location_repr = 'Chr%s: %.6f' % (
-                            LRS_Chr, float(LRS_Mb))
-
-    def retrieve_sample_data(self, trait):
-        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
-                    """
-
-        results = g.db.execute(query, (trait, self.id)).fetchall()
-        return results
-
-
-class GenotypeDataSet(DataSet):
-    DS_NAME_MAP['Geno'] = 'GenotypeDataSet'
-
-    def setup(self):
-        # Fields in the database table
-        self.search_fields = ['Name',
-                              'Chr']
-
-        # Find out what display_fields is
-        self.display_fields = ['name',
-                               'chr',
-                               'mb',
-                               'source2',
-                               'sequence']
-
-        # Fields displayed in the search results table header
-        self.header_fields = ['Index',
-                              'ID',
-                              'Location']
-
-        # Todo: Obsolete or rename this field
-        self.type = 'Geno'
-
-        self.query_for_group = '''
-                SELECT
-                        InbredSet.Name, InbredSet.Id, InbredSet.GeneticType
-                FROM
-                        InbredSet, GenoFreeze
-                WHERE
-                        GenoFreeze.InbredSetId = InbredSet.Id AND
-                        GenoFreeze.Name = "%s"
-                ''' % escape(self.name)
-
-    def check_confidentiality(self):
-        return geno_mrna_confidentiality(self)
-
-    def get_trait_info(self, trait_list, species=None):
-        for this_trait in trait_list:
-            if not this_trait.haveinfo:
-                this_trait.retrieveInfo()
-
-            if this_trait.chr and this_trait.mb:
-                this_trait.location_repr = 'Chr%s: %.6f' % (
-                    this_trait.chr, float(this_trait.mb))
-
-    def retrieve_sample_data(self, trait):
-        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
-                    """
-        results = g.db.execute(query,
-                               (webqtlDatabaseFunction.retrieve_species_id(self.group.name),
-                                trait, self.name)).fetchall()
-        return results
-
-
-def geno_mrna_confidentiality(ob):
-    dataset_table = ob.type + "Freeze"
-    #logger.debug("dataset_table [%s]: %s" % (type(dataset_table), dataset_table))
-
-    query = '''SELECT Id, Name, FullName, confidentiality,
-                        AuthorisedUsers FROM %s WHERE Name = "%s"''' % (dataset_table, ob.name)
-    #
-    result = g.db.execute(query)
-
-    (_dataset_id,
-     _name,
-     _full_name,
-     confidential,
-     _authorized_users) = result.fetchall()[0]
-
-    if confidential:
-        return True