cg 83.16.2__tar.gz → 83.16.4__tar.gz

{cg-83.16.2 → cg-83.16.4}/PKG-INFO

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

cg-83.16.4/cg/__init__.py

@@ -0,0 +1,2 @@
+__title__ = "cg"
+__version__ = "83.16.4"

{cg-83.16.2 → cg-83.16.4}/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-83.16.4/cg/constants/nextflow.py

@@ -0,0 +1,10 @@
+"""Nextflow related constants."""
+
+from cg.constants import Workflow
+
+NEXTFLOW_WORKFLOWS: list = [
+    Workflow.RAREDISEASE,
+    Workflow.RNAFUSION,
+    Workflow.TAXPROFILER,
+    Workflow.TOMTE,
+]

{cg-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/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-83.16.2 → cg-83.16.4}/cg/server/admin.py

@@ -31,6 +31,11 @@ class BaseView(ModelView):
         return redirect(url_for("google.login", next=request.url))
 
 
+def view_hifi_yield_in_gb(unused1, unused2, model, unused3):
+    del unused1, unused2, unused3
+    return Markup(f"{round(model.hifi_yield/1E9, 1)} Gb") if model.hifi_yield else ""
+
+
 def view_priority(unused1, unused2, model, unused3):
     """column formatter for priority"""
     del unused1, unused2, unused3
@@ -780,6 +785,7 @@ class SampleView(BaseView):
     column_formatters = {
         "application_version": view_application_link_via_application_version,
         "customer": view_customer_link,
+        "hifi_yield": view_hifi_yield_in_gb,
         "internal_id": view_case_sample_link,
         "invoice": InvoiceView.view_invoice_link,
         "original_ticket": view_ticket_link,

{cg-83.16.2 → cg-83.16.4}/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.2 → cg-83.16.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "cg"
-version = "83.16.2"
+version = "83.16.4"
 description = "Clinical Genomics command center"
 readme = {file = "README.md", content-type = "text/markdown"}
 homepage = "https://github.com/Clinical-Genomics/cg"

cg-83.16.2/cg/__init__.py

@@ -1,2 +0,0 @@
-__title__ = "cg"
-__version__ = "83.16.2"

cg-83.16.2/cg/constants/nextflow.py

@@ -1,29 +0,0 @@
-"""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