Revert unrelated init.sh/SNP scope creep; simplify regex loading and umap_expression

- config/init.sh: drop the db_exists/import_if_missing wrapper that had
  been applied to every database (including ones this PR never touches,
  like fastpheno and gaia). Every SQL dump already starts with DROP TABLE
  IF EXISTS/CREATE TABLE, so the wrapper wasn't needed for correctness --
  it introduced a bug (schema-exists check skipped real-data imports once
  the dynamic bootstrap created an empty table first) and needed a second
  fix to reorder around it. Restored plain unconditional imports for every
  database, keeping only DB_HOST (needed for docker-compose, where the api
  container talks to a separate BAR_mysqldb container).
- config/databases/soybean_nssnp.sql, tomato_nssnp.sql: restore the
  FOREIGN KEY constraint dropped by the same commit that bloated init.sh;
  unrelated to the expression API.
- api/utils/bar_utils.py: collapse the eFP-project alias assignments into
  a small alias dict + loop instead of six hardcoded lines.
- Remove the dead api/models/bar_utils.py bridge file that only
  re-exported BARUtils from api/utils/bar_utils.py; point
  api/services/efp_data.py at the real module directly.
- Move scripts/bootstrap_simple_efp_dbs.py's CLI into
  api/services/efp_bootstrap.py (run via `python3 -m
  api.services.efp_bootstrap`) and delete the standalone script;
  config/init.sh updated to match.
- api/resources/umap_expression.py: stop leaking raw exception text to
  API clients (no other endpoint does this -- they all return a fixed
  BARUtils.error_exit message), and extract the query/retry/merge logic
  out of one monolithic method into module-level helpers
  (_fetch_expression_row, _fetch_coords, _merge_coords_and_expression),
  matching the rest of the codebase's structure.

Author: rmobmina

api/models/bar_utils.py

@@ -31,6 +31,53 @@
     "arabidopsis_stem_lee_umap": "arabidopsis",
 }
 
+_EXPRESSION_SQL = text("SELECT expression FROM umap_expression WHERE gene_id = :gene_id")
+_COORDS_SQL = text("SELECT cell_id, umap_1, umap_2, cell_type FROM umap_coords ORDER BY cell_id")
+
+
+def _fetch_expression_row(engine, gene_id):
+    """Look up the expression JSON blob for gene_id, retrying uppercase
+    (some datasets store IDs in uppercase).
+
+    :returns: (row, error_response) -- exactly one of the two is None.
+    """
+    try:
+        with Session(engine) as session:
+            row = session.execute(_EXPRESSION_SQL, {"gene_id": gene_id}).first()
+            if row is None:
+                row = session.execute(_EXPRESSION_SQL, {"gene_id": gene_id.upper()}).first()
+    except SQLAlchemyError:
+        return None, (BARUtils.error_exit("Database query failed"), 500)
+
+    if row is None:
+        return None, (BARUtils.error_exit("No data found for the given gene"), 404)
+    return row, None
+
+
+def _fetch_coords(engine):
+    """Return every UMAP coordinate row (same for every gene), or an error response.
+
+    :returns: (rows, error_response) -- exactly one of the two is None.
+    """
+    try:
+        with Session(engine) as session:
+            return session.execute(_COORDS_SQL).all(), None
+    except SQLAlchemyError:
+        return None, (BARUtils.error_exit("Database query failed"), 500)
+
+
+def _merge_coords_and_expression(coords, expr_map):
+    """Zip UMAP coordinates with each cell's expression value, keyed by cell_id."""
+    return [
+        {
+            "umap_1": float(c.umap_1),
+            "umap_2": float(c.umap_2),
+            "expression": float(expr_map.get(str(c.cell_id), 0.0)),
+            "cell_type": str(c.cell_type),
+        }
+        for c in coords
+    ]
+
 
 @umap_expression.route("/<string:database>/<string:gene_id>")
 @umap_expression.doc(description="Retrieve per-cell UMAP coordinates and expression values for a gene.")
@@ -52,76 +99,35 @@ def get(self, database, gene_id):
         database = str(escape(database))
         gene_id = str(escape(gene_id))
 
-        # 1. Resolve database species
         species = UMAP_DATABASE_SPECIES.get(database)
         if species is None:
             return BARUtils.error_exit(
                 f"Unknown UMAP database '{database}'. "
                 f"Available: {', '.join(sorted(UMAP_DATABASE_SPECIES.keys()))}"
             ), 400
 
-        # 2. Validate gene ID format against the expected input species regex
         if BARUtils.is_injection_attempt(gene_id):
             return BARUtils.error_exit(f"Invalid {species} gene ID: '{gene_id}'"), 400
         if not GeneIdUtils.validate_gene_id(gene_id, species):
             return BARUtils.error_exit(f"Invalid {species} gene ID: '{gene_id}'"), 400
-
-        # 3. Normalise (e.g. strip maize transcript suffix _T##)
         gene_id = GeneIdUtils.normalize_gene_id(gene_id, species)
 
