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

genelastic/import_data/analysis.py

@@ -1,205 +0,0 @@
-import copy
-import logging
-import re
-import typing
-from pathlib import Path
-
-from genelastic.common import AnalysisMetaData
-
-from .constants import ALLOWED_CATEGORIES
-from .data_file import DataFile
-from .filename_pattern import FilenamePattern
-from .tags import Tags
-
-logger = logging.getLogger("genelastic")
-
-
-class Analysis:
-    """Class Analysis that represents an analysis."""
-
-    def __init__(  # noqa: PLR0913
-        self,
-        tags: Tags,
-        root_dir: str = ".",
-        bundle_file: str | None = None,
-        file_prefix: str | None = None,
-        files: typing.Sequence[str] | None = None,
-        data_path: str | None = None,
-        **metadata: str | int,
-    ) -> None:
-        self._bundle_file = Path(bundle_file) if bundle_file else None
-        self._file_prefix = file_prefix
-        self._files = files
-        self._data_path = Analysis._resolve_data_path(
-            Path(root_dir), Path(data_path) if data_path else None
-        )
-        self._tags = tags
-        self._metadata: AnalysisMetaData = metadata
-        self._categories: set[str] = set()
-
-    @property
-    def metadata(self) -> AnalysisMetaData:
-        """Get metadata."""
-        return copy.deepcopy(self._metadata)
-
-    @property
-    def bundle_file(self) -> Path | None:
-        """Get the bundle file."""
-        return self._bundle_file
-
-    @property
-    def filename_regex(self) -> str:
-        """Resolve placeholders in a file prefix using metadata
-        and unresolved placeholders are converted to regex groups
-        """
-        x: str = r"^.+\.(?P<ext>vcf|cov)(\.gz)?$"
-
-        # Use existing generic prefix
-        if self._file_prefix:
-            x = self._file_prefix
-            # Replace %* tags
-            for tag_name, tag_attrs in self._tags.items:
-                field = tag_attrs["field"]
-                regex = tag_attrs["regex"]
-
-                # Build field regex
-                field_regex = (
-                    f"(?P<{field}>{self._metadata.get(field)})"
-                    if field in self._metadata
-                    else f"(?P<{field}>{regex})"
-                )
-                # Replace tag with field regex
-                x = x.replace(tag_name, field_regex)
-
-            # Check for tags that were not replaced.
-            groups = re.findall(self._tags.search_regex, x)
-            for match in groups:
-                logger.warning(
-                    "String '%s' in key 'file_prefix' looks like an undefined tag. "
-                    "If this string is not a tag, you can ignore this warning.",
-                    match,
-                )
-
-            # Add missing start and end markers
-            if not x.startswith("^"):
-                x = "^" + x
-            if not x.endswith("$"):
-                x += r"\.(?P<ext>" + "|".join(ALLOWED_CATEGORIES) + r")(\.gz)?$"
-            logger.debug("File regex for %s: %s", self._bundle_file, x)
-
-        return x
-
-    def get_nb_files(self, cat: str | None = None) -> int:
-        """Returns the total number of files."""
-        return len(self.get_file_paths(cat=cat))
-
-    def get_data_files(self, cat: str | None = None) -> list[DataFile]:
-        """Returns the list of matched files as DataFile objects."""
-        files = self.get_file_paths(cat=cat)
-        filename_pattern = FilenamePattern(self.filename_regex)
-
-        data_files: list[DataFile] = []
-
-        for f in files:
-            try:
-                data_files.append(
-                    DataFile.make_from_bundle(
-                        path=f,
-                        bundle_path=self._bundle_file,
-                        pattern=filename_pattern,
-                    )
-                )
-            except (OSError, ValueError) as e:
-                logger.error("Error processing file %s: %s", f, str(e))
-
-        return data_files
-
-    def get_file_paths(self, cat: str | None = None) -> typing.Sequence[Path]:
-        """Returns the list of matched files."""
-        files, _, _ = self._do_get_file_paths(cat=cat)
-        return files
-
-    def get_unmatched_file_paths(
-        self, cat: str | None = None
-    ) -> typing.Sequence[Path]:
-        """Returns the list of unmatched files."""
-        _, files, _ = self._do_get_file_paths(cat=cat)
-        return files
-
-    def get_all_categories(self) -> set[str]:
-        """Returns all categories of the analysis."""
-        _, _, categories = self._do_get_file_paths()
-        return categories
-
-    @staticmethod
-    def _resolve_data_path(root_dir: Path, data_path: Path | None) -> Path:
-        resolved_data_path = Path() if data_path is None else data_path
-
-        if not resolved_data_path.is_absolute():
-            resolved_data_path = (root_dir / resolved_data_path).absolute()
-
-        return resolved_data_path
-
-    def _get_files_with_allowed_categories(self) -> dict[Path, str]:
-        # Create a dict to store allowed files. Keys are the filepaths,
-        # and values are their corresponding category.
-        allowed_files: dict[Path, str] = {}
-        # If files are listed explicitly in the YAML in the 'files' attribute, process them.
-        if self._files is not None:
-            abs_filepaths = [Path(self._data_path) / f for f in self._files]
-            # Try to retrieve files matching allowed categories by checking their first suffix.
-            for file in abs_filepaths:
-                cat = file.suffixes[0][1:]
-                # Add each matching file and its category to the dict.
-                if cat in ALLOWED_CATEGORIES:
-                    allowed_files[file] = cat
-        # Else, look for files on disk using the YAML 'data_path' attribute.
-        else:
-            # Try to retrieve files matching allowed categories using glob.
-            for cat in ALLOWED_CATEGORIES:
-                glob_res: list[Path] = []
-                glob_res.extend(self._data_path.glob(f"*.{cat}"))
-                glob_res.extend(self._data_path.glob(f"*.{cat}.gz"))
-
-                # Add each globed file and its category to the dict.
-                for g_file in glob_res:
-                    allowed_files[g_file] = cat
-
-        return allowed_files
-
-    def _do_get_file_paths(
-        self, cat: str | None = None
-    ) -> tuple[typing.Sequence[Path], typing.Sequence[Path], set[str]]:
-        # Raise an error if the category given as a parameter is not part of the allowed categories.
-        if cat is not None and cat not in ALLOWED_CATEGORIES:
-            msg = f"Unknown category {cat}."
-            raise ValueError(msg)
-
-        # Obtain a dict of all files matching the allowed categories.
-        allowed_files = self._get_files_with_allowed_categories()
-
-        if cat is None:
-            # No category was given as a parameter, so we match all categories.
-            files_to_match = allowed_files
-        else:
-            # A category was given as a parameter, so we match only this specific category.
-            files_to_match = {
-                k: v for k, v in allowed_files.items() if v == cat
-            }
-
-        filename_pattern = FilenamePattern(self.filename_regex)
-        matching_files: list[Path] = []
-        non_matching_files: list[Path] = []
-        categories = set()
-
-        # We filter files by ensuring that they match the filename pattern defined in the analysis.
-        for file, category in sorted(files_to_match.items()):
-            if filename_pattern.matches_pattern(file.name):
-                matching_files.append(file)
-                logger.info("MATCHED file %s.", file)
-                # Add the file category to the categories set.
-                categories.add(category)
-            else:
-                logger.warning("UNMATCHED file %s.", file)
-                non_matching_files.append(file)
-        return matching_files, non_matching_files, categories

