cg 83.16.1__py3-none-any.whl → 83.16.3__py3-none-any.whl

cg/__init__.py

@@ -1,2 +1,2 @@
 __title__ = "cg"
-__version__ = "83.16.1"
+__version__ = "83.16.3"

cg/cli/workflow/mip_dna/base.py

@@ -6,13 +6,7 @@ from typing import cast
 import rich_click as click
 
 from cg.cli.utils import CLICK_CONTEXT_SETTINGS
-from cg.cli.workflow.commands import (
-    ensure_illumina_runs_on_disk,
-    link,
-    resolve_compression,
-    store,
-    store_available,
-)
+from cg.cli.workflow.commands import ensure_illumina_runs_on_disk, store, store_available
 from cg.cli.workflow.mip.options import (
     ARGUMENT_CASE_ID,
     OPTION_BWA_MEM,
@@ -49,8 +43,6 @@ def mip_dna(
 
 for sub_cmd in [
     ensure_illumina_runs_on_disk,
-    link,
-    resolve_compression,
     store,
     store_available,
 ]:

cg/constants/nextflow.py

@@ -1,29 +1,10 @@
 """Nextflow related constants."""
 
-from enum import IntEnum
 from cg.constants import Workflow
 
-NFX_WORK_DIR = "work"
-NFX_SAMPLE_HEADER = "sample"
-NFX_READ1_HEADER = "fastq_1"
-NFX_READ2_HEADER = "fastq_2"
-NFX_SAMPLESHEET_READS_HEADERS = [NFX_READ1_HEADER, NFX_READ2_HEADER]
-NFX_SAMPLESHEET_HEADERS = [NFX_SAMPLE_HEADER] + NFX_SAMPLESHEET_READS_HEADERS
-DELIVER_FILE_HEADERS = ["format", "id", "path", "path_index", "step", "tag"]
-NXF_PID_FILE_ENV = "NXF_PID_FILE"
-NXF_JVM_ARGS_ENV = "NXF_JVM_ARGS"
-JAVA_MEMORY_HEADJOB = "-Xmx5g"
 NEXTFLOW_WORKFLOWS: list = [
     Workflow.RAREDISEASE,
     Workflow.RNAFUSION,
     Workflow.TAXPROFILER,
     Workflow.TOMTE,
 ]
-
-
-class SlurmHeadJobDefaults(IntEnum):
-    """Default parameters for slurm head jobs."""
-
-    HOURS: int = 96
-    MEMORY: int = 10
-    NUMBER_TASKS: int = 1

cg/constants/nf_analysis.py

@@ -1,20 +1,7 @@
 """Nf-tower related constants."""
 
-from enum import StrEnum
 from typing import Any
 
-
-class NfTowerStatus(StrEnum):
-    """NF-Tower job submission status."""
-
-    SUBMITTED: str = "SUBMITTED"
-    RUNNING: str = "RUNNING"
-    SUCCEEDED: str = "SUCCEEDED"
-    FAILED: str = "FAILED"
-    CANCELLED: str = "CANCELLED"
-    UNKNOWN: str = "UNKNOWN"
-
-
 NALLO_GENERAL_METRIC_CONDITIONS: dict[str, dict[str, Any]] = {
     "median_coverage": {"norm": "gt", "threshold": 20},
 }
@@ -68,17 +55,6 @@ TOMTE_METRIC_CONDITIONS: dict[str, dict[str, Any]] = {
     "pct_duplication": {"norm": "lt", "threshold": 70},
 }
 
-
-MULTIQC_NEXFLOW_CONFIG = """process {
-    withName:'MULTIQC' {
-        memory = { 4.GB * task.attempt }
-        time   = { 4.h  * task.attempt }
-        cpus = 2
-        ext.args = ' --data-format json --cl-config "max_table_rows: 10000" '
-    }
-}
-"""
-
 NALLO_COVERAGE_FILE_TAGS: list[str] = ["d4"]
 NALLO_COVERAGE_INTERVAL_TYPE: str = "genes"
 NALLO_COVERAGE_THRESHOLD: int = 10

cg/meta/workflow/nallo.py

@@ -60,9 +60,7 @@ class NalloAnalysisAPI(NfAnalysisAPI):
         self.tower_workflow: str = config.nallo.tower_workflow
         self.account: str = config.nallo.slurm.account
         self.email: str = config.nallo.slurm.mail_user
-        self.compute_env_base: str = config.nallo.compute_env
         self.revision: str = config.nallo.revision
-        self.nextflow_binary_path: str = config.nallo.binary_path
 
     def get_genome_build(self, case_id: str) -> GenomeVersion:
         """Return reference genome for a Nallo case. Currently fixed for hg38."""

cg/meta/workflow/nf_analysis.py

@@ -8,21 +8,12 @@ from pydantic import TypeAdapter
 from pydantic.v1 import ValidationError
 
 from cg.constants import Workflow
-from cg.constants.constants import (
-    FileExtensions,
-    FileFormat,
-    GenomeVersion,
-    MultiQC,
-    WorkflowManager,
-)
-from cg.constants.nextflow import NFX_WORK_DIR
-from cg.constants.nf_analysis import NfTowerStatus
+from cg.constants.constants import FileExtensions, FileFormat, GenomeVersion, MultiQC
 from cg.constants.tb import AnalysisStatus
 from cg.exc import CgError, HousekeeperStoreError, MetricsQCError
 from cg.io.controller import ReadFile, WriteFile
 from cg.io.json import read_json
 from cg.meta.workflow.analysis import AnalysisAPI
-from cg.meta.workflow.nf_handlers import NextflowHandler, NfTowerHandler
 from cg.models.analysis import NextflowAnalysis
 from cg.models.cg_config import CGConfig
 from cg.models.deliverables.metric_deliverables import (
@@ -30,10 +21,9 @@ from cg.models.deliverables.metric_deliverables import (
     MetricsDeliverablesCondition,
     MultiqcDataJson,
 )
-from cg.models.nf_analysis import FileDeliverable, NfCommandArgs, WorkflowDeliverables
+from cg.models.nf_analysis import FileDeliverable, WorkflowDeliverables
 from cg.models.qc_metrics import QCMetrics
 from cg.store.models import Analysis, Case, Sample
-from cg.utils import Process
 
 LOG = logging.getLogger(__name__)
 
@@ -58,72 +48,22 @@ class NfAnalysisAPI(AnalysisAPI):
         self.tower_workflow: str | None = None
         self.account: str | None = None
         self.email: str | None = None
-        self.compute_env_base: str | None = None
         self.revision: str | None = None
-        self.nextflow_binary_path: str | None = None
 
     @property
     def root(self) -> str:
         return self.root_dir
 
-    @property
-    def process(self):
-        if not self._process:
-            self._process = Process(
-                binary=self.tower_binary_path,
-            )
-        return self._process
-
-    @process.setter
-    def process(self, process: Process):
-        self._process = process
-
     @property
     def is_multiqc_pattern_search_exact(self) -> bool:
         """Return True if only exact pattern search is allowed to collect metrics information from MultiQC file.
         If false, pattern must be present but does not need to be exact."""
         return False
 
-    def get_profile(self, profile: str | None = None) -> str:
-        """Get NF profiles."""
-        return profile or self.profile
-
-    def get_workflow_manager(self) -> str:
-        """Get workflow manager from Tower."""
-        return WorkflowManager.Tower.value
-
-    def get_workflow_version(self, case_id: str) -> str:
-        """Get workflow version from config."""
-        return self.revision
-
     def get_case_path(self, case_id: str) -> Path:
         """Path to case working directory."""
         return Path(self.root_dir, case_id)
 
-    def get_sample_sheet_path(self, case_id: str) -> Path:
-        """Path to sample sheet."""
-        return Path(self.get_case_path(case_id), f"{case_id}_samplesheet").with_suffix(
-            FileExtensions.CSV
-        )
-
-    def get_compute_env(self, case_id: str) -> str:
-        """Get the compute environment for the head job based on the case priority."""
-        return f"{self.compute_env_base}-{self.get_slurm_qos_for_case(case_id=case_id)}"
-
-    def get_nextflow_config_path(
-        self, case_id: str, nextflow_config: Path | str | None = None
-    ) -> Path:
-        """Path to nextflow config file."""
-        if nextflow_config:
-            return Path(nextflow_config).absolute()
-        return Path((self.get_case_path(case_id)), f"{case_id}_nextflow_config").with_suffix(
-            FileExtensions.JSON
-        )
-
-    def get_job_ids_path(self, case_id: str) -> Path:
-        """Return the path to a Trailblazer config file containing Tower IDs."""
-        return Path(self.root_dir, case_id, "tower_ids").with_suffix(FileExtensions.YAML)
-
     def get_deliverables_file_path(self, case_id: str) -> Path:
         """Path to deliverables file for a case."""
         return Path(self.get_case_path(case_id), f"{case_id}_deliverables").with_suffix(
@@ -136,33 +76,6 @@ class NfAnalysisAPI(AnalysisAPI):
             FileExtensions.YAML
         )
 
-    def get_params_file_path(self, case_id: str, params_file: Path | None = None) -> Path:
-        """Return parameters file or a path where the default parameters file for a case id should be located."""
-        if params_file:
-            return Path(params_file).absolute()
-        return Path((self.get_case_path(case_id)), f"{case_id}_params_file").with_suffix(
-            FileExtensions.YAML
-        )
-
-    def get_log_path(self, case_id: str, workflow: str) -> Path:
-        """Path to NF log."""
-        launch_time: str = datetime.now().strftime("%Y-%m-%d_%H.%M.%S")
-        return Path(
-            self.get_case_path(case_id),
-            f"{case_id}_{workflow}_nextflow_{launch_time}",
-        ).with_suffix(FileExtensions.LOG)
-
-    def get_workdir_path(self, case_id: str, work_dir: Path | None = None) -> Path:
-        """Path to NF work directory."""
-        if work_dir:
-            return work_dir.absolute()
-        return Path(self.get_case_path(case_id), NFX_WORK_DIR)
-
-    def verify_sample_sheet_exists(self, case_id: str, dry_run: bool = False) -> None:
-        """Raise an error if sample sheet file is not found."""
-        if not dry_run and not Path(self.get_sample_sheet_path(case_id=case_id)).exists():
-            raise ValueError(f"No config file found for case {case_id}")
-
     def verify_deliverables_file_exists(self, case_id: str) -> None:
         """Raise an error if a deliverable file is not found."""
         if not Path(self.get_deliverables_file_path(case_id=case_id)).exists():
@@ -177,181 +90,6 @@ class NfAnalysisAPI(AnalysisAPI):
             content=deliverables_content, file_format=file_format, file_path=file_path
         )
 
-    def write_trailblazer_config(self, case_id: str, tower_id: str) -> None:
-        """Write Tower IDs to a file used as the Trailblazer config."""
-        config_path: Path = self.get_job_ids_path(case_id=case_id)
-        LOG.info(f"Writing Tower ID to {config_path.as_posix()}")
-        WriteFile.write_file_from_content(
-            content={case_id: [tower_id]},
-            file_format=FileFormat.YAML,
-            file_path=config_path,
-        )
-
-    def _run_analysis_with_nextflow(
-        self, case_id: str, command_args: NfCommandArgs, dry_run: bool
-    ) -> None:
-        """Run analysis with given options using Nextflow."""
-        self.process = Process(
-            binary=self.nextflow_binary_path,
-            environment=self.conda_env,
-            conda_binary=self.conda_binary,
-            launch_directory=self.get_case_path(case_id=case_id),
-        )
-        LOG.info("Workflow will be executed using Nextflow")
-        parameters: list[str] = NextflowHandler.get_nextflow_run_parameters(
-            case_id=case_id,
-            workflow_bin_path=self.workflow_bin_path,
-            root_dir=self.root_dir,
-            command_args=command_args.dict(),
-        )
-        self.process.export_variables(
-            export=NextflowHandler.get_variables_to_export(),
-        )
-        command: str = self.process.get_command(parameters=parameters)
-        LOG.info(f"{command}")
-        sbatch_number: int = NextflowHandler.execute_head_job(
-            case_id=case_id,
-            case_directory=self.get_case_path(case_id=case_id),
-            slurm_account=self.account,
-            email=self.email,
-            qos=self.get_slurm_qos_for_case(case_id=case_id),
-            commands=command,
-            dry_run=dry_run,
-        )
-        LOG.info(f"Nextflow head job running as job: {sbatch_number}")
-
-    def _run_analysis_with_tower(
-        self, case_id: str, command_args: NfCommandArgs, dry_run: bool
-    ) -> str | None:
-        """Run analysis with given options using NF-Tower."""
-        LOG.info("Workflow will be executed using Tower")
-        if command_args.resume:
-            from_tower_id: int = command_args.id or NfTowerHandler.get_last_tower_id(
-                case_id=case_id,
-                trailblazer_config=self.get_job_ids_path(case_id=case_id),
-            )
-            LOG.info(f"Workflow will be resumed from run with Tower id: {from_tower_id}.")
-            parameters: list[str] = NfTowerHandler.get_tower_relaunch_parameters(
-                from_tower_id=from_tower_id, command_args=command_args.dict()
-            )
-        else:
-            parameters: list[str] = NfTowerHandler.get_tower_launch_parameters(
-                tower_workflow=self.tower_workflow, command_args=command_args.dict()
-            )
-        self.process.run_command(parameters=parameters, dry_run=dry_run)
-        if self.process.stderr:
-            LOG.error(self.process.stderr)
-        if not dry_run:
-            tower_id = NfTowerHandler.get_tower_id(stdout_lines=self.process.stdout_lines())
-            self.write_trailblazer_config(case_id=case_id, tower_id=tower_id)
-            return tower_id
-        LOG.info(self.process.stdout)
-
-    def get_command_args(
-        self,
-        case_id: str,
-        work_dir: str,
-        from_start: bool,
-        profile: str,
-        config: str,
-        params_file: str | None,
-        revision: str,
-        compute_env: str,
-        nf_tower_id: str | None,
-        stub_run: bool,
-    ) -> NfCommandArgs:
-        command_args: NfCommandArgs = NfCommandArgs(
-            **{
-                "log": self.get_log_path(case_id=case_id, workflow=self.workflow),
-                "work_dir": self.get_workdir_path(case_id=case_id, work_dir=work_dir),
-                "resume": not from_start,
-                "profile": self.get_profile(profile=profile),
-                "config": self.get_nextflow_config_path(case_id=case_id, nextflow_config=config),
-                "params_file": self.get_params_file_path(case_id=case_id, params_file=params_file),
-                "name": case_id,
-                "compute_env": compute_env or self.get_compute_env(case_id=case_id),
-                "revision": revision or self.revision,
-                "wait": NfTowerStatus.SUBMITTED,
-                "id": nf_tower_id,
-                "stub_run": stub_run,
-            }
-        )
-        return command_args
-
-    def run_nextflow_analysis(
-        self,
-        case_id: str,
-        use_nextflow: bool,
-        work_dir: str,
-        from_start: bool,
-        profile: str,
-        config: str,
-        params_file: str | None,
-        revision: str,
-        compute_env: str,
-        stub_run: bool,
-        nf_tower_id: str | None = None,
-        dry_run: bool = False,
-    ) -> None:
-        """Prepare and start run analysis: check existence of all input files generated by config-case and sync with trailblazer."""
-        self.status_db.verify_case_exists(case_internal_id=case_id)
-
-        command_args = self.get_command_args(
-            case_id=case_id,
-            work_dir=work_dir,
-            from_start=from_start,
-            profile=profile,
-            config=config,
-            params_file=params_file,
-            revision=revision,
-            compute_env=compute_env,
-            nf_tower_id=nf_tower_id,
-            stub_run=stub_run,
-        )
-
-        try:
-            self.verify_sample_sheet_exists(case_id=case_id, dry_run=dry_run)
-            self.check_analysis_ongoing(case_id=case_id)
-            LOG.info(f"Running analysis for {case_id}")
-            tower_workflow_id: str | None = self.run_analysis(
-                case_id=case_id,
-                command_args=command_args,
-                use_nextflow=use_nextflow,
-                dry_run=dry_run,
-            )
-            if not dry_run:
-                self.on_analysis_started(case_id=case_id, tower_workflow_id=tower_workflow_id)
-        except FileNotFoundError as error:
-            LOG.error(f"Could not resume analysis: {error}")
-            raise FileNotFoundError
-        except ValueError as error:
-            LOG.error(f"Could not run analysis: {error}")
-            raise ValueError
-        except CgError as error:
-            LOG.error(f"Could not run analysis: {error}")
-            raise CgError
-
-    def run_analysis(
-        self,
-        case_id: str,
-        command_args: NfCommandArgs,
-        use_nextflow: bool,
-        dry_run: bool = False,
-    ) -> str | None:
-        """Execute run analysis with given options."""
-        if use_nextflow:
-            self._run_analysis_with_nextflow(
-                case_id=case_id,
-                command_args=command_args,
-                dry_run=dry_run,
-            )
-        else:
-            return self._run_analysis_with_tower(
-                case_id=case_id,
-                command_args=command_args,
-                dry_run=dry_run,
-            )
-
     def get_deliverables_template_content(self) -> list[dict[str, str]]:
         """Return deliverables file template content."""
         LOG.debug("Getting deliverables file template content")

cg/meta/workflow/raredisease.py

@@ -59,9 +59,7 @@ class RarediseaseAnalysisAPI(NfAnalysisAPI):
         self.tower_workflow: str = config.raredisease.tower_workflow
         self.account: str = config.raredisease.slurm.account
         self.email: str = config.raredisease.slurm.mail_user
-        self.compute_env_base: str = config.raredisease.compute_env
         self.revision: str = config.raredisease.revision
-        self.nextflow_binary_path: str = config.raredisease.binary_path
 
     @staticmethod
     def get_bundle_filenames_path() -> Path:

cg/meta/workflow/rnafusion.py

@@ -41,9 +41,7 @@ class RnafusionAnalysisAPI(NfAnalysisAPI):
         self.tower_workflow: str = config.rnafusion.tower_workflow
         self.account: str = config.rnafusion.slurm.account
         self.email: str = config.rnafusion.slurm.mail_user
-        self.compute_env_base: str = config.rnafusion.compute_env
         self.revision: str = config.rnafusion.revision
-        self.nextflow_binary_path: str = config.rnafusion.binary_path
 
     @property
     def is_multiple_samples_allowed(self) -> bool:

cg/meta/workflow/taxprofiler.py

@@ -40,8 +40,6 @@ class TaxprofilerAnalysisAPI(NfAnalysisAPI):
         self.tower_workflow: str = config.taxprofiler.tower_workflow
         self.account: str = config.taxprofiler.slurm.account
         self.email: str = config.taxprofiler.slurm.mail_user
-        self.nextflow_binary_path: str = config.taxprofiler.binary_path
-        self.compute_env_base: str = config.taxprofiler.compute_env
 
     @property
     def is_multiqc_pattern_search_exact(self) -> bool:

cg/meta/workflow/tomte.py

@@ -38,9 +38,7 @@ class TomteAnalysisAPI(NfAnalysisAPI):
         self.tower_workflow: str = config.tomte.tower_workflow
         self.account: str = config.tomte.slurm.account
         self.email: str = config.tomte.slurm.mail_user
-        self.compute_env_base: str = config.tomte.compute_env
         self.revision: str = config.tomte.revision
-        self.nextflow_binary_path: str = config.tomte.binary_path
 
     @staticmethod
     def get_bundle_filenames_path() -> Path:

cg/models/cg_config.py

@@ -232,7 +232,6 @@ class MipConfig(BaseModel):
 
 class NalloConfig(CommonAppConfig):
     binary_path: str | None = None
-    compute_env: str
     conda_binary: str | None = None
     conda_env: str
     platform: str
@@ -252,7 +251,6 @@ class NalloConfig(CommonAppConfig):
 
 class RarediseaseConfig(CommonAppConfig):
     binary_path: str | None = None
-    compute_env: str
     conda_binary: str | None = None
     conda_env: str
     platform: str
@@ -272,7 +270,6 @@ class RarediseaseConfig(CommonAppConfig):
 
 class TomteConfig(CommonAppConfig):
     binary_path: str | None = None
-    compute_env: str
     conda_binary: str | None = None
     conda_env: str
     platform: str
@@ -291,7 +288,6 @@ class TomteConfig(CommonAppConfig):
 
 class RnafusionConfig(CommonAppConfig):
     binary_path: str
-    compute_env: str
     conda_binary: str | None = None
     conda_env: str
     platform: str
@@ -313,7 +309,6 @@ class TaxprofilerConfig(CommonAppConfig):
     binary_path: str
     conda_binary: str | None = None
     conda_env: str
-    compute_env: str
     platform: str
     params: str
     config: str

cg/models/nf_analysis.py

@@ -3,25 +3,6 @@ from pathlib import Path
 from pydantic import BaseModel, field_validator
 
 
-class NfCommandArgs(BaseModel):
-    """Model for arguments and options supported."""
-
-    log: str | Path | None = None
-    resume: bool | None = None
-    profile: str | None = None
-    stub_run: bool | None = None
-    config: str | Path | None = None
-    name: str | None = None
-    revision: str | None = None
-    wait: str | None = None
-    id: str | None = None
-    with_tower: bool | None = None
-    use_nextflow: bool | None = None
-    compute_env: str | None = None
-    work_dir: str | Path | None = None
-    params_file: str | Path | None = None
-
-
 class FileDeliverable(BaseModel):
     """Specification for a general deliverables file."""
 

cg/services/run_devices/pacbio/post_processing_service.py

@@ -67,7 +67,7 @@ class PacBioPostProcessingService(PostProcessingService):
         return processing_complete_file.exists()
 
     def can_post_processing_start(self, run_name: str) -> bool:
-        LOG.info(f"Checking if Pacbio post-processing can start for run: {run_name}")
+        LOG.debug(f"Checking if Pacbio post-processing can start for run: {run_name}")
         parent_directory: Path = Path(self.sequencing_dir, run_name).parent
         all_smrt_cells_are_ready: bool = all(
             self.is_smrt_cell_ready_for_post_processing(f"{parent_directory.name}/{smrt_cell.name}")
@@ -76,7 +76,7 @@ class PacBioPostProcessingService(PostProcessingService):
         return all_smrt_cells_are_ready
 
     def is_smrt_cell_ready_for_post_processing(self, run_name: str) -> bool:
-        LOG.info(f"Checking if Pacbio SMRT-cell {run_name} is ready for postprocessing")
+        LOG.debug(f"Checking if Pacbio SMRT-cell {run_name} is ready for postprocessing")
         try:
             run_data: PacBioRunData = self.run_data_generator.get_run_data(
                 run_name=run_name, sequencing_dir=self.sequencing_dir

cg/utils/commands.py

@@ -58,13 +58,6 @@ class Process:
         self._stdout = ""
         self._stderr = ""
 
-    def export_variables(self, export: dict[str, str]) -> None:
-        """Export variables prior to execution."""
-        if export:
-            self.base_call.insert(
-                0, " ".join([f"export {variable}={value};" for variable, value in export.items()])
-            )
-
     def run_command(self, parameters: list = None, dry_run: bool = False) -> int:
         """Execute a command in the shell.
         If environment is supplied - shell=True has to be supplied to enable passing as a string for executing multiple
@@ -107,15 +100,6 @@ class Process:
 
         return res.returncode
 
-    def get_command(self, parameters: list = None) -> str:
-        """Returns a command string given a list of parameters."""
-
-        command: list[str] = copy.deepcopy(self.base_call)
-        if parameters:
-            command.extend(parameters)
-
-        return " ".join(command)
-
     @property
     def stdout(self):
         """Fetch stdout"""

{cg-83.16.1.dist-info → cg-83.16.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cg
-Version: 83.16.1
+Version: 83.16.3
 Summary: Clinical Genomics command center
 Requires-Python: >=3.11,<3.13
 Classifier: Programming Language :: Python

{cg-83.16.1.dist-info → cg-83.16.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-cg/__init__.py,sha256=NQd_1VSkCO7eKx0EXRODgO4qNS_gTytb4Ketu8sUyu4,41
+cg/__init__.py,sha256=-KNsXPFJmxOXBBMRVpEqc8plX6zgZhPUuS3dv88wMVY,41
 cg/apps/__init__.py,sha256=pYf0vxo4iYQqURzFRYzqpOCdV8Cm9MWx0GHvJOz0EMg,315
 cg/apps/coverage/__init__.py,sha256=dJtsmNf8tODE2-VEomMIoYA7ugLYZAk_upsfOQCZeF8,27
 cg/apps/coverage/api.py,sha256=e_ozC3QeNKoEfpjjMaL-XjeBLtz-JySWccrtw0E9mLM,2940
@@ -151,7 +151,7 @@ cg/cli/workflow/mip/__init__.py,sha256=tAp9BLY37Gsg-jvTdgUEoP8lnaHW4I61tXfHsBFkL
 cg/cli/workflow/mip/base.py,sha256=upsDouj2iQbq37xQXHR2gVl2aqGozVRDZTMjLPbtX8Q,6767
 cg/cli/workflow/mip/options.py,sha256=Yoo9yq2quE52zV3lzp2-OjWdON2jJfjCUrTY82hrq30,1139
 cg/cli/workflow/mip_dna/__init__.py,sha256=tAp9BLY37Gsg-jvTdgUEoP8lnaHW4I61tXfHsBFkLpk,22
-cg/cli/workflow/mip_dna/base.py,sha256=dw1GlXVDr_gcIzMoLjH5nACNqiZbnwbIlvzgK0-sl5Y,4305
+cg/cli/workflow/mip_dna/base.py,sha256=OKKTOsypeNeUdlUUuCJEz0PxuXWCbB92k15eUsx4_go,4218
 cg/cli/workflow/mip_rna/__init__.py,sha256=tAp9BLY37Gsg-jvTdgUEoP8lnaHW4I61tXfHsBFkLpk,22
 cg/cli/workflow/mip_rna/base.py,sha256=G6O77Y4DB5eV3Oc5Ktd9vkwH_aMeehnmGT-EDQUX4bk,1019
 cg/cli/workflow/mutant/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -206,8 +206,8 @@ cg/constants/housekeeper_tags.py,sha256=742ZAo6YdYhdZwRFOLN3HoPmLviuvfqutGlSscza
 cg/constants/invoice.py,sha256=Tdd3PY_Z7wz4eSfKaTapSFlkmk_FWM1bwWMOj5D5F5Y,95
 cg/constants/lims.py,sha256=vhATu1UtIXdfPZWEu8pne3uq4ZhCAdPNJcjSotD8AE8,6559
 cg/constants/metrics.py,sha256=jBLp8buIG_3fKFraerFvpfSJ6s-0H42jI1qysjjAXFc,847
-cg/constants/nextflow.py,sha256=bDoyqqt8yj2P49mGfDrA0LEHVn1MkZOe5bDhEiYpPZI,811
-cg/constants/nf_analysis.py,sha256=C-sgUS8eRxkjN-ncizHaWRvME0PDG4rw65jgqZ-c_og,3080
+cg/constants/nextflow.py,sha256=o5VxtsyZNJaA1bh_AyKQQ0Iov6grZIeik_hhE8zO268,197
+cg/constants/nf_analysis.py,sha256=r3bfzzIAL3fU3dxMSwIUmN_jYLhcF70L0NXymGLTj5M,2541
 cg/constants/nipt.py,sha256=KGy7Y08jIUmT9FKKdjGzfRwvklAkOHRLKXqDOQx4aPc,19
 cg/constants/observations.py,sha256=Sjxo3R7DCkcMkSWNSeg2Sznkjr3werFRRsSREjd6CCU,3887
 cg/constants/orderforms.py,sha256=pLD_ufw11aE-Fn4x87el3F_KRITi2lbrgpBYU7eJgpM,2362
@@ -383,14 +383,13 @@ cg/meta/workflow/mutant/quality_controller/quality_controller.py,sha256=JMMCZHBj
 cg/meta/workflow/mutant/quality_controller/report_generator_utils.py,sha256=bM5GSRBoheOzxR3lzATSp-ETvQ1uS8obAw2onP1Q2RE,1247
 cg/meta/workflow/mutant/quality_controller/result_logger_utils.py,sha256=LqdP8yxf-V4VQcmtt2smX7p6ljoAaL4GnfJRQfIbdqc,2822
 cg/meta/workflow/mutant/quality_controller/utils.py,sha256=8zbn210O5RIKRIsaZUkVvjvGnUjRDULW5pseyHEOViQ,627
-cg/meta/workflow/nallo.py,sha256=PFwG1gvA7pNqFzDA79AdOwk0udxknVdyG-1oGZwaAgI,10163
-cg/meta/workflow/nf_analysis.py,sha256=5M8IzSp0jXrBUDX46Tp1YFDefZtCNDhW9hDCyNmhVpw,30787
-cg/meta/workflow/nf_handlers.py,sha256=DJ0Xkk3tWbIh7uxxvoJ3615gqeKDtPpNtWMrOYh1VHM,6248
+cg/meta/workflow/nallo.py,sha256=V0yBQLIlRvWS-gtOfJ6OgxGXTTEjx5Yp-KObyBMCNjs,10035
+cg/meta/workflow/nf_analysis.py,sha256=eXl_1AxwwdzVC_k3ujiONH5q1FCw9wacGoVpVKx2_PI,20466
 cg/meta/workflow/prepare_fastq.py,sha256=HbkrsuqlZgb_7kQPf_j_Mqowh6nEms9jl7043ybxK4U,6149
-cg/meta/workflow/raredisease.py,sha256=XhlgCPSx-MmzDdpXrLY__vKl2f8np_1JuIIwwQKI-7c,9038
-cg/meta/workflow/rnafusion.py,sha256=S8Pxq9eKN4Bm0U5pPh8Qi3I3eTBYRySdR7S8M6SVb-g,3782
-cg/meta/workflow/taxprofiler.py,sha256=SojjfA9dKsfzf_PNpPf3tG2z8M0cO5Fe4b45l4fXsgo,3185
-cg/meta/workflow/tomte.py,sha256=VstaJTpe-mCTitzvXcxAVXJ_JpH-icfPK1qN7zMsfHE,2473
+cg/meta/workflow/raredisease.py,sha256=-bENb0f1f9bptMsP_PBy4niMmkxDnIxCOF32OBgDxts,8898
+cg/meta/workflow/rnafusion.py,sha256=Mcmn_HTAHpH-M6Pl_bOG2oSfIgZe11GqtTKrk6lFpPU,3646
+cg/meta/workflow/taxprofiler.py,sha256=pphhUfe-CguO1PIwR3orRoaNnVWi_8V23MkYORHcAh0,3045
+cg/meta/workflow/tomte.py,sha256=-WtxossQMfQjYR9CBdxS1V_gTix3gAVqjDR5tIBTHcE,2345
 cg/meta/workflow/utils/utils.py,sha256=eNTKbyggGavp4BXD1Lq1alMHL7Qpm_YRdJzmyrGmXAM,393
 cg/models/__init__.py,sha256=5mHdugMi0PtYuj-EP1N-M5LtnCY6CGpiP2XqgLFpQBI,67
 cg/models/analysis.py,sha256=o_0SGLl_Y8uQ1nt61OaG3N4D0t7C9Z9Wwq6FxU0Qlj0,775
@@ -398,7 +397,7 @@ cg/models/balsamic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 cg/models/balsamic/analysis.py,sha256=XSQDClACnH3tkff66yRdHWJVgsBQcUNuztYb7ICOV68,477
 cg/models/balsamic/config.py,sha256=uf5Vz_Ro4adM98absZZYm4W4vco2sJziEeO0f5UTtBE,4108
 cg/models/balsamic/metrics.py,sha256=wtPulyNkfEvKBo742kIsfqRP88-_TBfeWNesh4ezsVI,2279
-cg/models/cg_config.py,sha256=LG6gNvXm4a_Gg7nDnwucb8kerbqvoFckXOcz7CsCpas,25839
+cg/models/cg_config.py,sha256=fLqES5j4gPeuKB_K0eDDO6a7XgqRLuTYS1OqHaF_JTk,25734
 cg/models/compression_data.py,sha256=io1XjIsvlqsVpEZy_jN2XveEYzApPdBbAMs2xcld4Ao,11741
 cg/models/deliverables/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cg/models/deliverables/metric_deliverables.py,sha256=nWNhlN0I_xbjp43522Uv8yfN0sCCcEqa7S4infIh8HA,5488
@@ -428,7 +427,7 @@ cg/models/mip/mip_metrics_deliverables.py,sha256=WfnRQkNj8CIsI4EBXnPW2OuOd4394aR
 cg/models/mip/mip_sample_info.py,sha256=DM6tSwajQ-Cxf0peROiryYifFMCMHuD_jeZu39Q0-18,2550
 cg/models/nallo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cg/models/nallo/nallo.py,sha256=7oUCkDQyuRxvbsct1IItzfEtQnHvZdpTRiwt41EOoIo,727
-cg/models/nf_analysis.py,sha256=ZWloZxpyyMrwsDVbawEWTh28ywfL143WGX86gDeCebw,1158
+cg/models/nf_analysis.py,sha256=4iXBSiJJLap_H2zYJtTnRj8t24syWc6dwemFQAcPlbY,602
 cg/models/observations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cg/models/observations/input_files.py,sha256=oXDc4LFY3FXkxg6u4wASby4DjnNaKZ-zElf7-olezRk,1062
 cg/models/orders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -837,7 +836,7 @@ cg/services/run_devices/pacbio/metrics_parser/__init__.py,sha256=47DEQpj8HBSa-_T
 cg/services/run_devices/pacbio/metrics_parser/metrics_parser.py,sha256=26aAxw4xmBwtkVrSD4bmjThTTLsB6hmJgZEUXrITRW8,3279
 cg/services/run_devices/pacbio/metrics_parser/models.py,sha256=4BTxMv5d5eg2NSoBoZ8EwVqJyGuLTqHacgiSQ3AFL0E,7331
 cg/services/run_devices/pacbio/metrics_parser/utils.py,sha256=Y_Jsj-mnsuVF-iKZ7W1sJAuWqw25ayVonj9ktLHCNfA,3467
-cg/services/run_devices/pacbio/post_processing_service.py,sha256=0NOmLAzF3I2UHbyKDAcEFJL5XykPMBLxs2Dz40J-UTc,3962
+cg/services/run_devices/pacbio/post_processing_service.py,sha256=LYy3IRR48R2V-0azDSK_11kqxkAcla--7uN3uqkVyX8,3964
 cg/services/run_devices/pacbio/run_data_generator/pacbio_run_data_generator.py,sha256=rvNepeIjt2BeZk-CvOpD449jmxceME0npEYAlqIebWg,1902
 cg/services/run_devices/pacbio/run_data_generator/run_data.py,sha256=si-F7CCwmIFoLpb6YaJmxI_SWVxOi2ivmjnxQl3P0nk,268
 cg/services/run_devices/pacbio/run_file_manager/models.py,sha256=C6kycBPx6YKNq2oFJOIhdrcPloi3QIBOrlbaAgeYzgs,192
@@ -912,7 +911,7 @@ cg/utils/checksum/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 cg/utils/checksum/checksum.py,sha256=jRvL1f6TPV2QyhUBR-WUK7i67wB7a2FKcwrs6kr8GXI,1992
 cg/utils/click/EnumChoice.py,sha256=ogTT49nEAsu60YQeFLp1cCI9t6xzuxmVFA17za53cko,1669
 cg/utils/click/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cg/utils/commands.py,sha256=0RWc0t9PDsntS3uvVH2swMuNOD7VtbFmQGEAg7MbmAc,4910
+cg/utils/commands.py,sha256=D6tfGBGp3wQMXkNEhquSQ9ZyKzkMn8PvSGAllBVaZWQ,4344
 cg/utils/date.py,sha256=4aX7ZyyRfHHiNsA8yNYw2nzTON-yq3gQSypAEXHK4Wk,2192
 cg/utils/dict.py,sha256=Zr67gvr5_W1Lpe6_MUZDAegWa2oakXVW-JrZgiRcaAw,758
 cg/utils/email.py,sha256=VH15Ezbc_FgSOGJr9KvSiMaEU0TwNaZHVUXlRAaBzxs,1251
@@ -923,7 +922,7 @@ cg/utils/flask/enum.py,sha256=xwNVtFPkSzoloJctLHu7obRyxcng1GJrhkeYkqwf9tw,1052
 cg/utils/mapping.py,sha256=oZpZW2kgsbtAP2FZ7RtRPELiEE1zZk_nAGisHGtCOUo,491
 cg/utils/time.py,sha256=_VOglhrFEZ5cwHK1U1g36SdwzB7UvV-Nvlt4ymuZUho,1501
 cg/utils/utils.py,sha256=RciI_UhWcnG_pMZrmQZ1ZYb-O1N0DweTYMmhE0SIRgQ,1410
-cg-83.16.1.dist-info/METADATA,sha256=0qPOKTgbs7jLWPvz8c10Uv28QkzMKcGIsnLDPWst4IQ,4940
-cg-83.16.1.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-cg-83.16.1.dist-info/entry_points.txt,sha256=q5f47YQQGltzK_xnIq1mDopRXXEItr85Xe1BCtG-Wts,39
-cg-83.16.1.dist-info/RECORD,,
+cg-83.16.3.dist-info/METADATA,sha256=-3RkahOJHJQFkkc8FaLjRE5SMl3EluVnHVgux1aM9Mk,4940
+cg-83.16.3.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+cg-83.16.3.dist-info/entry_points.txt,sha256=q5f47YQQGltzK_xnIq1mDopRXXEItr85Xe1BCtG-Wts,39
+cg-83.16.3.dist-info/RECORD,,

cg/meta/workflow/nf_handlers.py

@@ -1,179 +0,0 @@
-"""Module to handle NF executors."""
-
-from datetime import datetime
-from pathlib import Path
-from typing import Iterable
-
-from cg.apps.slurm.slurm_api import SlurmAPI
-from cg.constants.constants import FileExtensions, FileFormat
-from cg.constants.nextflow import JAVA_MEMORY_HEADJOB, NXF_JVM_ARGS_ENV, SlurmHeadJobDefaults
-from cg.io.controller import ReadFile
-from cg.models.slurm.sbatch import Sbatch
-from cg.utils.utils import build_command_from_dict
-
-
-class NfBaseHandler:
-    """
-    Parent class for handling the interaction with NF executors that are common to both Nextflow and NF-Tower.
-    """
-
-    pass
-
-
-class NfTowerHandler(NfBaseHandler):
-    """
-    Parent class for handling the interaction with NF-Tower.
-    """
-
-    @classmethod
-    def get_tower_launch_parameters(cls, tower_workflow: str, command_args: dict) -> list[str]:
-        """Returns a tower launch command given a dictionary with arguments."""
-
-        tower_options: list[str] = build_command_from_dict(
-            options={
-                f"--{arg.replace('_', '-')}": command_args.get(arg, None)
-                for arg in (
-                    "work_dir",
-                    "profile",
-                    "params_file",
-                    "config",
-                    "name",
-                    "revision",
-                    "compute_env",
-                    "stub_run",
-                )
-            },
-            exclude_true=True,
-        )
-        return ["launch"] + tower_options + [tower_workflow]
-
-    @classmethod
-    def get_tower_relaunch_parameters(cls, from_tower_id: int, command_args: dict) -> list[str]:
-        """Returns a tower relaunch command given a dictionary with arguments."""
-
-        tower_options: list[str] = build_command_from_dict(
-            options={
-                f"--{arg.replace('_', '-')}": command_args.get(arg, None)
-                for arg in (
-                    "profile",
-                    "params_file",
-                    "config",
-                    "compute_env",
-                    "revision",
-                    "stub_run",
-                )
-            },
-            exclude_true=True,
-        )
-        now: str = datetime.now().strftime("%Y%m%d%H%M%S")
-        return [
-            "runs",
-            "relaunch",
-            "--id",
-            str(from_tower_id),
-            "--name",
-            f"{command_args.get('name')}_from{str(from_tower_id)}_{now}",
-        ] + tower_options
-
-    @staticmethod
-    def get_tower_id(stdout_lines: Iterable) -> str:
-        """Parse the stdout and return a workflow id. An example of the output to parse is:
-        Case <CASE_ID> exists in status db
-        Running RNAFUSION analysis for <CASE_ID>
-        Workflow will be executed using tower
-        Running command <COMMAND>
-
-          Workflow 1uxZE9JM7Tl58r submitted at [<WORKSPACE>] workspace.
-
-        https://<URL_TO_TOWER_CASE>
-        Action running set for case <CASE_ID>"""
-        for line in stdout_lines:
-            if line.strip().startswith("Workflow"):
-                return line.strip().split()[1]
-
-    @classmethod
-    def get_last_tower_id(cls, case_id: str, trailblazer_config: Path) -> int:
-        """Return the previously-stored NF-Tower ID."""
-        if not trailblazer_config.exists():
-            raise FileNotFoundError(f"No NF-Tower ID found for case {case_id}.")
-        return ReadFile.get_content_from_file(
-            file_format=FileFormat.YAML, file_path=trailblazer_config
-        ).get(case_id)[-1]
-
-
-class NextflowHandler(NfBaseHandler):
-    """
-    Parent class for handling the interaction with Nextflow.
-    """
-
-    @staticmethod
-    def get_variables_to_export() -> dict[str, str]:
-        """Dictionary with required environment variables to be exported."""
-        return {NXF_JVM_ARGS_ENV: f"'{JAVA_MEMORY_HEADJOB}'"}
-
-    @classmethod
-    def get_nextflow_run_parameters(
-        cls, case_id: str, workflow_bin_path: str, root_dir: str, command_args: dict
-    ) -> list[str]:
-        """Returns a Nextflow run command given a dictionary with arguments."""
-
-        nextflow_options: list[str] = build_command_from_dict(
-            options=dict((f"-{arg}", command_args.get(arg, True)) for arg in ("log", "config")),
-            exclude_true=True,
-        )
-        run_options: list[str] = build_command_from_dict(
-            options=dict(
-                (f"-{arg.replace('_', '-')}", command_args.get(arg, None))
-                for arg in (
-                    "work_dir",
-                    "resume",
-                    "profile",
-                    "with_tower",
-                    "params_file",
-                )
-            ),
-            exclude_true=True,
-        )
-        return nextflow_options + ["run", workflow_bin_path] + run_options
-
-    @staticmethod
-    def get_head_job_sbatch_path(case_directory: Path) -> Path:
-        """Path to Nextflow sbatch for the head job."""
-        return Path(case_directory, "nextflow_head_job").with_suffix(FileExtensions.SBATCH)
-
-    @classmethod
-    def execute_head_job(
-        cls,
-        case_id: str,
-        case_directory: Path,
-        slurm_account: str,
-        email: str,
-        qos: str,
-        commands: str,
-        hours: int = SlurmHeadJobDefaults.HOURS,
-        memory: int = SlurmHeadJobDefaults.MEMORY,
-        number_tasks: int = SlurmHeadJobDefaults.NUMBER_TASKS,
-        dry_run: bool = False,
-    ) -> int:
-        """Executes Nextflow head job command."""
-
-        slurm_api: SlurmAPI = SlurmAPI()
-        slurm_api.set_dry_run(dry_run=dry_run)
-        sbatch_parameters: Sbatch = Sbatch(
-            account=slurm_account,
-            commands=commands,
-            email=email,
-            hours=hours,
-            job_name=f"{case_id}.%j",
-            log_dir=case_directory.as_posix(),
-            memory=memory,
-            number_tasks=number_tasks,
-            quality_of_service=qos,
-        )
-
-        sbatch_content: str = slurm_api.generate_sbatch_content(sbatch_parameters=sbatch_parameters)
-        sbatch_path: Path = cls.get_head_job_sbatch_path(case_directory=case_directory)
-        sbatch_number: int = slurm_api.submit_sbatch(
-            sbatch_content=sbatch_content, sbatch_path=sbatch_path
-        )
-        return sbatch_number