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

cg/cli/workflow/balsamic/umi.py

@@ -1,25 +1,65 @@
 """CLI support to create config and/or start BALSAMIC """
 
 import logging
+import traceback
 
 import rich_click as click
 
 from cg.cli.utils import CLICK_CONTEXT_SETTINGS
-from cg.cli.workflow.balsamic.base import (
-    config_case,
-    report_deliver,
-    run,
-    start,
-    start_available,
-    store,
-    store_available,
-    store_housekeeper,
-)
-from cg.cli.workflow.commands import link, resolve_compression
+from cg.cli.workflow.balsamic.base import report_deliver, store, store_available, store_housekeeper
+from cg.cli.workflow.balsamic.options import OPTION_PANEL_BED, OPTION_WORKFLOW_PROFILE
+from cg.cli.workflow.commands import ARGUMENT_CASE_ID, link, resolve_compression
+from cg.constants import EXIT_FAIL, EXIT_SUCCESS, Sex
+from cg.constants.cli_options import DRY_RUN, LIMIT
+from cg.constants.constants import GenomeVersion
+from cg.constants.priority import SlurmQos
+from cg.exc import AnalysisNotReadyError, CgError
 from cg.meta.workflow.balsamic_umi import BalsamicUmiAnalysisAPI
+from cg.models.cg_config import CGConfig
+from cg.store.models import Case
 
 LOG = logging.getLogger(__name__)
 
+OPTION_GENDER = click.option(
+    "--gender",
+    type=click.Choice([Sex.FEMALE, Sex.MALE]),
+    required=False,
+    help="Case associated gender. Set this option to override the one selected by the customer in StatusDB.",
+)
+OPTION_GENOME_VERSION = click.option(
+    "--genome-version",
+    show_default=True,
+    default=GenomeVersion.HG19,
+    type=click.Choice([GenomeVersion.HG19, GenomeVersion.HG38, GenomeVersion.CANFAM3]),
+    help="Type and build version of the reference genome. Set this option to override the default.",
+)
+OPTION_QOS = click.option(
+    "-qos",
+    "--slurm-quality-of-service",
+    type=click.Choice([SlurmQos.LOW, SlurmQos.NORMAL, SlurmQos.HIGH, SlurmQos.EXPRESS]),
+    help="Job priority in SLURM. Setting this option will override the StatusDB case priority.",
+)
+OPTION_PON_CNN = click.option(
+    "--pon-cnn",
+    type=click.Path(exists=True),
+    required=False,
+    help="Panel of normal reference (.cnn) for CNVkit",
+)
+OPTION_OBSERVATIONS = click.option(
+    "--observations",
+    type=click.Path(exists=True),
+    multiple=True,
+    required=False,
+    help="VCF paths of clinical and/or cancer SNVs and SVs observations (WHOLE_GENOME_SEQUENCING analysis only). Set this option to "
+    "override the latest Loqusdb dump files.",
+)
+OPTION_CACHE_VERSION = click.option(
+    "--cache-version",
+    type=click.STRING,
+    required=False,
+    help="Cache version to be used for init or analysis. Use 'develop' or 'X.X.X'.",
+)
+
 
 @click.group(
     "balsamic-umi",
@@ -36,13 +76,168 @@ def balsamic_umi(context: click.Context):
     context.obj.meta_apis["analysis_api"] = BalsamicUmiAnalysisAPI(config=config)
 
 
+@balsamic_umi.command("config-case")
+@ARGUMENT_CASE_ID
+@OPTION_GENDER
+@OPTION_GENOME_VERSION
+@OPTION_PANEL_BED
+@OPTION_PON_CNN
+@OPTION_OBSERVATIONS
+@OPTION_CACHE_VERSION
+@DRY_RUN
+@click.pass_obj
+def config_case(
+    context: CGConfig,
+    case_id: str,
+    gender: str,
+    genome_version: str,
+    panel_bed: str,
+    pon_cnn: click.Path,
+    observations: list[click.Path],
+    cache_version: str,
+    dry_run: bool,
+):
+    """Create config file for BALSAMIC UMI analysis for a given CASE_ID."""
+
+    analysis_api: BalsamicUmiAnalysisAPI = context.meta_apis["analysis_api"]
+    try:
+        LOG.info(f"Creating config file for {case_id}.")
+        analysis_api.status_db.verify_case_exists(case_internal_id=case_id)
+        analysis_api.config_case(
+            case_id=case_id,
+            gender=gender,
+            genome_version=genome_version,
+            panel_bed=panel_bed,
+            pon_cnn=pon_cnn,
+            observations=observations,
+            cache_version=cache_version,
+            dry_run=dry_run,
+        )
+    except CgError as error:
+        error_info = f"Error: {type(error).__name__}: {str(error)}\n{traceback.format_exc()}"
+        LOG.error(f"Could not create config: {error_info}")
+        raise click.Abort()
+    except Exception as error:
+        error_info = f"Error: {type(error).__name__}: {str(error)}\n{traceback.format_exc()}"
+        LOG.error(f"Could not create config: {error_info}")
+        raise click.Abort()
+
+
+@balsamic_umi.command("run")
+@ARGUMENT_CASE_ID
+@OPTION_WORKFLOW_PROFILE
+@DRY_RUN
+@OPTION_QOS
+@click.pass_obj
+def run(
+    context: CGConfig,
+    case_id: str,
+    workflow_profile: click.Path,
+    slurm_quality_of_service: str,
+    dry_run: bool,
+):
+    """Run Balsamic UMI analysis for given CASE ID"""
+    analysis_api: BalsamicUmiAnalysisAPI = context.meta_apis["analysis_api"]
+    try:
+        analysis_api.status_db.verify_case_exists(case_internal_id=case_id)
+        analysis_api.verify_case_config_file_exists(case_id=case_id, dry_run=dry_run)
+        analysis_api.check_analysis_ongoing(case_id)
+        analysis_api.run_analysis(
+            case_id=case_id,
+            workflow_profile=workflow_profile,
+            slurm_quality_of_service=slurm_quality_of_service,
+            dry_run=dry_run,
+        )
+        if dry_run:
+            return
+        analysis_api.on_analysis_started(case_id)
+    except Exception as error:
+        error_info = f"Error: {type(error).__name__}: {str(error)}\n{traceback.format_exc()}"
+        LOG.error(f"Could not run analysis: {error_info}")
+        raise click.Abort()
+
+
+@balsamic_umi.command("start")
+@ARGUMENT_CASE_ID
+@OPTION_GENDER
+@OPTION_GENOME_VERSION
+@OPTION_QOS
+@DRY_RUN
+@OPTION_PANEL_BED
+@OPTION_PON_CNN
+@OPTION_CACHE_VERSION
+@OPTION_OBSERVATIONS
+@OPTION_WORKFLOW_PROFILE
+@click.pass_context
+def start(
+    context: click.Context,
+    case_id: str,
+    gender: str,
+    genome_version: str,
+    cache_version: str,
+    panel_bed: str,
+    pon_cnn: str,
+    observations: list[click.Path],
+    slurm_quality_of_service: str,
+    workflow_profile: click.Path,
+    dry_run: bool,
+):
+    """Start full workflow for case ID."""
+    analysis_api: BalsamicUmiAnalysisAPI = context.obj.meta_apis["analysis_api"]
+    analysis_api.prepare_fastq_files(case_id=case_id, dry_run=dry_run)
+    LOG.info(f"Starting analysis for {case_id}")
+    context.invoke(link, case_id=case_id, dry_run=dry_run)
+    context.invoke(
+        config_case,
+        case_id=case_id,
+        gender=gender,
+        genome_version=genome_version,
+        cache_version=cache_version,
+        panel_bed=panel_bed,
+        pon_cnn=pon_cnn,
+        observations=observations,
+        dry_run=dry_run,
+    )
+    context.invoke(
+        run,
+        case_id=case_id,
+        workflow_profile=workflow_profile,
+        slurm_quality_of_service=slurm_quality_of_service,
+        dry_run=dry_run,
+    )
+
+
+@balsamic_umi.command("start-available")
+@DRY_RUN
+@LIMIT
+@click.pass_context
+def start_available(context: click.Context, dry_run: bool = False, limit: int | None = None):
+    """Start full workflow for all cases ready for analysis"""
+
+    analysis_api: BalsamicUmiAnalysisAPI = context.obj.meta_apis["analysis_api"]
+
+    cases: list[Case] = analysis_api.get_cases_to_analyze(limit=limit)
+    LOG.info(f"Starting {len(cases)} available Balsamic UMI cases")
+
+    exit_code: int = EXIT_SUCCESS
+    for case in cases:
+        try:
+            context.invoke(start, case_id=case.internal_id, dry_run=dry_run)
+        except AnalysisNotReadyError as error:
+            LOG.error(error)
+        except CgError as error:
+            LOG.error(error)
+            exit_code = EXIT_FAIL
+        except Exception as error:
+            LOG.error(f"Unspecified error occurred: {error}")
+            exit_code = EXIT_FAIL
+    if exit_code:
+        raise click.Abort
+
+
 balsamic_umi.add_command(resolve_compression)
 balsamic_umi.add_command(link)
-balsamic_umi.add_command(config_case)
-balsamic_umi.add_command(run)
 balsamic_umi.add_command(report_deliver)
 balsamic_umi.add_command(store_housekeeper)
-balsamic_umi.add_command(start)
-balsamic_umi.add_command(start_available)
 balsamic_umi.add_command(store)
 balsamic_umi.add_command(store_available)

cg/cli/workflow/microsalt/base.py

@@ -12,12 +12,12 @@ from cg.constants.constants import Workflow
 from cg.meta.workflow.analysis import AnalysisAPI
 from cg.meta.workflow.microsalt import MicrosaltAnalysisAPI
 from cg.models.cg_config import CGConfig
+from cg.services.analysis_starter.analysis_starter import AnalysisStarter
 from cg.services.analysis_starter.configurator.implementations.microsalt import (
     MicrosaltConfigurator,
 )
 from cg.services.analysis_starter.factories.configurator_factory import ConfiguratorFactory
 from cg.services.analysis_starter.factories.starter_factory import AnalysisStarterFactory
-from cg.services.analysis_starter.service import AnalysisStarter
 
 LOG = logging.getLogger(__name__)
 
@@ -41,7 +41,9 @@ microsalt.add_command(resolve_compression)
 @ARGUMENT_CASE_ID
 @click.pass_obj
 def config_case(cg_config: CGConfig, case_id: str) -> None:
-    """Create a config file for a microSALT case."""
+    """
+    Configure a microSALT case so that it is ready to be run.
+    """
     factory = ConfiguratorFactory(cg_config)
     configurator = cast(MicrosaltConfigurator, factory.get_configurator(Workflow.MICROSALT))
     configurator.configure(case_id=case_id)

cg/cli/workflow/mip_dna/base.py

@@ -24,10 +24,10 @@ from cg.constants import Workflow
 from cg.meta.workflow.analysis import AnalysisAPI
 from cg.meta.workflow.mip_dna import MipDNAAnalysisAPI
 from cg.models.cg_config import CGConfig
+from cg.services.analysis_starter.analysis_starter import AnalysisStarter
 from cg.services.analysis_starter.configurator.implementations.mip_dna import MIPDNAConfigurator
 from cg.services.analysis_starter.factories.configurator_factory import ConfiguratorFactory
 from cg.services.analysis_starter.factories.starter_factory import AnalysisStarterFactory
-from cg.services.analysis_starter.service import AnalysisStarter
 
 LOG = logging.getLogger(__name__)
 

cg/cli/workflow/nallo/base.py

@@ -1,28 +1,29 @@
 """CLI support to create config and/or start NALLO."""
 
 import logging
+from typing import cast
 
 import rich_click as click
 
-from cg.cli.utils import CLICK_CONTEXT_SETTINGS, echo_lines
+from cg.cli.utils import CLICK_CONTEXT_SETTINGS
 from cg.cli.workflow.commands import ARGUMENT_CASE_ID
-from cg.constants.cli_options import DRY_RUN
 from cg.cli.workflow.nf_analysis import (
-    config_case,
+    OPTION_RESUME,
+    OPTION_REVISION,
     metrics_deliver,
     report_deliver,
-    run,
-    start,
-    start_available,
     store,
     store_available,
     store_housekeeper,
 )
-
-from cg.constants.constants import MetaApis
+from cg.constants.constants import MetaApis, Workflow
 from cg.meta.workflow.analysis import AnalysisAPI
 from cg.meta.workflow.nallo import NalloAnalysisAPI
 from cg.models.cg_config import CGConfig
+from cg.services.analysis_starter.analysis_starter import AnalysisStarter
+from cg.services.analysis_starter.configurator.implementations.nextflow import NextflowConfigurator
+from cg.services.analysis_starter.factories.configurator_factory import ConfiguratorFactory
+from cg.services.analysis_starter.factories.starter_factory import AnalysisStarterFactory
 
 LOG = logging.getLogger(__name__)
 
@@ -35,29 +36,78 @@ def nallo(context: click.Context) -> None:
     context.obj.meta_apis[MetaApis.ANALYSIS_API] = NalloAnalysisAPI(config=context.obj)
 
 
-nallo.add_command(config_case)
 nallo.add_command(report_deliver)
-nallo.add_command(run)
-nallo.add_command(start)
-nallo.add_command(start_available)
 nallo.add_command(store)
 nallo.add_command(store_available)
 nallo.add_command(store_housekeeper)
 nallo.add_command(metrics_deliver)
 
 
-@nallo.command("panel")
-@DRY_RUN
+@nallo.command("config-case")
 @ARGUMENT_CASE_ID
 @click.pass_obj
-def panel(context: CGConfig, case_id: str, dry_run: bool) -> None:
-    """Write aggregated gene panel file exported from Scout."""
+def config_case(cg_config: CGConfig, case_id: str):
+    """
+    Configure a Nallo case so that it is ready to be run.
+
+    \b
+    Creates the following files in the case run directory:
+        - CASE_ID_params_file.yaml
+        - CASE_ID_nextflow_config.json
+        - CASE_ID_samplesheet.csv
+    """
+    factory = ConfiguratorFactory(cg_config)
+    configurator = cast(NextflowConfigurator, factory.get_configurator(Workflow.NALLO))
+    configurator.configure(case_id=case_id)
+
+
+@nallo.command("run")
+@OPTION_REVISION
+@OPTION_RESUME
+@ARGUMENT_CASE_ID
+@click.pass_obj
+def run(cg_config: CGConfig, case_id: str, resume: bool, revision: str | None) -> None:
+    """
+    Run a preconfigured Nallo case.
+
+    \b
+    Assumes that the following files exist in the case run directory:
+        - CASE_ID_params_file.yaml
+        - CASE_ID_nextflow_config.json
+        - CASE_ID_samplesheet.csv
+    """
+    factory = AnalysisStarterFactory(cg_config)
+    analysis_starter: AnalysisStarter = factory.get_analysis_starter_for_workflow(Workflow.NALLO)
+    analysis_starter.run(case_id=case_id, resume=resume, revision=revision)
 
-    analysis_api: NalloAnalysisAPI = context.meta_apis["analysis_api"]
-    analysis_api.status_db.verify_case_exists(case_internal_id=case_id)
 
-    bed_lines: list[str] = analysis_api.get_gene_panel(case_id=case_id)
-    if dry_run:
-        echo_lines(lines=bed_lines)
-        return
-    analysis_api.write_panel_as_tsv(case_id=case_id, content=bed_lines)
+@nallo.command("start")
+@OPTION_REVISION
+@ARGUMENT_CASE_ID
+@click.pass_obj
+def start(cg_config: CGConfig, case_id: str, revision: str | None):
+    """
+    Start a Nallo case.
+
+    \b
+    Configures the case and writes the following files:
+        - CASE_ID_params_file.yaml
+        - CASE_ID_nextflow_config.json
+        - CASE_ID_samplesheet.csv
+    and submits the job to the Seqera Platform.
+    """
+    factory = AnalysisStarterFactory(cg_config)
+    analysis_starter: AnalysisStarter = factory.get_analysis_starter_for_workflow(Workflow.NALLO)
+    analysis_starter.start(case_id=case_id, revision=revision)
+
+
+@nallo.command("start-available")
+@click.pass_obj
+def start_available(cg_config: CGConfig):
+    """Starts all available Nallo cases."""
+    LOG.info("Starting Nallo workflow for all available cases.")
+    factory = AnalysisStarterFactory(cg_config)
+    analysis_starter: AnalysisStarter = factory.get_analysis_starter_for_workflow(Workflow.NALLO)
+    succeeded: bool = analysis_starter.start_available()
+    if not succeeded:
+        raise click.Abort

cg/cli/workflow/nf_analysis.py

@@ -3,232 +3,30 @@
 import logging
 
 import rich_click as click
-from pydantic import ValidationError
 
 from cg.cli.workflow.commands import ARGUMENT_CASE_ID
 from cg.cli.workflow.utils import validate_force_store_option
-from cg.constants import EXIT_FAIL, EXIT_SUCCESS, Workflow
 from cg.constants.cli_options import COMMENT, DRY_RUN, FORCE
 from cg.constants.constants import MetaApis
-from cg.exc import AnalysisNotReadyError, CgError, HousekeeperStoreError
+from cg.exc import CgError, HousekeeperStoreError
 from cg.meta.workflow.nf_analysis import NfAnalysisAPI
 from cg.models.cg_config import CGConfig
-from cg.store.models import Case
 
 LOG = logging.getLogger(__name__)
 
-OPTION_WORKDIR = click.option(
-    "--work-dir",
-    type=click.Path(),
-    help="Directory where intermediate result files are stored",
-)
+
 OPTION_RESUME = click.option(
     "--resume",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="Execute the script using the cached results, useful to continue \
-        executions that was stopped by an error",
-)
-OPTION_PROFILE = click.option(
-    "--profile",
-    type=str,
+    default=True,
     show_default=True,
-    help="Choose a configuration profile",
-)
-
-OPTION_CONFIG = click.option(
-    "--config",
-    type=click.Path(),
-    help="Nextflow config file path",
+    help="Execute the script using the cached results, useful to continue "
+    "executions that were stopped by an error",
 )
-
-OPTION_PARAMS_FILE = click.option(
-    "--params-file",
-    type=click.Path(),
-    help="Nextflow workflow-specific parameter file path",
-)
-
-OPTION_USE_NEXTFLOW = click.option(
-    "--use-nextflow",
-    type=bool,
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="Execute workflow using nextflow",
-)
-
 OPTION_REVISION = click.option(
     "--revision",
     type=str,
     help="Revision of workflow to run (either a git branch, tag or commit SHA number)",
 )
-OPTION_COMPUTE_ENV = click.option(
-    "--compute-env",
-    type=str,
-    help="Compute environment name. If not specified the primary compute environment will be used.",
-)
-OPTION_TOWER_RUN_ID = click.option(
-    "--nf-tower-id",
-    type=str,
-    is_flag=False,
-    default=None,
-    help="NF-Tower ID of run to relaunch. If not provided the latest NF-Tower ID for a case will be used.",
-)
-OPTION_FROM_START = click.option(
-    "--from-start",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="Start workflow from start without resuming execution",
-)
-OPTION_STUB = click.option(
-    "--stub-run",
-    is_flag=True,
-    default=False,
-    show_default=True,
-    help="Start a stub workflow",
-)
-
-
-@click.command("config-case")
-@ARGUMENT_CASE_ID
-@DRY_RUN
-@click.pass_obj
-def config_case(context: CGConfig, case_id: str, dry_run: bool) -> None:
-    """Create config files required by a workflow for a case."""
-    analysis_api: NfAnalysisAPI = context.meta_apis[MetaApis.ANALYSIS_API]
-    try:
-        analysis_api.config_case(case_id=case_id, dry_run=dry_run)
-    except (CgError, ValidationError) as error:
-        LOG.error(f"Could not create config files for {case_id}: {error}")
-        raise click.Abort() from error
-
-
-@click.command("run")
-@ARGUMENT_CASE_ID
-@OPTION_WORKDIR
-@OPTION_FROM_START
-@OPTION_PROFILE
-@OPTION_CONFIG
-@OPTION_PARAMS_FILE
-@OPTION_REVISION
-@OPTION_COMPUTE_ENV
-@OPTION_USE_NEXTFLOW
-@OPTION_TOWER_RUN_ID
-@OPTION_STUB
-@DRY_RUN
-@click.pass_obj
-def run(
-    context: CGConfig,
-    case_id: str,
-    work_dir: str,
-    from_start: bool,
-    profile: str,
-    config: str,
-    params_file: str,
-    revision: str,
-    compute_env: str,
-    use_nextflow: bool,
-    nf_tower_id: str | None,
-    stub_run: bool,
-    dry_run: bool,
-) -> None:
-    """Run analysis for a case."""
-    analysis_api: NfAnalysisAPI = context.meta_apis[MetaApis.ANALYSIS_API]
-    try:
-        analysis_api.run_nextflow_analysis(
-            case_id=case_id,
-            dry_run=dry_run,
-            work_dir=work_dir,
-            from_start=from_start,
-            profile=profile,
-            config=config,
-            params_file=params_file,
-            revision=revision,
-            compute_env=compute_env,
-            use_nextflow=use_nextflow,
-            nf_tower_id=nf_tower_id,
-            stub_run=stub_run,
-        )
-    except Exception as error:
-        LOG.error(f"Unspecified error occurred: {error}")
-        raise click.Abort() from error
-
-
-@click.command("start")
-@ARGUMENT_CASE_ID
-@OPTION_WORKDIR
-@OPTION_PROFILE
-@OPTION_CONFIG
-@OPTION_PARAMS_FILE
-@OPTION_REVISION
-@OPTION_COMPUTE_ENV
-@OPTION_USE_NEXTFLOW
-@OPTION_STUB
-@DRY_RUN
-@click.pass_obj
-def start(
-    context: CGConfig,
-    case_id: str,
-    work_dir: str,
-    profile: str,
-    config: str,
-    params_file: str,
-    revision: str,
-    compute_env: str,
-    use_nextflow: bool,
-    stub_run: bool,
-    dry_run: bool,
-) -> None:
-    """Start workflow for a case."""
-    LOG.info(f"Starting analysis for {case_id}")
-    analysis_api: NfAnalysisAPI = context.meta_apis[MetaApis.ANALYSIS_API]
-    try:
-        analysis_api.status_db.verify_case_exists(case_internal_id=case_id)
-        case: Case = analysis_api.status_db.get_case_by_internal_id(case_id)
-        if case.data_analysis != Workflow.NALLO:
-            analysis_api.prepare_fastq_files(case_id=case_id, dry_run=dry_run)
-        analysis_api.config_case(case_id=case_id, dry_run=dry_run)
-        analysis_api.run_nextflow_analysis(
-            case_id=case_id,
-            dry_run=dry_run,
-            work_dir=work_dir,
-            from_start=True,
-            profile=profile,
-            config=config,
-            params_file=params_file,
-            revision=revision,
-            compute_env=compute_env,
-            use_nextflow=use_nextflow,
-            stub_run=stub_run,
-        )
-    except Exception as error:
-        LOG.error(f"Unexpected error occurred: {error}")
-        raise click.Abort from error
-
-
-@click.command("start-available")
-@DRY_RUN
-@click.pass_context
-def start_available(context: click.Context, dry_run: bool = False) -> None:
-    """Start workflow for all cases ready for analysis."""
-    analysis_api: NfAnalysisAPI = context.obj.meta_apis[MetaApis.ANALYSIS_API]
-
-    cases: list[Case] = analysis_api.get_cases_to_analyze()
-    LOG.info(f"Starting {len(cases)} available {analysis_api.workflow} cases")
-
-    exit_code: int = EXIT_SUCCESS
-    for case in cases:
-        try:
-            context.invoke(start, case_id=case.internal_id, dry_run=dry_run)
-        except AnalysisNotReadyError as error:
-            LOG.error(error)
-        except Exception as error:
-            LOG.error(error)
-            exit_code = EXIT_FAIL
-    if exit_code:
-        raise click.Abort
 
 
 @click.command("metrics-deliver")