genelastic/import_data/bi_process.py

@@ -1,27 +0,0 @@
-import copy
-
-from genelastic.common import BioInfoProcessData
-
-
-class BioInfoProcess:
-    """Class representing a bio process."""
-
-    def __init__(
-        self,
-        proc_id: str,
-        bundle_file: str | None = None,
-        **data: str | list[str],
-    ) -> None:
-        self._proc_id = proc_id
-        self._bundle_file = bundle_file
-        self._data: BioInfoProcessData = data
-
-    @property
-    def id(self) -> str:
-        """Get the bio process ID."""
-        return self._proc_id
-
-    @property
-    def data(self) -> BioInfoProcessData:
-        """Get data associated to the bio process."""
-        return copy.deepcopy(self._data)

genelastic/import_data/bi_processes.py

@@ -1,49 +0,0 @@
-import logging
-import typing
-
-from genelastic.common import BundleDict
-
-from .bi_process import BioInfoProcess
-
-logger = logging.getLogger("genelastic")
-
-
-class BioInfoProcesses:
-    """Class BioInfoProcesses is a container of BioInfoProcess objects."""
-
-    def __init__(self) -> None:
-        self._dict: dict[str, BioInfoProcess] = {}
-
-    def __len__(self) -> int:
-        return len(self._dict)
-
-    def __getitem__(self, key: str) -> BioInfoProcess:
-        return self._dict[key]
-
-    def add(self, process: BioInfoProcess) -> None:
-        """Add one BioInfoProcess object.
-        If a BioInfoProcess object with the same ID already exists in the container,
-        the program exits.
-        """
-        if process.id in self._dict:
-            msg = f"A bi process with the id '{process.id}' is already present."
-            raise ValueError(msg)
-
-        # Add one WetProcess object.
-        self._dict[process.id] = process
-
-    def get_process_ids(self) -> set[str]:
-        """Get a list of the bio processes IDs."""
-        return set(self._dict.keys())
-
-    @classmethod
-    def from_array_of_dicts(
-        cls, arr: typing.Sequence[BundleDict]
-    ) -> typing.Self:
-        """Build a BioInfoProcesses instance."""
-        bi_processes = cls()
-
-        for d in arr:
-            bi_processes.add(BioInfoProcess(**d))
-
-        return bi_processes

genelastic/import_data/cli_gen_data.py

@@ -1,116 +0,0 @@
-import argparse
-import logging
-from pathlib import Path
-
-from genelastic.common import add_verbose_control_args
-
-from .logger import configure_logging
-from .random_bundle import (
-    RandomBundle,
-)
-
-logger = logging.getLogger("genelastic")
-
-
-def read_args() -> argparse.Namespace:
-    """Read arguments from command line."""
-    parser = argparse.ArgumentParser(
-        description="Genetics data random generator.",
-        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.",
-        type=Path,
-    )
-    parser.add_argument(
-        "--log-file", dest="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",
-        default=None,
-        help="Output YAML file.",
-        type=Path,
-    )
-    parser.add_argument(
-        "-s",
-        "--sequence-size",
-        type=int,
-        default=2000,
-        help="Sequence size (number of nucleotides) generated for each chromosome.",
-    )
-    parser.add_argument(
-        "-c",
-        "--coverage",
-        action="store_true",
-        help="Generate a coverage file for each analysis.",
-    )
-    parser.add_argument(
-        "-a",
-        "--analyses",
-        help="Number of analyses to generate. "
-        "Each analysis is composed of a YAML bundle file declaring its wet lab and bioinformatics processes, "
-        "a VCF file and optionally a coverage file.",
-        default=1,
-        type=int,
-    )
-    parser.add_argument(
-        "-p",
-        "--processes",
-        help="Number of Wet Lab and Bioinformatics processes to generate.",
-        default=1,
-        type=int,
-    )
-    return parser.parse_args()
-
-
-def main() -> None:
-    """Entry point of the gen-data script."""
-    # Read command line arguments
-    args = read_args()
-    folder = args.data_folder.resolve()
-
-    if not folder.is_dir():
-        msg = f"ERROR: '{folder}' does not exist or is not a directory."
-        raise SystemExit(msg)
-
-    if args.analyses < 1:
-        msg = "Analyses count must be at least 1."
-        raise SystemExit(msg)
-
-    if args.processes < 1:
-        msg = "Processes count must be at least 1."
-        raise SystemExit(msg)
-
-    # Configure logging
-    configure_logging(args.verbose, log_file=args.log_file)
-    logger.debug("Arguments: %s", args)
-
-    # Write to stdout or file
-    RandomBundle(
-        folder,
-        args.analyses,
-        args.processes,
-        args.chrom_nb,
-        args.sequence_size,
-        do_gen_coverage=args.coverage,
-    ).to_yaml(args.output_file)
-
-
-if __name__ == "__main__":
-    main()