cg 83.16.4__tar.gz → 83.17.0__tar.gz

{cg-83.16.4 → cg-83.17.0}/PKG-INFO

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

cg-83.17.0/cg/__init__.py

@@ -0,0 +1,2 @@
+__title__ = "cg"
+__version__ = "83.17.0"

{cg-83.16.4 → cg-83.17.0}/cg/cli/post_process/post_process.py

@@ -6,7 +6,7 @@ import rich_click as click
 
 from cg.cli.post_process.utils import (
     UnprocessedRunInfo,
-    get_post_processing_service_from_run_name,
+    get_post_processing_service_from_run_full_name,
     get_unprocessed_runs_info,
 )
 from cg.cli.utils import CLICK_CONTEXT_SETTINGS
@@ -25,18 +25,18 @@ def post_process_group():
 
 @post_process_group.command(name="run")
 @DRY_RUN
-@click.argument("run-name")
+@click.argument("run-full-name")
 @click.pass_obj
-def post_process_run(context: CGConfig, run_name: str, dry_run: bool) -> None:
+def post_process_run(context: CGConfig, run_full_name: str, dry_run: bool) -> None:
     """Post-process a sequencing run from the PacBio instrument.
 
-    run-name is the full name of the sequencing unit of run. For example:
+    run-full-name is the full name of the sequencing unit of run. For example:
         PacBio: 'r84202_20240522_133539/1_A01'
     """
-    post_processing_service: PostProcessingService = get_post_processing_service_from_run_name(
-        context=context, run_name=run_name
+    post_processing_service: PostProcessingService = get_post_processing_service_from_run_full_name(
+        context=context, run_full_name=run_full_name
     )
-    post_processing_service.post_process(run_name=run_name, dry_run=dry_run)
+    post_processing_service.post_process(run_full_name=run_full_name, dry_run=dry_run)
 
 
 @post_process_group.command(name="all")
@@ -58,7 +58,7 @@ def post_process_all_runs(context: CGConfig, instrument: str, dry_run: bool) ->
     )
     for run in unprocessed_runs:
         try:
-            run.post_processing_service.post_process(run_name=run.name, dry_run=dry_run)
+            run.post_processing_service.post_process(run_full_name=run.name, dry_run=dry_run)
         except Exception as error:
             LOG.error(f"Could not post-process {run.instrument} run {run.name}: {error}")
             exit_success = False

{cg-83.16.4 → cg-83.17.0}/cg/cli/post_process/utils.py

@@ -25,17 +25,17 @@ class UnprocessedRunInfo(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
-def get_post_processing_service_from_run_name(
-    context: CGConfig, run_name: str
+def get_post_processing_service_from_run_full_name(
+    context: CGConfig, run_full_name: str
 ) -> PacBioPostProcessingService:
-    """Get the correct post-processing service based on the run name."""
+    """Get the correct post-processing service based on the run full name."""
     try:
         device: str = get_item_by_pattern_in_source(
-            source=run_name, pattern_map=PATTERN_TO_DEVICE_MAP
+            source=run_full_name, pattern_map=PATTERN_TO_DEVICE_MAP
         )
     except CgError as error:
         raise NameError(
-            f"Run name {run_name} does not match with any known sequencing run name pattern"
+            f"Run name {run_full_name} does not match with any known sequencing run name pattern"
         ) from error
     return getattr(context.post_processing_services, device)
 
@@ -48,7 +48,7 @@ def get_unprocessed_runs_info(context: CGConfig, instrument: str) -> list[Unproc
         run_names_service: RunNamesService = getattr(context.run_names_services, instrument_name)
         runs.extend(
             _get_unprocessed_runs_from_run_names(
-                run_names=run_names_service.get_run_names(),
+                run_full_names=run_names_service.get_run_full_names(),
                 post_processing_service=getattr(context.post_processing_services, instrument_name),
                 instrument_name=instrument_name,
             )
@@ -63,18 +63,18 @@ def _instruments_to_check(instrument: str) -> list[str]:
 
 
 def _get_unprocessed_runs_from_run_names(
-    run_names: list[str], post_processing_service: PostProcessingService, instrument_name
+    run_full_names: list[str], post_processing_service: PostProcessingService, instrument_name
 ) -> list[UnprocessedRunInfo]:
     LOG.debug(f"Adding {instrument_name} run names to the post-processing list")
     runs: list[UnprocessedRunInfo] = []
-    for name in run_names:
-        if post_processing_service.is_run_processed(name):
-            LOG.debug(f"Run {name} has already been post-processed. Skipping")
+    for full_name in run_full_names:
+        if post_processing_service.is_run_processed(full_name):
+            LOG.debug(f"Run {full_name} has already been post-processed. Skipping")
             continue
-        if post_processing_service.can_post_processing_start(name):
+        if post_processing_service.can_post_processing_start(full_name):
             runs.append(
                 UnprocessedRunInfo(
-                    name=name,
+                    name=full_name,
                     post_processing_service=post_processing_service,
                     instrument=instrument_name,
                 )

{cg-83.16.4 → cg-83.17.0}/cg/server/admin.py

@@ -911,7 +911,7 @@ class PacbioSmrtCellMetricsView(BaseView):
 
     column_list = (
         "internal_id",
-        "sequencing_run.run_name",
+        "sequencing_run.run_id",
         "movie_name",
         "well",
         "plate",
@@ -935,9 +935,9 @@ class PacbioSmrtCellMetricsView(BaseView):
         "internal_id": view_pacbio_sample_sequencing_metrics_link,
         "model": view_smrt_cell_model,
     }
-    column_labels = {"sequencing_run.run_name": "Run Name"}
+    column_labels = {"sequencing_run.run_id": "Run ID"}
     column_default_sort = ("completed_at", True)
-    column_searchable_list = ["device.internal_id", "movie_name", "sequencing_run.run_name"]
+    column_searchable_list = ["device.internal_id", "movie_name", "sequencing_run.run_id"]
     column_sortable_list = [
         ("internal_id", "device.internal_id"),
         "started_at",
@@ -967,7 +967,7 @@ class PacbioSmrtCellMetricsView(BaseView):
 class PacbioSampleRunMetricsView(BaseView):
     column_filters = [
         "instrument_run.plate",
-        "instrument_run.sequencing_run.run_name",
+        "instrument_run.sequencing_run.run_id",
     ]
     column_formatters = {
         "smrt_cell": PacbioSmrtCellMetricsView.view_smrt_cell_link,
@@ -975,12 +975,12 @@ class PacbioSampleRunMetricsView(BaseView):
     }
     column_labels = {
         "instrument_run.plate": "Plate",
-        "instrument_run.sequencing_run.run_name": "Run Name",
+        "instrument_run.sequencing_run.run_id": "Run ID",
     }
     column_list = [
         "smrt_cell",
         "sample",
-        "instrument_run.sequencing_run.run_name",
+        "instrument_run.sequencing_run.run_id",
         "instrument_run.plate",
         "hifi_reads",
         "hifi_yield",
@@ -990,5 +990,5 @@ class PacbioSampleRunMetricsView(BaseView):
     column_searchable_list = [
         "sample.internal_id",
         "instrument_run.device.internal_id",
-        "instrument_run.sequencing_run.run_name",
+        "instrument_run.sequencing_run.run_id",
     ]

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/abstract_classes.py

@@ -14,7 +14,7 @@ class RunDataGenerator(ABC):
     """Abstract class that holds functionality to create a run data object."""
 
     @abstractmethod
-    def get_run_data(self, run_name: str, sequencing_dir: str) -> RunData:
+    def get_run_data(self, run_full_name: str, sequencing_dir: str) -> RunData:
         """Get the run data for a sequencing run."""
         pass
 
@@ -87,17 +87,17 @@ class PostProcessingService(ABC):
     """Abstract class that encapsulates the logic required for post-processing a sequencing run."""
 
     @abstractmethod
-    def post_process(self, run_name: str, dry_run: bool = False):
+    def post_process(self, run_full_name: str, dry_run: bool = False):
         """Store sequencing metrics in StatusDB and relevant files in Housekeeper."""
         pass
 
     @abstractmethod
-    def is_run_processed(self, run_name: str) -> bool:
+    def is_run_processed(self, run_full_name: str) -> bool:
         """Check if a run has been post-processed."""
         pass
 
     @abstractmethod
-    def can_post_processing_start(self, run_name: str) -> bool:
+    def can_post_processing_start(self, run_full_name: str) -> bool:
         """Check if a run can be post processed."""
         pass
 

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/data_storage_service/pacbio_store_service.py

@@ -41,8 +41,8 @@ class PacBioStoreService(PostProcessingStoreService):
         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)
+            LOG.debug(f"Sequencing run {sequencing_run_dto.run_id} already exists")
+            return self.store.get_pacbio_sequencing_run_by_run_id(sequencing_run_dto.run_id)
 
     def _create_pacbio_smrt_cell_metrics(
         self,
@@ -108,5 +108,5 @@ class PacBioStoreService(PostProcessingStoreService):
                 f"Dry run, no entries will be added to database for SMRT cell {run_data.full_path}."
             )
             return
-        LOG.debug(f"Data stored in statusDB for run {run_data.sequencing_run_name}")
+        LOG.debug(f"Data stored in statusDB for run {run_data.run_id}")
         self.store.commit_to_store()

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/data_transfer_service/dto.py

@@ -12,7 +12,7 @@ class PacBioSMRTCellMetricsDTO(BaseModel):
     type: DeviceType
     well: str
     plate: int
-    run_name: str
+    run_id: str
     movie_name: str
     started_at: datetime
     completed_at: datetime
@@ -64,7 +64,7 @@ class PacBioSampleSequencingMetricsDTO(BaseModel):
 
 class PacBioSequencingRunDTO(BaseModel):
     instrument_name: RevioNames
-    run_name: str
+    run_id: str
 
 
 class PacBioDTOs(PostProcessingDTOs):

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/data_transfer_service/utils.py

@@ -22,7 +22,7 @@ def get_smrt_cell_metrics_dto(
         type=DeviceType.PACBIO,
         well=metrics.dataset_metrics.well,
         plate=metrics.dataset_metrics.plate,
-        run_name=run_data.sequencing_run_name,
+        run_id=run_data.run_id,
         started_at=metrics.dataset_metrics.run_started_at,
         completed_at=metrics.dataset_metrics.run_completed_at,
         hifi_reads=metrics.read.hifi_reads,
@@ -81,5 +81,5 @@ def get_sequencing_run_dto(
 ) -> 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,
+        run_id=run_data.run_id,
     )

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/housekeeper_service/pacbio_houskeeper_service.py

@@ -60,7 +60,7 @@ class PacBioHousekeeperService(PostProcessingHKService):
                 file_path=bundle_info.file_path,
                 tags=bundle_info.tags,
             )
-        LOG.debug(f"Files stored in Housekeeper for run {run_data.sequencing_run_name}")
+        LOG.debug(f"Files stored in Housekeeper for run {run_data.run_id}")
 
     @staticmethod
     def _get_bundle_type_for_file(file_path: Path) -> str:

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/metrics_parser/metrics_parser.py

@@ -64,7 +64,7 @@ class PacBioMetricsParser(PostProcessingMetricsParser):
             metrics_files=metrics_files, file_name=PacBioDirsAndFiles.BARCODES_REPORT
         )
         sample_metrics: list[SampleMetrics] = get_parsed_sample_metrics(metrics_files)
-        LOG.debug(f"All metrics parsed for run {run_data.sequencing_run_name}")
+        LOG.debug(f"All metrics parsed for run {run_data.run_id}")
         return PacBioMetrics(
             read=read_metrics,
             control=control_metrics,

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/post_processing_service.py

@@ -51,38 +51,43 @@ class PacBioPostProcessingService(PostProcessingService):
         ),
         to_raise=PostProcessingError,
     )
-    def post_process(self, run_name: str, dry_run: bool = False) -> None:
-        LOG.info(f"Starting Pacbio post-processing for run: {run_name}")
+    def post_process(self, run_full_name: str, dry_run: bool = False) -> None:
+        LOG.info(f"Starting Pacbio post-processing for run: {run_full_name}")
         run_data: PacBioRunData = self.run_data_generator.get_run_data(
-            run_name=run_name, sequencing_dir=self.sequencing_dir
+            run_full_name=run_full_name, sequencing_dir=self.sequencing_dir
         )
         self.run_validator.ensure_post_processing_can_start(run_data)
         self.store_service.store_post_processing_data(run_data=run_data, dry_run=dry_run)
         self.hk_service.store_files_in_housekeeper(run_data=run_data, dry_run=dry_run)
         self._touch_post_processing_complete(run_data=run_data, dry_run=dry_run)
 
-    def is_run_processed(self, run_name: str) -> bool:
+    def is_run_processed(self, run_full_name: str) -> bool:
         """Check if a run has been post-processed."""
-        processing_complete_file = Path(self.sequencing_dir, run_name, POST_PROCESSING_COMPLETED)
+        processing_complete_file = Path(
+            self.sequencing_dir, run_full_name, POST_PROCESSING_COMPLETED
+        )
         return processing_complete_file.exists()
 
-    def can_post_processing_start(self, run_name: str) -> bool:
-        LOG.debug(f"Checking if Pacbio post-processing can start for run: {run_name}")
-        parent_directory: Path = Path(self.sequencing_dir, run_name).parent
+    def can_post_processing_start(self, run_full_name: str) -> bool:
+        """Makes sure that all SMRT cells in the sequencing run are ready to be post-processed."""
+        LOG.debug(f"Checking if Pacbio post-processing can start for run: {run_full_name}")
+        parent_directory: Path = Path(self.sequencing_dir, run_full_name).parent
         all_smrt_cells_are_ready: bool = all(
             self.is_smrt_cell_ready_for_post_processing(f"{parent_directory.name}/{smrt_cell.name}")
             for smrt_cell in parent_directory.iterdir()
         )
         return all_smrt_cells_are_ready
 
-    def is_smrt_cell_ready_for_post_processing(self, run_name: str) -> bool:
-        LOG.debug(f"Checking if Pacbio SMRT-cell {run_name} is ready for postprocessing")
+    def is_smrt_cell_ready_for_post_processing(self, smrt_cell_full_name: str) -> bool:
+        LOG.debug(f"Checking if Pacbio SMRT-cell {smrt_cell_full_name} is ready for postprocessing")
         try:
             run_data: PacBioRunData = self.run_data_generator.get_run_data(
-                run_name=run_name, sequencing_dir=self.sequencing_dir
+                run_full_name=smrt_cell_full_name, sequencing_dir=self.sequencing_dir
             )
             self.run_validator.validate_run_files(run_data)
         except PostProcessingRunFileManagerError as error:
-            LOG.debug(f"Run {run_name} is not ready for post-processing. {error.args[0]}.")
+            LOG.debug(
+                f"Run {smrt_cell_full_name} is not ready for post-processing. {error.args[0]}."
+            )
             return False
         return True

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/run_data_generator/pacbio_run_data_generator.py

@@ -17,24 +17,26 @@ class PacBioRunDataGenerator(RunDataGenerator):
     @handle_post_processing_errors(
         to_except=(ValueError,), to_raise=PostProcessingRunDataGeneratorError
     )
-    def get_run_data(self, run_name: str, sequencing_dir: str) -> PacBioRunData:
+    def get_run_data(self, run_full_name: str, sequencing_dir: str) -> PacBioRunData:
         """
         Get the run data for a PacBio SMRT cell run.
-        run_name should include the PacBio run including plate well, e.g. 'r84202_20240522_133539/1_A01'
+        run_full_name should include the PacBio run including plate well, e.g. 'r84202_20240522_133539/1_A01'
         """
-        self._validate_run_name(run_name)
-        full_path = Path(sequencing_dir, run_name)
+        self._validate_run_name(run_full_name)
+        full_path = Path(sequencing_dir, run_full_name)
 
         return PacBioRunData(
             full_path=full_path,
-            sequencing_run_name=self._get_sequencing_run_name(run_name),
-            well_name=self._get_well(run_name),
-            plate=self._get_plate(run_name),
+            run_id=self._get_run_id_from_run_full_name(run_full_name),
+            well_name=self._get_well(run_full_name),
+            plate=self._get_plate(run_full_name),  # type: ignore Pydantic transforming
         )
 
     @staticmethod
-    def _get_sequencing_run_name(run_name: str) -> str:
-        return run_name.split("/")[0]
+    def _get_run_id_from_run_full_name(
+        run_full_name: str,
+    ) -> str:
+        return run_full_name.split("/")[0]
 
     @staticmethod
     def _get_plate_well(run_name: str) -> str:

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/run_data_generator/run_data.py

@@ -7,6 +7,6 @@ class PacBioRunData(RunData):
     """Holds information on a single SMRTcell of a PacBio run."""
 
     full_path: Path
-    sequencing_run_name: str
+    run_id: str
     well_name: str
     plate: int

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/pacbio/sequencing_runs_service.py

@@ -14,17 +14,16 @@ class PacbioSequencingRunsService:
         self.store = store
 
     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
+        metrics: list[PacbioSmrtCellMetricsDTO] = []
+        db_smrt_cell_metrics: list[PacbioSMRTCellMetrics] = (
+            self.store.get_pacbio_smrt_cell_metrics_by_run_id(run_name)
         )
-        for db_run in db_runs:
-            run_dict = db_run.to_dict()
-            run_dict["internal_id"] = db_run.device.internal_id
-            run_dict["run_name"] = db_run.sequencing_run.run_name
-            run = PacbioSmrtCellMetricsDTO.model_validate(run_dict)
-            runs.append(run)
-        return PacbioSmrtCellMetricsResponse(runs=runs)
+        for metric in db_smrt_cell_metrics:
+            metric_dict = metric.to_dict()
+            metric_dict["internal_id"] = metric.device.internal_id
+            metric_dict["run_name"] = metric.run_id
+            metrics.append(PacbioSmrtCellMetricsDTO.model_validate(metric_dict))
+        return PacbioSmrtCellMetricsResponse(runs=metrics)
 
     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)
@@ -32,7 +31,7 @@ class PacbioSequencingRunsService:
         for db_run in db_runs:
             run = PacbioSequencingRunDTO(
                 id=db_run.id,
-                run_name=db_run.run_name,
+                run_name=db_run.run_id,
                 comment=db_run.comment,
                 processed=db_run.processed,
             )

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/run_names/pacbio.py

@@ -5,9 +5,9 @@ from cg.services.run_devices.run_names.service import RunNamesService
 
 class PacbioRunNamesService(RunNamesService):
 
-    def get_run_names(self) -> list[str]:
+    def get_run_full_names(self) -> list[str]:
         """
-        Get all the run names from the PacBio sequencing directory in the form
+        Get all the SMRTcell full names from the PacBio sequencing directory in the form
         <sequencing_run>/<SMRTcell>, for example:
             r84202_20240913_121403/1_C01
         """

{cg-83.16.4 → cg-83.17.0}/cg/services/run_devices/run_names/service.py

@@ -7,6 +7,6 @@ class RunNamesService(ABC):
         self.run_directory = run_directory
 
     @abstractmethod
-    def get_run_names(self) -> list[str]:
+    def get_run_full_names(self) -> list[str]:
         """Get all the run names from a run directory."""
         pass

{cg-83.16.4 → cg-83.17.0}/cg/store/crud/create.py

@@ -513,17 +513,17 @@ class CreateMixin(ReadHandler):
         """
         if (
             self._get_query(table=PacbioSequencingRun)
-            .filter(PacbioSequencingRun.run_name == pacbio_sequencing_run_dto.run_name)
+            .filter(PacbioSequencingRun.run_id == pacbio_sequencing_run_dto.run_id)
             .first()
         ):
             raise PacbioSequencingRunAlreadyExistsError(
-                message=f"{pacbio_sequencing_run_dto.run_name} already exists."
+                message=f"{pacbio_sequencing_run_dto.run_id} already exists."
             )
         else:
-            LOG.debug(f"Creating Pacbio Sequencing Run for {pacbio_sequencing_run_dto.run_name}")
+            LOG.debug(f"Creating Pacbio Sequencing Run for {pacbio_sequencing_run_dto.run_id}")
             sequencing_run = PacbioSequencingRun(
                 instrument_name=pacbio_sequencing_run_dto.instrument_name,
-                run_name=pacbio_sequencing_run_dto.run_name,
+                run_id=pacbio_sequencing_run_dto.run_id,
             )
             self.add_item_to_store(sequencing_run)
             return sequencing_run

{cg-83.16.4 → cg-83.17.0}/cg/store/crud/read.py

@@ -1808,21 +1808,20 @@ class ReadHandler(BaseHandler):
             sequencing_metrics = sequencing_metrics.filter(RunDevice.internal_id.in_(smrt_cell_ids))
         return sequencing_metrics.all()
 
-    def get_pacbio_smrt_cell_metrics_by_run_name(
-        self, run_name: str
-    ) -> list[PacbioSMRTCellMetrics]:
+    def get_pacbio_smrt_cell_metrics_by_run_id(self, run_id: str) -> list[PacbioSMRTCellMetrics]:
         """
-        Fetches data from PacbioSequencingRunDTO filtered on run name.
+        Fetches data from PacbioSMRTCellMetrics filtered on run ID.
         Raises:
-            EntryNotFoundError if no sequencing runs are found for the run name
+            EntryNotFoundError if no SMRT cell metrics are found for the run ID
         """
-        runs: Query = self._get_query(table=PacbioSMRTCellMetrics).join(
-            PacbioSMRTCellMetrics.sequencing_run
+        metrics: Query = (
+            self._get_query(table=PacbioSMRTCellMetrics)
+            .join(PacbioSMRTCellMetrics.sequencing_run)
+            .filter(PacbioSequencingRun.run_id == run_id)
         )
-        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()
+        if metrics.count() == 0:
+            raise EntryNotFoundError(f"Could not find any SMRT Cell metrics for run {run_id}")
+        return metrics.all()
 
     def get_pacbio_sequencing_runs(
         self, page: int = 0, page_size: int = 0
@@ -1856,7 +1855,7 @@ class ReadHandler(BaseHandler):
 
     def get_pacbio_sequencing_run_by_id(self, id: int):
         """
-        Get Pacbio Sequencing run by id.
+        Get Pacbio Sequencing run by database id.
         Raises:
             PacbioSequencingRunNotFoundError: If no Pacbio sequencing run is found with the given id.
         """
@@ -1871,15 +1870,15 @@ class ReadHandler(BaseHandler):
                 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:
+    def get_pacbio_sequencing_run_by_run_id(self, run_id: str) -> PacbioSequencingRun:
         """
-        Get Pacbio Sequencing run by run name.
         Raises:
-            PacbioSequencingRunNotFoundError: If no Pacbio sequencing run is found with the given run name.
+            PacbioSequencingRunNotFoundError: If no Pacbio sequencing run is found with the given
+            run ID.
         """
         try:
-            return self._get_query(table=PacbioSequencingRun).filter_by(run_name=run_name).one()
+            return self._get_query(table=PacbioSequencingRun).filter_by(run_id=run_id).one()
         except sqlalchemy.orm.exc.NoResultFound:
             raise PacbioSequencingRunNotFoundError(
-                f"Pacbio Sequencing run with run_name {run_name} was not found in the database."
+                f"Pacbio Sequencing run with ID {run_id} was not found in the database."
             )

{cg-83.16.4 → cg-83.17.0}/cg/store/models.py

@@ -1113,8 +1113,8 @@ class PacbioSMRTCellMetrics(InstrumentRun):
     __mapper_args__ = {"polymorphic_identity": DeviceType.PACBIO}
 
     @property
-    def run_name(self) -> str:
-        return self.sequencing_run.run_name
+    def run_id(self) -> str:
+        return self.sequencing_run.run_id
 
     def to_dict(self):
         return to_dict(self)
@@ -1185,7 +1185,7 @@ class PacbioSequencingRun(Base):
     __tablename__ = "pacbio_sequencing_run"
 
     id: Mapped[PrimaryKeyInt]
-    run_name: Mapped[Str64] = mapped_column(unique=True)
+    run_id: 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(

{cg-83.16.4 → cg-83.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "cg"
-version = "83.16.4"
+version = "83.17.0"
 description = "Clinical Genomics command center"
 readme = {file = "README.md", content-type = "text/markdown"}
 homepage = "https://github.com/Clinical-Genomics/cg"

cg-83.16.4/cg/__init__.py

@@ -1,2 +0,0 @@
-__title__ = "cg"
-__version__ = "83.16.4"