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

cg/services/run_devices/pacbio/data_storage_service/pacbio_store_service.py

@@ -3,6 +3,7 @@
 import logging
 from datetime import datetime
 
+from cg.exc import PacbioSequencingRunAlreadyExistsError
 from cg.services.run_devices.abstract_classes import PostProcessingStoreService
 from cg.services.run_devices.error_handler import handle_post_processing_errors
 from cg.services.run_devices.exc import (
@@ -17,9 +18,10 @@ from cg.services.run_devices.pacbio.data_transfer_service.dto import (
     PacBioSampleSequencingMetricsDTO,
     PacBioSequencingRunDTO,
     PacBioSMRTCellDTO,
+    PacBioSMRTCellMetricsDTO,
 )
 from cg.services.run_devices.pacbio.run_data_generator.run_data import PacBioRunData
-from cg.store.models import PacbioSequencingRun, PacbioSMRTCell
+from cg.store.models import PacbioSequencingRun, PacbioSMRTCell, PacbioSMRTCellMetrics
 from cg.store.store import Store
 
 LOG = logging.getLogger(__name__)
@@ -33,21 +35,35 @@ class PacBioStoreService(PostProcessingStoreService):
     def _create_run_device(self, run_device_dto: PacBioSMRTCellDTO) -> PacbioSMRTCell:
         return self.store.create_pac_bio_smrt_cell(run_device_dto)
 
-    def _create_instrument_run(
-        self, instrument_run_dto: PacBioSequencingRunDTO, smrt_cell: PacbioSMRTCell
+    def _create_pacbio_sequencing_run_if_non_existent(
+        self, sequencing_run_dto: PacBioSequencingRunDTO
     ) -> PacbioSequencingRun:
-        return self.store.create_pac_bio_sequencing_run(
-            sequencing_run_dto=instrument_run_dto, smrt_cell=smrt_cell
+        try:
+            return self.store.create_pacbio_sequencing_run(sequencing_run_dto)
+        except PacbioSequencingRunAlreadyExistsError:
+            LOG.debug(f"Sequencing run {sequencing_run_dto.run_name} already exists")
+            return self.store.get_pacbio_sequencing_run_by_run_name(sequencing_run_dto.run_name)
+
+    def _create_pacbio_smrt_cell_metrics(
+        self,
+        instrument_run_dto: PacBioSMRTCellMetricsDTO,
+        sequencing_run: PacbioSequencingRun,
+        smrt_cell: PacbioSMRTCell,
+    ) -> PacbioSMRTCellMetrics:
+        return self.store.create_pacbio_smrt_cell_metrics(
+            smrt_cell_metrics_dto=instrument_run_dto,
+            sequencing_run=sequencing_run,
+            smrt_cell=smrt_cell,
         )
 
     def _create_sample_run_metrics(
         self,
         sample_run_metrics_dtos: list[PacBioSampleSequencingMetricsDTO],
-        sequencing_run: PacbioSequencingRun,
+        smrt_cell_metrics: PacbioSMRTCellMetrics,
     ) -> None:
         for sample_run_metric in sample_run_metrics_dtos:
             self.store.create_pac_bio_sample_sequencing_run(
-                sample_run_metrics_dto=sample_run_metric, sequencing_run=sequencing_run
+                sample_run_metrics_dto=sample_run_metric, smrt_cell_metrics=smrt_cell_metrics
             )
 
     def _update_sample(
@@ -56,13 +72,12 @@ class PacBioStoreService(PostProcessingStoreService):
         sequencing_date: datetime,
     ) -> None:
         """Update the reads and last sequenced date for the SMRT cell samples."""
-        for sample_dto in sample_run_metrics_dtos:
-            self.store.update_sample_reads(
-                internal_id=sample_dto.sample_internal_id, reads=sample_dto.hifi_reads
-            )
-            self.store.update_sample_sequenced_at(
-                internal_id=sample_dto.sample_internal_id, date=sequencing_date
-            )
+        sample_ids_to_update: set[str] = {
+            sample_dto.sample_internal_id for sample_dto in sample_run_metrics_dtos
+        }
+        for sample_id in sample_ids_to_update:
+            self.store.recalculate_sample_reads_pacbio(sample_id)
+            self.store.update_sample_sequenced_at(internal_id=sample_id, date=sequencing_date)
 
     @handle_post_processing_errors(
         to_except=(PostProcessingDataTransferError, ValueError),
@@ -70,16 +85,22 @@ class PacBioStoreService(PostProcessingStoreService):
     )
     def store_post_processing_data(self, run_data: PacBioRunData, dry_run: bool = False) -> None:
         dtos: PacBioDTOs = self.data_transfer_service.get_post_processing_dtos(run_data)
+        sequencing_run: PacbioSequencingRun = self._create_pacbio_sequencing_run_if_non_existent(
+            dtos.sequencing_run
+        )
         smrt_cell: PacbioSMRTCell = self._create_run_device(dtos.run_device)
-        sequencing_run: PacbioSequencingRun = self._create_instrument_run(
-            instrument_run_dto=dtos.sequencing_run, smrt_cell=smrt_cell
+        smrt_cell_metrics: PacbioSMRTCellMetrics = self._create_pacbio_smrt_cell_metrics(
+            instrument_run_dto=dtos.smrt_cell_metrics,
+            sequencing_run=sequencing_run,
+            smrt_cell=smrt_cell,
         )
         self._create_sample_run_metrics(
-            sample_run_metrics_dtos=dtos.sample_sequencing_metrics, sequencing_run=sequencing_run
+            sample_run_metrics_dtos=dtos.sample_sequencing_metrics,
+            smrt_cell_metrics=smrt_cell_metrics,
         )
         self._update_sample(
             sample_run_metrics_dtos=dtos.sample_sequencing_metrics,
-            sequencing_date=sequencing_run.completed_at,
+            sequencing_date=smrt_cell_metrics.completed_at,
         )
         if dry_run:
             self.store.rollback()

cg/services/run_devices/pacbio/data_transfer_service/data_transfer_service.py

@@ -15,11 +15,13 @@ from cg.services.run_devices.pacbio.data_transfer_service.dto import (
     PacBioSampleSequencingMetricsDTO,
     PacBioSequencingRunDTO,
     PacBioSMRTCellDTO,
+    PacBioSMRTCellMetricsDTO,
 )
 from cg.services.run_devices.pacbio.data_transfer_service.utils import (
     get_sample_sequencing_metrics_dtos,
     get_sequencing_run_dto,
     get_smrt_cell_dto,
+    get_smrt_cell_metrics_dto,
 )
 from cg.services.run_devices.pacbio.metrics_parser.metrics_parser import PacBioMetricsParser
 from cg.services.run_devices.pacbio.metrics_parser.models import PacBioMetrics
@@ -38,16 +40,20 @@ class PacBioDataTransferService(PostProcessingDataTransferService):
     )
     def get_post_processing_dtos(self, run_data: PacBioRunData) -> PacBioDTOs:
         metrics: PacBioMetrics = self.metrics_service.parse_metrics(run_data)
-        smrt_cell_dto: PacBioSMRTCellDTO = get_smrt_cell_dto(metrics)
         sequencing_run_dto: PacBioSequencingRunDTO = get_sequencing_run_dto(
             metrics=metrics, run_data=run_data
         )
+        smrt_cell_dto: PacBioSMRTCellDTO = get_smrt_cell_dto(metrics)
+        smrt_cell_metrics_dto: PacBioSMRTCellMetricsDTO = get_smrt_cell_metrics_dto(
+            metrics=metrics, run_data=run_data
+        )
         sample_sequencing_metrics_dtos: list[PacBioSampleSequencingMetricsDTO] = (
             get_sample_sequencing_metrics_dtos(metrics.samples)
         )
         LOG.debug("DTOs created")
         return PacBioDTOs(
             run_device=smrt_cell_dto,
-            sequencing_run=sequencing_run_dto,
+            smrt_cell_metrics=smrt_cell_metrics_dto,
             sample_sequencing_metrics=sample_sequencing_metrics_dtos,
+            sequencing_run=sequencing_run_dto,
         )

cg/services/run_devices/pacbio/data_transfer_service/dto.py

@@ -4,11 +4,11 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from cg.constants.devices import DeviceType
+from cg.constants.devices import DeviceType, RevioNames
 from cg.services.run_devices.abstract_models import PostProcessingDTOs
 
 
-class PacBioSequencingRunDTO(BaseModel):
+class PacBioSMRTCellMetricsDTO(BaseModel):
     type: DeviceType
     well: str
     plate: int
@@ -62,7 +62,13 @@ class PacBioSampleSequencingMetricsDTO(BaseModel):
     polymerase_mean_read_length: int
 
 
+class PacBioSequencingRunDTO(BaseModel):
+    instrument_name: RevioNames
+    run_name: str
+
+
 class PacBioDTOs(PostProcessingDTOs):
     run_device: PacBioSMRTCellDTO
-    sequencing_run: PacBioSequencingRunDTO
+    smrt_cell_metrics: PacBioSMRTCellMetricsDTO
     sample_sequencing_metrics: list[PacBioSampleSequencingMetricsDTO]
+    sequencing_run: PacBioSequencingRunDTO

cg/services/run_devices/pacbio/data_transfer_service/utils.py

@@ -3,11 +3,9 @@ from cg.services.run_devices.pacbio.data_transfer_service.dto import (
     PacBioSampleSequencingMetricsDTO,
     PacBioSequencingRunDTO,
     PacBioSMRTCellDTO,
+    PacBioSMRTCellMetricsDTO,
 )
-from cg.services.run_devices.pacbio.metrics_parser.models import (
-    PacBioMetrics,
-    SampleMetrics,
-)
+from cg.services.run_devices.pacbio.metrics_parser.models import PacBioMetrics, SampleMetrics
 from cg.services.run_devices.pacbio.run_data_generator.run_data import PacBioRunData
 
 
@@ -16,11 +14,11 @@ def get_smrt_cell_dto(metrics: PacBioMetrics) -> PacBioSMRTCellDTO:
     return PacBioSMRTCellDTO(type=DeviceType.PACBIO, internal_id=internal_id)
 
 
-def get_sequencing_run_dto(
+def get_smrt_cell_metrics_dto(
     metrics: PacBioMetrics, run_data: PacBioRunData
-) -> PacBioSequencingRunDTO:
+) -> PacBioSMRTCellMetricsDTO:
     hifi_mean_read_quality: str = f"Q{metrics.read.hifi_median_read_quality}"
-    return PacBioSequencingRunDTO(
+    return PacBioSMRTCellMetricsDTO(
         type=DeviceType.PACBIO,
         well=metrics.dataset_metrics.well,
         plate=metrics.dataset_metrics.plate,
@@ -76,3 +74,12 @@ def get_sample_sequencing_metrics_dtos(
         )
         sample_metrics_dtos.append(sample_sequencing_metrics_dto)
     return sample_metrics_dtos
+
+
+def get_sequencing_run_dto(
+    metrics: PacBioMetrics, run_data: PacBioRunData
+) -> PacBioSequencingRunDTO:
+    return PacBioSequencingRunDTO(
+        instrument_name=metrics.dataset_metrics.instrument_name,  # type: ignore - pydantic will convert to correct type
+        run_name=run_data.sequencing_run_name,
+    )

cg/services/run_devices/pacbio/metrics_parser/models.py

@@ -98,6 +98,7 @@ class SmrtlinkDatasetsMetrics(BaseModel):
     cell_index: int = Field(..., alias=SmrtLinkDatabasesAliases.CELL_INDEX)
     path: str = Field(..., alias=SmrtLinkDatabasesAliases.PATH)
     plate: int
+    instrument_name: str = Field(..., alias=SmrtLinkDatabasesAliases.INSTRUMENT_NAME)
 
     @model_validator(mode="before")
     @classmethod

cg/services/run_devices/pacbio/sequencing_runs_service.py

@@ -1,8 +1,11 @@
 from cg.server.endpoints.sequencing_run.dtos import (
     PacbioSequencingRunDTO,
-    PacbioSequencingRunsResponse,
+    PacbioSequencingRunResponse,
+    PacbioSequencingRunUpdateRequest,
+    PacbioSmrtCellMetricsDTO,
+    PacbioSmrtCellMetricsResponse,
 )
-from cg.store.models import PacbioSequencingRun
+from cg.store.models import PacbioSMRTCellMetrics
 from cg.store.store import Store
 
 
@@ -10,14 +13,39 @@ class PacbioSequencingRunsService:
     def __init__(self, store: Store):
         self.store = store
 
-    def get_sequencing_runs_by_name(self, run_name: str) -> PacbioSequencingRunsResponse:
-        runs: list[PacbioSequencingRunDTO] = []
-        db_runs: list[PacbioSequencingRun] = self.store.get_pacbio_sequencing_runs_by_run_name(
+    def get_sequencing_runs_by_name(self, run_name: str) -> PacbioSmrtCellMetricsResponse:
+        runs: list[PacbioSmrtCellMetricsDTO] = []
+        db_runs: list[PacbioSMRTCellMetrics] = self.store.get_pacbio_smrt_cell_metrics_by_run_name(
             run_name
         )
         for db_run in db_runs:
             run_dict = db_run.to_dict()
             run_dict["internal_id"] = db_run.device.internal_id
-            run = PacbioSequencingRunDTO.model_validate(run_dict)
+            run_dict["run_name"] = db_run.sequencing_run.run_name
+            run = PacbioSmrtCellMetricsDTO.model_validate(run_dict)
             runs.append(run)
-        return PacbioSequencingRunsResponse(runs=runs)
+        return PacbioSmrtCellMetricsResponse(runs=runs)
+
+    def get_sequencing_runs(self, page: int = 0, page_size: int = 0) -> PacbioSequencingRunResponse:
+        db_runs, total_count = self.store.get_pacbio_sequencing_runs(page=page, page_size=page_size)
+        runs: list[PacbioSequencingRunDTO] = []
+        for db_run in db_runs:
+            run = PacbioSequencingRunDTO(
+                id=db_run.id,
+                run_name=db_run.run_name,
+                comment=db_run.comment,
+                processed=db_run.processed,
+            )
+            runs.append(run)
+        return PacbioSequencingRunResponse(pacbio_sequencing_runs=runs, total_count=total_count)
+
+    def update_sequencing_run(self, update_request: PacbioSequencingRunUpdateRequest) -> None:
+        if update_request.comment is not None:
+            self.store.update_pacbio_sequencing_run_comment(
+                id=update_request.id, comment=update_request.comment
+            )
+
+        if update_request.processed is not None:
+            self.store.update_pacbio_sequencing_run_processed(
+                id=update_request.id, processed=update_request.processed
+            )

cg/services/sequencing_qc_service/quality_checks/checks.py

@@ -1,12 +1,13 @@
+from collections.abc import Callable
 from enum import Enum
-from typing import Callable
 
 from cg.constants import Workflow
 from cg.services.sequencing_qc_service.quality_checks.utils import (
     all_samples_in_case_have_reads,
     any_sample_in_case_has_reads,
-    case_pass_sequencing_qc,
-    sample_pass_sequencing_qc,
+    case_pass_sequencing_qc_on_hifi_yield,
+    case_pass_sequencing_qc_on_reads,
+    sample_pass_sequencing_qc_on_reads,
 )
 from cg.store.models import Case
 
@@ -18,8 +19,9 @@ class QualityCheck(Enum):
 
 
 class SequencingQCCheck(QualityCheck):
-    CASE_PASSES: Callable = case_pass_sequencing_qc
-    SAMPLE_PASSES: Callable = sample_pass_sequencing_qc
+    CASE_PASSES_ON_READS: Callable = case_pass_sequencing_qc_on_reads
+    CASE_PASSES_ON_YIELD: Callable = case_pass_sequencing_qc_on_hifi_yield
+    SAMPLE_PASSES: Callable = sample_pass_sequencing_qc_on_reads
     ALL_SAMPLES_IN_CASE_HAVE_READS: Callable = all_samples_in_case_have_reads
     ANY_SAMPLE_IN_CASE_HAS_READS: Callable = any_sample_in_case_has_reads
 
@@ -29,20 +31,20 @@ def get_sequencing_quality_check_for_case(case: Case) -> Callable:
     workflow: Workflow = case.data_analysis
 
     workflow_qc_mapping = {
-        Workflow.BALSAMIC: SequencingQCCheck.CASE_PASSES,
-        Workflow.BALSAMIC_PON: SequencingQCCheck.CASE_PASSES,
-        Workflow.BALSAMIC_UMI: SequencingQCCheck.CASE_PASSES,
-        Workflow.MIP_DNA: SequencingQCCheck.CASE_PASSES,
-        Workflow.MIP_RNA: SequencingQCCheck.CASE_PASSES,
-        Workflow.RAREDISEASE: SequencingQCCheck.CASE_PASSES,
-        Workflow.RNAFUSION: SequencingQCCheck.CASE_PASSES,
-        Workflow.TOMTE: SequencingQCCheck.CASE_PASSES,
+        Workflow.BALSAMIC: SequencingQCCheck.CASE_PASSES_ON_READS,
+        Workflow.BALSAMIC_PON: SequencingQCCheck.CASE_PASSES_ON_READS,
+        Workflow.BALSAMIC_UMI: SequencingQCCheck.CASE_PASSES_ON_READS,
         Workflow.FLUFFY: SequencingQCCheck.ANY_SAMPLE_IN_CASE_HAS_READS,
-        Workflow.RAW_DATA: SequencingQCCheck.ANY_SAMPLE_IN_CASE_HAS_READS,
         Workflow.MICROSALT: SequencingQCCheck.ANY_SAMPLE_IN_CASE_HAS_READS,
+        Workflow.MIP_DNA: SequencingQCCheck.CASE_PASSES_ON_READS,
+        Workflow.MIP_RNA: SequencingQCCheck.CASE_PASSES_ON_READS,
         Workflow.MUTANT: SequencingQCCheck.ANY_SAMPLE_IN_CASE_HAS_READS,
+        Workflow.NALLO: SequencingQCCheck.CASE_PASSES_ON_YIELD,
+        Workflow.RAREDISEASE: SequencingQCCheck.CASE_PASSES_ON_READS,
+        Workflow.RAW_DATA: SequencingQCCheck.ANY_SAMPLE_IN_CASE_HAS_READS,
+        Workflow.RNAFUSION: SequencingQCCheck.CASE_PASSES_ON_READS,
         Workflow.TAXPROFILER: SequencingQCCheck.ALL_SAMPLES_IN_CASE_HAVE_READS,
-        Workflow.NALLO: SequencingQCCheck.ALL_SAMPLES_IN_CASE_HAVE_READS,
+        Workflow.TOMTE: SequencingQCCheck.CASE_PASSES_ON_READS,
     }
 
     if workflow in workflow_qc_mapping:
@@ -55,5 +57,5 @@ def get_sample_sequencing_quality_check() -> Callable:
     return SequencingQCCheck.SAMPLE_PASSES
 
 
-def run_quality_checks(quality_checks: list[QualityCheck], **kwargs) -> bool:
+def run_quality_checks(quality_checks: list[Callable], **kwargs) -> bool:
     return all(quality_check(**kwargs) for quality_check in quality_checks)

cg/services/sequencing_qc_service/quality_checks/utils.py

@@ -2,12 +2,13 @@ import logging
 
 from cg.constants.priority import Priority
 from cg.constants.sequencing import SeqLibraryPrepCategory
+from cg.exc import ApplicationDoesNotHaveHiFiYieldError
 from cg.store.models import Case, Sample
 
 LOG = logging.getLogger(__name__)
 
 
-def case_pass_sequencing_qc(case: Case) -> bool:
+def case_pass_sequencing_qc_on_reads(case: Case) -> bool:
     """
     Get the sequencing QC of a case. The checks are performed in the following order:
     1. If the case is a ready-made library, the ready made library QC is used.
@@ -21,22 +22,66 @@ def case_pass_sequencing_qc(case: Case) -> bool:
     if is_case_ready_made_library(case):
         return ready_made_library_case_pass_sequencing_qc(case)
     if is_case_express_priority(case):
-        return express_case_pass_sequencing_qc(case)
+        return express_case_pass_sequencing_qc_on_reads(case)
     return all(sample_has_enough_reads(sample) for sample in case.samples)
 
 
-def express_case_pass_sequencing_qc(case: Case) -> bool:
+def case_pass_sequencing_qc_on_hifi_yield(case: Case) -> bool:
+    """
+    Get the sequencing QC of a case using yield. The checks are performed in the following order:
+    1. If the case is express priority, the express QC is used.
+    2. If the above condition is not met then it checks if all samples have enough yield.
+
+    The express QC should be checked before the standard QC.
+    """
+    if is_case_express_priority(case):
+        return express_case_pass_sequencing_qc_on_hifi_yield(case)
+    return all(sample_has_enough_hifi_yield(sample) for sample in case.samples)
+
+
+def express_case_pass_sequencing_qc_on_reads(case: Case) -> bool:
     """
     Checks if all samples in an express case have enough reads.
     """
     return all(express_sample_has_enough_reads(sample) for sample in case.samples)
 
 
-def express_sample_pass_sequencing_qc(sample: Sample) -> bool:
+def express_case_pass_sequencing_qc_on_hifi_yield(case: Case) -> bool:
+    """
+    Checks if all samples in an express case have enough hifi yield.
+    """
+    return all(express_sample_has_enough_yield(sample) for sample in case.samples)
+
+
+def express_sample_pass_sequencing_qc_on_reads(sample: Sample) -> bool:
     return express_sample_has_enough_reads(sample)
 
 
-def sample_pass_sequencing_qc(sample: Sample) -> bool:
+def express_sample_has_enough_reads(sample: Sample) -> bool:
+    """
+    Checks if given express sample has enough reads. Gets the threshold from the sample's
+    application version.
+    """
+    express_reads_threshold: int = get_express_reads_threshold_for_sample(sample)
+    enough_reads: bool = sample.reads >= express_reads_threshold
+    if not enough_reads:
+        LOG.warning(f"Sample {sample.internal_id} has too few reads.")
+    return enough_reads
+
+
+def express_sample_has_enough_yield(sample: Sample) -> bool:
+    if not sample.hifi_yield:
+        LOG.debug(f"Sample {sample.internal_id} has no hifi yield.")
+        return False
+
+    express_yield_threshold: int = get_express_yield_threshold_for_sample(sample)
+    enough_yield: bool = sample.hifi_yield >= express_yield_threshold
+    if not enough_yield:
+        LOG.warning(f"Sample {sample.internal_id} does not have enough yield.")
+    return enough_yield
+
+
+def sample_pass_sequencing_qc_on_reads(sample: Sample) -> bool:
     """
     Get the standard sequencing QC of a sample. The checks are performed in the following order:
     1. If the sample is express priority, the express QC is used.
@@ -47,7 +92,7 @@ def sample_pass_sequencing_qc(sample: Sample) -> bool:
     checked before the standard QC.
     """
     if is_sample_express_priority(sample):
-        return express_sample_pass_sequencing_qc(sample)
+        return express_sample_pass_sequencing_qc_on_reads(sample)
     if is_sample_ready_made_library(sample):
         return ready_made_library_sample_has_enough_reads(sample)
     return sample_has_enough_reads(sample)
@@ -94,18 +139,6 @@ def is_case_express_priority(case: Case) -> bool:
     return case.priority == Priority.express
 
 
-def express_sample_has_enough_reads(sample: Sample) -> bool:
-    """
-    Checks if given express sample has enough reads. Gets the threshold from the sample's
-    application version.
-    """
-    express_reads_threshold: int = get_express_reads_threshold_for_sample(sample)
-    enough_reads: bool = sample.reads >= express_reads_threshold
-    if not enough_reads:
-        LOG.warning(f"Sample {sample.internal_id} has too few reads.")
-    return enough_reads
-
-
 def get_express_reads_threshold_for_sample(sample: Sample) -> int:
     """
     Get the express reads threshold for a sample.
@@ -113,6 +146,15 @@ def get_express_reads_threshold_for_sample(sample: Sample) -> int:
     return round(sample.application_version.application.target_reads / 2)
 
 
+def get_express_yield_threshold_for_sample(sample: Sample) -> int:
+    if threshold := sample.application_version.application.expected_express_hifi_yield:
+        return threshold
+    else:
+        raise ApplicationDoesNotHaveHiFiYieldError(
+            f"Application for sample {sample.internal_id} does not have target HiFi yield."
+        )
+
+
 def is_sample_ready_made_library(sample: Sample) -> bool:
     return sample.prep_category == SeqLibraryPrepCategory.READY_MADE_LIBRARY
 
@@ -143,6 +185,28 @@ def sample_has_enough_reads(sample: Sample) -> bool:
     return enough_reads
 
 
+def sample_has_enough_hifi_yield(sample: Sample) -> bool:
+    """
+    Return true if the sample's HiFi yield is greater than or equal to the threshold.
+    Returns false if the HiFi yield is lower than the threshold or None.
+    Raises:
+        ApplicationDoesNotHaveHiFiYieldError if the sample doesn't have expected HiFi yield.
+    """
+    if not sample.expected_hifi_yield:
+        raise ApplicationDoesNotHaveHiFiYieldError(
+            f"Application for sample {sample.internal_id} does not have target HiFi yield."
+        )
+
+    if not sample.hifi_yield:
+        LOG.debug(f"Sample {sample.internal_id} has no hifi yield.")
+        return False
+
+    enough_hifi_yield: bool = sample.hifi_yield >= sample.expected_hifi_yield
+    if not enough_hifi_yield:
+        LOG.warning(f"Sample {sample.internal_id} does not have enough HiFi yield.")
+    return enough_hifi_yield
+
+
 def is_sample_express_priority(sample: Sample) -> bool:
     """
     Check if a sample is express priority.

cg/services/sequencing_qc_service/sequencing_qc_service.py

@@ -2,15 +2,13 @@ import logging
 from typing import Callable
 
 from cg.constants.constants import SequencingQCStatus
-from cg.services.sequencing_qc_service.utils import qc_bool_to_status
-from typing import Callable
-
-from cg.store.models import Case, Sample
 from cg.services.sequencing_qc_service.quality_checks.checks import (
-    run_quality_checks,
-    get_sequencing_quality_check_for_case,
     get_sample_sequencing_quality_check,
+    get_sequencing_quality_check_for_case,
+    run_quality_checks,
 )
+from cg.services.sequencing_qc_service.utils import qc_bool_to_status
+from cg.store.models import Case, Sample
 from cg.store.store import Store
 
 LOG = logging.getLogger(__name__)
@@ -24,10 +22,14 @@ class SequencingQCService:
         """Run QC for samples in pending or failed cases and store the aggregated score on each case."""
         cases: list[Case] = self.store.get_cases_for_sequencing_qc()
         for case in cases:
-            passes_qc: bool = self.case_pass_sequencing_qc(case)
-            qc_status: SequencingQCStatus = qc_bool_to_status(passes_qc)
-            self.store.update_sequencing_qc_status(case=case, status=qc_status)
-            LOG.info(f"Sequencing QC status for case {case.internal_id}: {qc_status}")
+            LOG.debug(f"Performing sequencing QC for case: {case.internal_id}")
+            try:
+                passes_qc: bool = self.case_pass_sequencing_qc(case)
+                qc_status: SequencingQCStatus = qc_bool_to_status(passes_qc)
+                self.store.update_sequencing_qc_status(case=case, status=qc_status)
+                LOG.info(f"Sequencing QC status for case {case.internal_id}: {qc_status}")
+            except Exception as e:
+                LOG.error(f"Error found during sequencing QC of case: {case.internal_id}: {e}")
 
     @staticmethod
     def case_pass_sequencing_qc(case: Case) -> bool: