Fix cacao gene ID validation bypass and simplify eFP query service

query_efp_database_dynamic() validated cacao gene IDs by species alone,
but cacao is split across three patterns (ccn/sca/tc) with no single
"efp_cacao" entry in the registry, so validation silently passed any
string through. Switch to the per-database lookup, which resolves the
correct pattern.

Also removes an unused EFPDataService class wrapper (nothing called it,
only the plain module-level functions), collapses a multi-engine
candidate loop down to a single lookup now that sqlite-mirror fallback
is gone, and collapses eFP-utils' 8 near-identical per-species gene
validation blocks into one. Trims docstrings on newly-introduced code
to one line each.

Author: rmobmina

api/models/efp_dynamic.py

@@ -1,10 +1,4 @@
-"""
-Dynamic SQLAlchemy model generation for all eFP databases.
-
-At import time, one ORM model class is generated per database entry in
-SIMPLE_EFP_DATABASE_SCHEMAS and stored in SIMPLE_EFP_SAMPLE_MODELS.
-This replaces ~1,984 lines of hand-written boilerplate with a single registry.
-"""
+"""Generates one SQLAlchemy model class per database in SIMPLE_EFP_DATABASE_SCHEMAS at import time, instead of hand-writing each one."""
 
 from __future__ import annotations
 
@@ -18,23 +12,7 @@
 
 
 def _to_sqla_type(column_spec):
-    """
-    Map a column specification dictionary to a SQLAlchemy column type.
-
-    Converts the simple type descriptors used in schema definitions to the
-    appropriate SQLAlchemy type objects for ORM model generation.
-
-    :param column_spec: Column specification with 'type', 'length', and 'unsigned' keys
-    :type column_spec: Dict[str, Any]
-    :return: SQLAlchemy column type (String, Integer, Float, or Text)
-    :rtype: sqlalchemy.types.TypeEngine
-    :raises ValueError: If column type is not one of: string, integer, float, text
-
-    Example::
-
-        col_spec = {"type": "string", "length": 24}
-        sqla_type = _to_sqla_type(col_spec)  # Returns String(24)
-    """
+    """Map a schema column spec ('type', 'length', 'unsigned') to a SQLAlchemy column type."""
     col_type = column_spec.get("type")
     if col_type == "string":
         return String(column_spec["length"])
@@ -50,26 +28,7 @@ def _to_sqla_type(column_spec):
 
 
 def _generate_model(bind_key: str, spec) -> db.Model:
-    """
-    Build a concrete SQLAlchemy model class for the given schema specification.
-
-    Dynamically creates an ORM model with the specified table name, bind key,
-    and columns based on the schema definition. The generated model class can
-    be used like any Flask-SQLAlchemy model.
-
-    :param bind_key: Database bind key (e.g., 'cannabis', 'embryo')
-    :type bind_key: str
-    :param spec: Database schema specification from SIMPLE_EFP_DATABASE_SCHEMAS
-    :type spec: Dict[str, Any]
-    :return: Dynamically generated SQLAlchemy model class
-    :rtype: db.Model
-
-    Example::
-
-        schema = SIMPLE_EFP_DATABASE_SCHEMAS['cannabis']
-        CannabisModel = _generate_model('cannabis', schema)
-        # Returns class: CannabisSampleData(db.Model)
-    """
+    """Build a concrete SQLAlchemy model class for the given database's schema spec."""
     attrs = {"__bind_key__": bind_key, "__tablename__": spec["table_name"]}
 
     for column in spec["columns"]:

api/models/efp_schemas.py

@@ -1,13 +1,4 @@
-"""
-Schema definitions for all eFP databases that expose a sample_data table.
-
-Every database shares the same three-column structure:
-  data_probeset_id (VARCHAR 255), data_signal (FLOAT), data_bot_id (VARCHAR 255).
-
-Species and probeset/gene-model classification are sourced from combined_master.json.
-To add a new database, add its name to _DATABASE_NAMES (and an entry to combined_master.json
-if one doesn't already exist) — no other changes needed.
-"""
+"""Schema definitions for eFP databases sharing the same sample_data (data_probeset_id, data_signal, data_bot_id) table -- to add a database, just add its name to _DATABASE_NAMES."""
 
 from __future__ import annotations
 
@@ -33,13 +24,7 @@
 
 
 def _schema(species: str, charset: str = "latin1") -> DatabaseSpec:
