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

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
@@ -234,6 +145,22 @@ class NalloAnalysisAPI(NfAnalysisAPI):
         metrics = self.get_deduplicated_metrics(metrics=metrics)
         return metrics
 
+    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:
         if "somalier_sex" in metric_conditions:

cg/meta/workflow/nf_analysis.py

@@ -1,6 +1,4 @@
-import copy
 import logging
-import re
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Iterator, Type
@@ -17,16 +15,12 @@ from cg.constants.constants import (
     MultiQC,
     WorkflowManager,
 )
-from cg.constants.gene_panel import GenePanelGenomeBuild
-from cg.constants.housekeeper_tags import AlignmentFileTag
 from cg.constants.nextflow import NFX_WORK_DIR
 from cg.constants.nf_analysis import NfTowerStatus
 from cg.constants.tb import AnalysisStatus
 from cg.exc import CgError, HousekeeperStoreError, MetricsQCError
 from cg.io.controller import ReadFile, WriteFile
 from cg.io.json import read_json
-from cg.io.txt import concat_txt, write_txt
-from cg.io.yaml import read_yaml, write_yaml_nextflow_style
 from cg.meta.workflow.analysis import AnalysisAPI
 from cg.meta.workflow.nf_handlers import NextflowHandler, NfTowerHandler
 from cg.models.analysis import NextflowAnalysis
@@ -36,15 +30,9 @@ from cg.models.deliverables.metric_deliverables import (
     MetricsDeliverablesCondition,
     MultiqcDataJson,
 )
-from cg.models.fastq import FastqFileMeta
-from cg.models.nf_analysis import (
-    FileDeliverable,
-    NfCommandArgs,
-    WorkflowDeliverables,
-    WorkflowParameters,
-)
+from cg.models.nf_analysis import FileDeliverable, NfCommandArgs, WorkflowDeliverables
 from cg.models.qc_metrics import QCMetrics
-from cg.store.models import Analysis, Case, CaseSample, Sample
+from cg.store.models import Analysis, Case, Sample
 from cg.utils import Process
 
 LOG = logging.getLogger(__name__)
@@ -90,27 +78,12 @@ class NfAnalysisAPI(AnalysisAPI):
     def process(self, process: Process):
         self._process = process
 
-    @property
-    def sample_sheet_headers(self) -> list[str]:
-        """Headers for sample sheet."""
-        raise NotImplementedError
-
     @property
     def is_multiqc_pattern_search_exact(self) -> bool:
         """Return True if only exact pattern search is allowed to collect metrics information from MultiQC file.
         If false, pattern must be present but does not need to be exact."""
         return False
 
-    @property
-    def is_gene_panel_required(self) -> bool:
-        """Return True if a gene panel needs to be created using the information in StatusDB and exporting it from Scout."""
-        return False
-
-    @property
-    def is_managed_variants_required(self) -> bool:
-        """Return True if a managed variant export needs to be exported it from Scout."""
-        return False
-
     def get_profile(self, profile: str | None = None) -> str:
         """Get NF profiles."""
         return profile or self.profile
@@ -123,27 +96,6 @@ class NfAnalysisAPI(AnalysisAPI):
         """Get workflow version from config."""
         return self.revision
 
-    def get_built_workflow_parameters(
-        self, case_id: str, dry_run: bool = False
-    ) -> WorkflowParameters:
-        """Return workflow parameters."""
-        raise NotImplementedError
-
-    def get_nextflow_config_content(self, case_id: str) -> str:
-        """Return nextflow config content."""
-        config_files_list: list[str] = [
-            self.platform,
-            self.workflow_config_path,
-            self.resources,
-        ]
-        extra_parameters_str: list[str] = [
-            self.set_cluster_options(case_id=case_id),
-        ]
-        return concat_txt(
-            file_paths=config_files_list,
-            str_content=extra_parameters_str,
-        )
-
     def get_case_path(self, case_id: str) -> Path:
         """Path to case working directory."""
         return Path(self.root_dir, case_id)
@@ -192,11 +144,6 @@ class NfAnalysisAPI(AnalysisAPI):
             FileExtensions.YAML
         )
 
-    def create_case_directory(self, case_id: str, dry_run: bool = False) -> None:
-        """Create case directory."""
-        if not dry_run:
-            Path(self.get_case_path(case_id=case_id)).mkdir(parents=True, exist_ok=True)
-
     def get_log_path(self, case_id: str, workflow: str) -> Path:
         """Path to NF log."""
         launch_time: str = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
