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

cg/meta/observations/observations_api.py

@@ -17,10 +17,10 @@ from cg.models.cg_config import CGConfig, CommonAppConfig
 from cg.models.observations.input_files import (
     BalsamicObservationsInputFiles,
     MipDNAObservationsInputFiles,
-    RarediseaseObservationsInputFiles,
     NalloObservationsInputFiles,
+    RarediseaseObservationsInputFiles,
 )
-from cg.store.models import Analysis, Case
+from cg.store.models import Analysis, Case, Sample
 from cg.store.store import Store
 
 LOG = logging.getLogger(__name__)
@@ -38,6 +38,9 @@ class ObservationsAPI:
         self.loqusdb_wes_config: CommonAppConfig = config.loqusdb_wes
         self.loqusdb_somatic_config: CommonAppConfig = config.loqusdb_somatic
         self.loqusdb_tumor_config: CommonAppConfig = config.loqusdb_tumor
+        self.loqusdb_somatic_lymphoid_config: CommonAppConfig = config.loqusdb_somatic_lymphoid
+        self.loqusdb_somatic_myeloid_config: CommonAppConfig = config.loqusdb_somatic_myeloid
+        self.loqusdb_somatic_exome_config: CommonAppConfig = config.loqusdb_somatic_exome
 
     def upload(self, case_id: str) -> None:
         """
@@ -47,10 +50,7 @@ class ObservationsAPI:
             LoqusdbUploadCaseError: If case is not eligible for Loqusdb uploads
         """
         case: Case = self.store.get_case_by_internal_id(internal_id=case_id)
-        is_case_eligible_for_observations_upload: bool = (
-            self.is_case_eligible_for_observations_upload(case)
-        )
-        if is_case_eligible_for_observations_upload:
+        if self.is_case_eligible_for_observations_upload(case):
             self.load_observations(case=case)
         else:
             LOG.error(f"Case {case.internal_id} is not eligible for observations upload")
@@ -75,29 +75,21 @@ class ObservationsAPI:
 
     def get_loqusdb_api(self, loqusdb_instance: LoqusdbInstance) -> LoqusdbAPI:
         """Returns a Loqusdb API for the given Loqusdb instance."""
-        loqusdb_apis = {
-            LoqusdbInstance.LWP: LoqusdbAPI(
-                binary_path=self.loqusdb_rd_lwp_config.binary_path,
-                config_path=self.loqusdb_rd_lwp_config.config_path,
-            ),
-            LoqusdbInstance.WGS: LoqusdbAPI(
-                binary_path=self.loqusdb_config.binary_path,
-                config_path=self.loqusdb_config.config_path,
-            ),
-            LoqusdbInstance.WES: LoqusdbAPI(
-                binary_path=self.loqusdb_wes_config.binary_path,
-                config_path=self.loqusdb_wes_config.config_path,
-            ),
-            LoqusdbInstance.SOMATIC: LoqusdbAPI(
-                binary_path=self.loqusdb_somatic_config.binary_path,
-                config_path=self.loqusdb_somatic_config.config_path,
-            ),
-            LoqusdbInstance.TUMOR: LoqusdbAPI(
-                binary_path=self.loqusdb_tumor_config.binary_path,
-                config_path=self.loqusdb_tumor_config.config_path,
-            ),
+        loqusdb_config_map: dict = {
+            LoqusdbInstance.LWP: self.loqusdb_rd_lwp_config,
+            LoqusdbInstance.WGS: self.loqusdb_config,
+            LoqusdbInstance.WES: self.loqusdb_wes_config,
+            LoqusdbInstance.SOMATIC: self.loqusdb_somatic_config,
+            LoqusdbInstance.TUMOR: self.loqusdb_tumor_config,
+            LoqusdbInstance.SOMATIC_LYMPHOID: self.loqusdb_somatic_lymphoid_config,
+            LoqusdbInstance.SOMATIC_MYELOID: self.loqusdb_somatic_myeloid_config,
+            LoqusdbInstance.SOMATIC_EXOME: self.loqusdb_somatic_exome_config,
         }
-        return loqusdb_apis[loqusdb_instance]
+        loqusdb_config = loqusdb_config_map[loqusdb_instance]
+        return LoqusdbAPI(
+            binary_path=loqusdb_config.binary_path,
+            config_path=loqusdb_config.config_path,
+        )
 
     @staticmethod
     def is_duplicate(
@@ -117,11 +109,11 @@ class ObservationsAPI:
         )
         return bool(loqusdb_case or duplicate or case.loqusdb_uploaded_samples)
 
-    def update_statusdb_loqusdb_id(self, samples: list[Case], loqusdb_id: str | None) -> None:
+    def update_statusdb_loqusdb_id(self, samples: list[Sample], loqusdb_id: str | None) -> None:
         """Update Loqusdb ID field in StatusDB for each of the provided samples."""
         for sample in samples:
             sample.loqusdb_id = loqusdb_id
-        self.store.session.commit()
+        self.store.commit_to_store()
 
     def is_customer_eligible_for_observations_upload(self, customer_id: str) -> bool:
         """Return whether the customer has been whitelisted for uploading observations."""
@@ -140,8 +132,7 @@ class ObservationsAPI:
             return False
         return True
 
-    def is_sample_source_eligible_for_observations_upload(self, case_id: str) -> bool:
-        """Check if the sample source is FFPE."""
+    def is_sample_source_type_not_ffpe(self, case_id: str) -> bool:
         source_type: str | None = self.analysis_api.get_case_source_type(case_id)
         if source_type and SourceType.FFPE.lower() not in source_type.lower():
             return True

cg/meta/observations/raredisease_observations_api.py

@@ -58,7 +58,7 @@ class RarediseaseObservationsAPI(ObservationsAPI):
                 self.is_customer_eligible_for_observations_upload(case.customer.internal_id),
                 self.is_sequencing_method_eligible_for_observations_upload(case.internal_id),
                 self.is_sample_type_eligible_for_observations_upload(case),
-                self.is_sample_source_eligible_for_observations_upload(case.internal_id),
+                self.is_sample_source_type_not_ffpe(case.internal_id),
             ]
         )
 

cg/meta/tar/tar.py

@@ -24,8 +24,9 @@ class TarAPI:
         self.process.run_command(command, dry_run=self.dry_run)
 
     @staticmethod
-    def get_extract_file_command(input_file: Path, output_dir: Path) -> list[str]:
-        """Generates the Tar command for flow cel run directory extraction"""
+    def get_extract_file_command(input_file: Path, output_dir: Path, is_current: bool) -> list[str]:
+        """Generates the Tar command for flow cel run directory extraction. If the is_current flag
+        is set, the command will strip the first 6 components of the file path when extracting."""
         extraction_parameters: list = FlowCellExtractionParameters.EXTRACT_FILE.copy()
         extraction_parameters.append(str(input_file))
         exclude_files: list = FlowCellExtractionParameters.EXCLUDE_FILES.copy()
@@ -33,6 +34,8 @@ class TarAPI:
         target_directory_parameters: list = FlowCellExtractionParameters.CHANGE_TO_DIR.copy()
         extraction_parameters.extend(target_directory_parameters)
         extraction_parameters.append(str(output_dir))
+        if is_current:
+            extraction_parameters.append("--strip-components=6")
         return extraction_parameters
 
     def get_compress_cmd(self, input_path: Path) -> str:

cg/meta/transfer/lims.py

@@ -1,4 +1,5 @@
 import logging
+from datetime import datetime
 from enum import Enum
 
 import genologics.entities
@@ -6,6 +7,7 @@ import genologics.entities
 from cg.apps.lims import LimsAPI
 from cg.store.models import Pool, Sample
 from cg.store.store import Store
+from cg.utils.date import get_date_days_ago
 
 LOG = logging.getLogger(__name__)
 
@@ -52,14 +54,27 @@ class TransferLims(object):
         }
 
     def transfer_samples(
-        self, status_type: SampleState, include: str = "unset", sample_id: str = None
+        self,
+        status_type: SampleState,
+        include: str = "unset",
+        max_order_age: int | None = None,
+        sample_id: str = None,
     ):
         """Transfer information about samples."""
 
         if sample_id:
             samples: list[Sample] = self.status.get_samples_by_internal_id(internal_id=sample_id)
         else:
-            samples: list[Sample] = self._get_samples_to_include(include, status_type)
+            samples: list[Sample] | None = self._get_samples_to_include(
+                include=include, status_type=status_type
+            )
+
+        if max_order_age:
+            order_date_cutoff: datetime = get_date_days_ago(max_order_age * 365)
+            LOG.info(f"Remove samples ordered before {str(order_date_cutoff)}")
+            samples: list[Sample] = self._filter_out_older_orders(
+                samples=samples, order_date_cutoff=order_date_cutoff
+            )
 
         if samples is None:
             LOG.info(f"No samples to process found with {include} {status_type.value}")
@@ -80,10 +95,20 @@ class TransferLims(object):
                 )
 
                 setattr(sample_obj, f"{status_type.value}_at", lims_date)
-                self.status.session.commit()
+                self.status.commit_to_store()
             else:
                 LOG.debug(f"no {status_type.value} date found for {sample_obj.internal_id}")
 
+    def _filter_out_older_orders(
+        self, samples: list[Sample], order_date_cutoff: datetime
+    ) -> list[Sample]:
+        sample_within_time_window: list[Sample] = []
+        for sample in samples:
+            if not self._is_sample_too_old(sample=sample, order_date_cutoff=order_date_cutoff):
+                sample_within_time_window.append(sample)
+        LOG.debug(f"Filter out {len(samples)-len(sample_within_time_window)} samples")
+        return sample_within_time_window
+
     def _get_samples_to_include(self, include, status_type):
         samples = None
         if include == IncludeOptions.UNSET.value:
@@ -151,3 +176,7 @@ class TransferLims(object):
             )
             return False
         return True
+
+    @staticmethod
+    def _is_sample_too_old(sample: Sample, order_date_cutoff: datetime) -> bool:
+        return sample.ordered_at < order_date_cutoff

cg/meta/upload/balsamic/balsamic.py

@@ -5,7 +5,6 @@ import logging
 
 import rich_click as click
 
-from cg.apps.gens import GensAPI
 from cg.cli.generate.delivery_report.base import generate_delivery_report
 from cg.cli.upload.genotype import upload_genotypes
 from cg.cli.upload.gens import upload_to_gens
@@ -59,13 +58,7 @@ class BalsamicUploadAPI(UploadAPI):
             LOG.info(f"Balsamic case {case.internal_id} is not compatible for Genotype upload")
 
         # Observations upload
-        if (
-            self.analysis_api.get_case_application_type(case_id=case.internal_id)
-            == SeqLibraryPrepCategory.WHOLE_GENOME_SEQUENCING
-        ):
-            ctx.invoke(upload_observations_to_loqusdb, case_id=case.internal_id)
-        else:
-            LOG.info(f"Balsamic case {case.internal_id} is not compatible for Observations upload")
+        ctx.invoke(upload_observations_to_loqusdb, case_id=case.internal_id)
         LOG.info(
             f"Upload of case {case.internal_id} was successful. Setting uploaded at to {dt.datetime.now()}"
         )

cg/meta/upload/coverage.py

@@ -25,15 +25,15 @@ class UploadCoverageApi:
         """Get data for uploading coverage."""
         case_id = analysis.case.internal_id
         data = {"family": case_id, "family_name": analysis.case.name, "samples": []}
-        for link_obj in analysis.case.links:
+        for sample in analysis.case.samples:
             hk_coverage: File = self.hk_api.files(
                 version=analysis.housekeeper_version_id,
-                tags=[link_obj.sample.internal_id, "coverage"],
-            ).first()
+                tags={sample.internal_id, "coverage", "sambamba-depth", "chanjo"},
+            ).one()
             data["samples"].append(
                 {
-                    "sample": link_obj.sample.internal_id,
-                    "sample_name": link_obj.sample.name,
+                    "sample": sample.internal_id,
+                    "sample_name": sample.name,
                     "coverage": hk_coverage.full_path,
                 }
             )

cg/meta/upload/raredisease/raredisease.py

@@ -6,6 +6,7 @@ import logging
 import rich_click as click
 
 from cg.cli.generate.delivery_report.base import generate_delivery_report
+from cg.cli.upload.coverage import upload_coverage
 from cg.cli.upload.genotype import upload_genotypes
 from cg.cli.upload.gens import upload_to_gens
 from cg.cli.upload.observations import upload_observations_to_loqusdb
@@ -31,6 +32,8 @@ class RarediseaseUploadAPI(UploadAPI):
         analysis: Analysis = self.status_db.get_latest_completed_analysis_for_case(case.internal_id)
         self.update_upload_started_at(analysis=analysis)
 
+        ctx.invoke(upload_coverage, family_id=case.internal_id)
+
         # Delivery report generation
         if case.data_delivery in REPORT_SUPPORTED_DATA_DELIVERY:
             ctx.invoke(generate_delivery_report, case_id=case.internal_id)

cg/meta/upload/scout/hk_tags.py

@@ -85,6 +85,7 @@ class SampleTags(BaseModel):
     chromograph_sites: set[str] | None = None
     hificnv_coverage: set[str] | None = None
     minor_allele_frequency_wig: set[str] | None = None
+    phase_blocks: set[str] | None = None
     reviewer_alignment: set[str] | None = None
     reviewer_alignment_index: set[str] | None = None
     reviewer_catalog: set[str] | None = None

cg/meta/upload/scout/nallo_config_builder.py

@@ -1,4 +1,5 @@
 import logging
+from typing import cast
 
 from housekeeper.store.models import Version
 
@@ -88,27 +89,50 @@ class NalloConfigBuilder(ScoutConfigBuilder):
     ) -> None:
         """Include sample level files that are optional."""
         LOG.info("Including NALLO specific sample level files")
-        sample_id: str = config_sample.sample_id
+        sample_id: str = cast(str, config_sample.sample_id)
+        config_sample.chromograph_images.autozygous = self.remove_chromosome_substring(
+            self.get_sample_file(
+                hk_tags=self.sample_tags.chromograph_autozyg,
+                sample_id=sample_id,
+                hk_version=hk_version,
+            )
+        )
+        config_sample.chromograph_images.coverage = self.remove_chromosome_substring(
+            self.get_sample_file(
+                hk_tags=self.sample_tags.chromograph_coverage,
+                sample_id=sample_id,
+                hk_version=hk_version,
+            )
+        )
         config_sample.d4_file = self.get_sample_file(
-            hk_tags=self.sample_tags.d4_file, sample_id=sample_id, hk_version=hk_version
+            hk_tags=cast(set[str], self.sample_tags.d4_file),
+            sample_id=sample_id,
+            hk_version=hk_version,
         )
         config_sample.paraphase_alignment_path = self.get_sample_file(
-            hk_tags=self.sample_tags.paraphase_alignment_path,
+            hk_tags=cast(set[str], self.sample_tags.paraphase_alignment_path),
             sample_id=sample_id,
             hk_version=hk_version,
         )
         config_sample.tiddit_coverage_wig = self.get_sample_file(
-            hk_tags=self.sample_tags.hificnv_coverage,
+            hk_tags=cast(set[str], self.sample_tags.hificnv_coverage),
             sample_id=sample_id,
             hk_version=hk_version,
         )
         config_sample.minor_allele_frequency_wig = self.get_sample_file(
-            hk_tags=self.sample_tags.minor_allele_frequency_wig,
+            hk_tags=cast(set[str], self.sample_tags.minor_allele_frequency_wig),
+            sample_id=sample_id,
+            hk_version=hk_version,
+        )
+        alignment_and_mt_bam_path: str | None = self.get_sample_file(
+            hk_tags=cast(set[str], self.sample_tags.alignment_path),
             sample_id=sample_id,
             hk_version=hk_version,
         )
-        config_sample.alignment_path = self.get_sample_file(
-            hk_tags=self.sample_tags.alignment_path,
+        config_sample.alignment_path = alignment_and_mt_bam_path
+        config_sample.mt_bam = alignment_and_mt_bam_path
+        config_sample.phase_blocks = self.get_sample_file(
+            hk_tags=cast(set[str], self.sample_tags.phase_blocks),
             sample_id=sample_id,
             hk_version=hk_version,
         )

cg/meta/workflow/balsamic.py

@@ -4,15 +4,16 @@ import logging
 from pathlib import Path
 
 from housekeeper.store.models import File, Version
-from pydantic.v1 import EmailStr, ValidationError
+from pydantic import EmailStr
+from pydantic.v1 import ValidationError
 
 from cg.constants import Workflow
 from cg.constants.constants import FileFormat, GenomeVersion, SampleType
 from cg.constants.housekeeper_tags import BalsamicAnalysisTag
-from cg.constants.observations import ObservationsFileWildcards
+from cg.constants.observations import BalsamicObservationPanel, ObservationsFileWildcards
 from cg.constants.priority import SlurmQos
 from cg.constants.scout import BALSAMIC_CASE_TAGS
-from cg.constants.sequencing import Variants
+from cg.constants.sequencing import SeqLibraryPrepCategory, Variants
 from cg.constants.subject import Sex
 from cg.exc import BalsamicStartError, CgError
 from cg.io.controller import ReadFile
@@ -33,6 +34,15 @@ from cg.utils.utils import build_command_from_dict, get_string_from_list_by_patt
 LOG = logging.getLogger(__name__)
 
 
+PANELS_WITH_LOQUSDB_DUMP_FILES_MAP: dict[str, str] = {
+    BalsamicObservationPanel.MYELOID: "loqusdb_cancer_somatic_myeloid_snv_variants_export-20250920-.vcf.gz",
+    BalsamicObservationPanel.LYMPHOID: "loqusdb_cancer_somatic_lymphoid_snv_variants_export-20250920-.vcf.gz",
+    BalsamicObservationPanel.EXOME: "loqusdb_cancer_somatic_exome_snv_variants_export-20250920-.vcf.gz",
+}
+
+LOQUSDB_WGS_DUMP_FILE = "loqusdb_artefact_somatic_sv_variants_export-20250920-.vcf.gz"
+
+
 class BalsamicAnalysisAPI(AnalysisAPI):
     """Handles communication between BALSAMIC processes and the rest of CG infrastructure."""
 
@@ -46,23 +56,24 @@ class BalsamicAnalysisAPI(AnalysisAPI):
     ):
         super().__init__(workflow=workflow, config=config)
         self.account: str = config.balsamic.slurm.account
-        self.balsamic_cache: str = config.balsamic.balsamic_cache
-        self.bed_path: str = config.balsamic.bed_path
-        self.binary_path: str = config.balsamic.binary_path
-        self.cadd_path: str = config.balsamic.cadd_path
-        self.conda_binary: str = config.balsamic.conda_binary
+        self.balsamic_cache: str = str(config.balsamic.balsamic_cache)
+        self.bed_path: str = str(config.balsamic.bed_path)
+        self.binary_path: str = str(config.balsamic.binary_path)
+        self.cadd_path: str = str(config.balsamic.cadd_path)
+        self.conda_binary: str = str(config.balsamic.conda_binary)
         self.conda_env: str = config.balsamic.conda_env
         self.email: EmailStr = config.balsamic.slurm.mail_user
-        self.genome_interval_path: str = config.balsamic.genome_interval_path
-        self.gens_coverage_female_path: str = config.balsamic.gens_coverage_female_path
-        self.gens_coverage_male_path: str = config.balsamic.gens_coverage_male_path
-        self.gnomad_af5_path: str = config.balsamic.gnomad_af5_path
-        self.loqusdb_path: str = config.balsamic.loqusdb_path
-        self.pon_path: str = config.balsamic.pon_path
+        self.genome_interval_path: str = str(config.balsamic.genome_interval_path)
+        self.gens_coverage_female_path: str = str(config.balsamic.gens_coverage_female_path)
+        self.gens_coverage_male_path: str = str(config.balsamic.gens_coverage_male_path)
+        self.gnomad_af5_path: str = str(config.balsamic.gnomad_af5_path)
+        self.head_job_partition: str = config.balsamic.head_job_partition
+        self.loqusdb_path: str = str(config.balsamic.loqusdb_path)
+        self.pon_path: str = str(config.balsamic.pon_path)
         self.qos: SlurmQos = config.balsamic.slurm.qos
-        self.root_dir: str = config.balsamic.root
-        self.sentieon_licence_path: str = config.balsamic.sentieon_licence_path
-        self.sentieon_licence_server: str = config.sentieon_licence_server
+        self.root_dir: str = str(config.balsamic.root)
+        self.sentieon_licence_path: str = str(config.balsamic.sentieon_licence_path)
+        self.sentieon_licence_server: str = config.balsamic.sentieon_licence_server
         self.swegen_path: str = config.balsamic.swegen_path
 
     @property
@@ -253,10 +264,6 @@ class BalsamicAnalysisAPI(AnalysisAPI):
         if all(val["sex"] == sex for val in sample_data.values()) and sex in set(
             value for value in Sex
         ):
-            if sex not in [Sex.FEMALE, Sex.MALE]:
-                LOG.warning(f"The provided sex is unknown, setting {Sex.FEMALE} as the default")
-                sex = Sex.FEMALE
-
             return sex
         else:
             LOG.error(f"Unable to retrieve a valid sex from samples: {sample_data.keys()}")
@@ -308,8 +315,12 @@ class BalsamicAnalysisAPI(AnalysisAPI):
     def get_latest_metadata(self, case_id: str) -> BalsamicAnalysis:
         """Return the latest metadata of a specific BALSAMIC case."""
 
-        config_raw_data = self.get_latest_raw_file_data(case_id, BalsamicAnalysisTag.CONFIG)
-        metrics_raw_data = self.get_latest_raw_file_data(case_id, BalsamicAnalysisTag.QC_METRICS)
+        config_raw_data: dict = self.get_latest_raw_file_data(
+            case_id=case_id, tags=BalsamicAnalysisTag.CONFIG
+        )
+        metrics_raw_data: list[dict] = self.get_latest_raw_file_data(
+            case_id=case_id, tags=BalsamicAnalysisTag.QC_METRICS
+        )
 
         if config_raw_data and metrics_raw_data:
             try:
@@ -324,7 +335,9 @@ class BalsamicAnalysisAPI(AnalysisAPI):
             LOG.error(f"Unable to retrieve the latest metadata for {case_id}")
             raise CgError
 
-    def parse_analysis(self, config_raw: dict, qc_metrics_raw: dict, **kwargs) -> BalsamicAnalysis:
+    def parse_analysis(
+        self, config_raw: dict, qc_metrics_raw: list[dict], **kwargs
+    ) -> BalsamicAnalysis:
         """Returns a formatted BalsamicAnalysis object"""
 
         sequencing_type = config_raw["analysis"]["sequencing_type"]
@@ -399,9 +412,7 @@ class BalsamicAnalysisAPI(AnalysisAPI):
             "genome_interval": self.genome_interval_path,
             "gnomad_min_af5": self.gnomad_af5_path,
             "gens_coverage_pon": (
-                self.gens_coverage_female_path
-                if sex == Sex.FEMALE
-                else self.gens_coverage_male_path
+                self.gens_coverage_male_path if sex == Sex.MALE else self.gens_coverage_female_path
             ),
         }
 
@@ -443,6 +454,7 @@ class BalsamicAnalysisAPI(AnalysisAPI):
             raise BalsamicStartError(f"{case_id} has no samples tagged for BALSAMIC analysis!")
 
         verified_panel_bed = self.get_verified_bed(panel_bed=panel_bed, sample_data=sample_data)
+        loqusdb_panel_dump_file: str | None = self.get_panel_loqusdb_dump(verified_panel_bed)
         verified_pon = (
             self.get_verified_pon(pon_cnn=pon_cnn, panel_bed=verified_panel_bed)
             if verified_panel_bed
@@ -452,10 +464,16 @@ class BalsamicAnalysisAPI(AnalysisAPI):
 
         verified_exome_argument: bool = self.has_case_only_exome_samples(case_id=case_id)
 
+        is_wgs_case: bool = self.has_case_only_wgs_samples(case_id=case_id)
+
         config_case: dict[str, str] = {
             "case_id": case_id,
             "analysis_workflow": self.workflow,
             "genome_version": genome_version,
+            "loqusdb_panel_dump_file": loqusdb_panel_dump_file,
+            "loqusdb_wgs_dump_file": (
+                f"{self.loqusdb_path}/{LOQUSDB_WGS_DUMP_FILE}" if is_wgs_case else None
+            ),
             "sex": verified_sex,
             "panel_bed": verified_panel_bed,
             "pon_cnn": verified_pon,
@@ -480,6 +498,22 @@ class BalsamicAnalysisAPI(AnalysisAPI):
 
         return config_case
 
+    def has_case_only_wgs_samples(self, case_id: str) -> bool:
+        case: Case = self.status_db.get_case_by_internal_id(internal_id=case_id)
+        return all(
+            sample.prep_category == SeqLibraryPrepCategory.WHOLE_GENOME_SEQUENCING
+            for sample in case.samples
+        )
+
+    def get_panel_loqusdb_dump(self, bed_file: str | None) -> str | None:
+        if not bed_file:
+            return None
+        bed_file_name: str = Path(bed_file).name
+        bed_name: str = self.status_db.get_bed_version_by_file_name(bed_file_name).bed.name
+
+        if file_name := PANELS_WITH_LOQUSDB_DUMP_FILES_MAP.get(bed_name):
+            return f"{self.loqusdb_path}/{file_name}"
+
     @staticmethod
     def print_sample_params(case_id: str, sample_data: dict) -> None:
         """Outputs a table of samples to be displayed in log"""
@@ -557,13 +591,15 @@ class BalsamicAnalysisAPI(AnalysisAPI):
             {
                 "--analysis-dir": self.root_dir,
                 "--analysis-workflow": arguments.get("analysis_workflow"),
+                "--artefact-snv-observations": arguments.get("artefact_somatic_snv"),
+                "--artefact-sv-observations": arguments.get("loqusdb_wgs_dump_file"),
                 "--balsamic-cache": self.balsamic_cache,
                 "--cache-version": cache_version,
                 "--cadd-annotations": self.cadd_path,
-                "--artefact-snv-observations": arguments.get("artefact_somatic_snv"),
                 "--cancer-germline-snv-observations": arguments.get("cancer_germline_snv"),
                 "--cancer-germline-sv-observations": arguments.get("cancer_germline_sv"),
                 "--cancer-somatic-snv-observations": arguments.get("cancer_somatic_snv"),
+                "--cancer-somatic-snv-panel-observations": arguments.get("loqusdb_panel_dump_file"),
                 "--cancer-somatic-sv-observations": arguments.get("cancer_somatic_sv"),
                 "--case-id": arguments.get("case_id"),
                 "--clinical-snv-observations": arguments.get("clinical_snv"),
@@ -578,8 +614,8 @@ class BalsamicAnalysisAPI(AnalysisAPI):
                 "--gnomad-min-af5": arguments.get("gnomad_min_af5"),
                 "--normal-sample-name": arguments.get("normal_sample_name"),
                 "--panel-bed": arguments.get("panel_bed"),
+                "--exome": arguments.get("exome"),  # MUST be after panel bed
                 "--pon-cnn": arguments.get("pon_cnn"),
-                "--exome": arguments.get("exome"),
                 "--sentieon-install-dir": self.sentieon_licence_path,
                 "--sentieon-license": self.sentieon_licence_server,
                 "--soft-filter-normal": arguments.get("soft_filter_normal"),
@@ -595,7 +631,7 @@ class BalsamicAnalysisAPI(AnalysisAPI):
     def run_analysis(
         self,
         case_id: str,
-        cluster_config: Path | None = None,
+        workflow_profile: Path | None = None,
         slurm_quality_of_service: str | None = None,
         dry_run: bool = False,
     ) -> None:
@@ -603,17 +639,16 @@ class BalsamicAnalysisAPI(AnalysisAPI):
 
         command = ["run", "analysis"]
         run_analysis = ["--run-analysis"] if not dry_run else []
-        benchmark = ["--benchmark"]
         options = build_command_from_dict(
             {
                 "--account": self.account,
-                "--mail-user": self.email,
                 "--qos": slurm_quality_of_service or self.get_slurm_qos_for_case(case_id=case_id),
                 "--sample-config": self.get_case_config_path(case_id=case_id),
-                "--cluster-config": cluster_config,
+                "--workflow-profile": workflow_profile,
+                "--headjob-partition": self.head_job_partition,
             }
         )
-        parameters = command + options + run_analysis + benchmark
+        parameters = command + options + run_analysis
         self.process.run_command(parameters=parameters, dry_run=dry_run)
 
     def report_deliver(self, case_id: str, dry_run: bool = False) -> None:
@@ -630,8 +665,7 @@ class BalsamicAnalysisAPI(AnalysisAPI):
 
     def get_genome_build(self, case_id: str) -> str:
         """Returns the reference genome build version of a Balsamic analysis."""
-        analysis_metadata: BalsamicAnalysis = self.get_latest_metadata(case_id)
-        return analysis_metadata.balsamic_config.reference.reference_genome_version
+        return GenomeVersion.HG19
 
     @staticmethod
     def get_variant_caller_version(var_caller_name: str, var_caller_versions: dict) -> str | None:

cg/meta/workflow/fastq.py

@@ -212,6 +212,14 @@ class BalsamicFastqHandler(FastqHandler):
         date: str = date if isinstance(date, str) else date.strftime("%y%m%d")
         return f"{lane}_{date}_{flow_cell}_{sample}_{index}_R_{read_direction}{FileExtensions.FASTQ}{FileExtensions.GZIP}"
 
+    def get_sample_fastq_destination_dir(self, case: Case, sample: Sample) -> Path:
+        """Get FASTQ file paths for a Balsamic case (sample-independent)."""
+        return self.get_fastq_dir(case_id=case.internal_id)
+
+    def get_fastq_dir(self, case_id: str) -> Path:
+        """Get the FASTQ directory for a Balsamic case."""
+        return Path(self.root_dir, case_id, "fastq")
+
 
 class MipFastqHandler(FastqHandler):
     @staticmethod

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

@@ -17,8 +17,6 @@ class SampleQualityResult(BaseModel):
 class CaseQualityResult(BaseModel):
     passes_qc: bool
     control_passes_qc: bool
-    urgent_passes_qc: bool
-    non_urgent_passes_qc: bool
 
 
 class QualityResult(BaseModel):