10491698847

Committed 21 Aug 2024 02:18PM UTC coverage: 83.391%. First build

Build # 10491698847

Build Type

Pull #3300

github

Committed by

web-flow

Commit Message

Merge 822323b1a into 826231296

Pull Request Pull Request #3300: Add mutant qc

Run Details

290 of 379 new or added lines in 14 files covered. (76.52%)

17046 of 20441 relevant lines covered (83.39%)

1.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.19

/cg/cli/workflow/mutant/base.py

import logging

import click

from cg.cli.utils import CLICK_CONTEXT_SETTINGS
from cg.cli.workflow.commands import (
    ARGUMENT_CASE_ID,
    OPTION_ANALYSIS_PARAMETERS_CONFIG,
    link,
    resolve_compression,
    store,
)
from cg.constants import EXIT_FAIL, EXIT_SUCCESS
from cg.constants.cli_options import DRY_RUN
from cg.exc import AnalysisNotReadyError, CgError
from cg.meta.workflow.analysis import AnalysisAPI
from cg.meta.workflow.mutant import MutantAnalysisAPI
from cg.models.cg_config import CGConfig
from cg.store.models import Case

LOG = logging.getLogger(__name__)


@click.group(invoke_without_command=True, context_settings=CLICK_CONTEXT_SETTINGS)
@click.pass_context
def mutant(context: click.Context) -> None:
    """Mutant analysis workflow"""
    AnalysisAPI.get_help(context)
    context.obj.meta_apis["analysis_api"] = MutantAnalysisAPI(config=context.obj)


mutant.add_command(resolve_compression)
mutant.add_command(link)
mutant.add_command(store)


@mutant.command("config-case")
@DRY_RUN
@ARGUMENT_CASE_ID
@click.pass_obj
def config_case(context: CGConfig, dry_run: bool, case_id: str) -> None:
    """Create config file for a case"""
    analysis_api: MutantAnalysisAPI = context.meta_apis["analysis_api"]
    analysis_api.create_case_config(case_id=case_id, dry_run=dry_run)


@mutant.command("run")
@DRY_RUN
@ARGUMENT_CASE_ID
@click.pass_obj
def run(context: CGConfig, dry_run: bool, case_id: str, config_artic: str = None) -> None:
    """Run mutant analysis command for a case"""
    analysis_api: MutantAnalysisAPI = context.meta_apis["analysis_api"]
    analysis_api.check_analysis_ongoing(case_id=case_id)
    if not dry_run:
        analysis_api.add_pending_trailblazer_analysis(case_id=case_id)
        analysis_api.set_statusdb_action(case_id=case_id, action="running")
    try:
        analysis_api.run_analysis(case_id=case_id, dry_run=dry_run, config_artic=config_artic)
    except:
        analysis_api.set_statusdb_action(case_id=case_id, action=None)
        raise


@mutant.command("start")
@DRY_RUN
@ARGUMENT_CASE_ID
@OPTION_ANALYSIS_PARAMETERS_CONFIG
@click.pass_context
def start(context: click.Context, dry_run: bool, case_id: str, config_artic: str) -> None:
    """Start full analysis workflow for a case"""
    analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]
    analysis_api.prepare_fastq_files(case_id=case_id, dry_run=dry_run)
    context.invoke(link, case_id=case_id, dry_run=dry_run)
    context.invoke(config_case, case_id=case_id, dry_run=dry_run)
    context.invoke(run, case_id=case_id, dry_run=dry_run, config_artic=config_artic)


@mutant.command("start-available")
@DRY_RUN
@click.pass_context
def start_available(context: click.Context, dry_run: bool = False):
    """Start full analysis workflow for all cases ready for analysis"""

    analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]

    exit_code: int = EXIT_SUCCESS
    for case in analysis_api.get_cases_ready_for_analysis():
        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


@mutant.command("store-available")
@DRY_RUN
@click.pass_context
def store_available(context: click.Context, dry_run: bool) -> None:
    """Run QC checks and store bundles for all finished analyses in Housekeeper."""

    analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]

    exit_code: int = EXIT_SUCCESS

    cases_ready_for_qc: list[Case] = analysis_api.get_cases_with_completed_not_stored_analysis()
    LOG.info(f"Found {len(cases_ready_for_qc)} cases to perform QC on!")
    for case in cases_ready_for_qc:
        LOG.info(f"Performing QC on case {case.internal_id}.")
        try:
            analysis_api.run_qc_on_case(case=case, dry_run=dry_run)
        except Exception:
            exit_code = EXIT_FAIL

    cases_to_store: list[Case] = analysis_api.get_cases_to_store()
    LOG.info(f"Found {len(cases_to_store)} cases to store!")
    for case in cases_to_store:
        LOG.info(f"Storing deliverables for {case.internal_id}")
        try:
            store(context=context, case_id=case.internal_id, dry_run=dry_run)
        except Exception as exception_object:
            LOG.error(f"Error storing {case.internal_id}: {exception_object}")
            exit_code = EXIT_FAIL

    if exit_code:
        raise click.Abort


@mutant.command("run-qc")
@DRY_RUN
@ARGUMENT_CASE_ID
@click.pass_context
def run_qc(context: click.Context, case_id: str, dry_run: bool) -> None:
    """
    Run QC on case and generate QC_report file.
    """
    analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]

    analysis_api.run_qc(case_id=case_id, dry_run=dry_run)

1	import logging	1✔
2
3	import click	1✔
4
5	from cg.cli.utils import CLICK_CONTEXT_SETTINGS	1✔
6	from cg.cli.workflow.commands import (	1✔
7	ARGUMENT_CASE_ID,
8	OPTION_ANALYSIS_PARAMETERS_CONFIG,
9	link,
10	resolve_compression,
11	store,
12	)
13	from cg.constants import EXIT_FAIL, EXIT_SUCCESS	1✔
14	from cg.constants.cli_options import DRY_RUN	1✔
15	from cg.exc import AnalysisNotReadyError, CgError	1✔
16	from cg.meta.workflow.analysis import AnalysisAPI	1✔
17	from cg.meta.workflow.mutant import MutantAnalysisAPI	1✔
18	from cg.models.cg_config import CGConfig	1✔
19	from cg.store.models import Case	1✔
20
21	LOG = logging.getLogger(__name__)	1✔
22
23
24	@click.group(invoke_without_command=True, context_settings=CLICK_CONTEXT_SETTINGS)	1✔
25	@click.pass_context	1✔
26	def mutant(context: click.Context) -> None:	1✔
27	"""Mutant analysis workflow"""
28	AnalysisAPI.get_help(context)	×
29	context.obj.meta_apis["analysis_api"] = MutantAnalysisAPI(config=context.obj)	×
30
31
32	mutant.add_command(resolve_compression)	1✔
33	mutant.add_command(link)	1✔
34	mutant.add_command(store)	1✔
35
36
37	@mutant.command("config-case")	1✔
38	@DRY_RUN	1✔
39	@ARGUMENT_CASE_ID	1✔
40	@click.pass_obj	1✔
41	def config_case(context: CGConfig, dry_run: bool, case_id: str) -> None:	1✔
42	"""Create config file for a case"""
43	analysis_api: MutantAnalysisAPI = context.meta_apis["analysis_api"]	×
44	analysis_api.create_case_config(case_id=case_id, dry_run=dry_run)	×
45
46
47	@mutant.command("run")	1✔
48	@DRY_RUN	1✔
49	@ARGUMENT_CASE_ID	1✔
50	@click.pass_obj	1✔
51	def run(context: CGConfig, dry_run: bool, case_id: str, config_artic: str = None) -> None:	1✔
52	"""Run mutant analysis command for a case"""
53	analysis_api: MutantAnalysisAPI = context.meta_apis["analysis_api"]	×
54	analysis_api.check_analysis_ongoing(case_id=case_id)	×
55	if not dry_run:	×
56	analysis_api.add_pending_trailblazer_analysis(case_id=case_id)	×
57	analysis_api.set_statusdb_action(case_id=case_id, action="running")	×
58	try:	×
59	analysis_api.run_analysis(case_id=case_id, dry_run=dry_run, config_artic=config_artic)	×
60	except:	×
61	analysis_api.set_statusdb_action(case_id=case_id, action=None)	×
62	raise	×
63
64
65	@mutant.command("start")	1✔
66	@DRY_RUN	1✔
67	@ARGUMENT_CASE_ID	1✔
68	@OPTION_ANALYSIS_PARAMETERS_CONFIG	1✔
69	@click.pass_context	1✔
70	def start(context: click.Context, dry_run: bool, case_id: str, config_artic: str) -> None:	1✔
71	"""Start full analysis workflow for a case"""
72	analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]	×
73	analysis_api.prepare_fastq_files(case_id=case_id, dry_run=dry_run)	×
74	context.invoke(link, case_id=case_id, dry_run=dry_run)	×
75	context.invoke(config_case, case_id=case_id, dry_run=dry_run)	×
76	context.invoke(run, case_id=case_id, dry_run=dry_run, config_artic=config_artic)	×
77
78
79	@mutant.command("start-available")	1✔
80	@DRY_RUN	1✔
81	@click.pass_context	1✔
82	def start_available(context: click.Context, dry_run: bool = False):	1✔
83	"""Start full analysis workflow for all cases ready for analysis"""
84
85	analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]	×
86
87	exit_code: int = EXIT_SUCCESS	×
88	for case in analysis_api.get_cases_ready_for_analysis():	×
89	try:	×
90	context.invoke(start, case_id=case.internal_id, dry_run=dry_run)	×
91	except AnalysisNotReadyError as error:	×
92	LOG.error(error)	×
93	except CgError as error:	×
94	LOG.error(error)	×
95	exit_code = EXIT_FAIL	×
96	except Exception as error:	×
97	LOG.error(f"Unspecified error occurred: {error}")	×
98	exit_code = EXIT_FAIL	×
99	if exit_code:	×
100	raise click.Abort	×
101
102
103	@mutant.command("store-available")	1✔
104	@DRY_RUN	1✔
105	@click.pass_context	1✔
106	def store_available(context: click.Context, dry_run: bool) -> None:	1✔
107	"""Run QC checks and store bundles for all finished analyses in Housekeeper."""
108
NEW 109	analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]	×
110
NEW 111	exit_code: int = EXIT_SUCCESS	×
112
NEW 113	cases_ready_for_qc: list[Case] = analysis_api.get_cases_with_completed_not_stored_analysis()	×
NEW 114	LOG.info(f"Found {len(cases_ready_for_qc)} cases to perform QC on!")	×
NEW 115	for case in cases_ready_for_qc:	×
NEW 116	LOG.info(f"Performing QC on case {case.internal_id}.")	×
NEW 117	try:	×
NEW 118	analysis_api.run_qc_on_case(case=case, dry_run=dry_run)	×
NEW 119	except Exception:	×
NEW 120	exit_code = EXIT_FAIL	×
121
NEW 122	cases_to_store: list[Case] = analysis_api.get_cases_to_store()	×
NEW 123	LOG.info(f"Found {len(cases_to_store)} cases to store!")	×
NEW 124	for case in cases_to_store:	×
NEW 125	LOG.info(f"Storing deliverables for {case.internal_id}")	×
NEW 126	try:	×
NEW 127	store(context=context, case_id=case.internal_id, dry_run=dry_run)	×
NEW 128	except Exception as exception_object:	×
NEW 129	LOG.error(f"Error storing {case.internal_id}: {exception_object}")	×
NEW 130	exit_code = EXIT_FAIL	×
131
NEW 132	if exit_code:	×
NEW 133	raise click.Abort	×
134
135
136	@mutant.command("run-qc")	1✔
137	@DRY_RUN	1✔
138	@ARGUMENT_CASE_ID	1✔
139	@click.pass_context	1✔
140	def run_qc(context: click.Context, case_id: str, dry_run: bool) -> None:	1✔
141	"""
142	Run QC on case and generate QC_report file.
143	"""
NEW 144	analysis_api: MutantAnalysisAPI = context.obj.meta_apis["analysis_api"]	×
145
NEW 146	analysis_api.run_qc(case_id=case_id, dry_run=dry_run)	×

Clinical-Genomics / cg / 10491698847

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous