Merge remote-tracking branch 'upstream/dev' into dev

Author: TeresasaZ

api/__init__.py

@@ -53,6 +53,7 @@ def create_app():
     # Now add routes
     from api.resources.gene_information import gene_information
     from api.resources.rnaseq_gene_expression import rnaseq_gene_expression
+    from api.resources.microarray_gene_expression import microarray_gene_expression
     from api.resources.proxy import bar_proxy
     from api.resources.thalemine import thalemine
     from api.resources.snps import snps
@@ -65,6 +66,7 @@ def create_app():
 
     bar_api.add_namespace(gene_information)
     bar_api.add_namespace(rnaseq_gene_expression)
+    bar_api.add_namespace(microarray_gene_expression)
     bar_api.add_namespace(bar_proxy)
     bar_api.add_namespace(thalemine)
     bar_api.add_namespace(snps)

api/models/annotations_lookup.py

@@ -10,3 +10,13 @@ class AgiAlias(db.Model):
     agi: db.Mapped[str] = db.mapped_column(db.String(30), primary_key=True, nullable=False)
     alias: db.Mapped[str] = db.mapped_column(db.String(30), primary_key=True, nullable=False)
     date: db.Mapped[datetime] = db.mapped_column(db.Date, primary_key=True, nullable=False)
+
+
+class AtAgiLookup(db.Model):
+    __bind_key__ = "annotations_lookup"
+    __tablename__ = "at_agi_lookup"
+    __table_args__ = (db.Index("probeset_date_agi", "probeset", "agi", "date"),)
+
+    probeset: db.Mapped[str] = db.mapped_column(db.String(60), primary_key=True, nullable=False)
+    agi: db.Mapped[str] = db.mapped_column(db.String(30), primary_key=True, nullable=False)
+    date: db.Mapped[datetime] = db.mapped_column(db.Date, primary_key=True, nullable=False)

api/models/arabidopsis_ecotypes.py

@@ -0,0 +1,15 @@
+from api import db
+
+
+class SampleData(db.Model):
+    __bind_key__ = "arabidopsis_ecotypes"
+    __tablename__ = "sample_data"
+
+    sample_id: db.Mapped[int] = db.mapped_column(db.Integer, nullable=False)
+    proj_id: db.Mapped[str] = db.mapped_column(db.String(15), nullable=False)
+    sample_file_name: db.Mapped[str] = db.mapped_column(db.String)
+    data_probeset_id: db.Mapped[str] = db.mapped_column(db.String(30), nullable=False, primary_key=True)
+    data_signal: db.Mapped[float] = db.mapped_column(db.Float)
+    data_call: db.Mapped[str] = db.mapped_column(db.String)
+    data_p_val: db.Mapped[float] = db.mapped_column(db.Float)
+    data_bot_id: db.Mapped[str] = db.mapped_column(db.String(16), nullable=False)

api/resources/gene_information.py

@@ -9,14 +9,14 @@
 from api.models.eplant_soybean import Isoforms as EPlantSoybeanIsoforms
 from api.utils.bar_utils import BARUtils
 from marshmallow import Schema, ValidationError, fields as marshmallow_fields
-from api import cache, db
+from api import db
 
 
 gene_information = Namespace("Gene Information", description="Information about Genes", path="/gene_information")
 
 # I think this is only needed for Swagger UI POST
