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

genelastic/import_data/patterns.py

@@ -0,0 +1,90 @@
+import re
+from pathlib import Path
+
+from genelastic.common.types import Metadata
+from genelastic.import_data.constants import TOOLS_SUFFIX_RE
+
+
+class FilenamePattern:
+    """Utility class to extract metadata from filenames based on a regex
+    pattern.
+    """
+
+    def __init__(self, pattern: str) -> None:
+        """Initializes a FilenamePattern instance.
+
+        :param pattern: The regex pattern used to extract metadata from
+        filenames.
+        """
+        self._re = re.compile(pattern)
+
+    def extract_metadata(self, filename: str) -> Metadata:
+        """Extracts metadata from the given filename using the defined pattern.
+
+        :param filename: The filename from which metadata should be extracted.
+        :raises RuntimeError: If the filename does not match the pattern.
+        :returns: A dictionary containing the extracted metadata.
+        """
+        m = self._re.search(filename)
+        if not m:
+            msg = (
+                f"Failed parsing filename '{filename}' with pattern "
+                f"'{self._re.pattern}'."
+            )
+            raise RuntimeError(msg)
+
+        # Convert necessary values.
+        metadata = m.groupdict()
+        if "cov_depth" in metadata:
+            metadata["cov_depth"] = int(metadata["cov_depth"])
+
+        return metadata
+
+    def matches_pattern(self, filename: str) -> bool:
+        """Checks whether the given filename matches the defined pattern.
+
+        :param filename: The filename to check.
+        :returns: True if the filename matches the pattern, False otherwise.
+        """
+        return bool(self._re.fullmatch(filename))
+
+
+class MetricsPattern:
+    """Utility class to extract tool/version metadata from filenames with a
+    ``.metrics`` suffix.
+    """
+
+    @staticmethod
+    def extract_metadata(file: Path) -> list[dict[str, str]] | None:
+        """Extracts metadata from a filename based on the ``.metrics`` suffix.
+
+        :param file: The path to the file to be analyzed.
+        :raises RuntimeError: If the suffix is malformed or cannot be parsed.
+        :returns:
+            - None if the file does not have a ``.metrics`` prefix,
+            - An empty list if the prefix is present but no metadata is found,
+            - A list of dictionaries with ``tool`` and ``version`` keys if
+                metadata is extracted.
+        """
+        if not file.suffixes or not file.suffixes[0].startswith(".metrics"):
+            return None
+
+        tools_str = file.suffixes[0].replace(".metrics", "")
+        matches = list(re.finditer(TOOLS_SUFFIX_RE, tools_str))
+        matched_str = "".join(m.group(0) for m in matches)
+
+        if matched_str != tools_str:
+            msg = (
+                f"Failed extracting metrics from filename '{file}': "
+                f"'{tools_str}' does not fully match pattern "
+                f"'{TOOLS_SUFFIX_RE}'."
+            )
+            raise RuntimeError(msg)
+
+        return [
+            {
+                "tool": m.group("tool"),
+                "version": m.group("version").replace("-", "."),
+            }
+            for m in matches
+        ]

genelastic/import_data/random_bundle.py

@@ -1,4 +1,3 @@
-import copy
 import random
 import sys
 import tempfile
@@ -16,7 +15,7 @@ from biophony import (
     MutSimParams,
 )
 
-from genelastic.common import (
+from genelastic.common.types import (
     RandomAnalysisData,
     RandomBiProcessData,
     RandomWetProcessData,
@@ -170,13 +169,16 @@ class RandomBiProcess(RandomBundleItem):
 
     def _generate_steps(self) -> None:
         steps_count = random.randint(1, 5)
-        random_steps = copy.deepcopy(random.sample(self.STEPS, steps_count))
-        for random_step in random_steps:
-            random_step["version"] = self._generate_version(
-                random.choice(range(1, 5))
+        random_steps = random.sample(self.STEPS, steps_count)
+        for rs in random_steps:
+            v = self._generate_version(random.choice(range(1, 5)))
+            self._steps.append(
+                {
+                    "version": v,
+                    "name": str(rs["name"]),
+                    "cmd": random.choice(rs["cmd"]),
+                }
             )
-            random_step["cmd"] = random.choice(random_step["cmd"])
-            self._steps.append(random_step)
 
     def to_dict(self) -> RandomBiProcessData:
         """Return the generated bi informatics process as a dictionary."""

genelastic/import_data/resolve.py

@@ -0,0 +1,157 @@
+import logging
+import re
+
+from genelastic.common.exceptions import (
+    FilenamePatternResolveError,
+    InvalidFilePrefixError,
+)
+from genelastic.common.types import Metadata
+from genelastic.import_data.constants import (
+    FILE_SUFFIXES_RE,
+)
+from genelastic.import_data.models.tags import Tags
+from genelastic.import_data.patterns import FilenamePattern
+
+logger = logging.getLogger("genelastic")
+
+
+def validate_file_prefix(file_prefix: str, tags: Tags) -> None:
+    """Validate a filename prefix for correctness.
+
+    The file prefix must be non-empty and contain only defined tags,
+    with no duplicates. If any of these rules are violated, an
+    `InvalidFilePrefixError`` is raised.
+
+    :param file_prefix: The filename prefix containing tags to validate
+        (e.g. ``%S_%F_%W_%B_%D_%R_rep-1``).
+    :param tags: The tag definitions used to verify whether tags are defined.
+    :raises InvalidFilePrefixError: If the file prefix is invalid.
+    """
+    seen_tags = set()
+
+    if not file_prefix:
+        msg = "File prefix is empty."
+        raise InvalidFilePrefixError(msg)
+
+    # Check all tags in the file prefix:
+    # they must be defined and appear only once.
+    for match in re.finditer(tags.search_regex, file_prefix):
+        tag_name = match.group()
+        start = match.start() + 1
+        end = match.end()
+
+        if tag_name not in tags:
+            msg = (
+                f"File prefix '{file_prefix}' has an unknown tag "
+                f"'{tag_name}' at position {start}-{end}."
+            )
+            raise InvalidFilePrefixError(msg)
+
+        if tag_name in seen_tags:
+            msg = (
+                f"File prefix '{file_prefix}' has a duplicated tag "
+                f"'{tag_name}' at position {start}-{end}."
+            )
+            raise InvalidFilePrefixError(msg)
+        seen_tags.add(tag_name)
+
+
+def resolve_analysis_id(
+    file_prefix: str, tags: Tags, metadata: Metadata
+) -> str:
+    """Resolve an analysis identifier from a filename prefix and metadata.
+
+    Each tag in the file prefix is replaced with its corresponding value from
+    ``metadata``.
+
+    :param file_prefix: A filename prefix containing tags
+        (e.g. ``%S_%F_%W_%B_%D_%R_rep-1``).
+    :param tags: The tag definitions used to map tags to metadata fields.
+    :param metadata: A dictionary mapping metadata fields to their values.
+    :return: The resolved analysis identifier string where all tags have been
+        replaced by their metadata values.
+    """
+    analysis_id = file_prefix
+    for match in re.finditer(tags.search_regex, file_prefix):
+        tag_name = match.group()
+        tag_field = tags[tag_name]["field"]
+        analysis_id = analysis_id.replace(tag_name, str(metadata[tag_field]))
+    return analysis_id
+
+
+def resolve_filename_pattern(
+    file_prefix: str,
+    tags: Tags,
+    metadata: Metadata,
+    suffix: str | None = None,
+    *,
+    strict: bool = False,
+) -> FilenamePattern:
+    """Build a regex pattern from a filename prefix containing tags.
+
+    Each tag in the file prefix is replaced with a named capturing group.
+    The group name corresponds to the metadata field associated with the tag,
+    and the group regex is chosen as follows:
+
+    - If the field has a value in ``metadata``, the tag becomes a group that
+        matches exactly this value (e.g. ``(?P<sample_name>HG0003)``).
+    - Otherwise, the tag becomes a group that matches the tag's default regex
+        (e.g. ``(?P<sample_name>[^_]+)``), unless ``strict=True``,
+        in which case a ``FilenamePatternResolveError`` is raised.
+
+    The resulting pattern is anchored at the start and end of the string,
+    includes the optional ``suffix`` if provided, and always appends
+    ``FILE_SUFFIXES_RE`` at the end.
+
+    :param file_prefix: A string containing tags that describe the expected
+        structure of filenames (e.g. ``%S_%F_%W_%B_%D_%R_rep-1``).
+    :param tags: The tag definitions that map tag names to metadata fields
+        and default regexes.
+    :param metadata: Known metadata values used to restrict tag matches when
+        available.
+    :param suffix: Optional suffix to append to the regex after replacing tags.
+    :param strict: If True, all tags must have a corresponding value in
+        ``metadata``; otherwise a ``FilenamePatternResolveError`` exception is
+        raised.
+    :raises FilenamePatternResolveError: If ``strict=True`` and some tag fields
+        are missing from ``metadata``.
+    :return: A ``FilenamePattern`` object encapsulating the compiled regex.
+    """
+    filename_re = file_prefix
+    undefined_fields = []
+
+    # Expand each tag in the file prefix into a named capturing group.
+    # If a metadata value is provided, the group matches it exactly.
+    # Otherwise, fall back to the tag's default regex (or record it as
+    # undefined if strict).
+    for match in re.finditer(tags.search_regex, file_prefix):
+        tag_name = match.group()
+        tag_field = tags[tag_name]["field"]
+        tag_regex = tags[tag_name]["regex"]
+
+        tag_field_value = metadata.get(tag_field)
+        if not tag_field_value and strict:
+            undefined_fields.append(tag_field)
+
+        tag_field_regex = f"(?P<{tag_field}>{tag_field_value or tag_regex})"
+        filename_re = filename_re.replace(tag_name, tag_field_regex)
+
+    if undefined_fields:
+        formatted_fields = ", ".join(sorted(undefined_fields))
+        msg = (
+            f"In file prefix '{file_prefix}': "
+            f"no value in metadata found for field(s): {formatted_fields}. "
+            f"In single-match mode, "
+            f"all fields must have a corresponding value defined."
+        )
+        raise FilenamePatternResolveError(msg)
+
+    # Finalize the regex: append the optional suffix, enforce start (^) and end
+    # ($) anchors, and include FILE_SUFFIXES_RE to capture allowed file
+    # extensions.
+    parts = [f"^{filename_re}"]
+    if suffix:
+        # Avoid double anchors if suffix already ends with '$'.
+        parts.append(suffix.rstrip("$"))
+    parts.append(f"{FILE_SUFFIXES_RE}$")
+    return FilenamePattern("".join(parts))

genelastic/ui/.env

@@ -0,0 +1 @@
+GENUI_API_URL="http://127.0.0.1:8000/api/"

genelastic/ui/cli_start_ui.py

@@ -1,4 +1,4 @@
-from genelastic.common import parse_server_launch_args
+from genelastic.common.cli import parse_server_launch_args
 from genelastic.common.server import start_dev_server, start_prod_server
 
 
@@ -6,7 +6,9 @@ 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)
+        start_dev_server(
+            app_module, args, reload_includes=["*.html", "*.js", "*.css"]
+        )
     elif args.env == "prod":
         start_prod_server(app_module, args)
     else:

genelastic/ui/routes.py

@@ -1,36 +1,65 @@
+from typing import Any
+
 import requests
-from flask import Blueprint, current_app, render_template
+from flask import Blueprint, current_app, render_template, request
 
 routes_bp = Blueprint("routes", __name__)
 
 
+def clean_field_name(field: str) -> str:
+    return field.replace("metadata.", "").replace("_", " ").title()
+
+
 @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 = []
+
+    response = requests.get(
+        f"{api_url}analyses/count_key_value_analyses_index", timeout=20
+    ).json()
+    analyse_count = response.get("result", {})
+
+    response = requests.get(
+        f"{api_url}wet_processes/count_key_value_wet_processes_index",
+        timeout=20,
+    ).json()
+    wet_count = response.get("result", {})
+
+    response = requests.get(
+        f"{api_url}bi_processes/count_key_value_bi_processes_index", timeout=20
+    ).json()
+    bi_count = response.get("result", {})
+
+    total_analyses = (
+        sum(sum(values.values()) for values in analyse_count.values())
+        if analyse_count
+        else 0
+    )
+    total_wet = (
+        sum(sum(values.values()) for values in wet_count.values())
+        if wet_count
+        else 0
+    )
+    total_bi = (
+        sum(sum(values.values()) for values in bi_count.values())
+        if bi_count
+        else 0
+    )
+
+    total_analyses_per_key = {}
+    if analyse_count:
+        for key, values in analyse_count.items():
+            total_analyses_per_key[key] = sum(values.values())
+
     return render_template(
         "home.html",
-        version=version,
-        wet_processes=wet_processes,
-        bi_processes=bi_processes,
-        analyses=analyses,
+        analyse_count=analyse_count,
+        wet_count=wet_count,
+        bi_count=bi_count,
+        total_analyses=total_analyses,
+        total_wet=total_wet,
+        total_bi=total_bi,
+        total_analyses_per_key=total_analyses_per_key,
     )
 
 
@@ -38,49 +67,267 @@ def home() -> str:
 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()
+        response = requests.get(f"{api_url}analyses", timeout=20)
+        analyses = response.json()["result"]
     except requests.exceptions.RequestException:
         analyses = ["Error fetching data."]
 
     return render_template("analyses.html", analyses=analyses)
 
 
-@routes_bp.route("/bi_processes")
+@routes_bp.route("/analysis/<analysis_id>")
+def show_analysis_detail(analysis_id: str) -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+    source = request.args.get(
+        "source"
+    )  # récupère ?source=wet ou ?source=bi si présent
+
+    try:
+        wet_response = requests.get(f"{api_url}wet_processes", timeout=20)
+        bi_response = requests.get(f"{api_url}bi_processes", timeout=20)
+        wet_processes = wet_response.json()["result"]
+        bi_processes = bi_response.json()["result"]
+    except requests.exceptions.RequestException:
+        wet_processes = []
+        bi_processes = []
+
+    matched_wet = [wp for wp in wet_processes if wp in analysis_id]
+    matched_bi = [bp for bp in bi_processes if bp in analysis_id]
+
+    return render_template(
+        "analysis_detail.html",
+        analysis_id=analysis_id,
+        wet_processes=matched_wet,
+        bi_processes=matched_bi,
+        source=source,
+    )
+
+
+@routes_bp.route("/bi_processes", methods=["GET"])
 def show_bi_processes() -> str:
     api_url = current_app.config["GENUI_API_URL"]
+    selected_bi_processes = request.args.getlist("bi_processes")
+
     try:
-        bi_processes_reponse = requests.get(
-            f"{api_url}bi_processes", timeout=20
+        bi_processes, analyses = get_processes_and_analyses(
+            api_url, "bi_processes", selected_bi_processes
         )
-        bi_processes = bi_processes_reponse.json()
     except requests.exceptions.RequestException:
-        bi_processes = ["Error fetching data."]
+        bi_processes = []
+        analyses = []
 
-    return render_template("bi_processes.html", bi_processes=bi_processes)
+    return render_template(
+        "bi_processes.html",
+        bi_processes=bi_processes,
+        selected_bi_processes=selected_bi_processes,
+        analyses=analyses,
+    )
 
 
-@routes_bp.route("/wet_processes")
+@routes_bp.route("/wet_processes", methods=["GET"])
 def show_wet_processes() -> str:
     api_url = current_app.config["GENUI_API_URL"]
+    selected_wet_processes = request.args.getlist("wet_processes")
+
+    try:
+        wet_processes, analyses = get_processes_and_analyses(
+            api_url, "wet_processes", selected_wet_processes
+        )
+    except requests.exceptions.RequestException:
+        wet_processes = []
+        analyses = []
+
+    return render_template(
+        "wet_processes.html",
+        wet_processes=wet_processes,
+        selected_wet_processes=selected_wet_processes,
+        analyses=analyses,
+    )
+
+
+def get_processes_and_analyses(
+    api_url: str, process_type: str, selected_processes: list[str]
+) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    analyses = []
+
+    try:
+        processes_response = requests.get(
+            f"{api_url}{process_type}", timeout=20
+        )
+        processes = processes_response.json()["result"]
+
+        if selected_processes:
+            analyses_response = requests.get(f"{api_url}analyses", timeout=20)
+            all_analyses = analyses_response.json()["result"]
+            analyses = [
+                analysis
+                for analysis in all_analyses
+                if any(process in analysis for process in selected_processes)
+            ]
+    except requests.exceptions.RequestException:
+        processes = []
+        analyses = []
+
+    return processes, analyses
+
+
+@routes_bp.route("/wet_process/details/<wet_process_id>")
+def wet_process_detail(wet_process_id: str) -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+
     try:
-        wet_processes_reponse = requests.get(
-            f"{api_url}wet_processes", timeout=20
+        wet_response = requests.get(
+            f"{api_url}wet_processes/{wet_process_id}", timeout=20
+        )
+        wet_response.raise_for_status()
+        wet_process = wet_response.json()["result"]
+    except requests.exceptions.HTTPError as e:
+        return render_template(
+            "wet_process_detail.html",
+            proc_id=wet_process_id,
+            error=e.response.json(),
         )
-        wet_processes = wet_processes_reponse.json()
+
+    # Récupérer tous les bi-processus pour la sélection
+    try:
+        bi_list_response = requests.get(f"{api_url}bi_processes", timeout=20)
+        bi_processes = bi_list_response.json()["result"]
     except requests.exceptions.RequestException:
-        wet_processes = ["Error fetching data."]
+        bi_processes = []
 
-    return render_template("wet_processes.html", wet_processes=wet_processes)
+    # Si un bi_process_id est présent en paramètre GET, on le charge pour comparaison
+    bi_process_id = request.args.get("compare_with")
+    bi_process_data = None
+    if bi_process_id:
+        try:
+            bi_response = requests.get(
+                f"{api_url}bi_processes/{bi_process_id}", timeout=20
+            )
+            bi_response.raise_for_status()
+            bi_process_data = bi_response.json()["result"]
+        except requests.exceptions.RequestException:
+            bi_process_data = {"error": "Could not fetch bi process"}
+
+    return render_template(
+        "wet_process_detail.html",
+        proc_id=wet_process_id,
+        wet_process=wet_process,
+        bi_processes=bi_processes,
+        selected_bi=bi_process_id,
+        bi_process_data=bi_process_data,
+    )
+
+
+@routes_bp.route("/bi_process/details/<bi_process_id>")
+def bi_process_detail(bi_process_id: str) -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+
+    # Récupérer les données du bi process principal
+    try:
+        response = requests.get(
+            f"{api_url}bi_processes/{bi_process_id}", timeout=20
+        )
+        response.raise_for_status()
+        bi_process = response.json()["result"]
+    except requests.exceptions.HTTPError as e:
+        return render_template(
+            "bi_process_detail.html",
+            proc_id=bi_process_id,
+            error=e.response.json(),
+        )
+
+    # Charger tous les wet processes pour le menu déroulant
+    try:
+        wet_list_response = requests.get(f"{api_url}wet_processes", timeout=20)
+        wet_processes = wet_list_response.json()["result"]
+    except requests.exceptions.RequestException:
+        wet_processes = []
+
+    # Récupérer le wet process sélectionné pour la comparaison
+    wet_process_id = request.args.get("compare_with")
+    wet_process_data = None
+    if wet_process_id:
+        try:
+            wet_response = requests.get(
+                f"{api_url}wet_processes/{wet_process_id}", timeout=20
+            )
+            wet_response.raise_for_status()
+            wet_process_data = wet_response.json()["result"]
+        except requests.exceptions.RequestException:
+            wet_process_data = {"error": "Could not fetch wet process"}
+
+    return render_template(
+        "bi_process_detail.html",
+        proc_id=bi_process_id,
+        bi_process=bi_process,
+        wet_processes=wet_processes,
+        selected_wet=wet_process_id,
+        wet_process_data=wet_process_data,
+    )
 
 
 @routes_bp.route("/version")
-def show_version() -> str:
+def version() -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+    try:
+        response = requests.get(f"{api_url}version", timeout=20)
+        vers = response.json()["result"].get("version", "Version not found")
+    except requests.exceptions.RequestException:
+        vers = "Error fetching version."
+
+    return render_template("version.html", version=vers)
+
+
+@routes_bp.route("/search_analyses")
+def search_analyses() -> dict[str, list[str]]:
     api_url = current_app.config["GENUI_API_URL"]
+    query = request.args.get("q", "").lower()
+
     try:
-        version_reponse = requests.get(f"{api_url}version", timeout=20)
-        version = version_reponse.json().get("version", "Version not found")
+        analyses_response = requests.get(f"{api_url}analyses", timeout=20)
+        analyses = analyses_response.json()["result"]
     except requests.exceptions.RequestException:
-        version = "Error fetching version."
+        return {"results": []}
+
+    filtered = [a for a in analyses if query in a.lower()]
+
+    filtered = filtered[:10]
+
+    return {"results": filtered}
+
+
+@routes_bp.route("/explorer")
+def explorer() -> str:
+    api_url = current_app.config["GENUI_API_URL"]
+
+    try:
+        wet_count = requests.get(
+            f"{api_url}wet_processes/count_key_value_wet_processes_index",
+            timeout=20,
+        ).json()["result"]
+    except requests.exceptions.RequestException:
+        wet_count = {}
+
+    try:
+        bi_count = requests.get(
+            f"{api_url}bi_processes/count_key_value_bi_processes_index",
+            timeout=20,
+        ).json()["result"]
+    except requests.exceptions.RequestException:
+        bi_count = {}
+
+    # Fusionner les deux dictionnaires et exclure les champs contenant "index"
+    metadata_counts: dict[str, dict[str | None, int]] = {}
+
+    for dataset in [wet_count, bi_count]:
+        for key, values in dataset.items():
+            if "index" in key:
+                continue  # on saute les champs techniques
+            if key not in metadata_counts:
+                metadata_counts[key] = {}
+            for val, count in values.items():
+                metadata_counts[key][val] = (
+                    metadata_counts[key].get(val, 0) + count
+                )
 
-    return render_template("version.html", version=version)
+    return render_template("explorer.html", metadata_counts=metadata_counts)