cg 80.1.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,
@@ -1806,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)
@@ -1835,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

@@ -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:
@@ -729,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]
@@ -759,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)
@@ -1023,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)
 
@@ -1122,13 +1161,31 @@ class PacbioSampleSequencingMetrics(SampleRunMetrics):
     polymerase_mean_read_length: Mapped[BigInt]
 
     __mapper_args__ = {"polymorphic_identity": DeviceType.PACBIO}
-    instrument_run = orm.relationship(PacbioSequencingRun, back_populates="sample_metrics")
+    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-80.1.0.dist-info → cg-83.14.0.dist-info}/METADATA

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