-        # 4. Get SQLAlchemy bind engine for this database
         engine = db.engines.get(database)
         if engine is None:
             return BARUtils.error_exit("Database not available"), 503
 
-        # 5. Query expression JSON array for this gene (single PK lookup)
-        expr_sql = text(
-            "SELECT expression FROM umap_expression WHERE gene_id = :gene_id"
-        )
-
-        try:
-            with Session(engine) as session:
-                row = session.execute(expr_sql, {"gene_id": gene_id}).first()
-        except SQLAlchemyError as exc:
-            return BARUtils.error_exit(f"Database query failed: {str(exc)}"), 500
-
-        # Retry with uppercase (some datasets store IDs in uppercase)
-        if row is None:
-            try:
-                with Session(engine) as session:
-                    row = session.execute(expr_sql, {"gene_id": gene_id.upper()}).first()
-            except SQLAlchemyError as exc:
-                return BARUtils.error_exit(f"Database query failed: {str(exc)}"), 500
-
-        if row is None:
-            return BARUtils.error_exit("No data found for the given gene"), 404
-
-        # Parse expression JSON array: {cell_id: value, ...}
-        expr_raw = row.expression
+        expr_row, error = _fetch_expression_row(engine, gene_id)
+        if error:
+            return error
+
+        expr_raw = expr_row.expression
         expr_map = json.loads(expr_raw) if isinstance(expr_raw, str) else expr_raw
 
