cg 76.0.0__py3-none-any.whl → 83.14.0__py3-none-any.whl

cg/meta/workflow/microsalt/quality_controller/quality_controller.py

@@ -1,27 +1,21 @@
 import logging
 from pathlib import Path
+from typing import cast
 
 from cg.meta.workflow.microsalt.constants import QUALITY_REPORT_FILE_NAME
-from cg.meta.workflow.microsalt.metrics_parser import (
-    MetricsParser,
-    QualityMetrics,
-    SampleMetrics,
-)
+from cg.meta.workflow.microsalt.metrics_parser import MetricsParser, QualityMetrics, SampleMetrics
 from cg.meta.workflow.microsalt.quality_controller.models import (
     CaseQualityResult,
     QualityResult,
     SampleQualityResult,
 )
-from cg.meta.workflow.microsalt.quality_controller.report_generator import (
-    ReportGenerator,
-)
+from cg.meta.workflow.microsalt.quality_controller.report_generator import ReportGenerator
 from cg.meta.workflow.microsalt.quality_controller.result_logger import ResultLogger
 from cg.meta.workflow.microsalt.quality_controller.utils import (
     get_application_tag,
     get_percent_reads_guaranteed,
     get_report_path,
     get_sample_target_reads,
-    has_non_microbial_apptag,
     has_valid_10x_coverage,
     has_valid_average_coverage,
     has_valid_duplication_rate,
@@ -70,7 +64,7 @@ class MicroSALTQualityController:
         valid_coverage: bool = has_valid_average_coverage(metrics)
         valid_10x_coverage: bool = has_valid_10x_coverage(metrics)
 
-        sample: Sample = self.status_db.get_sample_by_internal_id(sample_id)
+        sample: Sample = self.status_db.get_sample_by_internal_id_strict(sample_id)
         application_tag: str = get_application_tag(sample)
 
         if is_control := is_sample_negative_control(sample):
@@ -93,9 +87,6 @@ class MicroSALTQualityController:
             and valid_10x_coverage
         )
 