@@ -211,68 +158,6 @@ class NfAnalysisAPI(AnalysisAPI):
             return work_dir.absolute()
         return Path(self.get_case_path(case_id), NFX_WORK_DIR)
 
-    def get_gene_panels_path(self, case_id: str) -> Path:
-        """Path to gene panels bed file exported from Scout."""
-        return Path(self.get_case_path(case_id=case_id), "gene_panels").with_suffix(
-            FileExtensions.BED
-        )
-
-    def set_cluster_options(self, case_id: str) -> str:
-        return f'process.clusterOptions = "-A {self.account} --qos={self.get_slurm_qos_for_case(case_id=case_id)}"\n'
-
-    @staticmethod
-    def extract_read_files(
-        metadata: list[FastqFileMeta], forward_read: bool = False, reverse_read: bool = False
-    ) -> list[str]:
-        """Extract a list of fastq file paths for either forward or reverse reads."""
-        if forward_read and not reverse_read:
-            read_direction = 1
-        elif reverse_read and not forward_read:
-            read_direction = 2
-        else:
-            raise ValueError("Either forward or reverse needs to be specified")
-        sorted_metadata: list = sorted(metadata, key=lambda k: k.path)
-        return [
-            fastq_file.path
-            for fastq_file in sorted_metadata
-            if fastq_file.read_direction == read_direction
-        ]
-
-    def get_paired_read_paths(self, sample: Sample) -> tuple[list[str], list[str]]:
-        """Returns a tuple of paired fastq file paths for the forward and reverse read."""
-        sample_metadata: list[FastqFileMeta] = self.gather_file_metadata_for_sample(sample=sample)
-        fastq_forward_read_paths: list[str] = self.extract_read_files(
-            metadata=sample_metadata, forward_read=True
-        )
-        fastq_reverse_read_paths: list[str] = self.extract_read_files(
-            metadata=sample_metadata, reverse_read=True
-        )
-        return fastq_forward_read_paths, fastq_reverse_read_paths
-
-    def get_bam_read_file_paths(self, sample: Sample) -> list[Path]:
-        """Gather BAM file path for a sample based on the BAM tag."""
-        return [
-            Path(hk_file.full_path)
-            for hk_file in self.housekeeper_api.files(
-                bundle=sample.internal_id, tags={AlignmentFileTag.BAM}
-            )
-        ]
-
-    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."""
-        raise NotImplementedError
-
-    def get_sample_sheet_content(self, case_id: str) -> list[list[Any]]:
-        """Return formatted information required to build a sample sheet for a case.
-        This contains information for all samples linked to the case."""
-        sample_sheet_content: list = []
-        case: Case = self.get_validated_case(case_id)
-        LOG.info(f"Samples linked to case {case_id}: {len(case.links)}")
-        LOG.debug("Getting sample sheet information")
-        for link in case.links:
-            sample_sheet_content.extend(self.get_sample_sheet_content_per_sample(case_sample=link))
-        return sample_sheet_content
-
     def verify_sample_sheet_exists(self, case_id: str, dry_run: bool = False) -> None:
         """Raise an error if sample sheet file is not found."""
         if not dry_run and not Path(self.get_sample_sheet_path(case_id=case_id)).exists():
@@ -283,33 +168,6 @@ class NfAnalysisAPI(AnalysisAPI):
         if not Path(self.get_deliverables_file_path(case_id=case_id)).exists():
             raise CgError(f"No deliverables file found for case {case_id}")
 
-    def write_params_file(self, case_id: str, replaced_workflow_parameters: dict = None) -> None:
-        """Write params-file for analysis."""
-        LOG.debug("Writing parameters file")
-        if replaced_workflow_parameters:
-            write_yaml_nextflow_style(
-                content=replaced_workflow_parameters,
-                file_path=self.get_params_file_path(case_id=case_id),
-            )
-        else:
-            self.get_params_file_path(case_id=case_id).touch()
-
-    @staticmethod
-    def write_sample_sheet(
-        content: list[list[Any]],
-        file_path: Path,
-        header: list[str],
-    ) -> None:
-        """Write sample sheet CSV file."""
-        LOG.debug("Writing sample sheet")
-        if header:
-            content.insert(0, header)
-        WriteFile.write_file_from_content(
-            content=content,
-            file_format=FileFormat.CSV,
-            file_path=file_path,
-        )
-
     @staticmethod
     def write_deliverables_file(
         deliverables_content: dict, file_path: Path, file_format=FileFormat.YAML
@@ -329,105 +187,6 @@ class NfAnalysisAPI(AnalysisAPI):
             file_path=config_path,
         )
 
-    def create_sample_sheet(self, case_id: str, dry_run: bool) -> None:
-        """Create sample sheet for a case."""
-        sample_sheet_content: list[list[Any]] = self.get_sample_sheet_content(case_id=case_id)
-        if not dry_run:
-            self.write_sample_sheet(
-                content=sample_sheet_content,
-                file_path=self.get_sample_sheet_path(case_id=case_id),
-                header=self.sample_sheet_headers,
-            )
-
-    def create_params_file(self, case_id: str, dry_run: bool) -> None:
-        """Create parameters file for a case."""
-        LOG.debug("Getting parameters information built on-the-fly")
-        built_workflow_parameters: dict | None = self.get_built_workflow_parameters(
-            case_id=case_id, dry_run=dry_run
-        ).model_dump()
-        LOG.debug("Adding parameters from the pipeline config file if it exist")
-
-        yaml_params: dict = (
-            read_yaml(self.params) if hasattr(self, "params") and self.params else {}
-        )
-
-        # Check for duplicate keys
-        duplicate_keys = set(built_workflow_parameters.keys()) & set(yaml_params.keys())
-        if duplicate_keys:
-            raise ValueError(f"Duplicate parameter keys found: {duplicate_keys}")
-        workflow_parameters: dict = built_workflow_parameters | (yaml_params)
-        replaced_workflow_parameters: dict = self.replace_values_in_params_file(
-            workflow_parameters=workflow_parameters
-        )
-        if not dry_run:
-            self.write_params_file(
-                case_id=case_id, replaced_workflow_parameters=replaced_workflow_parameters
-            )
-
-    def replace_values_in_params_file(self, workflow_parameters: dict) -> dict:
-        replaced_workflow_parameters = copy.deepcopy(workflow_parameters)
-        """Iterate through the dictionary until all placeholders are replaced with the corresponding value from the dictionary"""
-        while True:
-            resolved: bool = True
-            for key, value in replaced_workflow_parameters.items():
-                new_value: str | int = self.replace_params_placeholders(value, workflow_parameters)
-                if new_value != value:
-                    resolved = False
-                    replaced_workflow_parameters[key] = new_value
-            if resolved:
-                break
-        return replaced_workflow_parameters
-
-    def replace_params_placeholders(self, value: str | int, workflow_parameters: dict) -> str:
-        """Replace values marked as placeholders with values from the given dictionary"""
-        if isinstance(value, str):
-            placeholders: list[str] = re.findall(r"{{\s*([^{}\s]+)\s*}}", value)
-            for placeholder in placeholders:
-                if placeholder in workflow_parameters:
-                    value = value.replace(
-                        f"{{{{{placeholder}}}}}", str(workflow_parameters[placeholder])
-                    )
-        return value
-
-    def create_nextflow_config(self, case_id: str, dry_run: bool = False) -> None:
-        """Create nextflow config file."""
-        if content := self.get_nextflow_config_content(case_id=case_id):
-            LOG.debug("Writing nextflow config file")
-            if not dry_run:
-                write_txt(
-                    content=content,
-                    file_path=self.get_nextflow_config_path(case_id=case_id),
-                )
-
-    def create_gene_panel(self, case_id: str, dry_run: bool) -> None:
-        """Create and write an aggregated gene panel file exported from Scout."""
-        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(case_id=case_id, content=bed_lines)
-
-    def config_case(self, case_id: str, dry_run: bool):
-        """Create directory and config files required by a workflow for a case."""
-        if dry_run:
-            LOG.info("Dry run: Config files will not be written")
-        self.status_db.verify_case_exists(case_internal_id=case_id)
-        self.create_case_directory(case_id=case_id, dry_run=dry_run)
-        self.create_sample_sheet(case_id=case_id, dry_run=dry_run)
-        self.create_params_file(case_id=case_id, dry_run=dry_run)
-        self.create_nextflow_config(case_id=case_id, dry_run=dry_run)
-        if self.is_gene_panel_required:
-            self.create_gene_panel(case_id=case_id, dry_run=dry_run)
-        if self.is_managed_variants_required:
-            vcf_lines: list[str] = self.get_managed_variants(case_id=case_id)
-            if dry_run:
-                for line in vcf_lines:
-                    LOG.debug(line)
-            else:
-                self.write_managed_variants(case_id=case_id, content=vcf_lines)
-
     def _run_analysis_with_nextflow(
         self, case_id: str, command_args: NfCommandArgs, dry_run: bool
     ) -> None:
@@ -733,7 +492,9 @@ class NfAnalysisAPI(AnalysisAPI):
     ) -> list[MetricsBase]:
         """Parse a MultiqcDataJson and returns a list of metrics."""
         metrics: list[MetricsBase] = []
-        for section in multiqc_json.report_general_stats_data:
+        list_of_metric_dicts: list[dict[str, Any]] = self._get_list_of_metric_dicts(multiqc_json)
+
+        for section in list_of_metric_dicts:
             for subsection, metrics_dict in section.items():
                 if self._is_pattern_found(
                     pattern=search_pattern, text=subsection, exact_match=exact_match
@@ -745,6 +506,12 @@ class NfAnalysisAPI(AnalysisAPI):
                         metrics.append(metric)
         return metrics
 
+    def _get_list_of_metric_dicts(self, multiqc_json: MultiqcDataJson) -> list[dict[str, Any]]:
+        if metric_dicts := multiqc_json.report_general_stats_data:
+            return metric_dicts
+        else:
+            raise ValueError("No report_general_stats_data found in MultiqcDataJson")
+
     def get_multiqc_metric(
         self, metric_name: str, metric_value: str | int | float, metric_id: str
     ) -> MetricsBase:
@@ -912,24 +679,6 @@ class NfAnalysisAPI(AnalysisAPI):
     def get_genome_build(self, case_id: str) -> GenomeVersion:
         raise NotImplementedError
 
-    def get_gene_panel_genome_build(self, case_id: str) -> GenePanelGenomeBuild:
-        """Return build version of the gene panel for a case."""
-        reference_genome: GenomeVersion = self.get_genome_build(case_id=case_id)
-        try:
-            return getattr(GenePanelGenomeBuild, reference_genome)
-        except AttributeError as error:
-            raise CgError(
-                f"Reference {reference_genome} has no associated genome build for panels: {error}"
-            ) from error
-
-    def get_gene_panel(self, case_id: str, dry_run: bool = False) -> list[str]:
-        """Create and return the aggregated gene panel file."""
-        return self._get_gene_panel(
-            case_id=case_id,
-            genome_build=self.get_gene_panel_genome_build(case_id=case_id),
-            dry_run=dry_run,
-        )
-
     def parse_analysis(
         self, qc_metrics_raw: list[MetricsBase], qc_metrics_model: Type[QCMetrics], **kwargs
     ) -> NextflowAnalysis:

cg/meta/workflow/raredisease.py

@@ -1,6 +1,5 @@
 """Module for Raredisease Analysis API."""
 
-import csv
 import logging
 from itertools import permutations
 from pathlib import Path
@@ -24,22 +23,15 @@ from cg.constants.nf_analysis import (
     RAREDISEASE_METRIC_CONDITIONS_WGS,
     RAREDISEASE_PARENT_PEDDY_METRIC_CONDITION,
 )
-from cg.constants.scout import RAREDISEASE_CASE_TAGS, ScoutExportFileName
+from cg.constants.scout import RAREDISEASE_CASE_TAGS
 from cg.constants.sequencing import SeqLibraryPrepCategory
-from cg.constants.subject import PlinkPhenotypeStatus, PlinkSex
-from cg.constants.tb import AnalysisType
 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.raredisease.raredisease import (
-    RarediseaseParameters,
-    RarediseaseQCMetrics,
-    RarediseaseSampleSheetEntry,
-    RarediseaseSampleSheetHeaders,
-)
+from cg.models.raredisease.raredisease import RarediseaseQCMetrics
 from cg.resources import RAREDISEASE_BUNDLE_FILENAMES_PATH
-from cg.store.models import CaseSample, Sample
+from cg.store.models import Sample
 
 LOG = logging.getLogger(__name__)
 
@@ -71,95 +63,11 @@ class RarediseaseAnalysisAPI(NfAnalysisAPI):
         self.revision: str = config.raredisease.revision
         self.nextflow_binary_path: str = config.raredisease.binary_path
 
-    @property
-    def sample_sheet_headers(self) -> list[str]:
-        """Headers for sample sheet."""
-        return RarediseaseSampleSheetHeaders.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."""
-        fastq_forward_read_paths, fastq_reverse_read_paths = self.get_paired_read_paths(
-            sample=case_sample.sample
-        )
-        sample_sheet_entry = RarediseaseSampleSheetEntry(
-            name=case_sample.sample.internal_id,
-            fastq_forward_read_paths=fastq_forward_read_paths,
-            fastq_reverse_read_paths=fastq_reverse_read_paths,
-            sex=self.get_sex_code(case_sample.sample.sex),
-            phenotype=self.get_phenotype_code(case_sample.status),
-            paternal_id=case_sample.get_paternal_sample_id,
-            maternal_id=case_sample.get_maternal_sample_id,
-            case_id=case_sample.case.internal_id,
-        )
-        return sample_sheet_entry.reformat_sample_content
-
-    @property
-    def is_gene_panel_required(self) -> bool:
-        """Return True if a gene panel needs to be created using the information in StatusDB and exporting it from Scout."""
-        return True
-
-    def get_built_workflow_parameters(
-        self, case_id: str, dry_run: bool = False
-    ) -> RarediseaseParameters:
-        """Return parameters."""
-        analysis_type: AnalysisType = self.get_data_analysis_type(case_id=case_id)
-        target_bed_file: str = self.get_target_bed_from_lims(case_id=case_id) or ""
-        outdir = self.get_case_path(case_id=case_id)
-        sample_id_map: Path = self.get_sample_name_mapping_csv_path(case=case_id)
-        # Build the sample_id_map path
-        if not dry_run:
-            self.export_customer_internal_mapping_csv(case=case_id, output_path=sample_id_map)
-
-        return RarediseaseParameters(
-            input=self.get_sample_sheet_path(case_id=case_id),
-            outdir=outdir,
-            analysis_type=analysis_type,
-            target_bed_file=target_bed_file,
-            save_mapped_as_cram=True,
-            vcfanno_extra_resources=f"{outdir}/{ScoutExportFileName.MANAGED_VARIANTS}",
-            vep_filters_scout_fmt=f"{outdir}/{ScoutExportFileName.PANELS}",
-            sample_id_map=sample_id_map,
-        )
-
-    @staticmethod
-    def get_phenotype_code(phenotype: str) -> int:
-        """Return Raredisease 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 Raredisease 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
-
     @staticmethod
     def get_bundle_filenames_path() -> Path:
         """Return Raredisease bundle filenames path."""
         return RAREDISEASE_BUNDLE_FILENAMES_PATH
 
-    @property
-    def is_managed_variants_required(self) -> bool:
-        """Return True if a managed variants needs to be exported from Scout."""
-        return True
-
-    def write_managed_variants(self, case_id: str, content: list[str]) -> None:
-        self._write_managed_variants(out_dir=Path(self.root, case_id), content=content)
-
-    def get_managed_variants(self, case_id: str) -> list[str]:
-        """Create and return the managed variants."""
-        return self._get_managed_variants(
-            genome_build=self.get_gene_panel_genome_build(case_id=case_id)
-        )
-
     def get_workflow_metrics(self, sample_id: str) -> dict:
         """Return Raredisease workflow metric conditions for a sample."""
         sample: Sample = self.status_db.get_sample_by_internal_id(internal_id=sample_id)
@@ -282,20 +190,3 @@ class RarediseaseAnalysisAPI(NfAnalysisAPI):
         return super().parse_analysis(
             qc_metrics_raw=qc_metrics_raw, qc_metrics_model=qc_metrics_model, **kwargs
         )
-
-    def get_sample_name_mapping_csv_path(self, case: str) -> Path:
-        """Return the path to the CSV file containing the mapping between sample names and internal ids."""
-        return Path(self.get_case_path(case), f"{case}_customer_internal_mapping.csv")
-
-    def export_customer_internal_mapping_csv(self, case: str, output_path: Path):
-        """Export a CSV file mapping customer sample names to internal sample IDs."""
-        LOG.info(f"Exporting customer internal mapping CSV for case {case} to {output_path}")
-        with output_path.open("w", newline="") as csvfile:
-            writer = csv.writer(csvfile)
-            writer.writerow(
-                ["customer_id", "internal_id"]
-            )  # this is the header expected by the pipeline
-            for link in self.status_db.get_case_by_internal_id(case).links:
-                customer_sample_name = link.sample.name
-                internal_id = link.sample.internal_id
-                writer.writerow([customer_sample_name, internal_id])