Merge pull request #235 from TeresasaZ/dev

genes by positions + query genes databases, models, endpoints and tests

Author: asherpasha

api/models/eplant2.py

@@ -49,3 +49,29 @@ class Publications(db.Model):
     journal: db.Mapped[str] = db.mapped_column(db.String(64), nullable=False, primary_key=True)
     title: db.Mapped[str] = db.mapped_column(TEXT(), nullable=False, primary_key=True)
     pubmed: db.Mapped[str] = db.mapped_column(db.String(16), nullable=False, primary_key=True)
+
+
+class TAIR10GFF3(db.Model):
+    __bind_key__ = "eplant2"
+    __tablename__ = "tair10_gff3"
+
+    SeqID: db.Mapped[str] = db.mapped_column(db.String(20), nullable=False, primary_key=True)
+    Source: db.Mapped[str] = db.mapped_column(db.String(10), nullable=False, primary_key=True)
+    Type: db.Mapped[str] = db.mapped_column(db.String(30), nullable=False, primary_key=True)
+    Start: db.Mapped[int] = db.mapped_column(db.Integer, nullable=False, primary_key=True)
+    End: db.Mapped[int] = db.mapped_column(db.Integer, nullable=False, primary_key=True)
+    Score: db.Mapped[float] = db.mapped_column(db.Float, nullable=True, primary_key=True)
+    Strand: db.Mapped[str] = db.mapped_column(db.String(1), nullable=True, primary_key=True)
+    Phase: db.Mapped[str] = db.mapped_column(db.String(1), nullable=True, primary_key=True)
+    Id: db.Mapped[str] = db.mapped_column(db.String(20), nullable=True, primary_key=True)
+    geneId: db.Mapped[str] = db.mapped_column(db.String(20), nullable=True, primary_key=True)
+    Parent: db.Mapped[str] = db.mapped_column(db.String(40), nullable=True, primary_key=True)
+    Attributes: db.Mapped[str] = db.mapped_column(db.String(256), nullable=True, primary_key=True)
+
+
+class AgiAlias(db.Model):
+    __bind_key__ = "eplant2"
+    __tablename__ = "agi_alias"
+
+    agi: db.Mapped[str] = db.mapped_column(db.String(30), nullable=False, primary_key=True)
+    alias: db.Mapped[str] = db.mapped_column(db.String(30), nullable=False, primary_key=True)

api/resources/gene_information.py

@@ -4,6 +4,9 @@
 from api.models.annotations_lookup import AgiAlias
 from api.models.eplant2 import Isoforms as EPlant2Isoforms
 from api.models.eplant2 import Publications as EPlant2Publications
+from api.models.eplant2 import TAIR10GFF3 as EPlant2TAIR10_GFF3
+from api.models.eplant2 import AgiAlias as EPlant2AgiAlias
+from api.models.eplant2 import AgiAnnotation as EPlant2AgiAnnotation
 from api.models.eplant_poplar import Isoforms as EPlantPoplarIsoforms
 from api.models.eplant_tomato import Isoforms as EPlantTomatoIsoforms
 from api.models.eplant_soybean import Isoforms as EPlantSoybeanIsoforms
@@ -14,6 +17,16 @@
 
 gene_information = Namespace("Gene Information", description="Information about Genes", path="/gene_information")
 
+parser = gene_information.parser()
+parser.add_argument(
+    "terms",
+    type=list,
+    action="append",
+    required=True,
+    help="Gene IDs, format example: AT1G01010",
+    default=["AT1G01020", "AT1G01030"],
+)
+
 # I think this is only needed for Swagger UI POST
 gene_information_request_fields = gene_information.model(
     "GeneInformation",
@@ -27,6 +40,18 @@
     },
 )
 
+query_genes_request_fields = gene_information.model(
+    "GeneInformation",
+    {
+        "species": fields.String(required=True, example="Arabidopsis_thaliana"),
+        "terms": fields.List(
+            required=True,
+            example=["AT1G01010", "AT1G01020"],
+            cls_or_instance=fields.String,
+        ),
+    },
+)
+
 
 # Validation is done in a different way to keep things simple
 class GeneInformationSchema(Schema):
@@ -135,6 +160,286 @@ def get(self, species="", gene_id=""):
             return BARUtils.error_exit("There are no data found for the given gene")
 
 
+@gene_information.route("/genes_by_position/<string:species>/<string:chromosome>/<string:startParam>/<string:endParam>")
+class GeneTAIR10_GFF3(Resource):
+    @gene_information.param("species", _in="path", default="arabidopsis")
+    @gene_information.param("chromosome", _in="path", default="0")
+    @gene_information.param("startParam", _in="path", default=3000)
+    @gene_information.param("endParam", _in="path", default=6000)
+    def get(self, species="", chromosome="", startParam="", endParam=""):
+        """This end point provides genes given position."""
+
+        # Check if all parameters are provided
+        if not chromosome or not startParam or not endParam:
+            return BARUtils.error_exit("Missing parameters"), 400
+
+        # Check if the start param is smaller than end param
+        if startParam >= endParam:
+            return BARUtils.error_exit("Start location should be smaller than the end location")
+
+        # Check if both parameters are valid figures
+        if not BARUtils.is_integer(startParam) or not BARUtils.is_integer(endParam):
+            return BARUtils.error_exit("At lease one parameter is not valid")
+
+        # Escape input
+        species = escape(species)
+        chromosome = escape(chromosome)
+        startParam = escape(startParam)
+        endParam = escape(endParam)
+
+        try:
+            # Set database
+            if species == "arabidopsis":
+                database = EPlant2TAIR10_GFF3
+
+                # Map chromosome to its ID
+                chromosomeId = '0'
+                if chromosome == 'Chr1':
+                    chromosomeId = '1'
+                elif chromosome == 'Chr2':
+                    chromosomeId = '2'
+                elif chromosome == 'Chr3':
+                    chromosomeId = '3'
+                elif chromosome == 'Chr4':
+                    chromosomeId = '4'
+                elif chromosome == 'Chr5':
+                    chromosomeId = '5'
+                elif chromosome == 'ChrC':
+                    chromosomeId = 'C'
+                elif chromosome == 'ChrM':
+                    chromosomeId = 'M'
+                else:
+                    return BARUtils.error_exit("Invalid chromosome"), 400
+            else:
+                return BARUtils.error_exit("No data for the given species"), 400
+
+            # Construct the query
+            atnumg = "AT" + chromosomeId + "G"
+            query1 = db.select(database.geneId, database.Start, database.End, database.Strand).where(
+                database.Type == "gene",
+                database.geneId.startswith(atnumg),
+                (
+                    database.Start.between(startParam, endParam) |
+                    database.End.between(startParam, endParam) |
+                    ((database.Start < startParam) & (database.End > endParam))
+                )
+            )
+            result1 = db.session.execute(query1).all()
+            gene_ids = [row[0] for row in result1]
+
+            # Get aliases
+            query2 = db.select(EPlant2AgiAlias.agi, EPlant2AgiAlias.alias).where(EPlant2AgiAlias.agi.in_(gene_ids))
+            result2 = db.session.execute(query2).all()
+            all_aliases = {}
+            for row in result2:
+                if row[0] not in all_aliases:
+                    all_aliases[row[0]] = []
+                all_aliases[row[0]].append(row[1])
+
+            # Get annotation
+            query3 = db.select(EPlant2AgiAnnotation.agi, EPlant2AgiAnnotation.annotation).where(EPlant2AgiAnnotation.agi.in_(gene_ids))
+            result3 = db.session.execute(query3).all()
+            all_annotations = {}
+            for row in result3:
+                temp = row[1].split('__')
+                if len(temp) > 1:
+                    all_annotations[row[0].upper()] = temp[1]
+                else:
+                    all_annotations[row[0].upper()] = temp[0]
+
+            genes = []
+            for row in result1:
+                gene = {
+                    'id': row[0],
+                    'start': row[1],
+                    'end': row[2],
+                    'strand': row[3],
+                    'aliases': all_aliases.get(row[0], []),
+                    'annotation': all_annotations.get(row[0], None)
+                }
+
+                genes.append(gene)
+            return BARUtils.success_exit(genes)
+
+        except Exception as e:
+            return BARUtils.error_exit(str(e)), 400
+
+
+@gene_information.route("/gene_query")
+class GeneQueryGene(Resource):
+    @gene_information.expect(query_genes_request_fields)
+    def post(self):
+        """This end point provides gene information for multiple genes given multiple terms."""
+
+        # Escape input
+        data = request.get_json()
+        species = data["species"]
+        terms = data["terms"]
+        for one_term in terms:
+            one_term.upper()
+
+        try:
+            # Species check
+            if species != "Arabidopsis_thaliana":
+                return BARUtils.error_exit("No data for the given species"), 400
+
+            # Term check
+            for one_term in terms:
+                if not BARUtils.is_arabidopsis_gene_valid(one_term):
+                    return BARUtils.error_exit("Input list contains invalid term"), 400
+
+            database = EPlant2AgiAlias
+            gene_ids = []
+            agi_fail = []
+            for one_term in terms:
+                query = db.select(database.agi).where(database.agi.contains(one_term)).limit(1)
+                result = db.session.execute(query).fetchone()
+                if not result:
+                    agi_fail.append(one_term)
+                else:
+                    gene_ids.append(result[0])
+
+            # For terms that do not have results
+            database = EPlant2TAIR10_GFF3
+            for fail_term in agi_fail:
+                query = db.select(database.geneId).where(
+                    (
+                        (database.Type == 'gene') |
+                        (database.Type == 'transposable_element_gene')
+                    ),
+                    database.geneId.contains(fail_term)
+                ).limit(1)
+                result = db.session.execute(query).fetchone()
+                if result:
+                    gene_ids.append(result[0])
+
+            # Find information for each term
+            query = db.select(database.geneId, database.Start, database.End, database.Strand).where(
+                ((database.Type == "gene") | (database.Type == "transposable_element_gene")),
+                database.Source == "TAIR10",
+                database.geneId.in_(gene_ids)
+            )
+            result = db.session.execute(query).all()
+            genes_info = {}
+            for row in result:
+                if row[0] not in genes_info:
+                    gene = {}
+                    gene['id'] = row[0]
+                    gene['chromosome'] = 'Chr' + row[0][2:3]
+                    gene['start'] = row[1]
+                    gene['end'] = row[2]
+                    gene['strand'] = row[3]
+                    gene['aliases'] = []
+                    gene['annotation'] = None
+                    genes_info[row[0]] = gene
+
+            # Get aliases
+            database = EPlant2AgiAlias
+            query = db.select(database.agi, database.alias).where(database.agi.in_(gene_ids))
+            result = db.session.execute(query).all()
+            for row in result:
+                if row[0] in genes_info:
+                    genes_info[row[0]]['aliases'].append(row[1])
+
+            # Get annotations
+            database = EPlant2AgiAnnotation
+            query = db.select(database.agi, database.annotation).where(database.agi.in_(gene_ids))
+            result = db.session.execute(query)
+            for row in result:
+                if row[0].upper() in genes_info:
+                    temp = row[1].split('__')
+                    if len(temp) > 1:
+                        genes_info[row[0].upper()]['annotation'] = temp[1]
+                    else:
+                        genes_info[row[0].upper()]['annotation'] = temp[0]
+
+            return BARUtils.success_exit(genes_info)
+
+        except Exception as e:
+            return BARUtils.error_exit(str(e)), 400
+
+
+@gene_information.route("/single_gene_query/<string:species>/<string:term>")
+class SingleGeneQueryGene(Resource):
+    @gene_information.param("species", _in="path", default="Arabidopsis_thaliana")
+    @gene_information.param("term", _in="path", default="AT1G01010")
+    def get(self, species="", term=""):
+        """This end point provides gene information for a single gene given one term."""
+
+        # Escape input
+        species = escape(species)
+        term = escape(term).upper()
+
+        try:
+            # Species check
+            if species != "Arabidopsis_thaliana":
+                return BARUtils.error_exit("No data for the given species"), 400
+
+            # Term check
+            if not BARUtils.is_arabidopsis_gene_valid(term):
+                return BARUtils.error_exit("Input term invalid"), 400
+
+            database = EPlant2AgiAlias
+            query = db.select(database.agi).where(database.agi == term).limit(1)
+            result = db.session.execute(query).fetchone()
+
+            if not result:
+                database = EPlant2TAIR10_GFF3
+                query = db.select(database.geneId).where(
+                    (
+                        (database.Type == 'gene') |
+                        (database.Type == 'transposable_element_gene')
+                    ),
+                    database.geneId == term
+                ).limit(1)
+                result = db.session.execute(query).fetchone()
+
+            genes_info = {}
+            if result:
+                # Find information for the term
+                database = EPlant2TAIR10_GFF3
+                query = db.select(database.geneId, database.Start, database.End, database.Strand).where(
+                    ((database.Type == "gene") | (database.Type == "transposable_element_gene")),
+                    database.Source == "TAIR10",
+                    database.geneId == term
+                )
+                result = db.session.execute(query).fetchone()
+
+                gene = {}
+                gene['id'] = result[0]
+                gene['chromosome'] = 'Chr' + gene['id'][2:3]
+                gene['start'] = result[1]
+                gene['end'] = result[2]
+                gene['strand'] = result[3]
+                gene['aliases'] = []
+                gene['annotation'] = None
+                genes_info[result[0]] = gene
+
+                # Get aliases
+                database = EPlant2AgiAlias
+                query = db.select(database.agi, database.alias).where(database.agi == term)
+                result = db.session.execute(query).all()
+                for row in result:
+                    if row[1] not in gene['aliases']:
+                        gene['aliases'].append(row[1])
+
+                # Get annotations
+                database = EPlant2AgiAnnotation
+                query = db.select(database.agi, database.annotation).where(database.agi == term)
+                result = db.session.execute(query).all()
+                for row in result:
+                    temp = row[1].split('__')
+                    if len(temp) > 1:
+                        gene['annotation'] = temp[1]
+                    else:
+                        gene['annotation'] = temp[0]
+
+            return BARUtils.success_exit(genes_info)
+
+        except Exception as e:
+            return BARUtils.error_exit(str(e)), 400
+
+
 @gene_information.route("/gene_isoforms/<string:species>/<string:gene_id>")
 class GeneIsoforms(Resource):
     @gene_information.param("species", _in="path", default="arabidopsis")