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

cg/services/analysis_starter/configurator/file_creators/balsamic_config.py

@@ -0,0 +1,240 @@
+import logging
+import subprocess
+from pathlib import Path
+from subprocess import CalledProcessError
+from typing import cast
+
+from pydantic import EmailStr
+
+from cg.apps.lims.api import LimsAPI
+from cg.constants import SexOptions
+from cg.constants.constants import GenomeVersion, Workflow
+from cg.constants.process import EXIT_SUCCESS
+from cg.constants.sequencing import SeqLibraryPrepCategory
+from cg.models.cg_config import BalsamicConfig
+from cg.services.analysis_starter.configurator.models.balsamic import (
+    BalsamicConfigInput,
+    BalsamicConfigInputPanel,
+    BalsamicConfigInputWGS,
+)
+from cg.store.models import BedVersion, Case, Sample
+from cg.store.store import Store
+
+LOG = logging.getLogger(__name__)
+
+
+class BalsamicConfigFileCreator:
+
+    def __init__(self, cg_balsamic_config: BalsamicConfig, lims_api: LimsAPI, status_db: Store):
+        self.status_db = status_db
+        self.root_dir = cg_balsamic_config.root
+        self.lims_api: LimsAPI = lims_api
+        self.conda_binary: Path = cg_balsamic_config.conda_binary
+        self.conda_env: str = cg_balsamic_config.conda_env
+        self.balsamic_binary: Path = cg_balsamic_config.binary_path
+        self.root_dir: Path = cg_balsamic_config.root
+        self.bed_directory: Path = cg_balsamic_config.bed_path
+        self.cache_dir: Path = cg_balsamic_config.balsamic_cache
+        self.cadd_path: Path = cg_balsamic_config.cadd_path
+        self.genome_interval_path: Path = cg_balsamic_config.genome_interval_path
+        self.gens_coverage_female_path: Path = cg_balsamic_config.gens_coverage_female_path
+        self.gens_coverage_male_path: Path = cg_balsamic_config.gens_coverage_male_path
+        self.gnomad_af5_path: Path = cg_balsamic_config.gnomad_af5_path
+        self.environment: str = cg_balsamic_config.conda_env
+        self.sentieon_licence_path: Path = cg_balsamic_config.sentieon_licence_path
+        self.sentieon_licence_server: str = cg_balsamic_config.sentieon_licence_server
+        self.loqusdb_artefact_snv: Path = cg_balsamic_config.loqusdb_dump_files.artefact_snv
+        self.artefact_sv_observations: Path = cg_balsamic_config.loqusdb_dump_files.artefact_sv
+        self.loqusdb_cancer_germline_snv: Path = (
+            cg_balsamic_config.loqusdb_dump_files.cancer_germline_snv
+        )
+        self.loqusdb_cancer_somatic_snv: Path = (
+            cg_balsamic_config.loqusdb_dump_files.cancer_somatic_snv
+        )
+        self.loqusdb_cancer_somatic_snv_panels: dict = (
+            cg_balsamic_config.loqusdb_dump_files.cancer_somatic_snv_panels
+        )
+        self.loqusdb_cancer_somatic_sv: Path = (
+            cg_balsamic_config.loqusdb_dump_files.cancer_somatic_sv
+        )
+        self.loqusdb_clinical_snv: Path = cg_balsamic_config.loqusdb_dump_files.clinical_snv
+        self.loqusdb_clinical_sv: Path = cg_balsamic_config.loqusdb_dump_files.clinical_sv
+        self.panel_of_normals: dict = cg_balsamic_config.panel_of_normals
+        self.slurm_account: str = cg_balsamic_config.slurm.account
+        self.slurm_mail_user: EmailStr = cg_balsamic_config.slurm.mail_user
+        self.swegen_snv: Path = cg_balsamic_config.swegen_snv
+        self.swegen_sv: Path = cg_balsamic_config.swegen_sv
+
+    def create(self, case_id: str, fastq_path: Path, **flags) -> None:
+        config_cli_input: BalsamicConfigInput = self._build_config_input(
+            case_id=case_id, fastq_path=fastq_path, **flags
+        )
+        self._create_config_file(config_cli_input)
+
+    @staticmethod
+    def _create_config_file(config_cli_input: BalsamicConfigInput) -> None:
+        final_command: str = config_cli_input.dump_to_cli()
+        LOG.debug(f"Running: {final_command}")
+        result = subprocess.run(
+            args=final_command,
+            shell=True,
+            check=False,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        if result.returncode != EXIT_SUCCESS:
+            LOG.critical(result.stderr.decode("utf-8").rstrip())
+            raise CalledProcessError(result.returncode, final_command)
+
+    def _build_config_input(self, case_id: str, fastq_path: Path, **flags) -> BalsamicConfigInput:
+        case: Case = self.status_db.get_case_by_internal_id_strict(case_id)
+        if self._all_samples_are_wgs(case):
+            return self._build_wgs_config(case=case, fastq_path=fastq_path)
+        else:
+            return self._build_targeted_config(
+                case=case, fastq_path=fastq_path, override_panel_bed=flags.get("panel_bed")
+            )
+
+    def _build_wgs_config(self, case: Case, fastq_path: Path) -> BalsamicConfigInput:
+        patient_sex: SexOptions = self._get_patient_sex(case)
+        return BalsamicConfigInputWGS(
+            analysis_dir=self.root_dir,
+            analysis_workflow=cast(Workflow, case.data_analysis),
+            artefact_snv_observations=self.loqusdb_artefact_snv,
+            artefact_sv_observations=self.artefact_sv_observations,
+            balsamic_binary=self.balsamic_binary,
+            balsamic_cache=self.cache_dir,
+            cadd_annotations=self.cadd_path,
+            cancer_germline_snv_observations=self.loqusdb_cancer_germline_snv,
+            cancer_somatic_snv_observations=self.loqusdb_cancer_somatic_snv,
+            cancer_somatic_sv_observations=self.loqusdb_cancer_somatic_sv,
+            case_id=case.internal_id,
+            clinical_snv_observations=self.loqusdb_clinical_snv,
+            clinical_sv_observations=self.loqusdb_clinical_sv,
+            conda_binary=self.conda_binary,
+            conda_env=self.conda_env,
+            fastq_path=fastq_path,
+            gender=patient_sex,
+            genome_interval=self.genome_interval_path,
+            genome_version=GenomeVersion.HG19,
+            gens_coverage_pon=self._get_gens_coverage_pon_file(patient_sex),
+            gnomad_min_af5=self.gnomad_af5_path,
+            normal_sample_name=self._get_normal_sample_id_from_paired_analysis(case),
+            sentieon_install_dir=self.sentieon_licence_path,
+            sentieon_license=self.sentieon_licence_server,
+            swegen_snv=self.swegen_snv,
+            swegen_sv=self.swegen_sv,
+            tumor_sample_name=self._get_tumor_or_single_sample_id(case),
+        )
+
+    def _build_targeted_config(
+        self, case: Case, fastq_path: Path, override_panel_bed: str | None
+    ) -> BalsamicConfigInput:
+        bed_version: BedVersion = self._get_bed_version(
+            case=case, override_panel_bed=override_panel_bed
+        )
+        bed_file: Path = Path(self.bed_directory, bed_version.filename)
+        patient_sex: SexOptions = self._get_patient_sex(case)
+        return BalsamicConfigInputPanel(
+            analysis_dir=self.root_dir,
+            analysis_workflow=cast(Workflow, case.data_analysis),
+            artefact_snv_observations=self.loqusdb_artefact_snv,
+            balsamic_binary=self.balsamic_binary,
+            balsamic_cache=self.cache_dir,
+            cadd_annotations=self.cadd_path,
+            cancer_germline_snv_observations=self.loqusdb_cancer_germline_snv,
+            cancer_somatic_snv_observations=self.loqusdb_cancer_somatic_snv,
+            cancer_somatic_snv_panel_observations=self.loqusdb_cancer_somatic_snv_panels.get(
+                bed_version.bed_name
+            ),
+            cancer_somatic_sv_observations=self.loqusdb_cancer_somatic_sv,
+            case_id=case.internal_id,
+            clinical_snv_observations=self.loqusdb_clinical_snv,
+            clinical_sv_observations=self.loqusdb_clinical_sv,
+            conda_binary=self.conda_binary,
+            conda_env=self.conda_env,
+            fastq_path=fastq_path,
+            gender=patient_sex,
+            genome_version=GenomeVersion.HG19,
+            gnomad_min_af5=self.gnomad_af5_path,
+            normal_sample_name=self._get_normal_sample_id_from_paired_analysis(case),
+            panel_bed=bed_file,
+            pon_cnn=self._get_pon_file(bed_version.shortname),
+            exome=self._all_samples_are_exome(case),
+            sentieon_install_dir=self.sentieon_licence_path,
+            sentieon_license=self.sentieon_licence_server,
+            soft_filter_normal=self._is_case_paired_analysis(case),
+            swegen_snv=self.swegen_snv,
+            swegen_sv=self.swegen_sv,
+            tumor_sample_name=self._get_tumor_or_single_sample_id(case),
+        )
+
+    @staticmethod
+    def _all_samples_are_wgs(case: Case) -> bool:
+        """Check if all samples in the case are WGS."""
+        return all(
+            sample.prep_category == SeqLibraryPrepCategory.WHOLE_GENOME_SEQUENCING
+            for sample in case.samples
+        )
+
+    @staticmethod
+    def _all_samples_are_exome(case: Case) -> bool:
+        """Check if all samples in the case are exome."""
+        return all(
+            sample.prep_category == SeqLibraryPrepCategory.WHOLE_EXOME_SEQUENCING
+            for sample in case.samples
+        )
+
+    @staticmethod
+    def _get_patient_sex(case) -> SexOptions:
+        sample_sex: set[SexOptions] = {sample.sex for sample in case.samples}
+        return sample_sex.pop()
+
+    @staticmethod
+    def _get_normal_sample_id_from_paired_analysis(case) -> str | None:
+        """Return the internal id of the normal sample if the case is a paired analysis, otherwise None."""
+        if len(case.samples) == 2:
+            for sample in case.samples:
+                if not sample.is_tumour:
+                    return sample.internal_id
+
+    @staticmethod
+    def _get_tumor_or_single_sample_id(case) -> str:
+        """
+        Return the internal id of the tumour sample if the case is a paired analysis,
+        otherwise return the internal id of the single sample.
+        """
+        if len(case.samples) == 1:
+            return case.samples[0].internal_id
+        for sample in case.samples:
+            if sample.is_tumour:
+                return sample.internal_id
+
+    @staticmethod
+    def _is_case_paired_analysis(case: Case) -> bool:
+        return len(case.samples) == 2
+
+    def _get_bed_version(self, case: Case, override_panel_bed: str | None) -> BedVersion:
+        first_sample: Sample = case.samples[0]
+        short_name: str = override_panel_bed or self.lims_api.get_capture_kit_strict(
+            first_sample.internal_id
+        )
+        return self.status_db.get_bed_version_by_short_name_strict(short_name)
+
+    def _get_pon_file(self, bed_short_name: str | None) -> Path | None:
+        if pon_file := self.panel_of_normals.get(bed_short_name):
+            return pon_file
+        else:
+            LOG.info(f"No PON file found for bed file {pon_file}. Configuring without PON.")
+            return None
+
+    def _get_sample_config_path(self, case_id: str) -> Path:
+        return Path(self.root_dir, case_id, f"{case_id}.json")
+
+    def _get_gens_coverage_pon_file(self, patient_sex: SexOptions) -> Path:
+        """Return the corresponding PON file for WGS cases based on the patient's sex."""
+        return (
+            self.gens_coverage_male_path
+            if patient_sex == SexOptions.MALE
+            else self.gens_coverage_female_path
+        )

cg/services/analysis_starter/configurator/file_creators/gene_panel.py

@@ -17,18 +17,23 @@ class GenePanelFileCreator:
         self.store = store
         self.scout_api = scout_api
 
-    def create(self, case_id: str, file_path: Path) -> None:
-        content: list[str] = self._get_content(case_id)
+    def create(self, case_id: str, file_path: Path, double_hashtag_filtering: bool = False) -> None:
+        content: list[str] = self._get_content(
+            case_id=case_id, double_hashtag_filtering=double_hashtag_filtering
+        )
         write_txt_with_newlines(file_path=file_path, content=content)
         LOG.info(f"Created gene panel file for case {case_id} at {file_path}")
 
-    def _get_content(self, case_id: str) -> list[str]:
-        case: Case = self.store.get_case_by_internal_id(internal_id=case_id)
+    def _get_content(self, case_id: str, double_hashtag_filtering: bool) -> list[str]:
+        case: Case = self.store.get_case_by_internal_id_strict(internal_id=case_id)
         genome_build: GenePanelGenomeBuild = get_genome_build(workflow=case.data_analysis)
         all_panels: list[str] = self._get_aggregated_panels(
             customer_id=case.customer.internal_id, default_panels=set(case.panels)
         )
-        return self.scout_api.export_panels(build=genome_build, panels=all_panels)
+        panels: list[str] = self.scout_api.export_panels(build=genome_build, panels=all_panels)
+        if double_hashtag_filtering:
+            panels = [panel for panel in panels if not panel.startswith("##")]
+        return panels
 
     def _get_aggregated_panels(self, customer_id: str, default_panels: set[str]) -> list[str]:
         """Check if the customer is collaborator for gene panel master list

cg/services/analysis_starter/configurator/file_creators/nextflow/params_file/abstract.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 from pathlib import Path
+from typing import Any
 
 
 class ParamsFileCreator(ABC):
@@ -8,5 +9,5 @@ class ParamsFileCreator(ABC):
         self.params = Path(params)
 
     @abstractmethod
-    def create(self, case_id: str, file_path: Path, sample_sheet_path: Path) -> any:
+    def create(self, case_id: str, file_path: Path, sample_sheet_path: Path) -> Any:
         pass

cg/services/analysis_starter/configurator/file_creators/nextflow/params_file/models.py

@@ -1,6 +1,21 @@
 from pathlib import Path
 
-from cg.models.nf_analysis import WorkflowParameters
+from pydantic import BaseModel, field_validator
+
+from cg.constants.constants import GenomeVersion
+from cg.constants.sample_sources import SourceType
+from cg.utils.utils import replace_non_alphanumeric
+
+
+class WorkflowParameters(BaseModel):
+    input: Path
+    outdir: Path
+
+
+class NalloParameters(WorkflowParameters):
+    """Model for Nallo parameters."""
+
+    filter_variants_hgnc_ids: str
 
 
 class RarediseaseParameters(WorkflowParameters):
@@ -20,3 +35,27 @@ class RNAFusionParameters(WorkflowParameters):
 
 class TaxprofilerParameters(WorkflowParameters):
     """Taxprofiler parameters."""
+
+
+class TomteParameters(WorkflowParameters):
+    """Model for Tomte parameters."""
+
+    gene_panel_clinical_filter: Path
+    tissue: str
+    genome: str = GenomeVersion.HG38
+
+    @field_validator("tissue", mode="before")
+    @classmethod
+    def restrict_tissue_values(cls, tissue: str | None) -> str:
+        if tissue:
+            return replace_non_alphanumeric(string=tissue)
+        else:
+            return SourceType.UNKNOWN
+
+    @field_validator("genome", mode="before")
+    @classmethod
+    def restrict_genome_values(cls, genome: str) -> str:
+        if genome == GenomeVersion.HG38:
+            return GenomeVersion.GRCh38.value
+        elif genome == GenomeVersion.HG19:
+            return GenomeVersion.GRCh37.value

cg/services/analysis_starter/configurator/file_creators/nextflow/params_file/nallo.py

@@ -0,0 +1,37 @@
+import logging
+from pathlib import Path
+from typing import Any
+
+from cg.constants.scout import ScoutExportFileName
+from cg.io.yaml import read_yaml, write_yaml_nextflow_style
+from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.abstract import (
+    ParamsFileCreator,
+)
+from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.models import (
+    NalloParameters,
+)
+from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.utils import (
+    replace_values_in_params_file,
+)
+
+LOG = logging.getLogger(__name__)
+
+
+class NalloParamsFileCreator(ParamsFileCreator):
+    def create(self, case_id: str, file_path: Path, sample_sheet_path: Path) -> Any:
+        LOG.debug(f"Creating params file for case {case_id}")
+        content: dict = self._get_content(
+            case_run_directory=file_path.parent, sample_sheet_path=sample_sheet_path
+        )
+        write_yaml_nextflow_style(content=content, file_path=file_path)
+
+    def _get_content(self, case_run_directory: Path, sample_sheet_path: Path) -> dict:
+        nallo_parameters = NalloParameters(
+            input=sample_sheet_path,
+            outdir=case_run_directory,
+            filter_variants_hgnc_ids=f"{case_run_directory}/{ScoutExportFileName.PANELS_TSV}",
+        )
+        workflow_parameters: dict = read_yaml(self.params)
+        parameters: dict = nallo_parameters.model_dump() | workflow_parameters
+        curated_parameters: dict = replace_values_in_params_file(parameters)
+        return curated_parameters

cg/services/analysis_starter/configurator/file_creators/nextflow/params_file/raredisease.py

@@ -84,13 +84,16 @@ class RarediseaseParamsFileCreator(ParamsFileCreator):
         """
         case: Case = self.store.get_case_by_internal_id_strict(internal_id=case_id)
         sample: Sample = case.samples[0]
-        target_bed_shortname: str = self.lims.get_capture_kit_strict(
+        target_bed_shortname: str | None = self.lims.capture_kit(
             sample.from_sample or sample.internal_id
         )
-        bed_version: BedVersion = self.store.get_bed_version_by_short_name_strict(
-            target_bed_shortname
-        )
-        return bed_version.filename
+        if target_bed_shortname:
+            bed_version: BedVersion = self.store.get_bed_version_by_short_name_strict(
+                target_bed_shortname
+            )
+            return bed_version.filename
+        else:
+            return ""
 
     def _create_sample_mapping_file(self, case_id: str, case_path: Path) -> Path:
         """Create a sample mapping file for the case and returns its path."""

cg/services/analysis_starter/configurator/file_creators/nextflow/params_file/tomte_params_file_creator.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+from typing import Iterator
+
+from cg.apps.lims import LimsAPI
+from cg.constants.constants import GenomeVersion
+from cg.constants.scout import ScoutExportFileName
+from cg.exc import CgError
+from cg.io.yaml import read_yaml, write_yaml_nextflow_style
+from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.abstract import (
+    ParamsFileCreator,
+)
+from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.models import (
+    TomteParameters,
+)
+from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.utils import (
+    replace_values_in_params_file,
+)
+from cg.store.store import Store
+
+
+class TomteParamsFileCreator(ParamsFileCreator):
+    def __init__(self, params: str, lims_api: LimsAPI, status_db: Store):
+        super().__init__(params)
+        self.lims_api = lims_api
+        self.status_db = status_db
+
+    def create(self, case_id: str, file_path: Path, sample_sheet_path: Path) -> None:
+        content: dict = self._get_content(
+            case_id=case_id,
+            case_run_directory=file_path.parent,
+            sample_sheet_path=sample_sheet_path,
+        )
+        write_yaml_nextflow_style(content=content, file_path=file_path)
+
+    def _get_content(self, case_id: str, case_run_directory: Path, sample_sheet_path: Path):
+        case_parameters = TomteParameters(
+            input=sample_sheet_path,
+            outdir=case_run_directory,
+            gene_panel_clinical_filter=Path(case_run_directory, ScoutExportFileName.PANELS),
+            tissue=self._get_case_source_type(case_id),  # type:ignore
+            genome=GenomeVersion.HG38,
+        ).model_dump()
+
+        workflow_params = self._get_workflow_params()
+        workflow_parameters: dict = workflow_params | case_parameters
+        return replace_values_in_params_file(workflow_parameters=workflow_parameters)
+
+    def _get_workflow_params(self) -> dict:
+        return read_yaml(self.params)
+
+    def _get_case_source_type(self, case_id: str) -> str | None:
+        """
+        Return the sample source type of a case.
+
+        Raises:
+            CgError: If different sources are set for the samples linked to a case.
+        """
+        sample_ids: Iterator[str] = self.status_db.get_sample_ids_by_case_id(case_id=case_id)
+        source_types: set[str | None] = {
+            self.lims_api.get_source(sample_id) for sample_id in sample_ids
+        }
+        if len(source_types) > 1:
+            raise CgError(f"Different source types found for case: {case_id} ({source_types})")
+        return source_types.pop()

cg/services/analysis_starter/configurator/file_creators/nextflow/sample_sheet/creator.py

@@ -16,7 +16,7 @@ from cg.store.store import Store
 LOG = logging.getLogger(__name__)
 
 
-class NextflowSampleSheetCreator(ABC):
+class NextflowFastqSampleSheetCreator(ABC):
 
     def __init__(self, housekeeper_api: HousekeeperAPI, store: Store):
         self.housekeeper_api = housekeeper_api

cg/services/analysis_starter/configurator/file_creators/nextflow/sample_sheet/nallo_sample_sheet_creator.py

@@ -0,0 +1,65 @@
+import logging
+from pathlib import Path
+
+from cg.apps.housekeeper.hk import HousekeeperAPI
+from cg.constants.subject import PlinkPhenotypeStatus, PlinkSex
+from cg.io.csv import write_csv
+from cg.store.models import Case, CaseSample, Sample
+from cg.store.store import Store
+
+LOG = logging.getLogger(__name__)
+
+HEADERS: list[str] = [
+    "project",
+    "sample",
+    "file",
+    "family_id",
+    "paternal_id",
+    "maternal_id",
+    "sex",
+    "phenotype",
+]
+
+
+class NalloSampleSheetCreator:
+    def __init__(self, housekeeper_api: HousekeeperAPI, status_db: Store) -> None:
+        self.housekeeper_api = housekeeper_api
+        self.status_db = status_db
+
+    def create(self, case_id: str, file_path: Path) -> None:
+        LOG.debug(f"Creating sample sheet for case {case_id}")
+        content: list[list[str]] = self._get_content(case_id)
+        write_csv(content=content, file_path=file_path)
+
+    def _get_content(self, case_id: str) -> list[list[str]]:
+        case: Case = self.status_db.get_case_by_internal_id_strict(case_id)
+        sample_sheet_content: list[list[str]] = [HEADERS]
+        for link in case.links:
+            sample_sheet_content.extend(self._get_sample_sheet_content_per_sample(case_sample=link))
+        return sample_sheet_content
+
+    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: list[str] = self._get_bam_read_file_paths(sample=case_sample.sample)
+        sample_sheet_entries = []
+
+        for bam_path in read_file_paths:
+            sample_sheet_entry: list[str] = [
+                case_sample.case.internal_id,
+                case_sample.sample.internal_id,
+                bam_path,
+                case_sample.case.internal_id,
+                case_sample.get_paternal_sample_id or "0",
+                case_sample.get_maternal_sample_id or "0",
+                PlinkSex[case_sample.sample.sex.upper()].value,
+                str(PlinkPhenotypeStatus[case_sample.status.upper()]),
+            ]
+            sample_sheet_entries.append(sample_sheet_entry)
+        return sample_sheet_entries
+
+    def _get_bam_read_file_paths(self, sample: Sample) -> list[str]:
+        """Gather BAM file path for a sample based on the BAM tag."""
+        return [
+            hk_file.full_path
+            for hk_file in self.housekeeper_api.files(bundle=sample.internal_id, tags={"bam"})
+        ]

cg/services/analysis_starter/configurator/file_creators/nextflow/sample_sheet/protocol.py

@@ -0,0 +1,12 @@
+from abc import abstractmethod
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class SampleSheetCreator(Protocol):
+    @abstractmethod
+    def create(self, case_id: str, file_path: Path) -> None:
+        raise NotImplementedError(
+            "Please implement create to conform to the SampleSheetFileCreator protocol"
+        )

cg/services/analysis_starter/configurator/file_creators/nextflow/sample_sheet/{raredisease.py → raredisease_sample_sheet_creator.py}

@@ -2,7 +2,7 @@ from typing import Iterator
 
 from cg.constants.subject import PlinkPhenotypeStatus, PlinkSex
 from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.creator import (
-    NextflowSampleSheetCreator,
+    NextflowFastqSampleSheetCreator,
 )
 from cg.store.models import Case, CaseSample
 
@@ -19,7 +19,7 @@ HEADERS: list[str] = [
 ]
 
 
-class RarediseaseSampleSheetCreator(NextflowSampleSheetCreator):
+class RarediseaseSampleSheetCreator(NextflowFastqSampleSheetCreator):
 
     def _get_content(self, case_id: str) -> list[list[str]]:
         """Return formatted information required to build a sample sheet for a raredisease case.

cg/services/analysis_starter/configurator/file_creators/nextflow/sample_sheet/{rnafusion.py → rnafusion_sample_sheet_creator.py}

@@ -2,14 +2,14 @@ from collections.abc import Iterator
 
 from cg.constants.constants import Strandedness
 from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.creator import (
-    NextflowSampleSheetCreator,
+    NextflowFastqSampleSheetCreator,
 )
 from cg.store.models import Case, Sample
 
 HEADERS: list[str] = ["sample", "fastq_1", "fastq_2", "strandedness"]
 
 
-class RNAFusionSampleSheetCreator(NextflowSampleSheetCreator):
+class RNAFusionSampleSheetCreator(NextflowFastqSampleSheetCreator):
 
     def _get_content(self, case_id: str) -> list[list[str]]:
         content: list[list[str]] = [HEADERS]

cg/services/analysis_starter/configurator/file_creators/nextflow/sample_sheet/{taxprofiler.py → taxprofiler_sample_sheet_creator.py}

@@ -3,7 +3,7 @@ from collections.abc import Iterator
 from cg.constants.sequencing import SequencingPlatform
 from cg.constants.symbols import EMPTY_STRING
 from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.creator import (
-    NextflowSampleSheetCreator,
+    NextflowFastqSampleSheetCreator,
 )
 from cg.store.models import Case, Sample
 
@@ -17,7 +17,7 @@ HEADERS: list[str] = [
 ]
 
 
-class TaxprofilerSampleSheetCreator(NextflowSampleSheetCreator):
+class TaxprofilerSampleSheetCreator(NextflowFastqSampleSheetCreator):
 
     def _get_content(self, case_id: str) -> list[list[str]]:
         """Return formatted information required to build a sample sheet for a case.

cg/services/analysis_starter/configurator/file_creators/nextflow/sample_sheet/tomte_sample_sheet_creator.py

@@ -0,0 +1,36 @@
+from typing import Iterator
+
+from cg.constants.constants import Strandedness
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.creator import (
+    NextflowFastqSampleSheetCreator,
+)
+from cg.store.models import Case, Sample
+
+HEADERS: list[str] = ["case", "sample", "fastq_1", "fastq_2", "strandedness"]
+
+
+class TomteSampleSheetCreator(NextflowFastqSampleSheetCreator):
+    def _get_content(self, case_id: str) -> list[list[str]]:
+        content: list[list[str]] = [HEADERS]
+        case: Case = self.store.get_case_by_internal_id_strict(case_id)
+        for sample in case.samples:
+            content.extend(
+                self._get_sample_sheet_content_per_sample(case_id=case_id, sample=sample)
+            )
+        return content
+
+    def _get_sample_sheet_content_per_sample(self, case_id: str, sample: Sample) -> list[list[str]]:
+        """Collect and format information required to build a sample sheet for a single sample."""
+        paired_fastq_files: Iterator[tuple[str, str]] = self._get_paired_read_paths(sample)
+        content: list[list[str]] = []
+        for fastq_forward_read_path, fastq_reverse_read_path in paired_fastq_files:
+            content.append(
+                [
+                    case_id,
+                    sample.internal_id,
+                    fastq_forward_read_path,
+                    fastq_reverse_read_path,
+                    Strandedness.REVERSE,
+                ]
+            )
+        return content