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

cg/services/analysis_starter/configurator/implementations/balsamic.py

@@ -0,0 +1,68 @@
+import logging
+from pathlib import Path
+from typing import cast
+
+from cg.constants.priority import SlurmQos
+from cg.exc import CaseNotConfiguredError
+from cg.meta.workflow.fastq import BalsamicFastqHandler
+from cg.models.cg_config import BalsamicConfig
+from cg.services.analysis_starter.configurator.configurator import Configurator
+from cg.services.analysis_starter.configurator.file_creators.balsamic_config import (
+    BalsamicConfigFileCreator,
+)
+from cg.services.analysis_starter.configurator.models.balsamic import BalsamicCaseConfig
+from cg.store.store import Store
+
+LOG = logging.getLogger(__name__)
+
+
+class BalsamicConfigurator(Configurator):
+    def __init__(
+        self,
+        config: BalsamicConfig,
+        config_file_creator: BalsamicConfigFileCreator,
+        fastq_handler: BalsamicFastqHandler,
+        store: Store,
+    ):
+        self.store: Store = store
+
+        self.balsamic_binary: Path = config.binary_path
+        self.conda_binary: Path = config.conda_binary
+        self.environment: str = config.conda_env
+        self.head_job_partition: str = config.head_job_partition
+        self.root_dir: Path = config.root
+        self.slurm_account: str = config.slurm.account
+
+        self.fastq_handler: BalsamicFastqHandler = fastq_handler
+        self.config_file_creator: BalsamicConfigFileCreator = config_file_creator
+
+    def configure(self, case_id: str, **flags) -> BalsamicCaseConfig:
+        LOG.info(f"Configuring case {case_id}")
+        self.fastq_handler.link_fastq_files(case_id)
+        fastq_path: Path = self.fastq_handler.get_fastq_dir(case_id)
+        self.config_file_creator.create(case_id=case_id, fastq_path=fastq_path, **flags)
+        return self.get_config(case_id=case_id, **flags)
+
+    def get_config(self, case_id: str, **flags) -> BalsamicCaseConfig:
+        balsamic_config: BalsamicCaseConfig = BalsamicCaseConfig(
+            account=self.slurm_account,
+            binary=self.balsamic_binary,
+            case_id=case_id,
+            conda_binary=self.conda_binary,
+            environment=self.environment,
+            head_job_partition=self.head_job_partition,
+            qos=cast(SlurmQos, self.store.get_case_by_internal_id_strict(case_id).slurm_priority),
+            sample_config=self._get_sample_config_path(case_id),
+        )
+        balsamic_config: BalsamicCaseConfig = self._set_flags(config=balsamic_config, **flags)
+        self._ensure_required_config_files_exist(balsamic_config)
+        return balsamic_config
+
+    def _get_sample_config_path(self, case_id: str) -> Path:
+        return Path(self.root_dir, case_id, f"{case_id}.json")
+
+    def _ensure_required_config_files_exist(self, config: BalsamicCaseConfig) -> None:
+        if not config.sample_config.exists():
+            raise CaseNotConfiguredError(
+                f"Please ensure that the config file {config.sample_config} exists."
+            )

cg/services/analysis_starter/configurator/implementations/nextflow.py

@@ -1,19 +1,22 @@
 from pathlib import Path
 
-from cg.exc import MissingConfigFilesError
+from cg.exc import AnalysisAlreadyCompletedError, MissingConfigFilesError
 from cg.models.cg_config import CommonAppConfig
 from cg.services.analysis_starter.configurator.configurator import Configurator
-from cg.services.analysis_starter.configurator.extensions.abstract import PipelineExtension
+from cg.services.analysis_starter.configurator.extensions.pipeline_extension import (
+    PipelineExtension,
+)
 from cg.services.analysis_starter.configurator.file_creators.nextflow.config_file import (
     NextflowConfigFileCreator,
 )
 from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.abstract import (
     ParamsFileCreator,
 )
-from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.creator import (
-    NextflowSampleSheetCreator,
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.protocol import (
+    SampleSheetCreator,
 )
 from cg.services.analysis_starter.configurator.models.nextflow import NextflowCaseConfig
+from cg.store.models import Analysis
 from cg.store.store import Store
 
 
@@ -23,7 +26,7 @@ class NextflowConfigurator(Configurator):
         config_file_creator: NextflowConfigFileCreator,
         params_file_creator: ParamsFileCreator,
         pipeline_config: CommonAppConfig,
-        sample_sheet_creator: NextflowSampleSheetCreator,
+        sample_sheet_creator: SampleSheetCreator,
         store: Store,
         pipeline_extension: PipelineExtension = PipelineExtension(),
     ):
@@ -82,9 +85,23 @@ class NextflowConfigurator(Configurator):
             workflow=self.store.get_case_workflow(case_id),
         )
         config: NextflowCaseConfig = self._set_flags(config=config, **flags)
+        config = self._set_session_id(config)
         self._ensure_required_config_files_exist(config)
         return config
 
+    def _set_session_id(self, config: NextflowCaseConfig) -> NextflowCaseConfig:
+        new_config: NextflowCaseConfig = config.model_copy()
+        if config.resume:
+            analysis: Analysis = self.store.get_latest_started_analysis_for_case(
+                case_id=new_config.case_id
+            )
+            if analysis.completed_at:
+                raise AnalysisAlreadyCompletedError(
+                    "Resume not possible for an already completed analysis"
+                )
+            new_config.session_id = analysis.session_id
+        return new_config
+
     def _get_config_file_path(self, case_id: str) -> Path:
         """Return the path to the Nextflow config file."""
         return Path(self._get_case_run_directory(case_id), f"{case_id}_nextflow_config.json")

cg/services/analysis_starter/configurator/models/balsamic.py

@@ -0,0 +1,152 @@
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel
+
+from cg.constants import SexOptions, Workflow
+from cg.constants.constants import GenomeVersion
+from cg.constants.priority import SlurmQos
+from cg.services.analysis_starter.configurator.abstract_model import CaseConfig
+
+
+class BalsamicConfigInput(BaseModel):
+    analysis_dir: Path
+    analysis_workflow: Workflow
+    artefact_snv_observations: Path
+    balsamic_binary: Path
+    balsamic_cache: Path
+    cadd_annotations: Path
+    cancer_germline_snv_observations: Path
+    cancer_somatic_snv_observations: Path
+    cancer_somatic_sv_observations: Path
+    case_id: str
+    clinical_snv_observations: Path
+    clinical_sv_observations: Path
+    conda_binary: Path
+    conda_env: str
+    fastq_path: Path
+    gender: SexOptions
+    genome_version: GenomeVersion
+    gnomad_min_af5: Path
+    normal_sample_name: str | None = None
+    sentieon_install_dir: Path
+    sentieon_license: str
+    swegen_snv: Path
+    swegen_sv: Path
+    tumor_sample_name: str
+
+    def dump_to_cli(self) -> str:
+        """Dump the Balsamic case config to a CLI command. None flags are excluded and boolean flags are converted to
+        only add the flag."""
+        command = (
+            f"{self.conda_binary} run --name {self.conda_env} {self.balsamic_binary} config case"
+        )
+
+        for flag, value in self._get_flags().items():
+            if isinstance(value, bool):
+                if value is True:
+                    command += f" {flag}"
+            elif value is not None:
+                command += f" {flag} {value}"
+        return command
+
+    @abstractmethod
+    def _get_flags(self) -> dict[str, Any]:
+        pass
+
+
+class BalsamicConfigInputPanel(BalsamicConfigInput):
+    cancer_somatic_snv_panel_observations: Path | None = None
+    exome: bool
+    panel_bed: Path
+    pon_cnn: Path | None = (
+        None  # Equivalent to --gens-coverage-pon in wgs analysis, depends on the panel
+    )
+    soft_filter_normal: bool = False  # True for all panel analyses with a normal sample
+
+    def _get_flags(self) -> dict[str, Any]:
+        return {
+            "--analysis-dir": self.analysis_dir,
+            "--analysis-workflow": self.analysis_workflow,
+            "--artefact-snv-observations": self.artefact_snv_observations,
+            "--balsamic-cache": self.balsamic_cache,
+            "--cadd-annotations": self.cadd_annotations,
+            "--cancer-germline-snv-observations": self.cancer_germline_snv_observations,
+            "--cancer-somatic-snv-observations": self.cancer_somatic_snv_observations,
+            "--cancer-somatic-snv-panel-observations": self.cancer_somatic_snv_panel_observations,
+            "--cancer-somatic-sv-observations": self.cancer_somatic_sv_observations,
+            "--case-id": self.case_id,
+            "--clinical-snv-observations": self.clinical_snv_observations,
+            "--clinical-sv-observations": self.clinical_sv_observations,
+            "--fastq-path": self.fastq_path,
+            "--gender": self.gender,
+            "--genome-version": self.genome_version,
+            "--gnomad-min-af5": self.gnomad_min_af5,
+            "--normal-sample-name": self.normal_sample_name,
+            "--panel-bed": self.panel_bed,
+            "--exome": self.exome,  # MUST be after panel bed
+            "--pon-cnn": self.pon_cnn,
+            "--sentieon-install-dir": self.sentieon_install_dir,
+            "--sentieon-license": self.sentieon_license,
+            "--soft-filter-normal": self.soft_filter_normal,
+            "--swegen-snv": self.swegen_snv,
+            "--swegen-sv": self.swegen_sv,
+            "--tumor-sample-name": self.tumor_sample_name,
+        }
+
+
+class BalsamicConfigInputWGS(BalsamicConfigInput):
+    artefact_sv_observations: Path
+    genome_interval: Path
+    gens_coverage_pon: Path  # Equivalent to --pon-cnn in panel analysis, depends on the sex
+
+    def _get_flags(self) -> dict[str, Any]:
+        return {
+            "--analysis-dir": self.analysis_dir,
+            "--analysis-workflow": self.analysis_workflow,
+            "--artefact-snv-observations": self.artefact_snv_observations,
+            "--artefact-sv-observations": self.artefact_sv_observations,
+            "--balsamic-cache": self.balsamic_cache,
+            "--cadd-annotations": self.cadd_annotations,
+            "--cancer-germline-snv-observations": self.cancer_germline_snv_observations,
+            "--cancer-somatic-snv-observations": self.cancer_somatic_snv_observations,
+            "--cancer-somatic-sv-observations": self.cancer_somatic_sv_observations,
+            "--case-id": self.case_id,
+            "--clinical-snv-observations": self.clinical_snv_observations,
+            "--clinical-sv-observations": self.clinical_sv_observations,
+            "--fastq-path": self.fastq_path,
+            "--gender": self.gender,
+            "--genome-interval": self.genome_interval,
+            "--genome-version": self.genome_version,
+            "--gens-coverage-pon": self.gens_coverage_pon,
+            "--gnomad-min-af5": self.gnomad_min_af5,
+            "--normal-sample-name": self.normal_sample_name,
+            "--sentieon-install-dir": self.sentieon_install_dir,
+            "--sentieon-license": self.sentieon_license,
+            "--swegen-snv": self.swegen_snv,
+            "--swegen-sv": self.swegen_sv,
+            "--tumor-sample-name": self.tumor_sample_name,
+        }
+
+
+class BalsamicCaseConfig(CaseConfig):
+    account: str
+    binary: Path
+    conda_binary: Path
+    environment: str
+    head_job_partition: str
+    qos: SlurmQos
+    sample_config: Path
+    workflow: Workflow = Workflow.BALSAMIC
+    workflow_profile: Path | None = None
+
+    def get_start_command(self) -> str:
+        command = (
+            "{conda_binary} run --name {environment} {binary} run analysis --account {account} "
+            "--qos {qos} --sample-config {sample_config} --headjob-partition {head_job_partition} "
+            "--run-analysis".format(**self.model_dump())
+        )
+        if self.workflow_profile:
+            command += f" --workflow-profile {self.workflow_profile}"
+        return command

cg/services/analysis_starter/configurator/models/mip_dna.py

@@ -1,5 +1,3 @@
-from pydantic import Field
-
 from cg.constants.constants import Workflow
 from cg.constants.priority import SlurmQos
 from cg.services.analysis_starter.configurator.abstract_model import CaseConfig
@@ -13,8 +11,8 @@ class MIPDNACaseConfig(CaseConfig):
     pipeline_command: str
     pipeline_config_path: str
     slurm_qos: SlurmQos
-    start_after_recipe: str | None = Field(default=None, alias="start_after")
-    start_with_recipe: str | None = Field(default=None, alias="start_with")
+    start_after: str | None = None
+    start_with: str | None = None
     workflow: Workflow = Workflow.MIP_DNA
     use_bwa_mem: bool
 
@@ -25,11 +23,11 @@ class MIPDNACaseConfig(CaseConfig):
             "{slurm_qos} --email {email}"
         ).format(**self.model_dump())
 
-        if self.start_after_recipe:
-            start_command += f" --start_after_recipe {self.start_after_recipe}"
+        if self.start_after:
+            start_command += f" --start_after_recipe {self.start_after}"
 
-        if self.start_with_recipe:
-            start_command += f" --start_with_recipe {self.start_with_recipe}"
+        if self.start_with:
+            start_command += f" --start_with_recipe {self.start_with}"
 
         if self.use_bwa_mem:
             start_command += " --bwa_mem 1 --bwa_mem2 0"

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

@@ -9,5 +9,14 @@ class NextflowCaseConfig(CaseConfig):
     params_file: str
     pipeline_repository: str
     pre_run_script: str
+    resume: bool = False
     revision: str
+    session_id: str | None = None
     work_dir: str
+    workflow_id: str | None = None
+
+    def get_session_id(self) -> str | None:
+        return self.session_id
+
+    def get_workflow_id(self) -> str | None:
+        return self.workflow_id

cg/services/analysis_starter/constants.py

@@ -1,11 +1,13 @@
 from cg.constants import Workflow
 
 IMPLEMENTED_FASTQ_WORKFLOWS = [
+    Workflow.BALSAMIC,
     Workflow.MICROSALT,
     Workflow.MIP_DNA,
     Workflow.RAREDISEASE,
     Workflow.RNAFUSION,
     Workflow.TAXPROFILER,
+    Workflow.TOMTE,
 ]
 
 BAM_WORKFLOWS = [Workflow.NALLO]

cg/services/analysis_starter/factories/configurator_factory.py

@@ -4,11 +4,18 @@ from cg.apps.housekeeper.hk import HousekeeperAPI
 from cg.apps.lims import LimsAPI
 from cg.apps.scout.scoutapi import ScoutAPI
 from cg.constants import Workflow
-from cg.meta.workflow.fastq import MicrosaltFastqHandler, MipFastqHandler
+from cg.meta.workflow.fastq import BalsamicFastqHandler, MicrosaltFastqHandler, MipFastqHandler
 from cg.models.cg_config import CGConfig, CommonAppConfig
 from cg.services.analysis_starter.configurator.configurator import Configurator
-from cg.services.analysis_starter.configurator.extensions.abstract import PipelineExtension
+from cg.services.analysis_starter.configurator.extensions.nallo import NalloExtension
+from cg.services.analysis_starter.configurator.extensions.pipeline_extension import (
+    PipelineExtension,
+)
 from cg.services.analysis_starter.configurator.extensions.raredisease import RarediseaseExtension
+from cg.services.analysis_starter.configurator.extensions.tomte_extension import TomteExtension
+from cg.services.analysis_starter.configurator.file_creators.balsamic_config import (
+    BalsamicConfigFileCreator,
+)
 from cg.services.analysis_starter.configurator.file_creators.gene_panel import GenePanelFileCreator
 from cg.services.analysis_starter.configurator.file_creators.managed_variants import (
     ManagedVariantsFileCreator,
@@ -25,6 +32,9 @@ from cg.services.analysis_starter.configurator.file_creators.nextflow.config_fil
 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.nallo import (
+    NalloParamsFileCreator,
+)
 from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.raredisease import (
     RarediseaseParamsFileCreator,
 )
@@ -34,18 +44,28 @@ from cg.services.analysis_starter.configurator.file_creators.nextflow.params_fil
 from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.taxprofiler import (
     TaxprofilerParamsFileCreator,
 )
-from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.creator import (
-    NextflowSampleSheetCreator,
+from cg.services.analysis_starter.configurator.file_creators.nextflow.params_file.tomte_params_file_creator import (
+    TomteParamsFileCreator,
+)
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.nallo_sample_sheet_creator import (
+    NalloSampleSheetCreator,
 )
-from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.raredisease import (
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.protocol import (
+    SampleSheetCreator,
+)
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.raredisease_sample_sheet_creator import (
     RarediseaseSampleSheetCreator,
 )
-from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.rnafusion import (
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.rnafusion_sample_sheet_creator import (
     RNAFusionSampleSheetCreator,
 )
-from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.taxprofiler import (
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.taxprofiler_sample_sheet_creator import (
     TaxprofilerSampleSheetCreator,
 )
+from cg.services.analysis_starter.configurator.file_creators.nextflow.sample_sheet.tomte_sample_sheet_creator import (
+    TomteSampleSheetCreator,
+)
+from cg.services.analysis_starter.configurator.implementations.balsamic import BalsamicConfigurator
 from cg.services.analysis_starter.configurator.implementations.microsalt import (
     MicrosaltConfigurator,
 )
@@ -63,18 +83,30 @@ class ConfiguratorFactory:
         self.store: Store = cg_config.status_db
 
     def get_configurator(self, workflow: Workflow) -> Configurator:
-        if workflow in [Workflow.RAREDISEASE, Workflow.RNAFUSION, Workflow.TAXPROFILER]:
-            return self._get_nextflow_configurator(workflow)
-        elif workflow == Workflow.MICROSALT:
-            return self._get_microsalt_configurator()
-        elif workflow == Workflow.MIP_DNA:
-            return self._get_mip_dna_configurator()
-        raise NotImplementedError
+        match workflow:
+            case Workflow.BALSAMIC | Workflow.BALSAMIC_UMI:
+                return self._get_balsamic_configurator()
+            case Workflow.MICROSALT:
+                return self._get_microsalt_configurator()
+            case Workflow.MIP_DNA:
+                return self._get_mip_dna_configurator()
+            case (
+                Workflow.NALLO
+                | Workflow.RAREDISEASE
+                | Workflow.RNAFUSION
+                | Workflow.TAXPROFILER
+                | Workflow.TOMTE
+            ):
+                return self._get_nextflow_configurator(workflow)
+            case _:
+                raise NotImplementedError
 
     def _get_nextflow_configurator(self, workflow: Workflow) -> NextflowConfigurator:
-        config_file_creator = self._get_nextflow_config_file_creator(workflow)
+        config_file_creator: NextflowConfigFileCreator = self._get_nextflow_config_file_creator(
+            workflow
+        )
         params_file_creator: ParamsFileCreator = self._get_params_file_creator(workflow)
-        sample_sheet_creator: NextflowSampleSheetCreator = self._get_sample_sheet_creator(workflow)
+        sample_sheet_creator: SampleSheetCreator = self._get_sample_sheet_creator(workflow)
         extension: PipelineExtension = self._get_pipeline_extension(workflow)
         return NextflowConfigurator(
             config_file_creator=config_file_creator,
@@ -96,47 +128,79 @@ class ConfiguratorFactory:
         )
 
     def _get_params_file_creator(self, workflow: Workflow) -> ParamsFileCreator:
-        if workflow == Workflow.RAREDISEASE:
-            pipeline_config: CommonAppConfig = self._get_pipeline_config(workflow)
-            return RarediseaseParamsFileCreator(
-                lims=self.lims_api, store=self.store, params=pipeline_config.params
-            )
-        elif workflow == Workflow.RNAFUSION:
-            pipeline_config: CommonAppConfig = self._get_pipeline_config(workflow)
-            return RNAFusionParamsFileCreator(pipeline_config.params)
-        elif workflow == Workflow.TAXPROFILER:
-            pipeline_config: CommonAppConfig = self._get_pipeline_config(workflow)
-            return TaxprofilerParamsFileCreator(pipeline_config.params)
+        params: str = self._get_pipeline_config(workflow).params
+        match workflow:
+            case Workflow.NALLO:
+                return NalloParamsFileCreator(params)
+            case Workflow.RAREDISEASE:
+                return RarediseaseParamsFileCreator(
+                    lims=self.lims_api, params=params, store=self.store
+                )
+            case Workflow.RNAFUSION:
+                return RNAFusionParamsFileCreator(params)
+            case Workflow.TAXPROFILER:
+                return TaxprofilerParamsFileCreator(params)
+            case Workflow.TOMTE:
+                return TomteParamsFileCreator(
+                    lims_api=self.lims_api, params=params, status_db=self.store
+                )
+            case _:
+                raise NotImplementedError(f"There is no params file creator for {workflow}")
 
     def _get_pipeline_config(self, workflow: Workflow) -> CommonAppConfig:
         return getattr(self.cg_config, workflow)
 
-    def _get_sample_sheet_creator(self, workflow: Workflow) -> NextflowSampleSheetCreator:
-        if workflow == Workflow.RAREDISEASE:
-            return RarediseaseSampleSheetCreator(
-                housekeeper_api=self.cg_config.housekeeper_api,
-                store=self.store,
-            )
-        elif workflow == Workflow.RNAFUSION:
-            return RNAFusionSampleSheetCreator(
-                housekeeper_api=self.housekeeper_api, store=self.store
-            )
-        elif workflow == Workflow.TAXPROFILER:
-            return TaxprofilerSampleSheetCreator(
-                housekeeper_api=self.housekeeper_api, store=self.store
-            )
+    def _get_sample_sheet_creator(self, workflow: Workflow) -> SampleSheetCreator:
+        match workflow:
+            case Workflow.NALLO:
+                return NalloSampleSheetCreator(
+                    housekeeper_api=self.housekeeper_api, status_db=self.store
+                )
+            case Workflow.RAREDISEASE:
+                return RarediseaseSampleSheetCreator(
+                    housekeeper_api=self.cg_config.housekeeper_api,
+                    store=self.store,
+                )
+            case Workflow.RNAFUSION:
+                return RNAFusionSampleSheetCreator(
+                    housekeeper_api=self.housekeeper_api, store=self.store
+                )
+            case Workflow.TAXPROFILER:
+                return TaxprofilerSampleSheetCreator(
+                    housekeeper_api=self.housekeeper_api, store=self.store
+                )
+            case Workflow.TOMTE:
+                return TomteSampleSheetCreator(
+                    housekeeper_api=self.housekeeper_api, store=self.store
+                )
+            case _:
+                raise NotImplementedError(f"No sample sheet creator implemented for {workflow}")
 
     def _get_pipeline_extension(self, workflow: Workflow) -> PipelineExtension:
-        if workflow == Workflow.RAREDISEASE:
-            gene_panel_creator: GenePanelFileCreator = self._get_gene_panel_file_creator(workflow)
-            managed_variants_creator: ManagedVariantsFileCreator = (
-                self._get_managed_variants_file_creator(workflow)
-            )
-            return RarediseaseExtension(
-                gene_panel_file_creator=gene_panel_creator,
-                managed_variants_file_creator=managed_variants_creator,
-            )
-        return PipelineExtension()
+        match workflow:
+            case Workflow.NALLO:
+                gene_panel_creator: GenePanelFileCreator = self._get_gene_panel_file_creator(
+                    workflow
+                )
+                return NalloExtension(gene_panel_file_creator=gene_panel_creator)
+            case Workflow.RAREDISEASE:
+                gene_panel_creator: GenePanelFileCreator = self._get_gene_panel_file_creator(
+                    workflow
+                )
+                managed_variants_creator: ManagedVariantsFileCreator = (
+                    self._get_managed_variants_file_creator(workflow)
+                )
+                return RarediseaseExtension(
+                    gene_panel_file_creator=gene_panel_creator,
+                    managed_variants_file_creator=managed_variants_creator,
+                )
+            case Workflow.TOMTE:
+                gene_panel_creator: GenePanelFileCreator = self._get_gene_panel_file_creator(
+                    workflow
+                )
+                return TomteExtension(gene_panel_file_creator=gene_panel_creator)
+            case _:
+                return PipelineExtension()
 
     def _get_gene_panel_file_creator(self, workflow: Workflow) -> GenePanelFileCreator:
         return GenePanelFileCreator(scout_api=self._get_scout_api(workflow), store=self.store)
@@ -151,6 +215,22 @@ class ConfiguratorFactory:
             else self.cg_config.scout_api_37
         )
 
+    def _get_balsamic_configurator(self) -> BalsamicConfigurator:
+        return BalsamicConfigurator(
+            config_file_creator=BalsamicConfigFileCreator(
+                cg_balsamic_config=self.cg_config.balsamic,
+                lims_api=self.lims_api,
+                status_db=self.store,
+            ),
+            fastq_handler=BalsamicFastqHandler(
+                housekeeper_api=self.housekeeper_api,
+                root_dir=Path(self.cg_config.balsamic.root),
+                status_db=self.store,
+            ),
+            config=self.cg_config.balsamic,
+            store=self.store,
+        )
+
     def _get_microsalt_configurator(self) -> MicrosaltConfigurator:
         return MicrosaltConfigurator(
             config_file_creator=self._get_microsalt_config_file_creator(),