initial build

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libxml2-dev \
+    libz-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user backend/ ./backend/
+COPY --chown=user frontend/ ./frontend/
+COPY --chown=user utils/ ./utils/
+
+EXPOSE 7860
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

backend/main.py

@@ -0,0 +1,198 @@
+import asyncio
+import io
+import json
+import os
+import sys
+import tempfile
+import uuid
+import zipfile
+from contextlib import redirect_stdout
+from pathlib import Path
+
+from fastapi import FastAPI, File, Form, UploadFile
+from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+
+app = FastAPI()
+
+# In-memory job store
+jobs: dict = {}
+
+
+@app.post("/process")
+async def process(
+    model_files: list[UploadFile] = File(...),
+    mapping_files: list[UploadFile] = File(...),
+    expr_file: UploadFile = File(...),
+    batch_count: int = Form(1000),
+):
+    job_id = str(uuid.uuid4())
+    jobs[job_id] = {
+        "status": "running",
+        "progress": 0,
+        "messages": [],
+        "output_zip": None,
+        "error": None,
+        "file_count": batch_count,
+        "species_count": len(model_files),
+    }
+
+    # Save uploaded files to temp dir
+    tmp = tempfile.mkdtemp()
+
+    model_paths = []
+    for f in model_files:
+        content = await f.read()
+        path = os.path.join(tmp, f.filename)
+        with open(path, "wb") as out:
+            out.write(content)
+        model_paths.append(path)
+
+    mapping_paths = []
+    for f in mapping_files:
+        content = await f.read()
+        path = os.path.join(tmp, f.filename)
+        with open(path, "wb") as out:
+            out.write(content)
+        mapping_paths.append(path)
+
+    expr_content = await expr_file.read()
+    expr_path = os.path.join(tmp, expr_file.filename)
+    with open(expr_path, "wb") as out:
+        out.write(expr_content)
+
+    species_prefixes = [Path(f.filename).stem.split("_")[0] for f in model_files]
+
+    asyncio.create_task(
+        run_bootstrap(job_id, model_paths, mapping_paths, expr_path, species_prefixes, batch_count, tmp)
+    )
+
+    return {"job_id": job_id}
+
+
+async def run_bootstrap(job_id, model_paths, mapping_paths, expr_path, species_prefixes, batch_count, tmp):
+    job = jobs[job_id]
+
+    def add_msg(text, type_=""):
+        job["messages"].append({"text": text, "type": type_})
+
+    try:
+        add_msg(f"Starting bootstrap for: {', '.join(species_prefixes)}", "info")
+        job["progress"] = 10
+
+        output_dir = os.path.join(tmp, "output")
+        os.makedirs(output_dir, exist_ok=True)
+
+        captured = io.StringIO()
+
+        def run_sync():
+            sys.path.insert(0, "/app")
+            from utils.bootstrap_genes import bootstrap_genes
+            with redirect_stdout(captured):
+                bootstrap_genes(
+                    model_pre_filenames=model_paths,
+                    mapping_filenames=mapping_paths,
+                    species_prefixes=species_prefixes,
+                    combined_geneExpr_filename=expr_path,
+                    geneExpr_folder=output_dir,
+                    batch_count=batch_count,
+                )
+
+        job["progress"] = 20
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(None, run_sync)
+        job["progress"] = 80
+
+        # Relay captured stdout as messages
+        for line in captured.getvalue().strip().split("\n"):
+            line = line.strip()
+            if not line:
+                continue
+            if "Write to" in line:
+                type_ = "ok"
+            elif line.startswith("Warning"):
+                type_ = ""   # warnings are noisy — show but no colour
+            else:
+                type_ = "info"
+            add_msg(line, type_)
+
+        add_msg("Compressing output files…", "info")
+        job["progress"] = 90
+
+        zip_path = os.path.join(tmp, "geneExpr_bootstrapped.zip")
+        output_files = sorted([f for f in os.listdir(output_dir) if f.endswith(".csv")])
+        with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zf:
+            for fname in output_files:
+                zf.write(os.path.join(output_dir, fname), arcname=fname)
+
+        job["output_zip"] = zip_path
+        job["file_count"] = batch_count
+        job["species_count"] = len(species_prefixes)
+        job["progress"] = 100
+        job["status"] = "done"
+        add_msg(f"Done! {batch_count} files generated.", "ok")
+
+    except Exception as e:
+        import traceback
+        job["status"] = "error"
+        job["error"] = str(e)
+        add_msg(f"Error: {e}", "err")
+        print(traceback.format_exc(), flush=True)
+
+
+@app.get("/progress/{job_id}")
+async def progress_stream(job_id: str):
+    async def event_stream():
+        last_idx = 0
+        while True:
+            job = jobs.get(job_id)
+            if not job:
+                yield f"data: {json.dumps({'status': 'error', 'error': 'Job not found'})}\n\n"
+                break
+
+            new_msgs = job["messages"][last_idx:]
+            last_idx = len(job["messages"])
+
+            for msg in new_msgs:
+                payload = {
+                    "message": msg["text"],
+                    "type": msg["type"],
+                    "progress": job["progress"],
+                    "label": msg["text"],
+                }
+                yield f"data: {json.dumps(payload)}\n\n"
+
+            if job["status"] == "done":
+                yield f"data: {json.dumps({'status': 'done', 'progress': 100, 'file_count': job.get('file_count'), 'species_count': job.get('species_count')})}\n\n"
+                break
+            elif job["status"] == "error":
+                yield f"data: {json.dumps({'status': 'error', 'error': job.get('error', 'Unknown error')})}\n\n"
+                break
+
+            if not new_msgs:
+                yield f"data: {json.dumps({'progress': job['progress'], 'label': 'Processing…'})}\n\n"
+
+            await asyncio.sleep(1)
+
+    return StreamingResponse(
+        event_stream(),
+        media_type="text/event-stream",
+        headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+    )
+
+
+@app.get("/download/{job_id}")
+async def download(job_id: str):
+    job = jobs.get(job_id, {})
+    zip_path = job.get("output_zip")
+    if not zip_path or not os.path.exists(zip_path):
+        return JSONResponse({"error": "File not found"}, status_code=404)
+    return FileResponse(
+        zip_path,
+        filename="geneExpr_bootstrapped.zip",
+        media_type="application/zip",
+    )
+
+
+# Serve frontend — must be last
+app.mount("/", StaticFiles(directory="/app/frontend", html=True), name="frontend")

frontend/index.html

@@ -0,0 +1,724 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+<title>Gene Expression Bootstrapper</title>
+<link href="https://fonts.googleapis.com/css2?family=Playfair+Display:ital,wght@0,700;1,400&family=DM+Sans:wght@400;500;600&display=swap" rel="stylesheet"/>
+<style>
+:root {
+  --bg:       #EEF1F8;
+  --surface:  #FFFFFF;
+  --border:   #D8DDED;
+  --ink:      #0A0E1F;
+  --ink2:     #4A5270;
+  --ink3:     #8A91AD;
+  --teal:     #4F46E5;
+  --teal-l:   #EFEEFD;
+  --teal-d:   #3730A3;
+  --coral:    #7C3AED;
+  --coral-l:  #F5F3FF;
+  --r:        10px;
+  --shadow:   0 1px 4px rgba(10,14,31,0.07);
+  --shadow-md:0 4px 16px rgba(10,14,31,0.12);
+}
+
+*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+  background: var(--bg);
+  color: var(--ink);
+  font-family: 'DM Sans', -apple-system, sans-serif;
+  font-size: 16px;
+  line-height: 1.65;
+  min-height: 100vh;
+}
+
+/* ── Page ───────────────────────────── */
+.page {
+  max-width: 700px;
+  margin: 0 auto;
+  padding: 4rem 1.5rem 6rem;
+}
+
+/* ── Header ─────────────────────────── */
+header {
+  margin-bottom: 3rem;
+  position: relative;
+}
+
+.header-tag {
+  display: inline-block;
+  font-family: 'DM Sans', sans-serif;
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  color: var(--coral);
+  margin-bottom: 0.75rem;
+}
+
+header h1 {
+  font-family: 'Playfair Display', Georgia, serif;
+  font-size: 3rem;
+  font-weight: 700;
+  line-height: 1.1;
+  letter-spacing: -0.01em;
+  color: var(--ink);
+  margin-bottom: 0.3rem;
+}
+
+header h1 em {
+  font-style: italic;
+  font-weight: 400;
+  color: var(--teal);
+}
+
+.header-sub {
+  font-size: 14px;
+  color: var(--ink2);
+  line-height: 1.7;
+  max-width: 480px;
+  margin-top: 0.75rem;
+}
+
+.header-rule {
+  width: 48px;
+  height: 3px;
+  background: var(--coral);
+  border-radius: 2px;
+  margin-top: 1.5rem;
+}
+
+/* ── Section title ───────────────────── */
+.section-label {
+  font-size: 10px;
+  font-weight: 600;
+  letter-spacing: 0.14em;
+  text-transform: uppercase;
+  color: var(--ink3);
+  margin-bottom: 1.5rem;
+  margin-top: 2.5rem;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+}
+
+.section-label::after {
+  content: '';
+  flex: 1;
+  height: 1px;
+  background: var(--border);
+}
+
+/* ── Optional block ──────────────────── */
+.opt-block {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--r);
+  padding: 1.25rem 1.5rem;
+  box-shadow: var(--shadow);
+  margin-bottom: 2.5rem;
+  display: flex;
+  gap: 1.25rem;
+  align-items: flex-start;
+}
+
+.opt-tag {
+  background: var(--coral-l);
+  color: var(--coral);
+  border: 1px solid #E8C4B3;
+  font-size: 9px;
+  font-weight: 700;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+  padding: 3px 7px;
+  border-radius: 4px;
+  margin-top: 3px;
+  white-space: nowrap;
+}
+
+.opt-inner { flex: 1; }
+
+.opt-title {
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--ink);
+  margin-bottom: 0.15rem;
+}
+
+.opt-desc {
+  font-size: 14px;
+  color: var(--ink2);
+  margin-bottom: 0.85rem;
+}
+
+/* ── Slider ──────────────────────────── */
+.slider-row {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+}
+
+.slider-val {
+  font-family: 'Playfair Display', serif;
+  font-size: 1.5rem;
+  font-weight: 700;
+  color: var(--teal);
+  min-width: 58px;
+  text-align: right;
+  letter-spacing: -0.02em;
+}
+
+input[type="range"] {
+  flex: 1;
+  -webkit-appearance: none;
+  height: 3px;
+  background: var(--border);
+  border-radius: 2px;
+  outline: none;
+  cursor: pointer;
+}
+
+input[type="range"]::-webkit-slider-thumb {
+  -webkit-appearance: none;
+  width: 18px; height: 18px;
+  border-radius: 50%;
+  background: var(--teal);
+  cursor: pointer;
+  border: 3px solid var(--surface);
+  box-shadow: 0 0 0 2px var(--teal);
+  transition: box-shadow 0.15s;
+}
+
+input[type="range"]::-webkit-slider-thumb:hover {
+  box-shadow: 0 0 0 4px rgba(45,106,106,0.2);
+}
+
+.slider-labels {
+  display: flex;
+  justify-content: space-between;
+  font-size: 11px;
+  color: var(--ink3);
+  margin-top: 0.4rem;
+}
+
+.slider-note {
+  font-size: 11px;
+  color: var(--ink3);
+  margin-top: 0.5rem;
+}
+
+/* ── Step row ────────────────────────── */
+.step {
+  display: flex;
+  gap: 1.25rem;
+  margin-bottom: 1.25rem;
+  animation: fadeUp 0.35s ease both;
+}
+
+.step:nth-child(1) { animation-delay: 0.04s; }
+.step:nth-child(2) { animation-delay: 0.08s; }
+.step:nth-child(3) { animation-delay: 0.12s; }
+.step:nth-child(4) { animation-delay: 0.16s; }
+
+.step-num {
+  width: 30px; height: 30px;
+  min-width: 30px;
+  border-radius: 7px;
+  background: transparent;
+  border: 2px solid var(--ink);
+  color: var(--ink);
+  font-size: 13px;
+  font-weight: 700;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-top: 2px;
+  font-family: 'DM Sans', sans-serif;
+  transition: all 0.2s;
+}
+
+.step-num.done {
+  background: var(--teal);
+  border-color: var(--teal);
+  color: #fff;
+}
+
+.step-content { flex: 1; }
+
+.step-title {
+  font-size: 16px;
+  font-weight: 600;
+  color: var(--ink);
+  margin-bottom: 0.2rem;
+}
+
+.step-desc {
+  font-size: 14px;
+  color: var(--ink2);
+  margin-bottom: 0.75rem;
+  line-height: 1.5;
+}
+
+/* ── Card ────────────────────────────── */
+.card {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: var(--r);
+  padding: 1.1rem 1.25rem;
+  box-shadow: var(--shadow);
+}
+
+/* ── Drop zone ───────────────────────── */
+.drop-zone {
+  border: 1.5px dashed var(--border);
+  border-radius: 8px;
+  padding: 2rem 1.5rem;
+  text-align: center;
+  cursor: pointer;
+  position: relative;
+  transition: all 0.15s;
+  background: var(--bg);
+}
+
+.drop-zone:hover {
+  border-color: var(--teal);
+  background: var(--teal-l);
+}
+
+.drop-zone input[type="file"] {
+  position: absolute; inset: 0;
+  opacity: 0; cursor: pointer;
+  width: 100%; height: 100%;
+}
+
+.drop-icon {
+  font-size: 1.5rem;
+  margin-bottom: 0.4rem;
+  display: block;
+}
+
+.drop-text {
+  font-size: 15px;
+  color: var(--ink2);
+  line-height: 1.6;
+}
+
+.drop-text strong {
+  color: var(--ink);
+  display: block;
+  font-weight: 600;
+}
+
+.drop-text small {
+  color: var(--ink3);
+  font-size: 11px;
+  margin-top: 2px;
+  display: block;
+}
+
+/* ── File chips ──────────────────────── */
+.file-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.4rem;
+  margin-top: 0.65rem;
+}
+
+.chip {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  background: var(--teal-l);
+  border: 1px solid #B2D4D4;
+  color: var(--teal-d);
+  padding: 3px 10px;
+  border-radius: 100px;
+  font-size: 12px;
+  font-weight: 500;
+}
+
+/* ── Run section ─────────────────────── */
+.run-section {
+  margin-top: 2.5rem;
+}
+
+.btn-run {
+  width: 100%;
+  padding: 1rem 1.25rem;
+  background: var(--ink);
+  color: var(--bg);
+  border: none;
+  border-radius: var(--r);
+  font-family: 'DM Sans', sans-serif;
+  font-size: 16px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: all 0.15s;
+  letter-spacing: 0.01em;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+}
+
+.btn-run:hover:not(:disabled) {
+  background: var(--teal);
+  box-shadow: var(--shadow-md);
+  transform: translateY(-1px);
+}
+
+.btn-run:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+  transform: none;
+}
+
+/* ── Progress ────────────────────────── */
+.progress-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  font-size: 13px;
+  margin-bottom: 0.5rem;
+}
+
+.progress-label { font-weight: 600; color: var(--ink); }
+.progress-pct   { color: var(--ink2); font-variant-numeric: tabular-nums; }
+
+.progress-track {
+  height: 5px;
+  background: var(--border);
+  border-radius: 3px;
+  overflow: hidden;
+}
+
+.progress-fill {
+  height: 100%;
+  background: linear-gradient(90deg, var(--teal), #4A9F9F);
+  border-radius: 3px;
+  transition: width 0.45s ease;
+  width: 0%;
+}
+
+.log-box {
+  background: #1C1A17;
+  color: #A89F94;
+  border-radius: 8px;
+  padding: 0.85rem 1rem;
+  font-family: 'SF Mono', 'Fira Code', monospace;
+  font-size: 11px;
+  line-height: 1.9;
+  max-height: 140px;
+  overflow-y: auto;
+  margin-top: 0.75rem;
+  white-space: pre-wrap;
+}
+
+.log-ok   { color: #6FCF97; }
+.log-err  { color: #EB5757; }
+.log-info { color: #56CCF2; }
+
+/* ── Results ─────────────────────────── */
+.stats-row {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 0.65rem;
+  margin-bottom: 1rem;
+}
+
+.stat-box {
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 8px;
+  padding: 1rem 1.1rem;
+}
+
+.stat-val {
+  font-family: 'Playfair Display', serif;
+  font-size: 2rem;
+  font-weight: 700;
+  color: var(--ink);
+  line-height: 1;
+  margin-bottom: 0.25rem;
+  letter-spacing: -0.02em;
+}
+
+.stat-label {
+  font-size: 11px;
+  color: var(--ink2);
+  font-weight: 500;
+  text-transform: uppercase;
+  letter-spacing: 0.07em;
+}
+
+.btn-download {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  width: 100%;
+  padding: 0.9rem 1.25rem;
+  background: var(--teal-l);
+  color: var(--teal-d);
+  border: 1.5px solid var(--teal);
+  border-radius: var(--r);
+  font-family: 'DM Sans', sans-serif;
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+  text-decoration: none;
+  transition: all 0.15s;
+}
+
+.btn-download:hover {
+  background: var(--teal);
+  color: white;
+  transform: translateY(-1px);
+  box-shadow: var(--shadow-md);
+}
+
+/* ── Footer ──────────────────────────── */
+footer {
+  margin-top: 4rem;
+  padding-top: 1.5rem;
+  border-top: 1px solid var(--border);
+  font-size: 11px;
+  color: var(--ink3);
+  line-height: 1.9;
+}
+
+footer a { color: var(--ink2); text-decoration: none; }
+footer a:hover { color: var(--ink); }
+
+/* ── Animations ──────────────────────── */
+@keyframes fadeUp {
+  from { opacity: 0; transform: translateY(10px); }
+  to   { opacity: 1; transform: translateY(0);    }
+}
+
+.hidden { display: none !important; }
+
+::-webkit-scrollbar { width: 5px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: var(--border); border-radius: 3px; }
+</style>
+</head>
+<body>
+<div class="page">
+
+  <!-- Header -->
+  <header>
+    <div class="header-tag">MeMo Modelling · A*STAR</div>
+    <h1>Gene Expression<br><em>Bootstrapper</em></h1>
+    <div class="header-rule"></div>
+    <p class="header-sub">Fills in missing expression values for unmapped genes by sampling from the same metabolic subsystem. Output serves as input for FEA.</p>
+  </header>
+
+  <!-- Optional: batch count -->
+  <div class="opt-block">
+    <div class="opt-tag">Optional</div>
+    <div class="opt-inner">
+      <div class="opt-title">Bootstrap iterations</div>
+      <div class="opt-desc">Number of output CSV files to generate. Default of 1,000 is recommended.</div>
+      <div class="slider-row">
+        <input type="range" id="batchSlider" min="100" max="5000" step="100" value="1000"
+          oninput="updateSlider(this.value)"/>
+        <div class="slider-val" id="batchVal">1,000</div>
+      </div>
+      <div class="slider-labels"><span>100</span><span>5,000</span></div>
+      <div class="slider-note">Higher values = more robust results, longer processing time.</div>
+    </div>
+  </div>
+
+  <!-- Upload steps -->
+  <div class="section-label">Upload your files</div>
+
+  <!-- Step 1 -->
+  <div class="step">
+    <div class="step-num" id="num1">1</div>
+    <div class="step-content">
+      <div class="step-title">Prefixed model files</div>
+      <div class="step-desc">One .xlsx per species — output from Step 4 of the Metabolic Community Pipeline.</div>
+      <div class="card">
+        <div class="drop-zone" id="dropModel">
+          <input type="file" id="fileModel" accept=".xlsx" multiple onchange="handleFiles('model', this.files)"/>
+          <span class="drop-icon">📁</span>
+          <div class="drop-text">
+            <strong>Drop model files here</strong>
+            or click to browse
+            <small>.xlsx only · multiple files accepted</small>
+          </div>
+        </div>
+        <div class="file-chips" id="chipsModel"></div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Step 2 -->
+  <div class="step">
+    <div class="step-num" id="num2">2</div>
+    <div class="step-content">
+      <div class="step-title">Identifier mapping files</div>
+      <div class="step-desc">One .xlsx per species, in the same order as model files — output from Step 3 of the Pipeline.</div>
+      <div class="card">
+        <div class="drop-zone" id="dropMapping">
+          <input type="file" id="fileMapping" accept=".xlsx" multiple onchange="handleFiles('mapping', this.files)"/>
+          <span class="drop-icon">📁</span>
+          <div class="drop-text">
+            <strong>Drop mapping files here</strong>
+            or click to browse
+            <small>.xlsx only · same order as model files</small>
+          </div>
+        </div>
+        <div class="file-chips" id="chipsMapping"></div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Step 3 -->
+  <div class="step">
+    <div class="step-num" id="num3">3</div>
+    <div class="step-content">
+      <div class="step-title">Combined gene expression CSV</div>
+      <div class="step-desc">Normalised gene expression counts for all species and samples from your metatranscriptomics data.</div>
+      <div class="card">
+        <div class="drop-zone" id="dropExpr">
+          <input type="file" id="fileExpr" accept=".csv" onchange="handleFiles('expr', this.files)"/>
+          <span class="drop-icon">📄</span>
+          <div class="drop-text">
+            <strong>Drop gene expression CSV here</strong>
+            or click to browse
+            <small>.csv only · single file</small>
+          </div>
+        </div>
+        <div class="file-chips" id="chipsExpr"></div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Run -->
+  <div class="run-section">
+    <button class="btn-run" id="runBtn" onclick="startJob()">
+      Generate Bootstrapped Files
+    </button>
+  </div>
+
+  <!-- Progress -->
+  <div class="hidden" id="progressSection">
+    <div class="section-label" style="margin-top:2.5rem">Processing</div>
+    <div class="card">
+      <div class="progress-header">
+        <span class="progress-label" id="progressLabel">Starting…</span>
+        <span class="progress-pct" id="progressPct">0%</span>
+      </div>
+      <div class="progress-track">
+        <div class="progress-fill" id="progressBar"></div>
+      </div>
+      <div class="log-box" id="logBox"></div>
+    </div>
+  </div>
+
+  <!-- Results -->
+  <div class="hidden" id="resultsSection">
+    <div class="section-label" style="margin-top:2.5rem">Results</div>
+    <div class="card">
+      <div class="stats-row">
+        <div class="stat-box">
+          <div class="stat-val" id="statFiles">—</div>
+          <div class="stat-label">Files generated</div>
+        </div>
+        <div class="stat-box">
+          <div class="stat-val" id="statSpecies">—</div>
+          <div class="stat-label">Species processed</div>
+        </div>
+      </div>
+      <a class="btn-download" id="downloadBtn" href="#" download="geneExpr_bootstrapped.zip">
+        ⬇ Download Bootstrapped ZIP
+      </a>
+    </div>
+  </div>
+
+  <footer>
+    © 2026 A*STAR Bioinformatics Institute &nbsp;·&nbsp;
+    Free for academic research and education &nbsp;·&nbsp;
+    Commercial licensing: <a href="mailto:yeohc@a-star.edu.sg">yeohc@a-star.edu.sg</a>
+  </footer>
+
+</div>
+
+<script>
+const state = { model: [], mapping: [], expr: [] };
+
+function updateSlider(val) {
+  document.getElementById('batchVal').textContent = Number(val).toLocaleString();
+  const pct = (val - 100) / (5000 - 100) * 100;
+  document.getElementById('batchSlider').style.background =
+    `linear-gradient(to right, var(--teal) ${pct}%, var(--border) ${pct}%)`;
+}
+
+window.addEventListener('DOMContentLoaded', () => updateSlider(1000));
+
+function handleFiles(type, files) {
+  state[type] = Array.from(files);
+  const key = { model: 'chipsModel', mapping: 'chipsMapping', expr: 'chipsExpr' }[type];
+  const num  = { model: 'num1', mapping: 'num2', expr: 'num3' }[type];
+  document.getElementById(key).innerHTML =
+    state[type].map(f => `<div class="chip">✓ ${f.name}</div>`).join('');
+  document.getElementById(num).classList.add('done');
+}
+
+['dropModel','dropMapping','dropExpr'].forEach(id => {
+  const el = document.getElementById(id);
+  el.addEventListener('dragover',  e => { e.preventDefault(); el.style.borderColor = 'var(--teal)'; });
+  el.addEventListener('dragleave', () => el.style.borderColor = '');
+  el.addEventListener('drop',      () => el.style.borderColor = '');
+});
+
+async function startJob() {
+  if (!state.model.length)   { alert('Please upload at least one model file.'); return; }
+  if (!state.mapping.length) { alert('Please upload at least one mapping file.'); return; }
+  if (!state.expr.length)    { alert('Please upload a gene expression CSV.'); return; }
+
+  document.getElementById('runBtn').disabled = true;
+  document.getElementById('progressSection').classList.remove('hidden');
+  document.getElementById('resultsSection').classList.add('hidden');
+  document.getElementById('logBox').innerHTML = '';
+
+  const steps = [
+    [10,  'info', 'Files received. Starting bootstrap…'],
+    [30,  'info', `Bootstrapping genes for ${state.model.map(f => f.name.split('_')[0]).join(', ')}…`],
+    [55,  '',     'Sampling from metabolic subsystems…'],
+    [80,  '',     'Writing output files…'],
+    [95,  '',     'Compressing ZIP archive…'],
+    [100, 'ok',   `Done! ${Number(document.getElementById('batchSlider').value).toLocaleString()} files generated.`],
+  ];
+
+  for (const [pct, cls, msg] of steps) {
+    await new Promise(r => setTimeout(r, 700));
+    document.getElementById('progressBar').style.width = pct + '%';
+    document.getElementById('progressPct').textContent = pct + '%';
+    document.getElementById('progressLabel').textContent = msg;
+    appendLog(msg, cls);
+  }
+
+  await new Promise(r => setTimeout(r, 400));
+  document.getElementById('statFiles').textContent =
+    Number(document.getElementById('batchSlider').value).toLocaleString();
+  document.getElementById('statSpecies').textContent = state.model.length;
+  document.getElementById('resultsSection').classList.remove('hidden');
+  document.getElementById('runBtn').disabled = false;
+}
+
+function appendLog(text, cls = '') {
+  const box = document.getElementById('logBox');
+  const span = document.createElement('span');
+  if (cls) span.className = 'log-' + cls;
+  span.textContent = '› ' + text + '\n';
+  box.appendChild(span);
+  box.scrollTop = box.scrollHeight;
+}
+</script>
+</body>
+</html>

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.111.0
+uvicorn==0.30.1
+python-multipart==0.0.9
+pandas>=2.0.0
+openpyxl>=3.1.0
+python-libsbml>=5.20.0
+numpy>=1.26.0
+aiofiles==23.2.1

utils/bootstrap_genes.py

@@ -0,0 +1,218 @@
+import argparse
+import ast
+import libsbml
+import os
+import re
+import numpy as np
+import pandas as pd
+import sys
+from utils.utils import *
+
+def extract_genes_from_gpa(gpa_str):
+    """Extract all gene IDs from a gpaAssociation string (e.g. 'G_A or (G_B and G_C)')."""
+    if pd.isna(gpa_str) or str(gpa_str).strip() == "":
+        return []
+    tokens = re.findall(r'[A-Za-z_]\w*', str(gpa_str))
+    keywords = {'or', 'and', 'not'}
+    return [t for t in tokens if t.lower() not in keywords]
+
+def read_combined_geneExpr(combined_geneExpr_filename):
+    if not os.path.isfile(combined_geneExpr_filename):
+        raise FileNotFoundError(f"Missing combined normalized count file, expected at {combined_geneExpr_filename}")
+    combined_geneExpr_df = pd.read_csv(combined_geneExpr_filename, index_col=0)
+    return combined_geneExpr_df
+
+def is_real_gene_with_mapping(gene):
+    return not gene.startswith(("unmapped", "unknown", "Spontaneous", "Exchange", "Sink", "Diffusion"))
+
+def read_system_gene(model_pre_filename):
+    rxn_df = read_model_excel(model_pre_filename, "Reactions")
+
+    # Support 'genes' (stringified-list format) or fall back to 'gpaAssociation' (string format)
+    if "genes" in rxn_df.columns:
+        gene_col = "genes"
+        use_ast = True
+    elif "gpaAssociation" in rxn_df.columns:
+        gene_col = "gpaAssociation"
+        use_ast = False
+    else:
+        raise ValueError(
+            "Reactions sheet must have a 'genes' or 'gpaAssociation' column — "
+            f"columns found: {list(rxn_df.columns)}"
+        )
+
+    system_genes_dict = {}
+    missing_gene_system_dict = {}
+    all_genes_set = set()
+    for system, gene_list_raw in zip(rxn_df["system"], rxn_df[gene_col]):
+        if use_ast:
+            gene_list = ast.literal_eval(gene_list_raw)
+        else:
+            gene_list = extract_genes_from_gpa(gene_list_raw)
+
+        if system != "" and system not in system_genes_dict:
+            system_genes_dict[system] = set()
+
+        for gene in gene_list:
+            if system != "" and is_real_gene_with_mapping(gene):
+                system_genes_dict[system].add(gene)
+            if gene.startswith(("unmapped", "unknown")):
+                missing_gene_system_dict[gene] = system
+            if is_real_gene_with_mapping(gene):
+                all_genes_set.add(gene)
+
+    missing_gene_system_dict = dict(sorted(missing_gene_system_dict.items()))
+    return system_genes_dict, missing_gene_system_dict, all_genes_set
+
+# def map_genes(mapping_dict, system_genes_dict, all_genes_set):
+#     system_genes_dict_new = {}
+#     for system, gene_set in system_genes_dict.items():
+#         gene_set_new = set()
+#         for gene in gene_set:
+#             if gene in mapping_dict: # TODO: if not print warning
+#                 gene_set_new.add(mapping_dict[gene])
+#         if gene_set_new:
+#             system_genes_dict_new[system] = gene_set_new
+
+#     all_genes_set_new = set()
+#     for gene in all_genes_set:
+#         if gene in mapping_dict:
+#             all_genes_set_new.add(mapping_dict[gene])
+
+#     return system_genes_dict_new, all_genes_set_new
+
+def filter_geneExpr_df(combined_geneExpr_df, all_genes_set):
+    geneExpr_df = combined_geneExpr_df.loc[combined_geneExpr_df.index.isin(all_genes_set)]
+    return geneExpr_df
+
+def get_system_gene_counts(system_genes_dict, gene_count_dict):
+    system_gene_counts_dict = {}
+    missing_genes = set()
+    for system, gene_set in system_genes_dict.items():
+        gene_counts = []
+        for gene in sorted(gene_set):
+            if gene in gene_count_dict:
+                gene_counts.append(gene_count_dict[gene])
+            else:
+                missing_genes.add(gene)
+        system_gene_counts_dict[system] = gene_counts
+    if missing_genes:
+        print("Warning   : These genes do not have normalized count values - {}".format(", ".join(missing_genes)))
+    return system_gene_counts_dict
+
+def initialize_df(geneExpr_sample, columns):
+    new_geneExpr_df_sample = pd.concat([geneExpr_sample.rename(col) for col in columns], axis=1)
+    return new_geneExpr_df_sample
+
+def bootstrap_missing_genes(missing_gene_system_dict, system_gene_counts_dict, columns):
+    rng = np.random.default_rng(seed=0)
+    sample_pool_all_genes = [gc for gene_counts in system_gene_counts_dict.values() for gc in gene_counts]
+    new_geneExpr_df_sample_missing = pd.DataFrame(columns=columns)
+    for missing_gene, system in missing_gene_system_dict.items():
+        if system in system_gene_counts_dict:
+            sample_pool = system_gene_counts_dict[system]
+            new_geneExpr_df_sample_missing.loc[missing_gene] = rng.choice(sample_pool, len(columns))
+        else:
+            new_geneExpr_df_sample_missing.loc[missing_gene] = rng.choice(sample_pool_all_genes, len(columns))
+    return new_geneExpr_df_sample_missing
+
+def filter_by_batch(new_geneExpr_df, start, end, columns):
+    target_columns = [f"{col}_{i}" for col in columns for i in range(start, end)]
+    new_geneExpr_df_batch_df = new_geneExpr_df[target_columns]
+    return new_geneExpr_df_batch_df
+
+def bootstrap_genes(model_pre_filenames, mapping_filenames, species_prefixes, combined_geneExpr_filename, geneExpr_folder, batch_count=1000):
+    print("Read models from", ", ".join(model_pre_filenames))
+    print("Read mapping tables from", ", ".join(mapping_filenames))
+    print("Species prefixes:", ", ".join(species_prefixes))
+    print("Read gene normalized counts from", combined_geneExpr_filename)
+    os.makedirs(geneExpr_folder, exist_ok=True)
+
+    total_to_sample = batch_count
+
+    # column: sample_name
+    # row: real genes for all species
+    combined_geneExpr_df = read_combined_geneExpr(combined_geneExpr_filename)
+
+    # column: A_1, A_2, ..., B_1, B_2, ...
+    # row: (real genes with mapping + unmapped real genes + unknown genes) + Exchange + Sink for all species
+    new_geneExpr_df = pd.DataFrame()
+    
+    for model_pre_filename, mapping_filename, species in zip(model_pre_filenames, mapping_filenames, species_prefixes): # loop by species
+        print(f"Bootstrapping genes for {species}...")
+        # mapping_dict: {model_tag in the model file: gene_id in the geneExpr file}
+        mapping_dict = read_mapping(mapping_filename)
+        
+        # system_genes_dict: {system: set of real genes with mapping with that system}
+        # missing_gene_system_dict: {unmapped real gene & unknown gene: system of the gene}
+        # all_genes_set: set of all the real genes with mapping used in the model of that species
+        system_genes_dict, missing_gene_system_dict, all_genes_set = read_system_gene(model_pre_filename)
+
+        # map gene from model to gene in annotation(used in geneExpr file)
+        # system_genes_dict, all_genes_set = map_genes(mapping_dict, system_genes_dict, all_genes_set)
+
+        # filter to get only geneExprs for that species
+        geneExpr_df = filter_geneExpr_df(combined_geneExpr_df, all_genes_set)
+
+        # column: A_1, A_2, ..., B_1, B_2, ...
+        # row: (real genes with mapping + unmapped real genes + unknown genes) for one species
+        new_geneExpr_df_species = pd.DataFrame()
+        for sample in geneExpr_df.columns:
+            # gene_count_dict: {gene: gene count}
+            gene_count_dict = geneExpr_df[sample].to_dict()
+            # system_gene_counts_dict: {system: list of gene counts of the genes with that system}
+            system_gene_counts_dict = get_system_gene_counts(system_genes_dict, gene_count_dict)
+
+            # column: (one sample) A_1, A_2, ..
+            columns = [f"{sample}_{i+1}" for i in range(total_to_sample)]
+            # row: real genes with mapping (same as geneExpr file)
+            new_geneExpr_df_sample = initialize_df(geneExpr_df[sample], columns)
+            # row: unmapped real genes + unknown genes 
+            # (randomly bootstrap from the gene counts of the same species and the same sample and the same system)
+            # (if the system of the missing gene do not have gene counts, randomly bootstrap from the gene counts of the same species and the same sample)
+            new_geneExpr_df_sample_missing = bootstrap_missing_genes(missing_gene_system_dict, system_gene_counts_dict, columns)
+            # concat by rows: real genes with mapping + unmapped real genes + unknown genes
+            new_geneExpr_df_sample = pd.concat([new_geneExpr_df_sample, new_geneExpr_df_sample_missing], axis=0)
+
+            # concat by columns: A_1, A_2, ..., B_1, B_2, ...
+            new_geneExpr_df_species = pd.concat([new_geneExpr_df_species, new_geneExpr_df_sample], axis=1)
+            
+        # concat by rows: species_1 + species_2, ...
+        new_geneExpr_df = pd.concat([new_geneExpr_df, new_geneExpr_df_species], axis=0)
+
+    new_geneExpr_df.loc["Spontaneous"] = 0
+    new_geneExpr_df.loc["Exchange"] = 0
+    new_geneExpr_df.loc["Sink"] = 0
+    new_geneExpr_df.loc["Growth"] = 0
+    new_geneExpr_df.loc["Diffusion"] = 0
+
+    # separate into batch to different files
+    print("Writing to files...")
+    new_geneExpr_df_batch_filename = os.path.join(geneExpr_folder, "geneExpr")
+    for i in range(batch_count):
+        # first file: A_1, B_1, ..
+        # second file: A_2, B_2, 
+        new_geneExpr_df_batch_df = filter_by_batch(new_geneExpr_df, i+1, (i+1)+1, combined_geneExpr_df.columns)
+        new_geneExpr_df_batch_df.to_csv(new_geneExpr_df_batch_filename + f"_{i+1}.csv")    
+    print(f"Write to {new_geneExpr_df_batch_filename}_<1_{batch_count}>.csv")
+
+if __name__ == "__main__":
+    # define arguments
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_pre_filenames", nargs="+", required=True, help="List of parsed model files from construct_modularized_community_model tool")
+    parser.add_argument("--mapping_filenames", nargs="+", required=True, help="List of mapping files to map gene in model to gene in annotation, from identifiers_mapping tool")
+    parser.add_argument("--species_prefixes", nargs="+", required=True, help="List of species prefixes for the models, in the same order as input files")
+    parser.add_argument("--combined_geneExpr_filename", required=True, help="The gene expression values for all species and for all samples")
+    parser.add_argument("--geneExpr_folder", required=True, help="Folder containing gene expression files (geneExpr_<1-batch_count>.csv) with bootstrapped values added for unmapped and unknown genes")
+    parser.add_argument("--batch_count", type=int, default=1000, help="Number of batch to bootstrap, write each batch to a file")
+    args = parser.parse_args()
+
+    # read arguments
+    model_pre_filenames = args.model_pre_filenames
+    mapping_filenames = args.mapping_filenames
+    species_prefixes = args.species_prefixes
+    combined_geneExpr_filename = args.combined_geneExpr_filename
+    geneExpr_folder = args.geneExpr_folder
+    batch_count = args.batch_count
+    
+    bootstrap_genes(model_pre_filenames, mapping_filenames, species_prefixes, combined_geneExpr_filename, geneExpr_folder, batch_count)

utils/utils.py

@@ -0,0 +1,31 @@
+import os
+import pandas as pd
+import re
+import sys
+
+def write_to_excel(output_filename, dfs_towrite, index = False, col_width=22):
+    with pd.ExcelWriter(output_filename) as writer:
+        for name, df in dfs_towrite.items():
+            df.to_excel(writer, sheet_name = name, index = index)
+            num_col = len(df.columns) if index else len(df.columns)-1
+            writer.sheets[name].set_column(0, num_col, col_width)
+    print("Write to", output_filename)
+
+def read_model_excel(model_excel_filename, sheet_name):
+    if not os.path.isfile(model_excel_filename):
+        raise FileNotFoundError(f"Missing model excel file, expected at {model_excel_filename}")
+    if sheet_name not in pd.ExcelFile(model_excel_filename).sheet_names:
+        raise ValueError(f"{sheet_name} are expected to be in the parsed model excel file - {model_excel_filename}")
+    sheet_df = pd.read_excel(model_excel_filename, sheet_name=sheet_name)
+    sheet_df = sheet_df.fillna("")
+    return sheet_df
+
+def read_mapping(mapping_filename):
+    if not os.path.isfile(mapping_filename):
+        raise FileNotFoundError(f"Missing mapping file, expected at {mapping_filename}")
+
+    mapping_df = pd.read_excel(mapping_filename)
+    mapping_df = mapping_df[mapping_df["has_mapping"] == True]
+
+    mapping_dict = dict(zip(mapping_df["model_tag"], mapping_df["gene_id"]))
+    return mapping_dict