-        # 6. Query all coords ordered by cell_id (same for every gene)
-        coords_sql = text(
-            "SELECT cell_id, umap_1, umap_2, cell_type "
-            "FROM umap_coords ORDER BY cell_id"
-        )
-
-        try:
-            with Session(engine) as session:
-                coords = session.execute(coords_sql).all()
-        except SQLAlchemyError as exc:
-            return BARUtils.error_exit(f"Database query failed: {str(exc)}"), 500
-
-        # 7. Merge coords + expression by cell_id
-        data = [
-            {
-                "umap_1": float(c.umap_1),
-                "umap_2": float(c.umap_2),
-                "expression": float(expr_map.get(str(c.cell_id), 0.0)),
-                "cell_type": str(c.cell_type),
-            }
-            for c in coords
-        ]
+        coords, error = _fetch_coords(engine)
+        if error:
+            return error
+
+        data = _merge_coords_and_expression(coords, expr_map)
 
         return BARUtils.success_exit({
             "gene_id": gene_id,

api/resources/umap_expression.py

@@ -2,19 +2,26 @@
 Bootstrap utilities for creating eFP MySQL databases from the shared schema registry.
 
 Used by:
-  - scripts/bootstrap_simple_efp_dbs.py  (CLI)
-  - config/init.sh                        (Docker / CI)
+  - config/init.sh (Docker / CI), via `python3 -m api.services.efp_bootstrap`
+
+Usage:
+    python3 -m api.services.efp_bootstrap
+    python3 -m api.services.efp_bootstrap --databases embryo klepikova
+    python3 -m api.services.efp_bootstrap --host localhost --port 3306
 """
 
 from __future__ import annotations
 
+import argparse
+import os
 import re
 import hashlib
 from typing import Dict, Iterable, List
 
 from sqlalchemy import Column, Index, MetaData, Table, create_engine, text
 from sqlalchemy.dialects.mysql import FLOAT, INTEGER, TEXT, VARCHAR
 from sqlalchemy.engine import URL
+from sqlalchemy.exc import SQLAlchemyError
 
 from api.models.efp_schemas import SIMPLE_EFP_DATABASE_SCHEMAS
 
@@ -221,10 +228,8 @@ def bootstrap_simple_efp_databases(
     2. Creates the sample_data table with schema from SIMPLE_EFP_DATABASE_SCHEMAS
     3. Inserts seed rows if the table is empty and seed_rows are defined
 
-    Used by:
-    - scripts/bootstrap_simple_efp_dbs.py (CLI tool)
-    - config/init.sh (Docker/CI initialization)
-    - api/resources/efp_proxy.py (HTTP bootstrap endpoint)
+    Used by config/init.sh (Docker/CI initialization) via the CLI entry point
+    at the bottom of this module (`python3 -m api.services.efp_bootstrap`).
 
     :param host: MySQL server hostname (e.g., 'localhost', 'BAR_mysqldb' for Docker)
     :type host: str
@@ -280,3 +285,67 @@ def bootstrap_simple_efp_databases(
 
 
 __all__ = ["bootstrap_simple_efp_databases"]
+
+
+def _default_host() -> str:
+    """Resolve the default MySQL hostname from environment variables.
+
+    Checks DB_HOST, then MYSQL_HOST, then falls back to 'localhost'.
+    Docker deployments should set DB_HOST=BAR_mysqldb explicitly.
+
+    :returns: MySQL hostname string.
+    :rtype: str
+    """
+    if os.environ.get("DB_HOST"):
+        return os.environ["DB_HOST"]
+    if os.environ.get("MYSQL_HOST"):
+        return os.environ["MYSQL_HOST"]
+    return "localhost"
+
+
+def _parse_args() -> argparse.Namespace:
+    """Parse command-line arguments for the bootstrap CLI.
+
+    :returns: Parsed arguments with host, port, user, password, and optional database list.
+    :rtype: argparse.Namespace
+    """
+    parser = argparse.ArgumentParser(description="Create simple eFP MySQL databases from in-memory schemas.")
+    parser.add_argument("--host", default=_default_host(), help="MySQL hostname (default: %(default)s)")
+    parser.add_argument("--port", type=int, default=int(os.environ.get("DB_PORT", 3306)), help="MySQL port")
+    parser.add_argument("--user", default=os.environ.get("DB_USER", "root"), help="MySQL user")
+    parser.add_argument("--password", default=os.environ.get("DB_PASS", "root"), help="MySQL password")
+    parser.add_argument(
+        "--databases",
+        nargs="*",
+        help="Optional list of databases to bootstrap (defaults to every simple schema).",
+    )
+    return parser.parse_args()
+
+
+def _main():
+    """Run the bootstrap CLI — creates all eFP databases and prints a result per entry.
+
+    Output format: [ok] ensured database_name.table_name (seeded N rows)
+
+    :raises SQLAlchemyError: If database creation or connection fails.
+    """
+    args = _parse_args()
+    results = bootstrap_simple_efp_databases(
+        host=args.host,
+        port=args.port,
+        user=args.user,
+        password=args.password,
+        databases=args.databases,
+    )
+    for entry in results:
+        seeded = entry["seeded_rows"]
+        seed_msg = f"seeded {seeded} rows" if seeded else "no seed rows inserted"
+        print(f"[ok] ensured {entry['database']}.{entry['table']} ({seed_msg})")
+
+
+if __name__ == "__main__":
+    try:
+        _main()
+    except SQLAlchemyError as exc:
+        print(f"failed to initialize simple efp databases: {exc}")
+        raise

api/services/efp_bootstrap.py

@@ -25,8 +25,8 @@
 
 from api import db
 from api.models.annotations_lookup import AtAgiLookup
-from api.models.bar_utils import BARUtils
 from api.models.efp_schemas import SIMPLE_EFP_DATABASE_SCHEMAS
+from api.utils.bar_utils import BARUtils
 
 _RANDOM_ROWS_DIR = Path(__file__).resolve().parents[1] / "random_rows_json"
 

api/services/efp_data.py

@@ -28,12 +28,16 @@ def load_combined_master() -> dict:
 
 # Aliases for alternate eFP project key spellings used by the BAR (not present
 # in Vincent's registry, which is keyed by canonical eFP project name only).
-EFP_PROJECT_REGEXES["efpbarley"] = EFP_PROJECT_REGEXES["efp_barley"]
-EFP_PROJECT_REGEXES["efprice"] = EFP_PROJECT_REGEXES["efp_rice"]
-EFP_PROJECT_REGEXES["efpmedicago"] = EFP_PROJECT_REGEXES["efp_medicago"]
-EFP_PROJECT_REGEXES["efppop"] = EFP_PROJECT_REGEXES["efp_poplar"]
-EFP_PROJECT_REGEXES["efpsoybean"] = EFP_PROJECT_REGEXES["efp_soybean"]
-EFP_PROJECT_REGEXES["maizeefp"] = EFP_PROJECT_REGEXES["efp_maize"]
+_PROJECT_ALIASES = {
+    "efpbarley": "efp_barley",
+    "efprice": "efp_rice",
+    "efpmedicago": "efp_medicago",
+    "efppop": "efp_poplar",
+    "efpsoybean": "efp_soybean",
+    "maizeefp": "efp_maize",
+}
+for _alias, _canonical in _PROJECT_ALIASES.items():
+    EFP_PROJECT_REGEXES[_alias] = EFP_PROJECT_REGEXES[_canonical]
 
 # General injection guard, run before any per-project/probeset format check.
 # A handful of eFP projects accept loose freeform text (metabolite/enzyme/trait

api/utils/bar_utils.py

@@ -60,7 +60,8 @@ CREATE TABLE `sample_lookup` (
   `sample_id` varchar(45) NOT NULL,
   `dataset` varchar(45) DEFAULT NULL,
   `dataset_sample` varchar(45) DEFAULT NULL,
-  PRIMARY KEY (`sample_id`)
+  PRIMARY KEY (`sample_id`),
+  CONSTRAINT `sample_id` FOREIGN KEY (`sample_id`) REFERENCES `snps_reference` (`sample_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
 /*!40101 SET character_set_client = @saved_cs_client */;
 

config/databases/soybean_nssnp.sql

@@ -34,7 +34,8 @@ CREATE TABLE `lines_lookup` (
   `lines_id` varchar(45) NOT NULL,
   `species` varchar(35) DEFAULT NULL,
   `alias` varchar(35) DEFAULT NULL,
-  PRIMARY KEY (`lines_id`)
+  PRIMARY KEY (`lines_id`),
+  CONSTRAINT `lines_id` FOREIGN KEY (`lines_id`) REFERENCES `snps_reference` (`sample_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;
 /*!40101 SET character_set_client = @saved_cs_client */;