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

cg/store/crud/create.py

@@ -9,6 +9,7 @@ from sqlalchemy.orm import Session
 
 from cg.constants import DataDelivery, Priority, Workflow
 from cg.constants.archiving import PDC_ARCHIVE_LOCATION
+from cg.exc import PacbioSequencingRunAlreadyExistsError
 from cg.models.orders.constants import OrderType
 from cg.services.illumina.data_transfer.models import (
     IlluminaFlowCellDTO,
@@ -19,6 +20,7 @@ from cg.services.run_devices.pacbio.data_transfer_service.dto import (
     PacBioSampleSequencingMetricsDTO,
     PacBioSequencingRunDTO,
     PacBioSMRTCellDTO,
+    PacBioSMRTCellMetricsDTO,
 )
 from cg.store.crud.read import ReadHandler
 from cg.store.database import get_session
@@ -44,6 +46,7 @@ from cg.store.models import (
     PacbioSampleSequencingMetrics,
     PacbioSequencingRun,
     PacbioSMRTCell,
+    PacbioSMRTCellMetrics,
     Panel,
     Pool,
     Sample,
@@ -500,47 +503,75 @@ class CreateMixin(ReadHandler):
         self.add_item_to_store(new_smrt_cell)
         return new_smrt_cell
 
-    def create_pac_bio_sequencing_run(
-        self, sequencing_run_dto: PacBioSequencingRunDTO, smrt_cell: PacbioSMRTCell
+    def create_pacbio_sequencing_run(
+        self, pacbio_sequencing_run_dto: PacBioSequencingRunDTO
     ) -> PacbioSequencingRun:
-        LOG.debug(f"Creating Pacbio sequencing run for SMRT cell {smrt_cell.internal_id}")
-        new_sequencing_run = PacbioSequencingRun(
-            type=sequencing_run_dto.type,
-            well=sequencing_run_dto.well,
-            plate=sequencing_run_dto.plate,
-            run_name=sequencing_run_dto.run_name,
-            movie_name=sequencing_run_dto.movie_name,
-            started_at=sequencing_run_dto.started_at,
-            completed_at=sequencing_run_dto.completed_at,
-            hifi_reads=sequencing_run_dto.hifi_reads,
-            hifi_yield=sequencing_run_dto.hifi_yield,
-            hifi_mean_read_length=sequencing_run_dto.hifi_mean_read_length,
-            hifi_median_read_quality=sequencing_run_dto.hifi_median_read_quality,
-            percent_reads_passing_q30=sequencing_run_dto.percent_reads_passing_q30,
-            productive_zmws=sequencing_run_dto.productive_zmws,
-            p0_percent=sequencing_run_dto.p0_percent,
-            p1_percent=sequencing_run_dto.p1_percent,
-            p2_percent=sequencing_run_dto.p2_percent,
-            polymerase_mean_read_length=sequencing_run_dto.polymerase_mean_read_length,
-            polymerase_read_length_n50=sequencing_run_dto.polymerase_read_length_n50,
-            polymerase_mean_longest_subread=sequencing_run_dto.polymerase_mean_longest_subread,
-            polymerase_longest_subread_n50=sequencing_run_dto.polymerase_longest_subread_n50,
-            control_reads=sequencing_run_dto.control_reads,
-            control_mean_read_length=sequencing_run_dto.control_mean_read_length,
-            control_mean_read_concordance=sequencing_run_dto.control_mean_read_concordance,
-            control_mode_read_concordance=sequencing_run_dto.control_mode_read_concordance,
-            failed_reads=sequencing_run_dto.failed_reads,
-            failed_yield=sequencing_run_dto.failed_yield,
-            failed_mean_read_length=sequencing_run_dto.failed_mean_read_length,
-            barcoded_hifi_reads=sequencing_run_dto.barcoded_hifi_reads,
-            barcoded_hifi_reads_percentage=sequencing_run_dto.barcoded_hifi_reads_percentage,
-            barcoded_hifi_yield=sequencing_run_dto.barcoded_hifi_yield,
-            barcoded_hifi_yield_percentage=sequencing_run_dto.barcoded_hifi_yield_percentage,
-            barcoded_hifi_mean_read_length=sequencing_run_dto.barcoded_hifi_mean_read_length,
-            unbarcoded_hifi_reads=sequencing_run_dto.unbarcoded_hifi_reads,
-            unbarcoded_hifi_yield=sequencing_run_dto.unbarcoded_hifi_yield,
-            unbarcoded_hifi_mean_read_length=sequencing_run_dto.unbarcoded_hifi_mean_read_length,
+        """Create a new PacBio sequencing run
+
+        Raises PacbioSequencingRunAlreadyExistsError:
+        - When run name already exists in the database
+        """
+        if (
+            self._get_query(table=PacbioSequencingRun)
+            .filter(PacbioSequencingRun.run_name == pacbio_sequencing_run_dto.run_name)
+            .first()
+        ):
+            raise PacbioSequencingRunAlreadyExistsError(
+                message=f"{pacbio_sequencing_run_dto.run_name} already exists."
+            )
+        else:
+            LOG.debug(f"Creating Pacbio Sequencing Run for {pacbio_sequencing_run_dto.run_name}")
+            sequencing_run = PacbioSequencingRun(
+                instrument_name=pacbio_sequencing_run_dto.instrument_name,
+                run_name=pacbio_sequencing_run_dto.run_name,
+            )
+            self.add_item_to_store(sequencing_run)
+            return sequencing_run
+
+    def create_pacbio_smrt_cell_metrics(
+        self,
+        sequencing_run: PacbioSequencingRun,
+        smrt_cell_metrics_dto: PacBioSMRTCellMetricsDTO,
+        smrt_cell: PacbioSMRTCell,
+    ) -> PacbioSMRTCellMetrics:
+        LOG.debug(f"Creating Pacbio SMRT cell metrics for SMRT cell {smrt_cell.internal_id}")
+        new_sequencing_run = PacbioSMRTCellMetrics(
+            barcoded_hifi_mean_read_length=smrt_cell_metrics_dto.barcoded_hifi_mean_read_length,
+            barcoded_hifi_reads=smrt_cell_metrics_dto.barcoded_hifi_reads,
+            barcoded_hifi_reads_percentage=smrt_cell_metrics_dto.barcoded_hifi_reads_percentage,
+            barcoded_hifi_yield=smrt_cell_metrics_dto.barcoded_hifi_yield,
+            barcoded_hifi_yield_percentage=smrt_cell_metrics_dto.barcoded_hifi_yield_percentage,
+            completed_at=smrt_cell_metrics_dto.completed_at,
+            control_mean_read_concordance=smrt_cell_metrics_dto.control_mean_read_concordance,
+            control_mean_read_length=smrt_cell_metrics_dto.control_mean_read_length,
+            control_mode_read_concordance=smrt_cell_metrics_dto.control_mode_read_concordance,
+            control_reads=smrt_cell_metrics_dto.control_reads,
             device=smrt_cell,
+            failed_mean_read_length=smrt_cell_metrics_dto.failed_mean_read_length,
+            failed_reads=smrt_cell_metrics_dto.failed_reads,
+            failed_yield=smrt_cell_metrics_dto.failed_yield,
+            hifi_mean_read_length=smrt_cell_metrics_dto.hifi_mean_read_length,
+            hifi_median_read_quality=smrt_cell_metrics_dto.hifi_median_read_quality,
+            hifi_reads=smrt_cell_metrics_dto.hifi_reads,
+            hifi_yield=smrt_cell_metrics_dto.hifi_yield,
+            movie_name=smrt_cell_metrics_dto.movie_name,
+            p0_percent=smrt_cell_metrics_dto.p0_percent,
+            p1_percent=smrt_cell_metrics_dto.p1_percent,
+            p2_percent=smrt_cell_metrics_dto.p2_percent,
+            percent_reads_passing_q30=smrt_cell_metrics_dto.percent_reads_passing_q30,
+            plate=smrt_cell_metrics_dto.plate,
+            polymerase_longest_subread_n50=smrt_cell_metrics_dto.polymerase_longest_subread_n50,
+            polymerase_mean_longest_subread=smrt_cell_metrics_dto.polymerase_mean_longest_subread,
+            polymerase_mean_read_length=smrt_cell_metrics_dto.polymerase_mean_read_length,
+            polymerase_read_length_n50=smrt_cell_metrics_dto.polymerase_read_length_n50,
+            productive_zmws=smrt_cell_metrics_dto.productive_zmws,
+            sequencing_run=sequencing_run,
+            started_at=smrt_cell_metrics_dto.started_at,
+            type=smrt_cell_metrics_dto.type,
+            unbarcoded_hifi_mean_read_length=smrt_cell_metrics_dto.unbarcoded_hifi_mean_read_length,
+            unbarcoded_hifi_reads=smrt_cell_metrics_dto.unbarcoded_hifi_reads,
+            unbarcoded_hifi_yield=smrt_cell_metrics_dto.unbarcoded_hifi_yield,
+            well=smrt_cell_metrics_dto.well,
         )
         self.add_item_to_store(new_sequencing_run)
         return new_sequencing_run
@@ -548,11 +579,11 @@ class CreateMixin(ReadHandler):
     def create_pac_bio_sample_sequencing_run(
         self,
         sample_run_metrics_dto: PacBioSampleSequencingMetricsDTO,
-        sequencing_run: PacbioSequencingRun,
+        smrt_cell_metrics: PacbioSMRTCellMetrics,
     ) -> PacbioSampleSequencingMetrics:
         sample_id: str = sample_run_metrics_dto.sample_internal_id
         LOG.debug(f"Creating Pacbio sample sequencing metric for sample {sample_id}")
-        sample: Sample = self.get_sample_by_internal_id(sample_id)
+        sample: Sample = self.get_sample_by_internal_id_strict(sample_id)
         if not sample:
             self.rollback()
             raise EntryNotFoundError(f"Sample not found: {sample_id}")
@@ -562,7 +593,7 @@ class CreateMixin(ReadHandler):
             hifi_yield=sample_run_metrics_dto.hifi_yield,
             hifi_mean_read_length=sample_run_metrics_dto.hifi_mean_read_length,
             hifi_median_read_quality=sample_run_metrics_dto.hifi_median_read_quality,
-            instrument_run=sequencing_run,
+            instrument_run=smrt_cell_metrics,
             polymerase_mean_read_length=sample_run_metrics_dto.polymerase_mean_read_length,
         )
         self.add_item_to_store(new_sample_sequencing_run)

cg/store/crud/read.py

@@ -20,6 +20,7 @@ from cg.exc import (
     CgDataError,
     CgError,
     OrderNotFoundError,
+    PacbioSequencingRunNotFoundError,
     SampleNotFoundError,
 )
 from cg.models.orders.constants import OrderType
@@ -97,6 +98,7 @@ from cg.store.models import (
     PacbioSampleSequencingMetrics,
     PacbioSequencingRun,
     PacbioSMRTCell,
+    PacbioSMRTCellMetrics,
     Panel,
     Pool,
     RunDevice,
@@ -903,20 +905,19 @@ class ReadHandler(BaseHandler):
             valid_from=dt.datetime.now(),
         ).first()
 
-    def get_active_applications_by_prep_category(
+    def get_applications_by_prep_category(
         self, prep_category: SeqLibraryPrepCategory
     ) -> list[Application]:
-        """Return all active applications by prep category."""
+        """Return all applications by prep category."""
         return apply_application_filter(
             applications=self._get_query(table=Application),
             filter_functions=[
                 ApplicationFilter.BY_PREP_CATEGORIES,
-                ApplicationFilter.IS_NOT_ARCHIVED,
             ],
             prep_categories=[prep_category],
         ).all()
 
-    def get_bed_version_by_file_name(self, bed_version_file_name: str) -> BedVersion:
+    def get_bed_version_by_file_name(self, bed_version_file_name: str) -> BedVersion | None:
         """Return bed version with file name."""
         return apply_bed_version_filter(
             bed_versions=self._get_query(table=BedVersion),
@@ -1113,7 +1114,9 @@ class ReadHandler(BaseHandler):
         """Return all cases in the database with samples."""
         return self._get_join_cases_with_samples_query()
 
-    def get_cases_to_analyze(self, workflow: Workflow = None, limit: int = None) -> list[Case]:
+    def get_cases_to_analyze(
+        self, workflow: Workflow = None, limit: int | None = None
+    ) -> list[Case]:
         """Returns a list if cases ready to be analyzed or set to be reanalyzed.
         1. Get cases to be analyzed using BE query
         2. Use the latest analysis for case to determine if the case is to be analyzed"""
@@ -1165,6 +1168,23 @@ class ReadHandler(BaseHandler):
             internal_id=internal_id,
         ).first()
 
+    def get_sample_by_internal_id_strict(self, internal_id: str) -> Sample:
+        """
+        Return a sample by lims id.
+        Raises:
+            SampleNotFoundError: If no sample is found with the given internal id.
+        """
+        try:
+            return apply_sample_filter(
+                filter_functions=[SampleFilter.BY_INTERNAL_ID],
+                samples=self._get_query(table=Sample),
+                internal_id=internal_id,
+            ).one()
+        except sqlalchemy.orm.exc.NoResultFound:
+            raise SampleNotFoundError(
+                f"Sample with internal id {internal_id} was not found in the database."
+            )
+
     def get_samples_by_identifier(self, object_type: str, identifier: str) -> list[Sample]:
         """Return all samples from a flow cell, case or sample id"""
         object_to_filter: dict[str, Callable] = {
@@ -1788,18 +1808,34 @@ class ReadHandler(BaseHandler):
             sequencing_metrics = sequencing_metrics.filter(RunDevice.internal_id.in_(smrt_cell_ids))
         return sequencing_metrics.all()
 
-    def get_pacbio_sequencing_runs_by_run_name(self, run_name: str) -> list[PacbioSequencingRun]:
+    def get_pacbio_smrt_cell_metrics_by_run_name(
+        self, run_name: str
+    ) -> list[PacbioSMRTCellMetrics]:
         """
         Fetches data from PacbioSequencingRunDTO filtered on run name.
         Raises:
             EntryNotFoundError if no sequencing runs are found for the run name
         """
-        runs: Query = self._get_query(table=PacbioSequencingRun)
+        runs: Query = self._get_query(table=PacbioSMRTCellMetrics).join(
+            PacbioSMRTCellMetrics.sequencing_run
+        )
         runs = runs.filter(PacbioSequencingRun.run_name == run_name)
         if runs.count() == 0:
             raise EntryNotFoundError(f"Could not find any sequencing runs for {run_name}")
         return runs.all()
 
+    def get_pacbio_sequencing_runs(
+        self, page: int = 0, page_size: int = 0
+    ) -> tuple[list[PacbioSequencingRun], int]:
+        query = self._get_query(PacbioSequencingRun).order_by(PacbioSequencingRun.id.desc())
+
+        if page and page_size:
+            query = query.limit(page_size).offset((page - 1) * page_size)
+
+        total_count: int = self._get_query(table=PacbioSequencingRun).count()
+
+        return query.all(), total_count
+
     def get_case_priority(self, case_id: str) -> SlurmQos:
         """Get case priority."""
         case: Case = self.get_case_by_internal_id(case_id)
@@ -1817,3 +1853,33 @@ class ReadHandler(BaseHandler):
         ):
             return True
         return False
+
+    def get_pacbio_sequencing_run_by_id(self, id: int):
+        """
+        Get Pacbio Sequencing run by id.
+        Raises:
+            PacbioSequencingRunNotFoundError: If no Pacbio sequencing run is found with the given id.
+        """
+        try:
+            return (
+                self._get_query(table=PacbioSequencingRun)
+                .filter(PacbioSequencingRun.id == id)
+                .one()
+            )
+        except sqlalchemy.orm.exc.NoResultFound:
+            raise PacbioSequencingRunNotFoundError(
+                f"Pacbio Sequencing run with id {id} was not found in the database."
+            )
+
+    def get_pacbio_sequencing_run_by_run_name(self, run_name: str) -> PacbioSequencingRun:
+        """
+        Get Pacbio Sequencing run by run name.
+        Raises:
+            PacbioSequencingRunNotFoundError: If no Pacbio sequencing run is found with the given run name.
+        """
+        try:
+            return self._get_query(table=PacbioSequencingRun).filter_by(run_name=run_name).one()
+        except sqlalchemy.orm.exc.NoResultFound:
+            raise PacbioSequencingRunNotFoundError(
+                f"Pacbio Sequencing run with run_name {run_name} was not found in the database."
+            )

cg/store/crud/update.py

@@ -13,6 +13,7 @@ from cg.store.models import (
     IlluminaSampleSequencingMetrics,
     IlluminaSequencingRun,
     Order,
+    PacbioSequencingRun,
     Sample,
 )
 
@@ -78,10 +79,10 @@ class UpdateMixin(ReadHandler):
         sample.reads = total_reads_for_sample
         self.commit_to_store()
 
-    def update_sample_reads(self, internal_id: str, reads: int):
+    def update_sample_reads_pacbio(self, internal_id: str, reads: int):
         """Add reads to the current reads for a sample."""
-        sample: Sample = self.get_sample_by_internal_id(internal_id)
-        sample.reads += reads
+        sample: Sample = self.get_sample_by_internal_id_strict(internal_id)
+        sample.reads = reads
         self.commit_to_store()
 
     def update_sample_sequenced_at(self, internal_id: str, date: datetime):
@@ -132,3 +133,13 @@ class UpdateMixin(ReadHandler):
         analysis: Analysis = self.get_analysis_by_entry_id(analysis_id)
         analysis.delivery_report_created_at = delivery_report_date
         self.commit_to_store()
+
+    def update_pacbio_sequencing_run_comment(self, id: int, comment: str):
+        sequencing_run: PacbioSequencingRun = self.get_pacbio_sequencing_run_by_id(id)
+        sequencing_run.comment = comment
+        self.commit_to_store()
+
+    def update_pacbio_sequencing_run_processed(self, id: int, processed: bool):
+        sequencing_run: PacbioSequencingRun = self.get_pacbio_sequencing_run_by_id(id)
+        sequencing_run.processed = processed
+        self.commit_to_store()

cg/store/models.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 from enum import Enum
-from typing import Annotated
+from typing import Annotated, cast
 
 import sqlalchemy
 from sqlalchemy import (
@@ -28,7 +28,7 @@ from cg.constants.constants import (
     SexOptions,
     StatusOptions,
 )
-from cg.constants.devices import DeviceType
+from cg.constants.devices import DeviceType, RevioNames
 from cg.constants.priority import SlurmQos
 from cg.constants.sequencing import SeqLibraryPrepCategory
 from cg.constants.symbols import EMPTY_STRING
@@ -147,6 +147,8 @@ class Application(Base):
     min_sequencing_depth: Mapped[int] = mapped_column(default=0)
     target_reads: Mapped[BigInt | None] = mapped_column(default=0)
     percent_reads_guaranteed: Mapped[int]
+    target_hifi_yield: Mapped[BigInt | None] = mapped_column(default=None)
+    percent_hifi_yield_guaranteed: Mapped[int | None] = mapped_column(default=None)
     sample_amount: Mapped[int | None]
     sample_volume: Mapped[Text | None]
     sample_concentration: Mapped[Text | None]
@@ -191,9 +193,20 @@ class Application(Base):
         return self.tag
 
     @property
-    def expected_reads(self):
+    def expected_reads(self) -> float:
         return self.target_reads * self.percent_reads_guaranteed / 100
 
+    @property
+    def expected_hifi_yield(self) -> int | None:
+        if self.target_hifi_yield and self.percent_hifi_yield_guaranteed:
+            return round(self.target_hifi_yield * self.percent_hifi_yield_guaranteed / 100)
+        else:
+            return None
+
+    @property
+    def expected_express_hifi_yield(self) -> int | None:
+        return round(self.target_hifi_yield * 0.5) if self.target_hifi_yield else None
+
     @property
     def analysis_type(self) -> str:
         if self.prep_category == SeqLibraryPrepCategory.WHOLE_TRANSCRIPTOME_SEQUENCING.value:
@@ -283,6 +296,7 @@ class Analysis(Base):
     case: Mapped["Case"] = orm.relationship(back_populates="analyses")
     trailblazer_id: Mapped[int | None]
     housekeeper_version_id: Mapped[int | None]
+    session_id: Mapped[str | None]
 
     def __str__(self):
         return f"{self.case.internal_id} | {self.completed_at.date()}"
@@ -324,7 +338,7 @@ class BedVersion(Base):
     __table_args__ = (UniqueConstraint("bed_id", "version", name="_app_version_uc"),)
 
     id: Mapped[PrimaryKeyInt]
-    shortname: Mapped[Str64 | None]
+    shortname: Mapped[Str64]
     version: Mapped[int]
     filename: Mapped[Str256]
     checksum: Mapped[Str32 | None]
@@ -338,6 +352,10 @@ class BedVersion(Base):
 
     bed: Mapped[Bed] = orm.relationship(back_populates="versions")
 
+    @property
+    def bed_name(self) -> str:
+        return self.bed.name
+
     def __str__(self) -> str:
         return f"{self.bed.name} ({self.version})"
 
@@ -441,7 +459,7 @@ class Case(Base, PriorityMixin):
     created_at: Mapped[datetime | None] = mapped_column(default=datetime.now)
     customer_id: Mapped[int] = mapped_column(ForeignKey("customer.id", ondelete="CASCADE"))
     customer: Mapped["Customer"] = orm.relationship(foreign_keys=[customer_id])
-    data_analysis: Mapped[str] = mapped_column(
+    data_analysis: Mapped[Workflow] = mapped_column(
         types.Enum(*(workflow.value for workflow in Workflow))
     )
     data_delivery: Mapped[str | None] = mapped_column(
@@ -548,11 +566,11 @@ class Case(Base, PriorityMixin):
         return [link.sample for link in self.links if link.sample.loqusdb_id]
 
     @property
-    def slurm_priority(self) -> str:
+    def slurm_priority(self) -> SlurmQos:
         """Get Quality of service (SLURM QOS) for the case."""
         if self.are_all_samples_control():
             return SlurmQos.EXPRESS
-        return Priority.priority_to_slurm_qos().get(self.priority)
+        return cast(SlurmQos, Priority.priority_to_slurm_qos().get(self.priority))
 
     def to_dict(self, links: bool = False, analyses: bool = False) -> dict:
         """Represent as dictionary."""
@@ -724,7 +742,7 @@ class Sample(Base, PriorityMixin):
     prepared_at: Mapped[datetime | None]
 
     priority: Mapped[Priority] = mapped_column(default=Priority.standard)
-    reads: Mapped[BigInt | None] = mapped_column(default=0)
+    reads: Mapped[BigInt] = mapped_column(default=0)
     last_sequenced_at: Mapped[datetime | None]
     received_at: Mapped[datetime | None]
     reference_genome: Mapped[Str255 | None]
@@ -754,16 +772,28 @@ class Sample(Base, PriorityMixin):
     def __str__(self) -> str:
         return f"{self.internal_id} ({self.name})"
 
+    @property
+    def hifi_yield(self) -> int | None:
+        if self._sample_run_metrics and getattr(self._sample_run_metrics[0], "hifi_yield", False):
+            return sum(metric.hifi_yield for metric in self._sample_run_metrics)  # type: ignore
+        else:
+            return None
+
     @property
     def archive_location(self) -> str:
         """Returns the data_archive_location if the customer linked to the sample."""
         return self.customer.data_archive_location
 
     @property
-    def expected_reads_for_sample(self) -> int:
+    def expected_reads_for_sample(self) -> float | None:
         """Return the expected reads of the sample."""
         return self.application_version.application.expected_reads
 
+    @property
+    def expected_hifi_yield(self) -> int | None:
+        """Return the expected HiFi yield of the sample."""
+        return self.application_version.application.expected_hifi_yield
+
     @property
     def has_reads(self) -> bool:
         return bool(self.reads)
@@ -1018,49 +1048,63 @@ class IlluminaSequencingRun(InstrumentRun):
         return data
 
 
-class PacbioSequencingRun(InstrumentRun):
-    __tablename__ = "pacbio_sequencing_run"
+class PacbioSMRTCellMetrics(InstrumentRun):
+    __tablename__ = "pacbio_smrt_cell_metrics"
 
     id: Mapped[int] = mapped_column(
         ForeignKey("instrument_run.id", ondelete="CASCADE"), primary_key=True
     )
-    well: Mapped[Str32]
-    plate: Mapped[int]
-    run_name: Mapped[Str32]
-    movie_name: Mapped[Str32]
-    started_at: Mapped[datetime]
+    barcoded_hifi_mean_read_length: Mapped[BigInt]
+    barcoded_hifi_reads_percentage: Mapped[Num_6_2]
+    barcoded_hifi_reads: Mapped[BigInt]
+    barcoded_hifi_yield_percentage: Mapped[Num_6_2]
+    barcoded_hifi_yield: Mapped[BigInt]
     completed_at: Mapped[datetime]
-    hifi_reads: Mapped[BigInt]
-    hifi_yield: Mapped[BigInt]
+    control_mean_read_concordance: Mapped[Num_6_2]
+    control_mean_read_length: Mapped[BigInt]
+    control_mode_read_concordance: Mapped[Num_6_2]
+    control_reads: Mapped[BigInt]
+    failed_mean_read_length: Mapped[BigInt]
+    failed_reads: Mapped[BigInt]
+    failed_yield: Mapped[BigInt]
     hifi_mean_read_length: Mapped[BigInt]
     hifi_median_read_quality: Mapped[Str32]
-    percent_reads_passing_q30: Mapped[Num_6_2]
+    hifi_reads: Mapped[BigInt]
+    hifi_yield: Mapped[BigInt]
+    movie_name: Mapped[Str32]
     p0_percent: Mapped[Num_6_2]
     p1_percent: Mapped[Num_6_2]
     p2_percent: Mapped[Num_6_2]
-    productive_zmws: Mapped[BigInt]
+    pacbio_sequencing_run_id: Mapped[int] = mapped_column(
+        ForeignKey(
+            "pacbio_sequencing_run.id",
+            ondelete="CASCADE",
+            name="pacbio_smrt_cell_metrics_pacbio_sequencing_run_fk",
+        )
+    )
+    percent_reads_passing_q30: Mapped[Num_6_2]
+    plate: Mapped[int]
+    polymerase_longest_subread_n50: Mapped[BigInt]
+    polymerase_mean_longest_subread: Mapped[BigInt]
     polymerase_mean_read_length: Mapped[BigInt]
     polymerase_read_length_n50: Mapped[BigInt]
-    polymerase_mean_longest_subread: Mapped[BigInt]
-    polymerase_longest_subread_n50: Mapped[BigInt]
-    control_reads: Mapped[BigInt]
-    control_mean_read_length: Mapped[BigInt]
-    control_mean_read_concordance: Mapped[Num_6_2]
-    control_mode_read_concordance: Mapped[Num_6_2]
-    failed_reads: Mapped[BigInt]
-    failed_yield: Mapped[BigInt]
-    failed_mean_read_length: Mapped[BigInt]
-    barcoded_hifi_reads: Mapped[BigInt]
-    barcoded_hifi_reads_percentage: Mapped[Num_6_2]
-    barcoded_hifi_yield: Mapped[BigInt]
-    barcoded_hifi_yield_percentage: Mapped[Num_6_2]
-    barcoded_hifi_mean_read_length: Mapped[BigInt]
+    productive_zmws: Mapped[BigInt]
+    started_at: Mapped[datetime]
+    unbarcoded_hifi_mean_read_length: Mapped[BigInt]
     unbarcoded_hifi_reads: Mapped[BigInt]
     unbarcoded_hifi_yield: Mapped[BigInt]
-    unbarcoded_hifi_mean_read_length: Mapped[BigInt]
+    well: Mapped[Str32]
+
+    sequencing_run: Mapped["PacbioSequencingRun"] = orm.relationship(
+        back_populates="smrt_cell_metrics"
+    )
 
     __mapper_args__ = {"polymorphic_identity": DeviceType.PACBIO}
 
+    @property
+    def run_name(self) -> str:
+        return self.sequencing_run.run_name
+
     def to_dict(self):
         return to_dict(self)
 
@@ -1117,12 +1161,31 @@ class PacbioSampleSequencingMetrics(SampleRunMetrics):
     polymerase_mean_read_length: Mapped[BigInt]
 
     __mapper_args__ = {"polymorphic_identity": DeviceType.PACBIO}
+    instrument_run = orm.relationship(PacbioSMRTCellMetrics, back_populates="sample_metrics")
 
     def to_dict(self) -> dict:
         """Represent as dictionary"""
         return to_dict(self)
 
 
+class PacbioSequencingRun(Base):
+    """PacBio sequencing run, consisting of a set of SMRT-cells sequenced simultaneously."""
+
+    __tablename__ = "pacbio_sequencing_run"
+
+    id: Mapped[PrimaryKeyInt]
+    run_name: Mapped[Str64] = mapped_column(unique=True)
+    processed: Mapped[bool] = mapped_column(default=False)
+    comment: Mapped[Text] = mapped_column(default="")
+    instrument_name: Mapped[RevioNames] = mapped_column(
+        types.Enum(*(revio_name.value for revio_name in RevioNames))
+    )
+
+    smrt_cell_metrics: Mapped[list[PacbioSMRTCellMetrics]] = orm.relationship(
+        back_populates="sequencing_run"
+    )
+
+
 class OrderTypeApplication(Base):
     """Maps an order type to its allowed applications"""
 

cg/store/store.py

@@ -10,4 +10,11 @@ class Store(
     DeleteMixin,
     UpdateMixin,
 ):
-    pass
+    def recalculate_sample_reads_pacbio(self, sample_id: str) -> None:
+        reads: int = sum(
+            metric.hifi_reads
+            for metric in self.get_pacbio_sample_sequencing_metrics(
+                sample_id=sample_id, smrt_cell_ids=None
+            )
+        )
+        self.update_sample_reads_pacbio(internal_id=sample_id, reads=reads)

{cg-76.0.0.dist-info → cg-83.14.0.dist-info}/METADATA

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