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

cg/meta/workflow/rnafusion.py

@@ -4,7 +4,7 @@ import logging
 from pathlib import Path
 
 from cg.constants import Workflow
-from cg.constants.constants import GenomeVersion, Strandedness
+from cg.constants.constants import GenomeVersion
 from cg.constants.nf_analysis import RNAFUSION_METRIC_CONDITIONS
 from cg.constants.scout import RNAFUSION_CASE_TAGS
 from cg.exc import MissingMetrics
@@ -12,13 +12,8 @@ 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
-from cg.models.rnafusion.rnafusion import (
-    RnafusionParameters,
-    RnafusionQCMetrics,
-    RnafusionSampleSheetEntry,
-)
+from cg.models.rnafusion.rnafusion import RnafusionQCMetrics
 from cg.resources import RNAFUSION_BUNDLE_FILENAMES_PATH
-from cg.store.models import CaseSample
 
 LOG = logging.getLogger(__name__)
 
@@ -50,11 +45,6 @@ class RnafusionAnalysisAPI(NfAnalysisAPI):
         self.revision: str = config.rnafusion.revision
         self.nextflow_binary_path: str = config.rnafusion.binary_path
 
-    @property
-    def sample_sheet_headers(self) -> list[str]:
-        """Headers for sample sheet."""
-        return RnafusionSampleSheetEntry.headers()
-
     @property
     def is_multiple_samples_allowed(self) -> bool:
         """Return whether the analysis supports multiple samples to be linked to the case."""
@@ -69,28 +59,6 @@ class RnafusionAnalysisAPI(NfAnalysisAPI):
         """Return Rnafusion bundle filenames path."""
         return RNAFUSION_BUNDLE_FILENAMES_PATH
 
-    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 = RnafusionSampleSheetEntry(
-            name=case_sample.sample.internal_id,
-            fastq_forward_read_paths=fastq_forward_read_paths,
-            fastq_reverse_read_paths=fastq_reverse_read_paths,
-            strandedness=Strandedness.REVERSE,
-        )
-        return sample_sheet_entry.reformat_sample_content()
-
-    def get_built_workflow_parameters(
-        self, case_id: str, dry_run: bool = False
-    ) -> RnafusionParameters:
-        """Get Rnafusion parameters."""
-        return RnafusionParameters(
-            input=self.get_sample_sheet_path(case_id=case_id),
-            outdir=self.get_case_path(case_id=case_id),
-        )
-
     @staticmethod
     def ensure_mandatory_metrics_present(metrics: list[MetricsBase]) -> None:
         """Check that all mandatory metrics are present.

cg/meta/workflow/taxprofiler.py

@@ -5,19 +5,13 @@ from pathlib import Path
 
 from cg.constants import Workflow
 from cg.constants.constants import GenomeVersion
-from cg.constants.sequencing import SequencingPlatform
-from cg.constants.symbols import EMPTY_STRING
 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
-from cg.models.taxprofiler.taxprofiler import (
-    TaxprofilerParameters,
-    TaxprofilerQCMetrics,
-    TaxprofilerSampleSheetEntry,
-)
+from cg.models.taxprofiler.taxprofiler import TaxprofilerQCMetrics
 from cg.resources import TAXPROFILER_BUNDLE_FILENAMES_PATH
-from cg.store.models import CaseSample, Sample
+from cg.store.models import Sample
 
 LOG = logging.getLogger(__name__)
 
@@ -49,11 +43,6 @@ class TaxprofilerAnalysisAPI(NfAnalysisAPI):
         self.nextflow_binary_path: str = config.taxprofiler.binary_path
         self.compute_env_base: str = config.taxprofiler.compute_env
 
-    @property
-    def sample_sheet_headers(self) -> list[str]:
-        """Headers for sample sheet."""
-        return TaxprofilerSampleSheetEntry.headers()
-
     @property
     def is_multiqc_pattern_search_exact(self) -> bool:
         """Only exact pattern search is allowed to collect metrics information from multiqc file."""
@@ -64,31 +53,6 @@ class TaxprofilerAnalysisAPI(NfAnalysisAPI):
         """Return Taxprofiler bundle filenames path."""
         return TAXPROFILER_BUNDLE_FILENAMES_PATH
 
-    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."""
-        sample_name: str = case_sample.sample.name
-        fastq_forward_read_paths, fastq_reverse_read_paths = self.get_paired_read_paths(
-            sample=case_sample.sample
-        )
-        sample_sheet_entry = TaxprofilerSampleSheetEntry(
-            name=sample_name,
-            run_accession=sample_name,
-            instrument_platform=SequencingPlatform.ILLUMINA,
-            fastq_forward_read_paths=fastq_forward_read_paths,
-            fastq_reverse_read_paths=fastq_reverse_read_paths,
-            fasta=EMPTY_STRING,
-        )
-        return sample_sheet_entry.reformat_sample_content()
-
-    def get_built_workflow_parameters(
-        self, case_id: str, dry_run: bool = False
-    ) -> TaxprofilerParameters:
-        """Return Taxprofiler parameters."""
-        return TaxprofilerParameters(
-            input=self.get_sample_sheet_path(case_id=case_id),
-            outdir=self.get_case_path(case_id=case_id),
-        )
-
     def get_multiqc_search_patterns(self, case_id: str) -> dict:
         """Return search patterns for MultiQC for Taxprofiler."""
         samples: list[Sample] = self.status_db.get_samples_by_case_id(case_id=case_id)

cg/meta/workflow/tomte.py

@@ -4,20 +4,14 @@ import logging
 from pathlib import Path
 
 from cg.constants import Workflow
-from cg.constants.constants import GenomeVersion, Strandedness
+from cg.constants.constants import GenomeVersion
 from cg.constants.nf_analysis import TOMTE_METRIC_CONDITIONS
 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
-from cg.models.tomte.tomte import (
-    TomteParameters,
-    TomteQCMetrics,
-    TomteSampleSheetEntry,
-    TomteSampleSheetHeaders,
-)
+from cg.models.tomte.tomte import TomteQCMetrics
 from cg.resources import TOMTE_BUNDLE_FILENAMES_PATH
-from cg.store.models import CaseSample
 
 LOG = logging.getLogger(__name__)
 
@@ -48,45 +42,11 @@ class TomteAnalysisAPI(NfAnalysisAPI):
         self.revision: str = config.tomte.revision
         self.nextflow_binary_path: str = config.tomte.binary_path
 
-    @property
-    def sample_sheet_headers(self) -> list[str]:
-        """Headers for sample sheet."""
-        return TomteSampleSheetHeaders.list()
-
-    @property
-    def is_gene_panel_required(self) -> bool:
-        """Return True if a gene panel is needs to be created using the information in StatusDB and exporting it from Scout."""
-        return True
-
     @staticmethod
     def get_bundle_filenames_path() -> Path:
         """Return path to bundle template."""
         return TOMTE_BUNDLE_FILENAMES_PATH
 
-    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 = TomteSampleSheetEntry(
-            case_id=case_sample.case.internal_id,
-            name=case_sample.sample.internal_id,
-            fastq_forward_read_paths=fastq_forward_read_paths,
-            fastq_reverse_read_paths=fastq_reverse_read_paths,
-            strandedness=Strandedness.REVERSE,
-        )
-        return sample_sheet_entry.reformat_sample_content
-
-    def get_built_workflow_parameters(self, case_id: str, dry_run: bool = False) -> TomteParameters:
-        """Return parameters."""
-        return TomteParameters(
-            input=self.get_sample_sheet_path(case_id=case_id),
-            outdir=self.get_case_path(case_id=case_id),
-            gene_panel_clinical_filter=self.get_gene_panels_path(case_id=case_id),
-            tissue=self.get_case_source_type(case_id=case_id),
-            genome=self.get_genome_build(case_id=case_id),
-        )
-
     def get_genome_build(self, case_id: str) -> str:
         return GenomeVersion.HG38
 

cg/models/deliverables/metric_deliverables.py

@@ -164,6 +164,6 @@ class MetricsDeliverablesCondition(BaseModel):
 class MultiqcDataJson(BaseModel):
     """Multiqc data json model."""
 
-    report_general_stats_data: list[dict] | None = None
+    report_general_stats_data: list[dict[str, Any]] | None = None
     report_data_sources: dict | None = None
     report_saved_raw_data: dict[str, dict] | None = None

cg/models/nallo/nallo.py

@@ -1,14 +1,22 @@
-from enum import StrEnum
-from pathlib import Path
+from typing import Annotated
 
-from pydantic import BaseModel, field_validator
+from pydantic import BeforeValidator, Field
 
 from cg.constants import SexOptions
-from cg.exc import NfSampleSheetError
-from cg.models.nf_analysis import WorkflowParameters
 from cg.models.qc_metrics import QCMetrics
 
 
+def convert_sex(plink_sex: float) -> SexOptions:
+    if plink_sex == 2:
+        return SexOptions.FEMALE
+    elif plink_sex == 1:
+        return SexOptions.MALE
+    elif plink_sex == 0:
+        return SexOptions.UNKNOWN
+    else:
+        raise NotImplementedError
+
+
 class NalloQCMetrics(QCMetrics):
     """Nallo QC metrics."""
 
@@ -16,62 +24,4 @@ class NalloQCMetrics(QCMetrics):
     coverage_bases: float | None
     median_coverage: float | None
     percent_duplicates: float | None
-    predicted_sex_sex_check: SexOptions
-
-
-class NalloSampleSheetEntry(BaseModel):
-    """Nallo sample model is used when building the sample sheet."""
-
-    project: str
-    sample: str
-    read_file: Path
-    family_id: str
-    paternal_id: str
-    maternal_id: str
-    sex: int
-    phenotype: int
-
-    @property
-    def reformat_sample_content(self) -> list[list[str]]:
-        """Reformat sample sheet content as a list of lists, where each list represents a line in the final file."""
-        return [
-            [
-                self.project,
-                self.sample,
-                self.read_file,
-                self.family_id,
-                self.paternal_id,
-                self.maternal_id,
-                self.sex,
-                self.phenotype,
-            ]
-        ]
-
-    @field_validator("read_file")
-    @classmethod
-    def read_file_exists(cls, bam_path: Path) -> Path:
-        """Verify that bam files exist."""
-        if not bam_path.is_file():
-            raise NfSampleSheetError(f"Bam file does not exist: {str(bam_path)}")
-        return bam_path
-
-
-class NalloSampleSheetHeaders(StrEnum):
-    project: str = "project"
-    sample: str = "sample"
-    file: str = "file"
-    family_id: str = "family_id"
-    paternal_id: str = "paternal_id"
-    maternal_id: str = "maternal_id"
-    sex: str = "sex"
-    phenotype: str = "phenotype"
-
-    @classmethod
-    def list(cls) -> list[str]:
-        return list(map(lambda header: header.value, cls))
-
-
-class NalloParameters(WorkflowParameters):
-    """Model for Nallo parameters."""
-
-    filter_variants_hgnc_ids: str
+    predicted_sex: Annotated[SexOptions, BeforeValidator(convert_sex)] = Field(alias="somalier_sex")

cg/models/nf_analysis.py

@@ -1,13 +1,6 @@
 from pathlib import Path
 
-from pydantic import BaseModel, ValidationInfo, conlist, field_validator
-
-from cg.exc import NfSampleSheetError
-
-
-class WorkflowParameters(BaseModel):
-    input: Path
-    outdir: Path
+from pydantic import BaseModel, field_validator
 
 
 class NfCommandArgs(BaseModel):
@@ -29,39 +22,6 @@ class NfCommandArgs(BaseModel):
     params_file: str | Path | None = None
 
 
-class NextflowSampleSheetEntry(BaseModel):
-    """Nextflow sample sheet model.
-
-    Attributes:
-        name: sample name, or case id
-        fastq_forward_read_paths: list of all fastq read1 file paths corresponding to sample
-        fastq_reverse_read_paths: list of all fastq read2 file paths corresponding to sample
-    """
-
-    name: str
-    fastq_forward_read_paths: conlist(Path, min_length=1)
-    fastq_reverse_read_paths: conlist(Path, min_length=1)
-
-    @field_validator("fastq_reverse_read_paths")
-    @classmethod
-    def validate_complete_fastq_file_pairs(
-        cls, fastq_reverse: list[str], info: ValidationInfo
-    ) -> list[str]:
-        """Verify that the number of fastq forward files is the same as for the reverse."""
-        if len(fastq_reverse) != len(info.data.get("fastq_forward_read_paths")):
-            raise NfSampleSheetError("Fastq file length for forward and reverse do not match")
-        return fastq_reverse
-
-    @field_validator("fastq_forward_read_paths", "fastq_reverse_read_paths")
-    @classmethod
-    def fastq_files_exist(cls, fastq_paths: list[str]) -> list[str]:
-        """Verify that fastq files exist."""
-        for fastq_path in fastq_paths:
-            if not fastq_path.is_file():
-                raise NfSampleSheetError(f"Fastq file does not exist: {str(fastq_path)}")
-        return fastq_paths
-
-
 class FileDeliverable(BaseModel):
     """Specification for a general deliverables file."""
 

cg/models/raredisease/raredisease.py

@@ -1,8 +1,4 @@
-from enum import StrEnum
-from pathlib import Path
-
 from cg.constants.constants import SexOptions
-from cg.models.nf_analysis import NextflowSampleSheetEntry, WorkflowParameters
 from cg.models.qc_metrics import QCMetrics
 
 
@@ -13,61 +9,3 @@ class RarediseaseQCMetrics(QCMetrics):
     percent_duplication: float
     predicted_sex_sex_check: SexOptions
     total_reads: int
-
-
-class RarediseaseSampleSheetEntry(NextflowSampleSheetEntry):
-    """Raredisease sample model is used when building the sample sheet."""
-
-    sex: str
-    phenotype: int
-    sex: int
-    paternal_id: str
-    maternal_id: str
-    case_id: str
-
-    @property
-    def reformat_sample_content(self) -> list[list[str]]:
-        """Reformat sample sheet content as a list of lists, where each list represents a line in the final file."""
-        return [
-            [
-                self.name,
-                lane + 1,
-                self.fastq_forward_read_paths,
-                self.fastq_reverse_read_paths,
-                self.sex,
-                self.phenotype,
-                self.paternal_id,
-                self.maternal_id,
-                self.case_id,
-            ]
-            for lane, (self.fastq_forward_read_paths, self.fastq_reverse_read_paths) in enumerate(
-                zip(self.fastq_forward_read_paths, self.fastq_reverse_read_paths)
-            )
-        ]
-
-
-class RarediseaseSampleSheetHeaders(StrEnum):
-    sample: str = "sample"
-    lane: str = "lane"
-    fastq_1: str = "fastq_1"
-    fastq_2: str = "fastq_2"
-    sex: str = "sex"
-    phenotype: str = "phenotype"
-    paternal_id: str = "paternal_id"
-    maternal_id: str = "maternal_id"
-    case_id: str = "case_id"
-
-    @classmethod
-    def list(cls) -> list[str]:
-        return list(map(lambda header: header.value, cls))
-
-
-class RarediseaseParameters(WorkflowParameters):
-    """Model for Raredisease parameters."""
-
-    target_bed_file: str
-    analysis_type: str
-    save_mapped_as_cram: bool
-    vcfanno_extra_resources: str
-    vep_filters_scout_fmt: str
-    sample_id_map: Path

cg/models/rnafusion/rnafusion.py

@@ -1,5 +1,3 @@
-from cg.constants.constants import Strandedness
-from cg.models.nf_analysis import NextflowSampleSheetEntry, WorkflowParameters
 from cg.models.qc_metrics import QCMetrics
 
 
@@ -19,27 +17,3 @@ class RnafusionQCMetrics(QCMetrics):
     pct_duplication: float
     read_pairs_examined: float
     uniquely_mapped_percent: float
-
-
-class RnafusionParameters(WorkflowParameters):
-    """Rnafusion parameters."""
-
-
-class RnafusionSampleSheetEntry(NextflowSampleSheetEntry):
-    """Rnafusion sample sheet model."""
-
-    strandedness: Strandedness
-
-    @staticmethod
-    def headers() -> list[str]:
-        """Return sample sheet headers."""
-        return ["sample", "fastq_1", "fastq_2", "strandedness"]
-
-    def reformat_sample_content(self) -> list[list[str]]:
-        """Reformat sample sheet content as a list of list, where each list represents a line in the final file."""
-        return [
-            [self.name, fastq_forward_read_path, fastq_reverse_read_path, str(self.strandedness)]
-            for fastq_forward_read_path, fastq_reverse_read_path in zip(
-                self.fastq_forward_read_paths, self.fastq_reverse_read_paths
-            )
-        ]

cg/models/scout/scout_load_config.py

@@ -85,6 +85,7 @@ class ScoutMipIndividual(ScoutIndividual):
 
 class ScoutNalloIndividual(ScoutIndividual):
     assembly_alignment_path: str | None = None
+    chromograph_images: ChromographImages = ChromographImages()
     d4_file: str | None = None
     minor_allele_frequency_wig: str | None = None
     mt_bam: str | None = None

cg/models/taxprofiler/taxprofiler.py

@@ -1,5 +1,3 @@
-from cg.constants.sequencing import SequencingPlatform
-from cg.models.nf_analysis import NextflowSampleSheetEntry, WorkflowParameters
 from cg.models.qc_metrics import QCMetrics
 
 
@@ -14,43 +12,3 @@ class TaxprofilerQCMetrics(QCMetrics):
     pct_duplication: float
     raw_total_sequences: float
     reads_mapped: float
-
-
-class TaxprofilerParameters(WorkflowParameters):
-    """Taxprofiler parameters."""
-
-
-class TaxprofilerSampleSheetEntry(NextflowSampleSheetEntry):
-    """Taxprofiler sample model is used when building the sample sheet."""
-
-    instrument_platform: SequencingPlatform
-    fasta: str
-
-    @staticmethod
-    def headers() -> list[str]:
-        """Return sample sheet headers."""
-        return [
-            "sample",
-            "run_accession",
-            "instrument_platform",
-            "fastq_1",
-            "fastq_2",
-            "fasta",
-        ]
-
-    def reformat_sample_content(self) -> list[list[str]]:
-        """Reformat sample sheet content as a list of list, where each list represents a line in the final file."""
-        reformatted_content = []
-        for run_accession, (forward_path, reverse_path) in enumerate(
-            zip(self.fastq_forward_read_paths, self.fastq_reverse_read_paths), 1
-        ):
-            line = [
-                self.name,
-                run_accession,
-                self.instrument_platform,
-                forward_path,
-                reverse_path,
-                self.fasta,
-            ]
-            reformatted_content.append(line)
-        return reformatted_content

cg/models/tomte/tomte.py

@@ -1,73 +1,4 @@
-from enum import StrEnum
-from pathlib import Path
-
-from pydantic import field_validator
-
-from cg.constants.constants import GenomeVersion, Strandedness
-from cg.constants.sample_sources import SourceType
-from cg.models.nf_analysis import NextflowSampleSheetEntry, WorkflowParameters
 from cg.models.qc_metrics import QCMetrics
-from cg.utils.utils import replace_non_alphanumeric
-
-
-class TomteSampleSheetEntry(NextflowSampleSheetEntry):
-    """Tomte sample model is used when building the sample sheet."""
-
-    case_id: str
-    strandedness: Strandedness
-
-    @property
-    def reformat_sample_content(self) -> list[list[str]]:
-        """Reformat sample sheet content as a list of lists, where
-        each list represents a line in the final file."""
-        return [
-            [
-                self.case_id,
-                self.name,
-                fastq_forward_read_path,
-                fastq_reverse_read_path,
-                str(self.strandedness),
-            ]
-            for fastq_forward_read_path, fastq_reverse_read_path in zip(
-                self.fastq_forward_read_paths, self.fastq_reverse_read_paths
-            )
-        ]
-
-
-class TomteSampleSheetHeaders(StrEnum):
-    case_id: str = "case"
-    name: str = "sample"
-    fastq_1: str = "fastq_1"
-    fastq_2: str = "fastq_2"
-    strandedness: str = "strandedness"
-
-    @classmethod
-    def list(cls) -> list[str]:
-        return list(map(lambda header: header.value, cls))
-
-
-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
 
 
 class TomteQCMetrics(QCMetrics):