-        if has_non_microbial_apptag(sample):
-            sample_passes_qc = valid_read_count
-
         sample_quality = SampleQualityResult(
             sample_id=sample_id,
             passes_qc=sample_passes_qc,
@@ -111,7 +102,8 @@ class MicroSALTQualityController:
         ResultLogger.log_sample_result(sample_quality)
         return sample_quality
 
-    def is_qc_required(self, case_run_dir: Path) -> bool:
+    @staticmethod
+    def is_qc_required(case_run_dir: Path | None) -> bool:
         if not case_run_dir:
             LOG.warning(f"Skipping QC, run directory {case_run_dir} does not exist.")
             return False
@@ -122,10 +114,10 @@ class MicroSALTQualityController:
         return not qc_done_path.exists()
 
     def has_valid_total_reads(self, sample_id: str) -> bool:
-        sample: Sample = self.status_db.get_sample_by_internal_id(sample_id)
+        sample: Sample = self.status_db.get_sample_by_internal_id_strict(sample_id)
         target_reads: int = get_sample_target_reads(sample)
         percent_reads_guaranteed: int = get_percent_reads_guaranteed(sample)
-        sample_reads: int = sample.reads
+        sample_reads: int = cast(int, sample.reads)
 
         if is_sample_negative_control(sample):
             return is_valid_total_reads_for_negative_control(

cg/meta/workflow/microsalt/quality_controller/result_logger.py

@@ -1,5 +1,6 @@
 import logging
 from pathlib import Path
+
 from cg.meta.workflow.microsalt.quality_controller.models import (
     CaseQualityResult,
     SampleQualityResult,
@@ -43,10 +44,6 @@ def get_case_fail_message(case: CaseQualityResult) -> str:
 
     if not case.control_passes_qc:
         fail_reasons.append("The negative control sample failed QC.\n")
-    if not case.urgent_passes_qc:
-        fail_reasons.append("The urgent samples failed QC.\n")
-    if not case.non_urgent_passes_qc:
-        fail_reasons.append("The non-urgent samples failed QC.\n")
     fail_message = "QC failed.\n"
     return fail_message + "".join(fail_reasons)
 
@@ -62,9 +59,9 @@ def sample_result_message(samples: list[SampleQualityResult]) -> str:
     return f"Sample results: {failed_count} failed, {passed_count} passed, {total_count} total."
 
 
-def get_failed_results(samples: list[SampleQualityResult]) -> list[str]:
+def get_failed_results(samples: list[SampleQualityResult]) -> list[SampleQualityResult]:
     return [result for result in samples if not result.passes_qc]
 
 
-def get_passed_results(samples: list[SampleQualityResult]) -> list[str]:
+def get_passed_results(samples: list[SampleQualityResult]) -> list[SampleQualityResult]:
     return [result for result in samples if result.passes_qc]

cg/meta/workflow/microsalt/quality_controller/utils.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from cg.constants.constants import MicrosaltAppTags, MicrosaltQC
+from cg.constants.constants import MicrosaltQC
 from cg.meta.workflow.microsalt.constants import QUALITY_REPORT_FILE_NAME
 from cg.meta.workflow.microsalt.metrics_parser.models import SampleMetrics
 from cg.meta.workflow.microsalt.quality_controller.models import (
@@ -65,11 +65,6 @@ def has_valid_10x_coverage(metrics: SampleMetrics) -> bool:
     return is_valid_10x_coverage(coverage_10x) if coverage_10x else False
 
 
-def has_non_microbial_apptag(sample: Sample) -> bool:
-    app_tag: str = get_application_tag(sample)
-    return app_tag not in list(MicrosaltAppTags)
-
-
 def get_negative_control_result(results: list[SampleQualityResult]) -> SampleQualityResult | None:
     for result in results:
         if result.is_control:
@@ -82,38 +77,6 @@ def negative_control_pass_qc(results: list[SampleQualityResult]) -> bool:
     return True
 
 
-def get_results_passing_qc(results: list[SampleQualityResult]) -> list[SampleQualityResult]:
-    return [result for result in results if result.passes_qc]
-
-
-def get_non_urgent_results(results: list[SampleQualityResult]) -> list[SampleQualityResult]:
-    return [result for result in results if not is_urgent_result(result)]
-
-
-def get_urgent_results(results: list[SampleQualityResult]) -> list[SampleQualityResult]:
-    return [result for result in results if is_urgent_result(result)]
-
-
-def is_urgent_result(result: SampleQualityResult) -> bool:
-    return result.application_tag == MicrosaltAppTags.MWRNXTR003
-
-
-def urgent_samples_pass_qc(results: list[SampleQualityResult]) -> bool:
-    urgent_results: list[SampleQualityResult] = get_urgent_results(results)
-    return all(result.passes_qc for result in urgent_results)
-
-
-def non_urgent_samples_pass_qc(results: list[SampleQualityResult]) -> bool:
-    non_urgent_samples: list[SampleQualityResult] = get_non_urgent_results(results)
-    passing_qc: list[SampleQualityResult] = get_results_passing_qc(non_urgent_samples)
-
-    if not non_urgent_samples:
-        return True
-
-    fraction_passing_qc: float = len(passing_qc) / len(non_urgent_samples)
-    return fraction_passing_qc >= MicrosaltQC.MWX_THRESHOLD_SAMPLES_PASSING
-
-
 def is_sample_negative_control(sample: Sample) -> bool:
     return sample.control == ControlEnum.negative
 
@@ -136,16 +99,10 @@ def get_report_path(metrics_file_path: Path) -> Path:
 
 def quality_control_case(sample_results: list[SampleQualityResult]) -> CaseQualityResult:
     control_pass_qc: bool = negative_control_pass_qc(sample_results)
-    urgent_pass_qc: bool = urgent_samples_pass_qc(sample_results)
-    non_urgent_pass_qc: bool = non_urgent_samples_pass_qc(sample_results)
-
-    case_passes_qc: bool = control_pass_qc and urgent_pass_qc and non_urgent_pass_qc
-
+    case_passes_qc: bool = all(sample.passes_qc for sample in sample_results)
     result = CaseQualityResult(
         passes_qc=case_passes_qc,
         control_passes_qc=control_pass_qc,
-        urgent_passes_qc=urgent_pass_qc,
-        non_urgent_passes_qc=non_urgent_pass_qc,
     )
     ResultLogger.log_case_result(result)
     return result

cg/meta/workflow/nallo.py

@@ -1,5 +1,6 @@
 """Module for Nallo Analysis API."""
 
+import copy
 import logging
 from itertools import permutations
 from pathlib import Path
@@ -14,7 +15,7 @@ from cg.clients.chanjo2.models import (
     CoverageSample,
 )
 from cg.constants import Workflow
-from cg.constants.constants import FileFormat, GenomeVersion
+from cg.constants.constants import GenomeVersion
 from cg.constants.nf_analysis import (
     NALLO_COVERAGE_FILE_TAGS,
     NALLO_COVERAGE_INTERVAL_TYPE,
@@ -23,21 +24,15 @@ from cg.constants.nf_analysis import (
     NALLO_PARENT_PEDDY_METRIC_CONDITION,
     NALLO_RAW_METRIC_CONDITIONS,
 )
-from cg.constants.scout import NALLO_CASE_TAGS, ScoutExportFileName
-from cg.constants.subject import PlinkPhenotypeStatus, PlinkSex
-from cg.io.controller import WriteFile
+from cg.constants.scout import NALLO_CASE_TAGS
+from cg.constants.subject import PlinkSex
 from cg.meta.workflow.nf_analysis import NfAnalysisAPI
 from cg.models.analysis import NextflowAnalysis
 from cg.models.cg_config import CGConfig
 from cg.models.deliverables.metric_deliverables import MetricsBase, MultiqcDataJson
-from cg.models.nallo.nallo import (
-    NalloParameters,
-    NalloQCMetrics,
-    NalloSampleSheetEntry,
-    NalloSampleSheetHeaders,
-)
+from cg.models.nallo.nallo import NalloQCMetrics
 from cg.resources import NALLO_BUNDLE_FILENAMES_PATH
-from cg.store.models import CaseSample, Sample
+from cg.store.models import Sample
 
 LOG = logging.getLogger(__name__)
 
@@ -69,90 +64,6 @@ class NalloAnalysisAPI(NfAnalysisAPI):
         self.revision: str = config.nallo.revision
         self.nextflow_binary_path: str = config.nallo.binary_path
 
-    @property
-    def sample_sheet_headers(self) -> list[str]:
-        """Headers for sample sheet."""
-        return NalloSampleSheetHeaders.list()
-
-    def get_sample_sheet_content_per_sample(self, case_sample: CaseSample) -> list[list[str]]:
-        """Collect and format information required to build a sample sheet for a single sample."""
-        read_file_paths = self.get_bam_read_file_paths(sample=case_sample.sample)
-        sample_sheet_entries = []
-
-        for bam_path in read_file_paths:
-            sample_sheet_entry = NalloSampleSheetEntry(
-                project=case_sample.case.internal_id,
-                sample=case_sample.sample.internal_id,
-                read_file=Path(bam_path),
-                family_id=case_sample.case.internal_id,
-                paternal_id=case_sample.get_paternal_sample_id or "0",
-                maternal_id=case_sample.get_maternal_sample_id or "0",
-                sex=self.get_sex_code(case_sample.sample.sex),
-                phenotype=self.get_phenotype_code(case_sample.status),
-            )
-            sample_sheet_entries.extend(sample_sheet_entry.reformat_sample_content)
-        return sample_sheet_entries
-
-    @staticmethod
-    def get_phenotype_code(phenotype: str) -> int:
-        """Return Nallo phenotype code."""
-        LOG.debug("Translate phenotype to integer code")
-        try:
-            code = PlinkPhenotypeStatus[phenotype.upper()]
-        except KeyError:
-            raise ValueError(f"{phenotype} is not a valid phenotype")
-        return code
-
-    @staticmethod
-    def get_sex_code(sex: str) -> int:
-        """Return Nallo sex code."""
-        LOG.debug("Translate sex to integer code")
-        try:
-            code = PlinkSex[sex.upper()]
-        except KeyError:
-            raise ValueError(f"{sex} is not a valid sex")
-        return code
-
-    def get_built_workflow_parameters(self, case_id: str, dry_run: bool = False) -> NalloParameters:
-        """Return parameters."""
-        outdir = self.get_case_path(case_id=case_id)
-
-        return NalloParameters(
-            input=self.get_sample_sheet_path(case_id=case_id),
-            outdir=outdir,
-            filter_variants_hgnc_ids=f"{outdir}/{ScoutExportFileName.PANELS_TSV}",
-        )
-
-    @property
-    def is_gene_panel_required(self) -> bool:
-        """Return True if a gene panel needs to be created using information in StatusDB and exporting it from Scout."""
-        return True
-
-    def create_gene_panel(self, case_id: str, dry_run: bool) -> None:
-        """Create and write an aggregated gene panel file exported from Scout as tsv file."""
-        LOG.info("Creating gene panel file")
-        bed_lines: list[str] = self.get_gene_panel(case_id=case_id, dry_run=dry_run)
-        if dry_run:
-            bed_lines: str = "\n".join(bed_lines)
-            LOG.debug(f"{bed_lines}")
-            return
-        self.write_panel_as_tsv(case_id=case_id, content=bed_lines)
-
-    def write_panel_as_tsv(self, case_id: str, content: list[str]) -> None:
-        """Write the gene panel to case dir."""
-        self._write_panel_as_tsv(out_dir=Path(self.root, case_id), content=content)
-
-    @staticmethod
-    def _write_panel_as_tsv(out_dir: Path, content: list[str]) -> None:
-        """Write the gene panel to case dir while omitted the commented BED lines."""
-        filtered_content = [line for line in content if not line.startswith("##")]
-        out_dir.mkdir(parents=True, exist_ok=True)
-        WriteFile.write_file_from_content(
-            content="\n".join(filtered_content),
-            file_format=FileFormat.TXT,
-            file_path=Path(out_dir, ScoutExportFileName.PANELS_TSV),
-        )
-
     def get_genome_build(self, case_id: str) -> GenomeVersion:
         """Return reference genome for a Nallo case. Currently fixed for hg38."""
         return GenomeVersion.HG38
@@ -168,7 +79,6 @@ class NalloAnalysisAPI(NfAnalysisAPI):
         if "-" not in sample_id:
             metric_conditions: dict[str, dict[str, Any]] = NALLO_GENERAL_METRIC_CONDITIONS.copy()
             metric_conditions.update(NALLO_RAW_METRIC_CONDITIONS)
-            self.set_peddy_sex_for_sample(sample=sample, metric_conditions=metric_conditions)
             self.set_somalier_sex_for_sample(sample=sample, metric_conditions=metric_conditions)
         else:
             metric_conditions = NALLO_PARENT_PEDDY_METRIC_CONDITION.copy()
@@ -235,9 +145,21 @@ class NalloAnalysisAPI(NfAnalysisAPI):
         metrics = self.get_deduplicated_metrics(metrics=metrics)
         return metrics
 
-    @staticmethod
-    def set_peddy_sex_for_sample(sample: Sample, metric_conditions: dict) -> None:
-        metric_conditions["predicted_sex_sex_check"]["threshold"] = sample.sex
+    def _get_list_of_metric_dicts(self, multiqc_json: MultiqcDataJson) -> list[dict[str, Any]]:
+        metric_dicts: list[dict[str, Any]] = super()._get_list_of_metric_dicts(multiqc_json)
+
+        list_copy: list[dict[str, Any]] = copy.deepcopy(metric_dicts)
+        list_copy.append(self._get_somalier_dict(multiqc_json))
+
+        return list_copy
+
+    def _get_somalier_dict(self, multiqc_json: MultiqcDataJson) -> dict[str, Any]:
+        somalier_raw = copy.deepcopy(multiqc_json.report_saved_raw_data["multiqc_somalier"])
+
+        for sample_id, metrics in somalier_raw.items():
+            somalier_raw[sample_id] = {f"somalier_{k}": v for k, v in metrics.items()}
+
+        return somalier_raw
 
     @staticmethod
     def set_somalier_sex_for_sample(sample: Sample, metric_conditions: dict) -> None: