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

genelastic/import_data/cli_validate.py

@@ -0,0 +1,54 @@
+import argparse
+import logging
+from pathlib import Path
+
+from schema import SchemaError
+
+from genelastic.common import add_verbose_control_args
+
+from .import_bundle_factory import make_import_bundle_from_files
+from .logger import configure_logging
+
+logger = logging.getLogger("genelastic")
+
+
+def read_args() -> argparse.Namespace:
+    """Read arguments from command line."""
+    parser = argparse.ArgumentParser(
+        description="Ensure that YAML files "
+        "follow the genelastic YAML bundle schema.",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        allow_abbrev=False,
+    )
+    add_verbose_control_args(parser)
+    parser.add_argument(
+        "files",
+        type=Path,
+        nargs="+",
+        default=None,
+        help="YAML files to validate.",
+    )
+    parser.add_argument(
+        "-c",
+        "--check",
+        action="store_true",
+        help="In addition to validating the schema, "
+        "check for undefined referenced processes.",
+    )
+    return parser.parse_args()
+
+
+def main() -> int:
+    """Entry point of the validate script."""
+    args = read_args()
+    configure_logging(args.verbose)
+
+    try:
+        make_import_bundle_from_files(args.files, check=args.check)
+    except (ValueError, RuntimeError, TypeError, SchemaError) as e:
+        # Catch any exception that can be raised by 'make_import_bundle_from_files'.
+        logger.error(e)
+        return 1
+
+    logger.info("All YAML files respect the genelastic YAML bundle format.")
+    return 0

genelastic/import_data/constants.py

@@ -1,11 +1,11 @@
-"""
-Module: constants
+"""Module: constants
 
 This module contains genelastic constants.
 """
+
 import typing
 
-ALLOWED_CATEGORIES: typing.Final[typing.List[str]] = ['vcf', 'cov']
+ALLOWED_CATEGORIES: typing.Final[list[str]] = ["vcf", "cov"]
 
 BUNDLE_CURRENT_VERSION = 3
 
@@ -13,33 +13,12 @@ DEFAULT_TAG_REGEX = "[^_-]+"
 DEFAULT_TAG_PREFIX = "%"
 DEFAULT_TAG_SUFFIX = ""
 
-DEFAULT_TAG2FIELD: typing.Final[typing.Dict[str, typing.Dict[str, str]]] = {
-    '%S': {
-        "field": 'sample_name',
-        "regex": DEFAULT_TAG_REGEX
-    },
-    '%F': {
-        "field": 'source',
-        "regex": DEFAULT_TAG_REGEX
-    },
-    '%W': {
-        "field": 'wet_process',
-        "regex": DEFAULT_TAG_REGEX
-    },
-    '%B': {
-        "field": 'bi_process',
-        "regex": DEFAULT_TAG_REGEX
-    },
-    '%D': {
-        "field": 'cov_depth',
-        "regex": DEFAULT_TAG_REGEX
-    },
-    '%A': {
-        "field": 'barcode',
-        "regex": DEFAULT_TAG_REGEX
-    },
-    '%R':  {
-        "field": 'reference_genome',
-        "regex": DEFAULT_TAG_REGEX
-    }
+DEFAULT_TAG2FIELD: typing.Final[dict[str, dict[str, str]]] = {
+    "%S": {"field": "sample_name", "regex": DEFAULT_TAG_REGEX},
+    "%F": {"field": "source", "regex": DEFAULT_TAG_REGEX},
+    "%W": {"field": "wet_process", "regex": DEFAULT_TAG_REGEX},
+    "%B": {"field": "bi_process", "regex": DEFAULT_TAG_REGEX},
+    "%D": {"field": "cov_depth", "regex": DEFAULT_TAG_REGEX},
+    "%A": {"field": "barcode", "regex": DEFAULT_TAG_REGEX},
+    "%R": {"field": "reference_genome", "regex": DEFAULT_TAG_REGEX},
 }

genelastic/import_data/data_file.py

@@ -1,5 +1,4 @@
-"""
-This module defines the DataFile class, which handles the representation,
+"""This module defines the DataFile class, which handles the representation,
 management, and extraction of metadata for a data file within a data bundle.
 
 It includes functionality to construct DataFile instances from paths and
@@ -8,45 +7,47 @@ for extracting metadata from filenames using specified patterns.
 """
 
 import logging
-import os
 import pathlib
-import typing
+from pathlib import Path
 
 from genelastic.common import AnalysisMetaData
 
 from .filename_pattern import FilenamePattern
 
-logger = logging.getLogger('genelastic')
+logger = logging.getLogger("genelastic")
 
 
 class DataFile:
     """Class for handling a data file and its metadata."""
 
     # Initializer
-    def __init__(self, path: str, bundle_path: str | None = None,
-                 metadata: typing.Optional[AnalysisMetaData] = None) -> None:
+    def __init__(
+        self,
+        path: Path,
+        bundle_path: Path | None = None,
+        metadata: AnalysisMetaData | None = None,
+    ) -> None:
         self._path = path
         self._bundle_path = bundle_path  # The bundle YAML file in which this
         # file was listed.
         self._metadata = {} if metadata is None else metadata
 
     def __repr__(self) -> str:
-        return (f"File {self._path}, from bundle {self._bundle_path}"
-                + f", with metadata {self._metadata}")
+        return f"File {self._path}, from bundle {self._bundle_path}, with metadata {self._metadata}"
 
     # Get path
     @property
-    def path(self) -> str:
+    def path(self) -> Path:
         """Retrieve the data file path."""
         return self._path
 
     def exists(self) -> bool:
         """Tests if the associated file exists on disk."""
-        return os.path.isfile(self._path)
+        return self._path.is_file()
 
     # Get bundle path
     @property
-    def bundle_path(self) -> str | None:
+    def bundle_path(self) -> Path | None:
         """Retrieve the path to the associated data bundle file."""
         return self._bundle_path
 
@@ -59,20 +60,22 @@ class DataFile:
     # Factory
     @classmethod
     def make_from_bundle(
-            cls,
-            path: str,
-            bundle_path: str | None,
-            pattern: typing.Optional[FilenamePattern] = None) -> 'DataFile':
+        cls,
+        path: Path,
+        bundle_path: Path | None,
+        pattern: FilenamePattern | None = None,
+    ) -> "DataFile":
         """Construct a DataFile instance from a bundle path, file path,
-        and optional filename pattern."""
+        and optional filename pattern.
+        """
         # Make absolute path
-        if not os.path.isabs(path) and not bundle_path is None:
-            path = os.path.join(os.path.dirname(bundle_path), path)
+        if not path.is_absolute() and bundle_path is not None:
+            path = bundle_path.parent / path
 
         # Extract filename metadata
         metadata = None
         if pattern is not None:
-            metadata = pattern.extract_metadata(os.path.basename(path))
+            metadata = pattern.extract_metadata(path.name)
 
         if metadata:
             if "ext" not in metadata:

genelastic/import_data/filename_pattern.py

@@ -1,14 +1,11 @@
-"""
-This module defines the FilenamePattern class, used to define a filename pattern
+"""This module defines the FilenamePattern class, used to define a filename pattern
 and extract metadata from file names using this pattern.
 """
 
-import logging
 import re
 
 from genelastic.common import AnalysisMetaData
 