-gene_isoforms_request_fields = gene_information.model(
-    "GeneIsoforms",
+gene_information_request_fields = gene_information.model(
+    "GeneInformation",
     {
         "species": fields.String(required=True, example="arabidopsis"),
         "genes": fields.List(
@@ -29,46 +29,62 @@
 
 
 # Validation is done in a different way to keep things simple
-class GeneIsoformsSchema(Schema):
+class GeneInformationSchema(Schema):
     species = marshmallow_fields.String(required=True)
     genes = marshmallow_fields.List(cls_or_instance=marshmallow_fields.String)
 
 
-@gene_information.route("/gene_alias")
-class GeneAliasList(Resource):
-    def get(self):
-        """This end point returns the list of species available"""
-        species = ["arabidopsis"]  # This are the only species available so far
-        return BARUtils.success_exit(species)
-
+@gene_information.route("/gene_aliases")
+class GeneAliases(Resource):
+    @gene_information.expect(gene_information_request_fields)
+    def post(self):
+        """This end point retrieves gene aliases for a large dataset"""
+        json_data = request.get_json()
+        data = {}
 
-@gene_information.route("/gene_alias/<string:species>/<string:gene_id>")
-class GeneAlias(Resource):
-    @gene_information.param("species", _in="path", default="arabidopsis")
-    @gene_information.param("gene_id", _in="path", default="At3g24650")
-    @cache.cached()
-    def get(self, species="", gene_id=""):
-        """This end point provides gene alias given a gene ID."""
-        aliases = []
+        # Validate json
+        try:
+            json_data = GeneInformationSchema().load(json_data)
+        except ValidationError as err:
+            return BARUtils.error_exit(err.messages), 400
 
-        # Escape input
-        species = escape(species)
-        gene_id = escape(gene_id)
+        genes = json_data["genes"]
+        species = json_data["species"]
 
+        # Set species and check gene ID format
         if species == "arabidopsis":
-            if BARUtils.is_arabidopsis_gene_valid(gene_id):
-                rows = db.session.execute(db.select(AgiAlias).where(AgiAlias.agi == gene_id)).scalars().all()
-                [aliases.append(row.alias) for row in rows]
-            else:
-                return BARUtils.error_exit("Invalid gene id"), 400
+            database = AgiAlias
+
+            # Check if gene is valid
+            for gene in genes:
+                if not BARUtils.is_arabidopsis_gene_valid(gene):
+                    return BARUtils.error_exit("Invalid gene id"), 400
+
         else:
-            return BARUtils.error_exit("No data for the given species")
+            return BARUtils.error_exit("Invalid species"), 400
+
+        # Query must be run individually for each species
+        rows = db.session.execute(db.select(database).where(database.agi.in_(genes))).scalars().all()
+
+        # If there are any isoforms found, return data
+        data = []
+        data_items = {}
+
+        if len(rows) > 0:
+            for row in rows:
+                if row.agi in data_items.keys():
+                    data_items[row.agi].append(row.agi)
+                else:
+                    data_items[row.agi] = []
+                    data_items[row.agi].append(row.alias)
+
+            for gene in data_items.keys():
+                data.append({"gene": gene, "aliases": data_items[gene]})
+
+            return BARUtils.success_exit(data)
 
-        # Return results if there are data
-        if len(aliases) > 0:
-            return BARUtils.success_exit(aliases)
         else:
-            return BARUtils.error_exit("There are no data found for the given gene")
+            return BARUtils.error_exit("No data for the given species/genes"), 400
 
 
 @gene_information.route("/gene_publications/<string:species>/<string:gene_id>")
@@ -166,7 +182,7 @@ def get(self, species="", gene_id=""):
 
 @gene_information.route("/gene_isoforms/")
 class PostGeneIsoforms(Resource):
-    @gene_information.expect(gene_isoforms_request_fields)
+    @gene_information.expect(gene_information_request_fields)
     def post(self):
         """This end point returns gene isoforms data for a multiple genes for a species.
         Only genes/isoforms with pdb structures are returned"""
@@ -176,7 +192,7 @@ def post(self):
 
         # Validate json
         try:
-            json_data = GeneIsoformsSchema().load(json_data)
+            json_data = GeneInformationSchema().load(json_data)
         except ValidationError as err:
             return BARUtils.error_exit(err.messages), 400
 

api/resources/microarray_gene_expression.py

@@ -0,0 +1,52 @@
+from flask_restx import Namespace, Resource
+from markupsafe import escape
+from api import db
+from api.models.annotations_lookup import AtAgiLookup
+from api.models.arabidopsis_ecotypes import SampleData as EcotypesSampleData
+from api.utils.bar_utils import BARUtils
+from api.utils.world_efp_utils import WorldeFPUtils
+
+
+microarray_gene_expression = Namespace(
+    "Microarray Gene Expression",
+    description="Microarray (probe-based) Gene Expression data from the BAR Databases",
+    path="/microarray_gene_expression",
+)
+
+
+@microarray_gene_expression.route("/world_efp/<string:species>/<string:gene_id>")
+class GetWorldeFPExpression(Resource):
+    @microarray_gene_expression.param("species", _in="path", default="arabidopsis")
+    @microarray_gene_expression.param("gene_id", _in="path", default="At1g01010")
+    def get(self, species="", gene_id=""):
+        """This end point returns World Efp gene expression data"""
+        species = escape(species)
+        gene_id = escape(gene_id)
+
+        if species == "arabidopsis":
+            if not BARUtils.is_arabidopsis_gene_valid(gene_id):
+                return BARUtils.error_exit("Invalid gene id")
+        else:
+            return BARUtils.error_exit("Invalid species")
+        subquery = db.select(AtAgiLookup.probeset).where(AtAgiLookup.agi == gene_id).order_by(AtAgiLookup.date.desc()).limit(1).subquery()
+
+        sq_query = db.session.query(subquery)
+        if sq_query.count() > 0:
+            sq_result = sq_query[0][0]
+        else:
+            return BARUtils.error_exit("There are no data found for the given gene")
+
+        rows = db.session.execute(
+            db.select(EcotypesSampleData.data_probeset_id, EcotypesSampleData.data_signal, EcotypesSampleData.data_bot_id).where(EcotypesSampleData.data_probeset_id == sq_result)
+        ).all()
+        final_json = {}
+
+        if len(rows) > 0:
+            for row in rows:
+                if row[2][5:8] not in final_json:
+                    final_json[row[2][5:8]] = WorldeFPUtils.wrap_json(row[2][5:8], row[2], row[1], row[0])
+                elif row[2][5:8] in final_json:
+                    final_json[row[2][5:8]]['values'].update({row[2] : row[1]})
+            return BARUtils.success_exit(final_json)
+        else:
+            return BARUtils.error_exit("There are no data found for the given gene")