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

genelastic/import_data/random_bundle.py

@@ -1,6 +1,4 @@
-import copy
 import random
-import shutil
 import sys
 import tempfile
 import typing
@@ -8,9 +6,16 @@ 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 (
+from genelastic.common.types import (
     RandomAnalysisData,
     RandomBiProcessData,
     RandomWetProcessData,
@@ -164,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."""
@@ -184,25 +192,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 +237,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 +297,7 @@ class RandomAnalysis(RandomBundleItem):
                 "DUAL228",
                 "DUAL289",
             ],
-            "data_path": str(self._folder),
+            "data_path": str(self._output_dir),
         }
 
 
@@ -289,15 +306,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 +337,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/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

@@ -0,0 +1,20 @@
+from genelastic.common.cli 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, reload_includes=["*.html", "*.js", "*.css"]
+        )
+    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()