genelastic 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

genelastic/import_data/cli_gen_data.py

@@ -2,6 +2,8 @@ import argparse
 import logging
 from pathlib import Path
 
+from biophony import DEFAULT_RATE, MutSimParams
+
 from genelastic.common import add_verbose_control_args
 
 from .logger import configure_logging
@@ -13,46 +15,45 @@ logger = logging.getLogger("genelastic")
 
 
 def read_args() -> argparse.Namespace:
-    """Read arguments from command line."""
+    """Read arguments from the command line."""
     parser = argparse.ArgumentParser(
-        description="Genetics data random generator.",
+        description="Random bundle generator. "
+        "A bundle is a YAML file format used to import genetic data into an Elasticsearch database. "
+        "It can contain one or more analyses; "
+        "each analysis including metadata, references to "
+        "a wet lab and bioinformatics process "
+        "and paths to a VCF file and optionally to a coverage file.",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
         allow_abbrev=False,
     )
     add_verbose_control_args(parser)
     parser.add_argument(
-        "-d",
-        "--data-folder",
-        dest="data_folder",
-        required=True,
-        help="Data destination folder.",
+        "output_dir",
+        help="Path where analyses VCF and coverage files will be generated.",
         type=Path,
     )
-    parser.add_argument(
-        "--log-file", dest="log_file", help="Path to a log file."
-    )
+    parser.add_argument("--log-file", help="Path to a log file.")
     parser.add_argument(
         "-n",
         "--chrom-nb",
-        dest="chrom_nb",
         type=int,
         default=5,
         help="Number of chromosomes to include in the generated VCF file.",
     )
     parser.add_argument(
         "-o",
-        "--output-yaml-file",
-        dest="output_file",
+        "--output-bundle",
         default=None,
-        help="Output YAML file.",
+        help="Path where the YAML bundle file will be written. "
+        "If no path is provided, the bundle is written to stdout.",
         type=Path,
     )
     parser.add_argument(
-        "-s",
-        "--sequence-size",
+        "-l",
+        "--sequence-length",
         type=int,
         default=2000,
-        help="Sequence size (number of nucleotides) generated for each chromosome.",
+        help="Sequence length (number of nucleotides) generated for each chromosome.",
     )
     parser.add_argument(
         "-c",
@@ -64,7 +65,7 @@ def read_args() -> argparse.Namespace:
         "-a",
         "--analyses",
         help="Number of analyses to generate. "
-        "Each analysis is composed of a YAML bundle file declaring its wet lab and bioinformatics processes, "
+        "Each analysis will reference a wet lab and bioinformatics process, "
         "a VCF file and optionally a coverage file.",
         default=1,
         type=int,
@@ -72,10 +73,31 @@ def read_args() -> argparse.Namespace:
     parser.add_argument(
         "-p",
         "--processes",
-        help="Number of Wet Lab and Bioinformatics processes to generate.",
+        help="Number of wet lab and bioinformatics processes to generate.",
         default=1,
         type=int,
     )
+    parser.add_argument(
+        "-s",
+        "--snp-rate",
+        help="Generated VCF SNP rate.",
+        type=float,
+        default=DEFAULT_RATE,
+    )
+    parser.add_argument(
+        "-i",
+        "--ins-rate",
+        help="Generated VCF insertion rate.",
+        type=float,
+        default=DEFAULT_RATE,
+    )
+    parser.add_argument(
+        "-d",
+        "--del-rate",
+        help="Generated VCF deletion rate.",
+        type=float,
+        default=DEFAULT_RATE,
+    )
     return parser.parse_args()
 
 
@@ -83,10 +105,10 @@ def main() -> None:
     """Entry point of the gen-data script."""
     # Read command line arguments
     args = read_args()
-    folder = args.data_folder.resolve()
+    output_dir = args.output_dir.resolve()
 
-    if not folder.is_dir():
-        msg = f"ERROR: '{folder}' does not exist or is not a directory."
+    if not output_dir.is_dir():
+        msg = f"ERROR: '{output_dir}' does not exist or is not a directory."
         raise SystemExit(msg)
 
     if args.analyses < 1:
@@ -103,13 +125,18 @@ def main() -> None:
 
     # Write to stdout or file
     RandomBundle(
-        folder,
+        output_dir,
         args.analyses,
         args.processes,
         args.chrom_nb,
-        args.sequence_size,
+        args.sequence_length,
+        MutSimParams(
+            snp_rate=args.snp_rate,
+            ins_rate=args.ins_rate,
+            del_rate=args.del_rate,
+        ),
         do_gen_coverage=args.coverage,
-    ).to_yaml(args.output_file)
+    ).to_yaml(args.output_bundle)
 
 
 if __name__ == "__main__":

genelastic/import_data/random_bundle.py

@@ -1,6 +1,5 @@
 import copy
 import random
-import shutil
 import sys
 import tempfile
 import typing
@@ -8,7 +7,14 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 
 import yaml
-from biophony import BioSeqGen, CovGen, Elements, FastaWriter, MutSim
+from biophony import (
+    BioSeqGen,
+    CovGen,
+    Elements,
+    FastaWriter,
+    MutSim,
+    MutSimParams,
+)
 
 from genelastic.common import (
     RandomAnalysisData,
@@ -184,25 +190,39 @@ class RandomBiProcess(RandomBundleItem):
 
 
 class RandomAnalysis(RandomBundleItem):
-    """Generate a random analysis."""
+    """Generate a random analysis.
+
+    :param fasta_dir: Directory where to create the FASTA file used as a basis to generate the analysis VCF file.
+    :param output_dir: Directory where the analysis VCF file
+        (and coverage file if `do_gen_coverage` is set to True) is generated.
+
+    :raises RuntimeError: Could not generate a VCF file with the given simulation parameters.
+    """
 
     def __init__(  # noqa: PLR0913
         self,
-        folder: Path,
+        fasta_dir: Path,
+        output_dir: Path,
         seq_len: int,
         nb_chrom: int,
         wet_proc_id: str,
         bi_proc_id: str,
+        sim_params: MutSimParams,
         *,
         do_gen_coverage: bool,
     ) -> None:
-        self._folder = folder
+        self._fasta_dir = fasta_dir
+        self._output_dir = output_dir
         self._seq_len = seq_len
         self._nb_chrom = nb_chrom
-        self._sample_name = "HG0003"
-        self._source = "CNRGH"
         self._wet_process_id = wet_proc_id
         self._bi_process_id = bi_proc_id
+
+        self._sample_name = "HG000" + str(random.randint(1, 9))
+        sim_params.sample_name = self._sample_name
+        self._sim_params = sim_params
+
+        self._source = "CNRGH"
         self._barcode = self._random_alphanum_str(n=6)
         self._reference_genome = "hg38"
         self._prefix = (
@@ -215,37 +235,32 @@ class RandomAnalysis(RandomBundleItem):
             self.gen_cov_file()
 
     def _gen_vcf_file(self) -> None:
-        """Generate a dummy VCF file."""
-        temp_dir = Path(tempfile.mkdtemp())
-
-        try:
-            fasta_out_file = temp_dir / "seq.fasta"
-            vcf_out_file = self._folder / f"{self._prefix}.vcf"
+        """Generate a dummy VCF file.
 
-            # 1 - Generate a FASTA file and save it to a temporary directory.
-            gen = BioSeqGen(
-                elements=Elements(), seqlen=self._seq_len, count=self._nb_chrom
-            )
-            with fasta_out_file.open("w", encoding="utf-8") as f:
-                FastaWriter(f, header=False).write_seqs(gen)
+        :raises RuntimeError: The call to `mutation-simulator` returned a non-zero exit status.
+        """
+        fasta_out_file = self._fasta_dir / "seq.fasta"
+        vcf_out_file = self._output_dir / f"{self._prefix}.vcf"
 
-            # 2 - Generate a VCF from the previously created FASTA file.
-            MutSim(
-                fasta_file=str(fasta_out_file),
-                vcf_file=str(vcf_out_file),
-                snp_rate=0.02,
-                ins_rate=0.01,
-                del_rate=0.01,
-            ).run()
+        # 1 - Generate a FASTA file and save it to a temporary directory.
+        gen = BioSeqGen(
+            elements=Elements(), seqlen=self._seq_len, count=self._nb_chrom
+        )
+        with fasta_out_file.open("w", encoding="utf-8") as f:
+            FastaWriter(f, header=False).write_seqs(gen)
 
-        finally:
-            shutil.rmtree(temp_dir)
+        # 2 - Generate a VCF from the previously created FASTA file.
+        MutSim(
+            fasta_file=str(fasta_out_file),
+            vcf_file=str(vcf_out_file),
+            sim_params=self._sim_params,
+        ).run()
 
     def gen_cov_file(self) -> None:
         """Generate a dummy coverage file."""
         chrom_end = self._seq_len - 1
 
-        output_path = self._folder / f"{self._prefix}.cov.tsv"
+        output_path = self._output_dir / f"{self._prefix}.cov.tsv"
         with output_path.open("w", encoding="utf-8") as f:
             for chrom in range(1, self._nb_chrom + 1):
                 coverage = CovGen(
@@ -280,7 +295,7 @@ class RandomAnalysis(RandomBundleItem):
                 "DUAL228",
                 "DUAL289",
             ],
-            "data_path": str(self._folder),
+            "data_path": str(self._output_dir),
         }
 
 
@@ -289,15 +304,16 @@ class RandomBundle(RandomBundleItem):
 
     def __init__(  # noqa: PLR0913
         self,
-        folder: Path,
+        output_dir: Path,
         analyses_count: int,
         processes_count: int,
         nb_chrom: int,
         seq_len: int,
+        sim_params: MutSimParams,
         *,
         do_gen_coverage: bool,
     ) -> None:
-        self._folder = folder
+        self._output_dir = output_dir
         self._analyses_count = analyses_count
         self._processes_count = processes_count
         self._nb_chrom = nb_chrom
@@ -319,19 +335,26 @@ class RandomBundle(RandomBundleItem):
             self._bi_processes, self._analyses_count
         )
 
-        self._analyses.extend(
-            [
-                RandomAnalysis(
-                    self._folder,
-                    self._seq_len,
-                    self._nb_chrom,
-                    str(self._assigned_wet_processes[i]["proc_id"]),
-                    str(self._assigned_bi_processes[i]["proc_id"]),
-                    do_gen_coverage=self._do_gen_coverage,
-                ).to_dict()
-                for i in range(self._analyses_count)
-            ]
-        )
+        with tempfile.TemporaryDirectory() as fasta_dir:
+            try:
+                self._analyses.extend(
+                    [
+                        RandomAnalysis(
+                            Path(fasta_dir),
+                            self._output_dir,
+                            self._seq_len,
+                            self._nb_chrom,
+                            str(self._assigned_wet_processes[i]["proc_id"]),
+                            str(self._assigned_bi_processes[i]["proc_id"]),
+                            sim_params,
+                            do_gen_coverage=self._do_gen_coverage,
+                        ).to_dict()
+                        for i in range(self._analyses_count)
+                    ]
+                )
+            except RuntimeError as e:
+                msg = f"VCF file generation for one analysis failed. {e}"
+                raise SystemExit(msg) from None
 
     @staticmethod
     def _assign_processes(

genelastic/ui/cli_start_ui.py

@@ -0,0 +1,18 @@
+from genelastic.common import parse_server_launch_args
+from genelastic.common.server import start_dev_server, start_prod_server
+
+
+def main() -> None:
+    app_module = "genelastic.ui.server:app"
+    args = parse_server_launch_args("Start UI server.", 8001)
+    if args.env == "dev":
+        start_dev_server(app_module, args)
+    elif args.env == "prod":
+        start_prod_server(app_module, args)
+    else:
+        msg = f"Environment '{args.env}' is not implemented."
+        raise NotImplementedError(msg)
+
+
+if __name__ == "__main__":
+    main()

genelastic/ui/routes.py

@@ -0,0 +1,86 @@
+import requests
+from flask import Blueprint, current_app, render_template
+
+routes_bp = Blueprint("routes", __name__)
+
+
+@routes_bp.route("/")
+def home() -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+    try:
+        version_reponse = requests.get(f"{api_url}version", timeout=20)
+        version = version_reponse.json().get("version")
+        wet_processes_reponse = requests.get(
+            f"{api_url}wet_processes", timeout=20
+        )
+        wet_processes = wet_processes_reponse.json()
+        bi_processes_reponse = requests.get(
+            f"{api_url}bi_processes", timeout=20
+        )
+        bi_processes = bi_processes_reponse.json()
+        analyses_reponse = requests.get(f"{api_url}analyses", timeout=20)
+        analyses = analyses_reponse.json()
+    except requests.exceptions.RequestException:
+        version = "API not reachable"
+        wet_processes = []
+        bi_processes = []
+        analyses = []
+    return render_template(
+        "home.html",
+        version=version,
+        wet_processes=wet_processes,
+        bi_processes=bi_processes,
+        analyses=analyses,
+    )
+
+
+@routes_bp.route("/analyses")
+def show_analyses() -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+    try:
+        analyses_reponse = requests.get(f"{api_url}analyses", timeout=20)
+        analyses = analyses_reponse.json()
+    except requests.exceptions.RequestException:
+        analyses = ["Error fetching data."]
+
+    return render_template("analyses.html", analyses=analyses)
+
+
+@routes_bp.route("/bi_processes")
+def show_bi_processes() -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+    try:
+        bi_processes_reponse = requests.get(
+            f"{api_url}bi_processes", timeout=20
+        )
+        bi_processes = bi_processes_reponse.json()
+    except requests.exceptions.RequestException:
+        bi_processes = ["Error fetching data."]
+
+    return render_template("bi_processes.html", bi_processes=bi_processes)
+
+
+@routes_bp.route("/wet_processes")
+def show_wet_processes() -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+    try:
+        wet_processes_reponse = requests.get(
+            f"{api_url}wet_processes", timeout=20
+        )
+        wet_processes = wet_processes_reponse.json()
+    except requests.exceptions.RequestException:
+        wet_processes = ["Error fetching data."]
+
+    return render_template("wet_processes.html", wet_processes=wet_processes)
+
+
+@routes_bp.route("/version")
+def show_version() -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+    try:
+        version_reponse = requests.get(f"{api_url}version", timeout=20)
+        version = version_reponse.json().get("version", "Version not found")
+    except requests.exceptions.RequestException:
+        version = "Error fetching version."
+
+    return render_template("version.html", version=version)

genelastic/ui/server.py

@@ -1,87 +1,14 @@
-import requests
-from flask import Flask, render_template
+from asgiref.wsgi import WsgiToAsgi
+from flask import Flask
 
-app = Flask(__name__)
-app.config.from_object("src.genelastic.ui.settings.Config")
+from .routes import routes_bp
 
 
-@app.route("/")
-def home() -> str:
-    api_url = app.config["GENUI_API_URL"]
-    try:
-        version_reponse = requests.get(f"{api_url}version", timeout=20)
-        version = version_reponse.json().get("version")
-        wet_processes_reponse = requests.get(
-            f"{api_url}wet_processes", timeout=20
-        )
-        wet_processes = wet_processes_reponse.json()
-        bi_processes_reponse = requests.get(
-            f"{api_url}bi_processes", timeout=20
-        )
-        bi_processes = bi_processes_reponse.json()
-        analyses_reponse = requests.get(f"{api_url}analyses", timeout=20)
-        analyses = analyses_reponse.json()
-    except requests.exceptions.RequestException:
-        version = "API not reachable"
-        wet_processes = []
-        bi_processes = []
-        analyses = []
-    return render_template(
-        "home.html",
-        version=version,
-        wet_processes=wet_processes,
-        bi_processes=bi_processes,
-        analyses=analyses,
-    )
+def create_app() -> WsgiToAsgi:
+    flask_app = Flask(__name__)
+    flask_app.config.from_object("genelastic.ui.settings")
+    flask_app.register_blueprint(routes_bp)
+    return WsgiToAsgi(flask_app)  # type: ignore[no-untyped-call]
 
 
-@app.route("/analyses")
-def show_analyses() -> str:
-    api_url = app.config["GENUI_API_URL"]
-    try:
-        analyses_reponse = requests.get(f"{api_url}analyses", timeout=20)
-        analyses = analyses_reponse.json()
-    except requests.exceptions.RequestException:
-        analyses = ["Error fetching data."]
-
-    return render_template("analyses.html", analyses=analyses)
-
-
-@app.route("/bi_processes")
-def show_bi_processes() -> str:
-    api_url = app.config["GENUI_API_URL"]
-    try:
-        bi_processes_reponse = requests.get(
-            f"{api_url}bi_processes", timeout=20
-        )
-        bi_processes = bi_processes_reponse.json()
-    except requests.exceptions.RequestException:
-        bi_processes = ["Error fetching data."]
-
-    return render_template("bi_processes.html", bi_processes=bi_processes)
-
-
-@app.route("/wet_processes")
-def show_wet_processes() -> str:
-    api_url = app.config["GENUI_API_URL"]
-    try:
-        wet_processes_reponse = requests.get(
-            f"{api_url}wet_processes", timeout=20
-        )
-        wet_processes = wet_processes_reponse.json()
-    except requests.exceptions.RequestException:
-        wet_processes = ["Error fetching data."]
-
-    return render_template("wet_processes.html", wet_processes=wet_processes)
-
-
-@app.route("/version")
-def show_version() -> str:
-    api_url = app.config["GENUI_API_URL"]
-    try:
-        version_reponse = requests.get(f"{api_url}version", timeout=20)
-        version = version_reponse.json().get("version", "Version not found")
-    except requests.exceptions.RequestException:
-        version = "Error fetching version."
-
-    return render_template("version.html", version=version)
+app = create_app()

genelastic/ui/settings.py

@@ -3,9 +3,5 @@ from environs import Env
 env = Env()
 env.read_env()
 
-
-class Config:
-    """Flask config class."""
-
-    # Charger toutes les variables d'environnement nécessaires
-    GENUI_API_URL = env.url("GENUI_API_URL").geturl()
+# Charger toutes les variables d'environnement nécessaires
+GENUI_API_URL = env.url("GENUI_API_URL").geturl()

genelastic/ui/templates/analyses.html

@@ -0,0 +1,11 @@
+{% extends "layout.html" %}
+{% block title %}Analyses{% endblock %}
+{% block content %}
+<h2>List of Analyses</h2>
+<ul>
+    {% for analyse in analyses %}
+    <li>{{ analyse }}</li>
+    {% endfor %}
+</ul>
+<a href="/">Back to Home</a>
+{% endblock %}

genelastic/ui/templates/bi_processes.html

@@ -0,0 +1,11 @@
+{% extends "layout.html" %}
+{% block title %}Bi Processes{% endblock %}
+{% block content %}
+<h2>List of Bi Processes</h2>
+<ul>
+    {% for bi_process in bi_processes %}
+    <li>{{ bi_process }}</li>
+    {% endfor %}
+</ul>
+<a href="/">Back to Home</a>
+{% endblock %}

genelastic/ui/templates/home.html

@@ -0,0 +1,4 @@
+{% extends "layout.html" %}
+{% block title %}Home{% endblock %}
+{% block content %}
+{% endblock %}

genelastic/ui/templates/layout.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>{% block title %}Genelastic{% endblock %}</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"
+          rel="stylesheet"
+          integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH"
+          crossorigin="anonymous"
+    >
+
+</head>
+<body>
+<h1>Welcome to DEMO - genelastic UI</h1>
+<nav>
+    <a href="/">Home</a>
+    <a href="/analyses">Analyses</a>
+    <a href="/wet_processes">Wet Processes</a>
+    <a href="/bi_processes">Bi Processes</a>
+    <a href="/version">Version</a>
+</nav>
+<hr>
+<div id="content">
+    {% block content %}{% endblock %}
+</div>
+
+
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js"
+        integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz"
+        crossorigin="anonymous">
+</script>
+</body>
+</html>

genelastic/ui/templates/version.html

@@ -0,0 +1,9 @@
+{% extends "layout.html" %}
+{% block title %}Version{% endblock %}
+{% block content %}
+<h2 class="text-center">Genelastic Version</h2>
+<p class="text-center">{{ version }}</p>
+<div class="mt-4 text-center">
+    <a href="/" class="btn btn-primary">Back to Home</a>
+</div>
+{% endblock %}

genelastic/ui/templates/wet_processes.html

@@ -0,0 +1,11 @@
+{% extends "layout.html" %}
+{% block title %}Wet Processes{% endblock %}
+{% block content %}
+<h2>List of Wet Processes</h2>
+<ul>
+    {% for wet_process in wet_processes %}
+    <li>{{ wet_process }}</li>
+    {% endfor %}
+</ul>
+<a href="/">Back to Home</a>
+{% endblock %}