-logger = logging.getLogger('genelastic')
 
 class FilenamePattern:
     """Class for defining a filename pattern.
@@ -18,46 +15,43 @@ class FilenamePattern:
 
     # Initializer
     def __init__(self, pattern: str) -> None:
-        """
-                Initializes a FilenamePattern instance.
+        """Initializes a FilenamePattern instance.
 
-                Args:
-                    pattern (str): The pattern string used for defining
-                     the filename pattern.
-                """
+        Args:
+            pattern (str): The pattern string used for defining
+             the filename pattern.
+        """
         self._re = re.compile(pattern)
 
     def extract_metadata(self, filename: str) -> AnalysisMetaData:
-        """
-                Extracts metadata from the given filename based
-                on the defined pattern.
+        """Extracts metadata from the given filename based
+        on the defined pattern.
 
-                Args:
-                    filename (str): The filename from which metadata
-                    needs to be extracted.
+        Args:
+            filename (str): The filename from which metadata
+            needs to be extracted.
 
-                Returns:
-                    dict: A dictionary containing the extracted metadata.
+        Returns:
+            dict: A dictionary containing the extracted metadata.
 
-                Raises:
-                    RuntimeError: If parsing of filename fails
-                    with the defined pattern.
-                """
+        Raises:
+            RuntimeError: If parsing of filename fails
+            with the defined pattern.
+        """
         m = self._re.search(filename)
         if not m:
-            raise RuntimeError(f'Failed parsing filename "{filename}"' +
-                               f'with pattern "{self._re.pattern}".')
+            msg = f'Failed parsing filename "{filename}" with pattern "{self._re.pattern}".'
+            raise RuntimeError(msg)
         return m.groupdict()
 
     def matches_pattern(self, filename: str) -> bool:
-        """
-                Checks if the given filename matches the defined pattern.
+        """Checks if the given filename matches the defined pattern.
 
-                Args:
-                    filename (str): The filename to be checked.
+        Args:
+            filename (str): The filename to be checked.
 
-                Returns:
-                    bool: True if the filename matches the pattern,
-                    False otherwise.
-                """
+        Returns:
+            bool: True if the filename matches the pattern,
+            False otherwise.
+        """
         return bool(self._re.match(filename))

genelastic/import_data/import_bundle.py

@@ -1,5 +1,4 @@
-"""
-Module: import_bundle
+"""Module: import_bundle
 
 This module provides functionality for importing data bundles.
 """
@@ -10,63 +9,68 @@ import typing
 
 from genelastic.common import BundleDict
 
+from .analyses import Analyses
 from .bi_processes import BioInfoProcesses
-from .data_file import DataFile
 from .constants import BUNDLE_CURRENT_VERSION
-from .analyses import Analyses
+from .data_file import DataFile
 from .tags import Tags
 from .wet_processes import WetProcesses
 
-logger = logging.getLogger('genelastic')
+logger = logging.getLogger("genelastic")
 
 
 class ImportBundle:
     """Class for handling an import bundle description."""
 
-    def __init__(self, x: typing.Sequence[BundleDict],
-                 check: bool = False) -> None:
-
-        analyses: typing.List[BundleDict] = []
-        wet_processes: typing.List[BundleDict] = []
-        bi_processes: typing.List[BundleDict] = []
+    def __init__(  # noqa: C901
+        self, x: typing.Sequence[BundleDict], *, check: bool = False
+    ) -> None:
+        analyses: list[BundleDict] = []
+        wet_processes: list[BundleDict] = []
+        bi_processes: list[BundleDict] = []
         tags = Tags(x)
 
         # Loop on dicts
         for d in x:
             # Check version
-            if 'version' not in d:
-                raise RuntimeError("No version inside YAML document.")
-            if int(d['version']) != BUNDLE_CURRENT_VERSION:
-                raise RuntimeError("")
+            if "version" not in d:
+                msg = "No version inside YAML document."
+                raise RuntimeError(msg)
+            if int(d["version"]) != BUNDLE_CURRENT_VERSION:
+                raise RuntimeError
 
             # Gather all analyses
-            if 'analyses' in d and d['analyses'] is not None:
+            if "analyses" in d and d["analyses"] is not None:
                 # Copy some bundle properties into each analysis
-                for analysis in d['analyses']:
-                    for key in ['bundle_file', 'root_dir']:
+                for analysis in d["analyses"]:
+                    for key in ["bundle_file", "root_dir"]:
                         if key in d:
                             analysis[key] = d[key]
 
                     # Add the tags to use.
-                    analysis['tags'] = tags
+                    analysis["tags"] = tags
 
-                analyses.extend(d['analyses'])
+                analyses.extend(d["analyses"])
 
             # If some wet processes are defined, copy the bundle file path into each of them.
-            if 'wet_processes' in d and d['wet_processes'] is not None:
-                for wet_process in d['wet_processes']:
-                    wet_process['bundle_file'] = d['bundle_file']
-                wet_processes.extend(d['wet_processes'])
+            if "wet_processes" in d and d["wet_processes"] is not None:
+                for wet_process in d["wet_processes"]:
+                    wet_process["bundle_file"] = d["bundle_file"]
+                wet_processes.extend(d["wet_processes"])
 
             # If some bio processes are defined, copy the bundle file path into each of them.
-            if 'bi_processes' in d and d['bi_processes'] is not None:
-                for bi_process in d['bi_processes']:
-                    bi_process['bundle_file'] = d['bundle_file']
-                bi_processes.extend(d['bi_processes'])
+            if "bi_processes" in d and d["bi_processes"] is not None:
+                for bi_process in d["bi_processes"]:
+                    bi_process["bundle_file"] = d["bundle_file"]
+                bi_processes.extend(d["bi_processes"])
 
         # Instantiate all objects
-        self._wet_processes: WetProcesses = WetProcesses.from_array_of_dicts(wet_processes)
-        self._bi_processes: BioInfoProcesses = BioInfoProcesses.from_array_of_dicts(bi_processes)
+        self._wet_processes: WetProcesses = WetProcesses.from_array_of_dicts(
+            wet_processes
+        )
+        self._bi_processes: BioInfoProcesses = (
+            BioInfoProcesses.from_array_of_dicts(bi_processes)
+        )
         self._analyses: Analyses = Analyses.from_array_of_dicts(analyses)
 
         if check:
@@ -79,17 +83,27 @@ class ImportBundle:
         for index, analysis in enumerate(self._analyses):
             analysis_wet_process = analysis.metadata.get("wet_process")
 
-            if (analysis_wet_process and
-                    analysis_wet_process not in self._wet_processes.get_process_ids()):
-                sys.exit(f"Analysis at index {index} in file {analysis.bundle_file} "
-                         f"is referencing an undefined wet process: {analysis_wet_process}")
+            if (
+                analysis_wet_process
+                and analysis_wet_process
+                not in self._wet_processes.get_process_ids()
+            ):
+                sys.exit(
+                    f"Analysis at index {index} in file {analysis.bundle_file} "
+                    f"is referencing an undefined wet process: {analysis_wet_process}"
+                )
 
             analysis_bi_process = analysis.metadata.get("bi_process")
 
-            if (analysis_bi_process and
-                    analysis_bi_process not in self._bi_processes.get_process_ids()):
-                sys.exit(f"Analysis at index {index} in file {analysis.bundle_file} "
-                         f"is referencing an undefined bi process: {analysis_bi_process}")
+            if (
+                analysis_bi_process
+                and analysis_bi_process
+                not in self._bi_processes.get_process_ids()
+            ):
+                sys.exit(
+                    f"Analysis at index {index} in file {analysis.bundle_file} "
+                    f"is referencing an undefined bi process: {analysis_bi_process}"
+                )
 
     @property
     def analyses(self) -> Analyses:
@@ -111,10 +125,9 @@ class ImportBundle:
         files = self.get_files(cat)
         return len(files)
 
-    def get_files(self, cat: str | None = None) -> typing.List[DataFile]:
+    def get_files(self, cat: str | None = None) -> list[DataFile]:
         """Returns all files of a category."""
-
-        files: typing.List[DataFile] = []
+        files: list[DataFile] = []
 
         # Loop on all analyses
         for analysis in self.analyses:
@@ -124,12 +137,8 @@ class ImportBundle:
 
     def get_nb_matched_files(self) -> int:
         """Get the number of files that match the pattern."""
-
-        return sum(a.get_nb_files()
-                   for a in self.analyses)
+        return sum(a.get_nb_files() for a in self.analyses)
 
     def get_nb_unmatched_files(self) -> int:
         """Get the number of files that do not match."""
-
-        return sum(len(a.get_unmatched_file_paths())
-                   for a in self.analyses)
+        return sum(len(a.get_unmatched_file_paths()) for a in self.analyses)