-    """Build a schema entry for one eFP database.
-
-    :param species: Species name stored in metadata (e.g., 'arabidopsis').
-    :param charset: MySQL character set — 'latin1' for most, 'utf8mb4' for non-Latin labels.
-    :returns: Full database schema dict ready for model generation.
-    :rtype: DatabaseSpec
-    """
+    """Build a schema entry for one eFP database, defaulting to latin1 (utf8mb4 for non-Latin labels)."""
     return {
         **_SCHEMA_TEMPLATE,
         "charset": charset,

api/resources/gene_density.py

@@ -1,17 +1,4 @@
-"""
-Gene density endpoint for the BAR API.
-
-Returns per-bin gene density across all Arabidopsis thaliana chromosomes for a
-given bin size (in base pairs), as used by Eplant's ChromosomeView to colour
-chromosomes by gene density.
-
-Reads:  eplant2.tair10_gff3
-Writes: JSON — list of chromosomes with density arrays
-
-Usage::
-
-    GET /gene_density?species=Arabidopsis_thaliana&bin_size=143061.51645207437
-"""
+"""Per-bin gene density across Arabidopsis chromosomes, used by Eplant's ChromosomeView to colour chromosomes by gene density."""
 
 from flask import request
 from flask_restx import Namespace, Resource
@@ -67,9 +54,7 @@ def get(self):
         start_bin_expr = func.floor(TAIR10GFF3.Start / bin_size)
         end_bin_expr = func.floor(TAIR10GFF3.End / bin_size)
 
-        # Aggregated query for single-bin genes (~98%+ of all genes at typical zoom levels).
-        # FLOOR(start/binSize) == FLOOR(end/binSize) means the gene fits within one bin,
-        # so GROUP BY is safe and avoids fetching one row per gene.
+        # genes that fit in one bin (~98%+) can be counted with GROUP BY instead of fetched row by row
         single_bin_rows = db.session.execute(
             db.select(chr_expr, start_bin_expr, func.count())
             .where(
@@ -85,8 +70,7 @@ def get(self):
                 if 0 <= idx < len(bins[chr_char]):
                     bins[chr_char][idx] += cnt
 
-        # Individual rows for genes that span multiple bins (rare — typically <2% of genes).
-        # Each such gene is counted once in every bin it spans, matching the original behaviour.
+        # genes spanning multiple bins (rare) are counted once in every bin they touch
         multi_bin_rows = db.session.execute(
             db.select(chr_expr, start_bin_expr, end_bin_expr)
             .where(

api/resources/microarray_gene_expression.py

@@ -67,11 +67,7 @@ def get(self, species="", gene_id=""):
 class GetDatabases(Resource):
     @microarray_gene_expression.param("species", _in="path", default="arabidopsis")
     def get(self, species=""):
-        """This endpoint returns the databases and views available for a given
-        species, and how many of each -- sourced live from combined_master.json
-        (data/efp_info/combined_master.json) instead of a hardcoded mapping, so
-        it can't drift out of sync with the actual database/frontend catalog.
-        """
+        """Returns the databases and views available for a given species, sourced live from combined_master.json."""
         species = str(escape(species)).lower()
 
         master = load_combined_master()
@@ -84,9 +80,7 @@ def get(self, species=""):
             if db_info["species"] == species
         }
 
-        # A database can be exposed under different view display names by
-        # different frontend instances (efp vs eplant); collapse to a single
-        # view_name -> database_name mapping like the endpoint has always returned.
+        # collapse each database's views (efp/eplant may name them differently) into one view_name -> database_name mapping
         views = {}
         for db_name, db_info in databases.items():
             for used_by in db_info["used_by"]:
@@ -103,8 +97,6 @@ def get(self, species=""):
 
 @microarray_gene_expression.route("/<string:species>/<string:view>/samples")
 class GetSamples1(Resource):
-    """This endpoint returns control and sample group mappings for a given species and view (or all views)"""
-
     @microarray_gene_expression.param("species", _in="path", default="arabidopsis")
     @microarray_gene_expression.param("view", _in="path", default="Abiotic_Stress")
     def get(self, species="", view=""):
@@ -122,8 +114,7 @@ def get(self, species="", view=""):
             if db_info["species"] == species
         }
 
-        # Collapse every database's views to a single view_name -> {database,
-        # platform, groups} mapping, same view-name normalization as /databases.
+        # same view_name -> {database, platform, groups} collapsing as /databases
         all_views = {}
         for db_name, db_info in species_databases.items():
             for view_info in db_info["views"].values():