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

cg/services/analysis_starter/factories/starter_factory.py

@@ -5,21 +5,25 @@ from cg.constants import Workflow
 from cg.meta.archive.archive import SpringArchiveAPI
 from cg.meta.compress import CompressAPI
 from cg.models.cg_config import CGConfig
+from cg.services.analysis_starter.analysis_starter import AnalysisStarter
 from cg.services.analysis_starter.configurator.configurator import Configurator
 from cg.services.analysis_starter.constants import IMPLEMENTED_FASTQ_WORKFLOWS
 from cg.services.analysis_starter.factories.configurator_factory import ConfiguratorFactory
+from cg.services.analysis_starter.input_fetcher.implementations.bam_fetcher import BamFetcher
 from cg.services.analysis_starter.input_fetcher.implementations.fastq_fetcher import FastqFetcher
 from cg.services.analysis_starter.input_fetcher.input_fetcher import InputFetcher
-from cg.services.analysis_starter.service import AnalysisStarter
-from cg.services.analysis_starter.submitters.seqera_platform.client import SeqeraPlatformClient
-from cg.services.analysis_starter.submitters.seqera_platform.submitter import (
+from cg.services.analysis_starter.submitters.seqera_platform.seqera_platform_client import (
+    SeqeraPlatformClient,
+)
+from cg.services.analysis_starter.submitters.seqera_platform.seqera_platform_submitter import (
     SeqeraPlatformSubmitter,
 )
 from cg.services.analysis_starter.submitters.submitter import Submitter
 from cg.services.analysis_starter.submitters.subprocess.submitter import SubprocessSubmitter
+from cg.services.analysis_starter.tracker.implementations.balsamic import BalsamicTracker
 from cg.services.analysis_starter.tracker.implementations.microsalt import MicrosaltTracker
 from cg.services.analysis_starter.tracker.implementations.mip_dna import MIPDNATracker
-from cg.services.analysis_starter.tracker.implementations.nextflow import NextflowTracker
+from cg.services.analysis_starter.tracker.implementations.nextflow_tracker import NextflowTracker
 from cg.services.analysis_starter.tracker.tracker import Tracker
 from cg.store.store import Store
 
@@ -71,10 +75,18 @@ class AnalysisStarterFactory:
                 spring_archive_api=spring_archive_api,
                 status_db=self.store,
             )
-        return InputFetcher()
+        elif workflow == Workflow.NALLO:
+            return BamFetcher(housekeeper_api=self.housekeeper_api, status_db=self.store)
+        raise NotImplementedError(f"No input fetcher for workflow {workflow}")
 
     def _get_submitter(self, workflow: Workflow) -> Submitter:
-        if workflow in [Workflow.RAREDISEASE, Workflow.RNAFUSION, Workflow.TAXPROFILER]:
+        if workflow in [
+            Workflow.NALLO,
+            Workflow.RAREDISEASE,
+            Workflow.RNAFUSION,
+            Workflow.TAXPROFILER,
+            Workflow.TOMTE,
+        ]:
             return self._get_seqera_platform_submitter()
         else:
             return SubprocessSubmitter()
@@ -87,7 +99,13 @@ class AnalysisStarterFactory:
         )
 
     def _get_tracker(self, workflow: Workflow) -> Tracker:
-        if workflow in [Workflow.RAREDISEASE, Workflow.RNAFUSION, Workflow.TAXPROFILER]:
+        if workflow in [
+            Workflow.NALLO,
+            Workflow.RAREDISEASE,
+            Workflow.RNAFUSION,
+            Workflow.TAXPROFILER,
+            Workflow.TOMTE,
+        ]:
             return NextflowTracker(
                 store=self.store,
                 trailblazer_api=self.cg_config.trailblazer_api,
@@ -100,9 +118,20 @@ class AnalysisStarterFactory:
                 trailblazer_api=self.cg_config.trailblazer_api,
                 workflow_root=self.cg_config.microsalt.root,
             )
+        elif workflow in [
+            Workflow.BALSAMIC,
+            Workflow.BALSAMIC_UMI,
+        ]:
+            return BalsamicTracker(
+                store=self.store,
+                trailblazer_api=self.cg_config.trailblazer_api,
+                workflow_root=str(self.cg_config.balsamic.root),
+            )
         elif workflow == Workflow.MIP_DNA:
             return MIPDNATracker(
                 store=self.store,
                 trailblazer_api=self.cg_config.trailblazer_api,
                 workflow_root=self.cg_config.mip_rd_dna.root,
             )
+        else:
+            raise NotImplementedError(f"No {workflow} tracker")

cg/services/analysis_starter/input_fetcher/implementations/bam_fetcher.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+from housekeeper.store.models import File
+
+from cg.apps.housekeeper.hk import HousekeeperAPI
+from cg.exc import AnalysisNotReadyError
+from cg.services.analysis_starter.input_fetcher.input_fetcher import InputFetcher
+from cg.store.models import Case
+from cg.store.store import Store
+
+
+class BamFetcher(InputFetcher):
+    def __init__(self, housekeeper_api: HousekeeperAPI, status_db: Store) -> None:
+        self.housekeeper_api = housekeeper_api
+        self.status_db = status_db
+
+    def ensure_files_are_ready(self, case_id: str) -> None:
+        case: Case = self.status_db.get_case_by_internal_id_strict(case_id)
+        samples_without_files: list[str] = self._get_samples_without_files(case)
+        missing_files: list[str] = self._get_missing_file_paths(case)
+        if samples_without_files or missing_files:
+            self._raise_error(
+                missing_files=missing_files, samples_without_files=samples_without_files
+            )
+
+    def _get_samples_without_files(self, case: Case) -> list[str]:
+        samples_without_files: list[str] = []
+        for sample in case.samples:
+            sample_files: list[File] = self.housekeeper_api.files(
+                bundle=sample.internal_id, tags={"bam"}
+            ).all()
+            if not sample_files:
+                samples_without_files.append(sample.internal_id)
+        return samples_without_files
+
+    def _get_missing_file_paths(self, case: Case) -> list[str]:
+        missing_files: list[str] = []
+        for sample in case.samples:
+            sample_files: list[File] = self.housekeeper_api.files(
+                bundle=sample.internal_id, tags={"bam"}
+            ).all()
+            missing_sample_files: list[str] = [
+                file.full_path for file in sample_files if not Path(file.full_path).is_file()
+            ]
+            missing_files.extend(missing_sample_files)
+        return missing_files
+
+    @staticmethod
+    def _raise_error(missing_files: list[str], samples_without_files: list[str]) -> None:
+        error_message = ""
+        if samples_without_files:
+            samples_without_files_str = "\n".join(samples_without_files)
+            error_message += f"The following samples are missing BAM files in Housekeeper: \n{samples_without_files_str}"
+        if missing_files:
+            missing_files_str = "\n".join(missing_files)
+            error_message += f"\nThe following BAM files are missing on disk: \n{missing_files_str}"
+        raise AnalysisNotReadyError(error_message)

cg/services/analysis_starter/input_fetcher/implementations/fastq_fetcher.py

@@ -96,7 +96,7 @@ class FastqFetcher(InputFetcher):
             else:
                 self._decompress_case(case_id)
         elif case_compression_data.is_spring_decompression_running():
-            self.status_db.set_case_action(case_internal_id=case_id, action=CaseActions.ANALYZE)
+            self.status_db.update_case_action(case_internal_id=case_id, action=CaseActions.ANALYZE)
             return
 
         self._add_decompressed_fastq_files_to_housekeeper(case_id)
@@ -109,7 +109,7 @@ class FastqFetcher(InputFetcher):
         except DecompressionCouldNotStartError:
             LOG.warning(f"Decompression failed to start for {case_id}")
             return
-        self.status_db.set_case_action(case_internal_id=case_id, action=CaseActions.ANALYZE)
+        self.status_db.update_case_action(case_internal_id=case_id, action=CaseActions.ANALYZE)
         LOG.info(f"Decompression started for {case_id}")
 
     def _are_fastq_files_ready_for_analysis(self, case_id: str) -> bool:
@@ -155,7 +155,7 @@ class FastqFetcher(InputFetcher):
             LOG.info(
                 f"Decompression is running for {case_id}, analysis will be started when decompression is done"
             )
-            self.status_db.set_case_action(case_internal_id=case_id, action=CaseActions.ANALYZE)
+            self.status_db.update_case_action(case_internal_id=case_id, action=CaseActions.ANALYZE)
 
     @staticmethod
     def _should_skip_sample(case: Case, sample: Sample) -> bool:

cg/services/analysis_starter/submitters/seqera_platform/{client.py → seqera_platform_client.py}

@@ -1,4 +1,5 @@
 import logging
+from typing import Any
 
 import requests
 
@@ -17,7 +18,7 @@ class SeqeraPlatformClient:
         self.compute_environment_ids: dict[SlurmQos, str] = config.compute_environments
         self.workspace_id: int = config.workspace_id
 
-    def run_case(self, request: WorkflowLaunchRequest) -> str:
+    def launch_workflow(self, request: WorkflowLaunchRequest) -> dict:
         """Launches a case from the request and returns the workflow ID."""
         url = f"{self.base_url}/workflow/launch"
         params: dict = {"workspaceId": self.workspace_id}
@@ -25,10 +26,25 @@ class SeqeraPlatformClient:
             f"Sending request body {request.model_dump()} \n Headers: {self.auth_headers} \n Params: {params}"
         )
         response: requests.Response = requests.post(
+            headers=self.auth_headers,
+            json=request.model_dump(),
+            params=params,
             url=url,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_workflow(self, workflow_id: str) -> dict[str, Any]:
+        """Gets information about the specified workflow (the Seqera equivalent of an analysis) in Seqera."""
+        url = f"{self.base_url}/workflow/{workflow_id}"
+        params: dict = {"workspaceId": self.workspace_id}
+        LOG.debug(
+            f"Get seqera workflow with id: {workflow_id} \n Headers: {self.auth_headers} \n Params: {params}"
+        )
+        response: requests.Response = requests.get(
             headers=self.auth_headers,
             params=params,
-            json=request.model_dump(),
+            url=url,
         )
         response.raise_for_status()
-        return response.json()["workflowId"]
+        return response.json()

cg/services/analysis_starter/submitters/seqera_platform/seqera_platform_submitter.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Any, cast
+
+from cg.constants.priority import SlurmQos
+from cg.exc import SeqeraError
+from cg.io.yaml import read_yaml, write_yaml_stream
+from cg.services.analysis_starter.configurator.models.nextflow import NextflowCaseConfig
+from cg.services.analysis_starter.submitters.seqera_platform.dtos import (
+    LaunchRequest,
+    WorkflowLaunchRequest,
+)
+from cg.services.analysis_starter.submitters.seqera_platform.seqera_platform_client import (
+    SeqeraPlatformClient,
+)
+from cg.services.analysis_starter.submitters.submitter import Submitter
+
+
+class SeqeraPlatformSubmitter(Submitter):
+
+    def __init__(self, client: SeqeraPlatformClient, compute_environment_ids: dict[SlurmQos, str]):
+        self.client: SeqeraPlatformClient = client
+        self.compute_environment_ids: dict[str, str] = compute_environment_ids
+
+    def submit(self, case_config: NextflowCaseConfig) -> NextflowCaseConfig:
+        """Starts a case and returns the workflow id for the job."""
+        new_case_config: NextflowCaseConfig = case_config.model_copy()
+        run_request: WorkflowLaunchRequest = self._create_launch_request(new_case_config)
+
+        response: dict = self.client.launch_workflow(run_request)
+        if not (workflow_id := response.get("workflowId")):
+            raise SeqeraError(f"workflowId missing from response: {response}")
+        new_case_config.workflow_id = workflow_id
+
+        workflow_response: dict = self.client.get_workflow(cast(str, new_case_config.workflow_id))
+        if not (session_id := self._get_session_id(workflow_response)):
+            raise SeqeraError(f"No sessionId found in response: {workflow_response}")
+        new_case_config.session_id = session_id
+
+        return new_case_config
+
+    @staticmethod
+    def _get_session_id(workflow_response: dict[str, Any]) -> str | None:
+        workflow: dict | None = workflow_response.get("workflow")
+        if workflow and (session_id := workflow.get("sessionId")):
+            return session_id
+        else:
+            return None
+
+    def _create_launch_request(self, case_config: NextflowCaseConfig) -> WorkflowLaunchRequest:
+        parameters: dict = read_yaml(Path(case_config.params_file))
+        parameter_stream: str = write_yaml_stream(parameters)
+        launch_request = LaunchRequest(
+            computeEnvId=self.compute_environment_ids[case_config.case_priority],
+            configProfiles=case_config.config_profiles,
+            configText=f"includeConfig '{case_config.nextflow_config_file}'",
+            paramsText=parameter_stream,
+            pipeline=case_config.pipeline_repository,
+            preRunScript=case_config.pre_run_script,
+            resume=case_config.resume,
+            revision=case_config.revision,
+            runName=self._create_run_name(case_id=case_config.case_id, resume=case_config.resume),
+            sessionId=case_config.session_id,
+            workDir=case_config.work_dir,
+        )
+        return WorkflowLaunchRequest(launch=launch_request)
+
+    @staticmethod
+    def _create_run_name(case_id: str, resume: bool) -> str:
+        if resume:
+            return f"{case_id}_resumed_{datetime.now().strftime('%Y-%m-%d_%H-%M')}"
+        else:
+            return case_id

cg/services/analysis_starter/submitters/submitter.py

@@ -4,7 +4,7 @@ from cg.services.analysis_starter.configurator.abstract_model import CaseConfig
 
 
 class Submitter(ABC):
-    def submit(self, case_config: CaseConfig) -> str | None:
+    def submit(self, case_config: CaseConfig) -> CaseConfig:
         """Submits the case to be run either as a SubProcess or using the Seqera Platform.
         Returns the workflowId if run via the Seqera Platform."""
         pass

cg/services/analysis_starter/submitters/subprocess/submitter.py

@@ -12,7 +12,7 @@ SubprocessCaseConfig = MicrosaltCaseConfig | MIPDNACaseConfig
 
 
 class SubprocessSubmitter(Submitter):
-    def submit(self, case_config: SubprocessCaseConfig) -> None:
+    def submit(self, case_config: SubprocessCaseConfig) -> SubprocessCaseConfig:
         command: str = case_config.get_start_command()
         LOG.info(f"Running: {command}")
         subprocess.run(
@@ -22,6 +22,7 @@ class SubprocessSubmitter(Submitter):
             stdout=subprocess.PIPE,
             stderr=subprocess.PIPE,
         )
+        return case_config
 
     @staticmethod
     def get_workflow_version(case_config: SubprocessCaseConfig) -> str:

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

@@ -0,0 +1,22 @@
+from pathlib import Path
+
+from cg.constants.constants import WorkflowManager
+from cg.io.json import read_json
+from cg.services.analysis_starter.configurator.models.balsamic import BalsamicCaseConfig
+from cg.services.analysis_starter.tracker.tracker import Tracker
+
+
+class BalsamicTracker(Tracker):
+
+    def _workflow_manager(self):
+        return WorkflowManager.Slurm
+
+    def _get_job_ids_path(self, case_id: str) -> Path:
+        return Path(self._get_out_dir_path(case_id), "slurm_jobids.yaml")
+
+    def _get_out_dir_path(self, case_id: str) -> Path:
+        return Path(self.workflow_root, case_id, "analysis")
+
+    def _get_workflow_version(self, case_config: BalsamicCaseConfig) -> str:
+        config_data: dict = read_json(case_config.sample_config)
+        return config_data["analysis"]["BALSAMIC_version"]

cg/services/analysis_starter/tracker/implementations/microsalt.py

@@ -27,13 +27,13 @@ class MicrosaltTracker(Tracker):
     def _get_job_ids_path(self, case_id: str) -> Path:
         project_id: str = self._get_file_name_start(case_id)
         return Path(
-            self.workflow_root,
-            "results",
-            "reports",
-            "trailblazer",
+            self._get_out_dir_path(case_id),
             f"{project_id}_slurm_ids{FileExtensions.YAML}",
         )
 
+    def _get_out_dir_path(self, case_id: str) -> Path:
+        return Path(self.workflow_root, "results", "reports", "trailblazer")
+
     def _get_file_name_start(self, case_id: str) -> str:
         """Returns the LIMS project id if the case contains multiple samples, else the sample id."""
         case: Case = self.store.get_case_by_internal_id(case_id)

cg/services/analysis_starter/tracker/implementations/mip_dna.py

@@ -12,7 +12,10 @@ class MIPDNATracker(Tracker):
         return WorkflowManager.Slurm
 
     def _get_job_ids_path(self, case_id: str) -> Path:
-        return Path(self.workflow_root, case_id, "analysis", "slurm_job_ids.yaml")
+        return Path(self._get_out_dir_path(case_id), "slurm_job_ids.yaml")
+
+    def _get_out_dir_path(self, case_id: str) -> Path:
+        return Path(self.workflow_root, case_id, "analysis")
 
     def _get_sample_info_path(self, case_id: str) -> Path:
         return Path(self.workflow_root, case_id, "analysis", f"{case_id}_qc_sample_info.yaml")

cg/services/analysis_starter/tracker/implementations/{nextflow.py → nextflow_tracker.py}

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from cg.constants.constants import FileExtensions, WorkflowManager
+from cg.constants.constants import WorkflowManager
 from cg.services.analysis_starter.configurator.models.nextflow import NextflowCaseConfig
 from cg.services.analysis_starter.tracker.tracker import Tracker
 
@@ -9,9 +9,11 @@ class NextflowTracker(Tracker):
     def _workflow_manager(self) -> WorkflowManager:
         return WorkflowManager.Tower
 
-    def _get_job_ids_path(self, case_id: str) -> Path:
-        """Return the path to a Trailblazer config file containing Tower IDs."""
-        return Path(self.workflow_root, case_id, "tower_ids").with_suffix(FileExtensions.YAML)
+    def _get_job_ids_path(self, case_id: str) -> Path | None:
+        return None
+
+    def _get_out_dir_path(self, case_id: str) -> Path:
+        return Path(self.workflow_root, case_id)
 
     def _get_workflow_version(self, case_config: NextflowCaseConfig) -> str:
         return case_config.revision

cg/services/analysis_starter/tracker/tracker.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from cg.apps.environ import environ_email
 from cg.apps.tb import TrailblazerAPI
 from cg.apps.tb.models import TrailblazerAnalysis
-from cg.constants.constants import CaseActions, CustomerId, Workflow
+from cg.constants.constants import CaseActions, CustomerId, Workflow, WorkflowManager
 from cg.constants.priority import TrailblazerPriority
 from cg.constants.sequencing import SeqLibraryPrepCategory
 from cg.constants.tb import AnalysisType
@@ -35,10 +35,9 @@ class Tracker(ABC):
     def track(
         self,
         case_config: CaseConfig,
-        tower_workflow_id: str | None = None,
     ) -> None:
         tb_analysis: TrailblazerAnalysis = self._track_in_trailblazer(
-            case_id=case_config.case_id, tower_workflow_id=tower_workflow_id
+            case_id=case_config.case_id, tower_workflow_id=case_config.get_workflow_id()
         )
         LOG.info(
             f"Analysis entry for case {case_config.case_id} created in Trailblazer with id {tb_analysis.id}"
@@ -59,20 +58,20 @@ class Tracker(ABC):
         self.store.update_case_action(case_internal_id=case_id, action=None)
 
     def _track_in_trailblazer(
-        self, case_id: str, tower_workflow_id: int | None
+        self, case_id: str, tower_workflow_id: str | None
     ) -> TrailblazerAnalysis:
         analysis_type: str = self._get_analysis_type(case_id)
-        config_path: Path = self._get_job_ids_path(case_id)
+        config_path: Path | None = self._get_job_ids_path(case_id)
         email: str = environ_email()
-        order_id: int = self.store.get_case_by_internal_id(case_id).latest_order.id
-        out_dir: str = config_path.parent.as_posix()
+        order_id: int = self.store.get_case_by_internal_id_strict(case_id).latest_order.id
+        out_dir: str = self._get_out_dir_path(case_id).as_posix()
         priority: TrailblazerPriority = self._get_trailblazer_priority(case_id)
         ticket: str = self.store.get_latest_ticket_from_case(case_id)
         is_case_for_development: bool = self._is_case_for_development(case_id)
         return self.trailblazer_api.add_pending_analysis(
             analysis_type=analysis_type,
             case_id=case_id,
-            config_path=config_path.as_posix(),
+            config_path=config_path.as_posix() if config_path else None,
             email=email,
             order_id=order_id,
             out_dir=out_dir,
@@ -90,19 +89,20 @@ class Tracker(ABC):
         """Storing an analysis bundle in StatusDB for a provided case."""
         case_id: str = case_config.case_id
         LOG.info(f"Storing analysis in StatusDB for {case_id}")
-        case: Case = self.store.get_case_by_internal_id(case_id)
+        case: Case = self.store.get_case_by_internal_id_strict(case_id)
         is_primary: bool = len(case.analyses) == 0
         analysis_start: datetime = datetime.now()
         workflow_version: str = self._get_workflow_version(case_config)
         new_analysis: Analysis = self.store.add_analysis(
+            case=case,
             workflow=Workflow(case.data_analysis),
             version=workflow_version,
             completed_at=None,
             primary=is_primary,
+            session_id=case_config.get_session_id(),
             started_at=analysis_start,
             trailblazer_id=trailblazer_id,
         )
-        new_analysis.case = case
         self.store.add_item_to_store(new_analysis)
         self.store.commit_to_store()
         LOG.info(f"Analysis successfully stored in StatusDB: {case_id} : {analysis_start}")
@@ -112,7 +112,7 @@ class Tracker(ABC):
         Return the analysis type for sample.
         Only analysis types supported by Trailblazer are valid outputs.
         """
-        sample: Sample = self.store.get_case_by_internal_id(case_id).samples[0]
+        sample: Sample = self.store.get_case_by_internal_id_strict(case_id).samples[0]
         prep_category: str = sample.prep_category
         if prep_category and prep_category.lower() in {
             SeqLibraryPrepCategory.TARGETED_GENOME_SEQUENCING,
@@ -125,19 +125,23 @@ class Tracker(ABC):
 
     def _get_trailblazer_priority(self, case_id: str) -> TrailblazerPriority:
         """Get the priority for the case in Trailblazer."""
-        case: Case = self.store.get_case_by_internal_id(internal_id=case_id)
+        case: Case = self.store.get_case_by_internal_id_strict(internal_id=case_id)
         return MAP_TO_TRAILBLAZER_PRIORITY[case.priority]
 
     def _is_case_for_development(self, case_id: str) -> bool:
-        case: Case = self.store.get_case_by_internal_id(case_id)
+        case: Case = self.store.get_case_by_internal_id_strict(case_id)
         return case.customer.internal_id == CustomerId.CG_INTERNAL_CUSTOMER
 
     @abstractmethod
-    def _workflow_manager(self):
+    def _workflow_manager(self) -> WorkflowManager:
         pass
 
     @abstractmethod
-    def _get_job_ids_path(self, case_id: str):
+    def _get_job_ids_path(self, case_id: str) -> Path | None:
+        pass
+
+    @abstractmethod
+    def _get_out_dir_path(self, case_id: str) -> Path:
         pass
 
     @abstractmethod

cg/services/deliver_files/factory.py

@@ -180,7 +180,7 @@ class DeliveryServiceFactory:
         tag: str = case.samples[0].application_version.application.tag
         microbial_tags: list[str] = [
             application.tag
-            for application in self.store.get_active_applications_by_prep_category(
+            for application in self.store.get_applications_by_prep_category(
                 prep_category=SeqLibraryPrepCategory.MICROBIAL
             )
         ]

cg/services/delivery_message/messages/__init__.py

@@ -1,25 +1,35 @@
-from cg.services.delivery_message.messages.analysis_scout_message import (
-    AnalysisScoutMessage,
-)
+from cg.services.delivery_message.messages.analysis_scout_message import AnalysisScoutMessage
 from cg.services.delivery_message.messages.covid_message import CovidMessage
 from cg.services.delivery_message.messages.fastq_analysis_scout_message import (
     FastqAnalysisScoutMessage,
 )
 from cg.services.delivery_message.messages.fastq_message import FastqMessage
 from cg.services.delivery_message.messages.fastq_scout_message import FastqScoutMessage
-from cg.services.delivery_message.messages.microsalt_mwr_message import (
-    MicrosaltMwrMessage,
-)
-from cg.services.delivery_message.messages.microsalt_mwx_message import (
-    MicrosaltMwxMessage,
-)
-from cg.services.delivery_message.messages.scout_message import ScoutMessage
-from cg.services.delivery_message.messages.statina_message import StatinaMessage
+from cg.services.delivery_message.messages.microsalt_message import MicrosaltMessage
 from cg.services.delivery_message.messages.rna_delivery_message import (
-    RNAScoutStrategy,
-    RNAFastqStrategy,
     RNAAnalysisStrategy,
+    RNADeliveryMessage,
     RNAFastqAnalysisStrategy,
+    RNAFastqStrategy,
+    RNAScoutStrategy,
     RNAUploadMessageStrategy,
-    RNADeliveryMessage,
 )
+from cg.services.delivery_message.messages.scout_message import ScoutMessage
+from cg.services.delivery_message.messages.statina_message import StatinaMessage
+
+__all__ = [
+    "AnalysisScoutMessage",
+    "CovidMessage",
+    "FastqAnalysisScoutMessage",
+    "FastqMessage",
+    "FastqScoutMessage",
+    "MicrosaltMessage",
+    "RNAAnalysisStrategy",
+    "RNADeliveryMessage",
+    "RNAFastqAnalysisStrategy",
+    "RNAFastqStrategy",
+    "RNAScoutStrategy",
+    "RNAUploadMessageStrategy",
+    "ScoutMessage",
+    "StatinaMessage",
+]

cg/services/delivery_message/messages/{microsalt_mwr_message.py → microsalt_message.py}

@@ -6,7 +6,7 @@ from cg.services.delivery_message.messages.utils import (
 from cg.store.models import Case
 
 
-class MicrosaltMwrMessage(DeliveryMessage):
+class MicrosaltMessage(DeliveryMessage):
     def create_message(self, cases: list[Case]) -> str:
         delivery_path: str = get_caesar_delivery_path(cases[0])
         return (

cg/services/delivery_message/utils.py

@@ -1,4 +1,4 @@
-from cg.constants.constants import DataDelivery, MicrosaltAppTags, Workflow
+from cg.constants.constants import DataDelivery, Workflow
 from cg.exc import CaseNotFoundError, OrderMismatchError
 from cg.services.delivery_message.messages import (
     AnalysisScoutMessage,
@@ -6,7 +6,7 @@ from cg.services.delivery_message.messages import (
     FastqAnalysisScoutMessage,
     FastqMessage,
     FastqScoutMessage,
-    MicrosaltMwrMessage,
+    MicrosaltMessage,
     ScoutMessage,
     StatinaMessage,
 )
@@ -14,7 +14,6 @@ from cg.services.delivery_message.messages.analysis_message import AnalysisMessa
 from cg.services.delivery_message.messages.bam_message import BamMessage
 from cg.services.delivery_message.messages.delivery_message import DeliveryMessage
 from cg.services.delivery_message.messages.fastq_analysis_message import FastqAnalysisMessage
-from cg.services.delivery_message.messages.microsalt_mwx_message import MicrosaltMwxMessage
 from cg.services.delivery_message.messages.order_message import TaxprofilerDeliveryMessage
 from cg.services.delivery_message.messages.raw_data_analysis_message import RawDataAnalysisMessage
 from cg.services.delivery_message.messages.raw_data_analysis_scout_message import (
@@ -29,7 +28,7 @@ from cg.services.delivery_message.messages.rna_delivery_message import (
     RNAScoutStrategy,
     RNAUploadMessageStrategy,
 )
-from cg.store.models import Case, Sample
+from cg.store.models import Case
 from cg.store.store import Store
 
 MESSAGE_MAP = {
@@ -64,7 +63,7 @@ def get_message(cases: list[Case], store: Store) -> str:
 
 def get_message_strategy(case: Case, store: Store) -> DeliveryMessage:
     if case.data_analysis == Workflow.MICROSALT:
-        return get_microsalt_message_strategy(case)
+        return MicrosaltMessage()
 
     if case.data_analysis == Workflow.MUTANT:
         return CovidMessage()
@@ -96,41 +95,6 @@ def get_rna_message_strategy_from_data_delivery(
     return MESSAGE_MAP[case.data_delivery]()
 
 
-def get_microsalt_message_strategy(case: Case) -> DeliveryMessage:
-    if has_mwx_samples(case) or has_vwg_samples(case):
-        return MicrosaltMwxMessage()
-
-    if has_mwr_samples(case):
-        return MicrosaltMwrMessage()
-
-    app_tag: str = get_case_app_tag(case)
-    raise NotImplementedError(f"Microsalt apptag {app_tag} not supported.")
-
-
-def has_mwx_samples(case: Case) -> bool:
-    case_app_tag: str = get_case_app_tag(case)
-    return case_app_tag == MicrosaltAppTags.MWXNXTR003
-
-
-def has_mwr_samples(case: Case) -> bool:
-    case_app_tag: str = get_case_app_tag(case)
-    return case_app_tag == MicrosaltAppTags.MWRNXTR003
-
-
-def has_vwg_samples(case: Case) -> bool:
-    case_app_tag: str = get_case_app_tag(case)
-    return case_app_tag == MicrosaltAppTags.VWGNXTR001
-
-
-def get_case_app_tag(case: Case) -> str:
-    sample: Sample = case.samples[0]
-    return get_sample_app_tag(sample)
-
-
-def get_sample_app_tag(sample: Sample) -> str:
-    return sample.application_version.application.tag
-
-
 def validate_cases(cases: list[Case], case_ids: list[str]) -> None:
     if set(case_ids) != set(case.internal_id for case in cases):
         raise CaseNotFoundError("Internal id not found in the database")