nominal 1.108.0__py3-none-any.whl → 1.110.0__py3-none-any.whl

CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## [1.110.0](https://github.com/nominal-io/nominal-client/compare/v1.109.0...v1.110.0) (2026-01-23)
+
+
+### Features
+
+* add data review/checklist methods to assets and runs ([#567](https://github.com/nominal-io/nominal-client/issues/567)) ([4b080d9](https://github.com/nominal-io/nominal-client/commit/4b080d96700fc51555b69a093d592cb03b92e073))
+* add video clone capability in experimental and refactor video methods ([#576](https://github.com/nominal-io/nominal-client/issues/576)) ([f58a89c](https://github.com/nominal-io/nominal-client/commit/f58a89c1fe2220677f439fdf306f0c743e441548))
+
+
+### Bug Fixes
+
+* properly handle dataset files in the new deletion states ([#590](https://github.com/nominal-io/nominal-client/issues/590)) ([e71bcc9](https://github.com/nominal-io/nominal-client/commit/e71bcc9f8fd752257dc2b33789380f0ffb7c5410))
+
+## [1.109.0](https://github.com/nominal-io/nominal-client/compare/v1.108.0...v1.109.0) (2026-01-23)
+
+
+### Features
+
+* clone channels when cloning datasets ([#587](https://github.com/nominal-io/nominal-client/issues/587)) ([ab6de09](https://github.com/nominal-io/nominal-client/commit/ab6de0962c55e2c0a6933d6b9f94fb36f5e91273))
+
 ## [1.108.0](https://github.com/nominal-io/nominal-client/compare/v1.107.0...v1.108.0) (2026-01-22)
 
 

nominal/core/_checklist_types.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from enum import IntEnum
+
+from nominal_api import scout_api
+
+
+class Priority(IntEnum):
+    P0 = 0
+    P1 = 1
+    P2 = 2
+    P3 = 3
+    P4 = 4
+
+    @classmethod
+    def _from_conjure(cls, priority: scout_api.Priority) -> Priority:
+        match priority.name:
+            case "P0":
+                return cls.P0
+            case "P1":
+                return cls.P1
+            case "P2":
+                return cls.P2
+            case "P3":
+                return cls.P3
+            case "P4":
+                return cls.P4
+            case _:
+                raise ValueError(f"unknown priority '{priority}', expected one of {list(cls)}")
+
+    def _to_conjure(self) -> scout_api.Priority:
+        match self:
+            case Priority.P0:
+                return scout_api.Priority.P0
+            case Priority.P1:
+                return scout_api.Priority.P1
+            case Priority.P2:
+                return scout_api.Priority.P2
+            case Priority.P3:
+                return scout_api.Priority.P3
+            case Priority.P4:
+                return scout_api.Priority.P4
+            case _:
+                raise ValueError(f"unknown priority '{self}', expected one of {list(Priority)}")
+
+
+def _conjure_priority_to_priority(priority: scout_api.Priority) -> Priority:
+    return Priority._from_conjure(priority)

nominal/core/_utils/api_tools.py

@@ -5,13 +5,15 @@ import importlib.metadata
 import logging
 import platform
 import sys
-from typing import Any, Generic, Mapping, Protocol, Sequence, TypeAlias, TypedDict, TypeVar, runtime_checkable
+from typing import Any, Generic, Literal, Mapping, Protocol, Sequence, TypeAlias, TypedDict, TypeVar, runtime_checkable
 
-from nominal_api import scout_compute_api, scout_run_api
+from nominal_api import scout_asset_api, scout_compute_api, scout_run_api
 from typing_extensions import NotRequired, Self
 
 from nominal._utils.dataclass_tools import update_dataclass
 
+ScopeTypeSpecifier: TypeAlias = Literal["connection", "dataset", "video"]
+
 logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
@@ -94,3 +96,15 @@ def create_api_tags(tags: Mapping[str, str] | None = None) -> dict[str, scout_co
         return {}
 
     return {key: scout_compute_api.StringConstant(literal=value) for key, value in tags.items()}
+
+
+def filter_scopes(
+    scopes: Sequence[scout_asset_api.DataScope], scope_type: ScopeTypeSpecifier
+) -> Sequence[scout_asset_api.DataScope]:
+    return [scope for scope in scopes if scope.data_source.type.lower() == scope_type]
+
+
+def filter_scope_rids(scopes: Sequence[scout_asset_api.DataScope], scope_type: ScopeTypeSpecifier) -> Mapping[str, str]:
+    return {
+        scope.data_scope_name: getattr(scope.data_source, scope_type) for scope in filter_scopes(scopes, scope_type)
+    }

nominal/core/_video_types.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+from nominal.ts import IntegralNanosecondsUTC
+
+
+@dataclass(init=True, repr=False, eq=False, order=False, unsafe_hash=False)
+class McapVideoDetails:
+    mcap_channel_locator_topic: str
+
+
+@dataclass(init=True, repr=False, eq=False, order=False, unsafe_hash=False)
+class TimestampOptions:
+    starting_timestamp: IntegralNanosecondsUTC
+    ending_timestamp: IntegralNanosecondsUTC
+    scaling_factor: float
+    true_framerate: float

nominal/core/asset.py

@@ -4,7 +4,7 @@ import datetime
 import logging
 from dataclasses import dataclass, field
 from types import MappingProxyType
-from typing import Iterable, Literal, Mapping, Protocol, Sequence, TypeAlias
+from typing import Iterable, Mapping, Protocol, Sequence, TypeAlias
 
 from nominal_api import (
     event,
@@ -15,6 +15,7 @@ from nominal_api import (
 )
 from typing_extensions import Self
 
+from nominal.core import data_review, streaming_checklist
 from nominal.core._clientsbunch import HasScoutParams
 from nominal.core._event_types import EventType, SearchEventOriginType
 from nominal.core._utils.api_tools import (
@@ -22,7 +23,10 @@ from nominal.core._utils.api_tools import (
     Link,
     LinkDict,
     RefreshableMixin,
+    ScopeTypeSpecifier,
     create_links,
+    filter_scope_rids,
+    filter_scopes,
     rid_from_instance_or_string,
 )
 from nominal.core._utils.pagination_tools import search_runs_by_asset_paginated
@@ -35,25 +39,10 @@ from nominal.core.video import Video, _create_video, _get_video
 from nominal.ts import IntegralNanosecondsDuration, IntegralNanosecondsUTC, _SecondsNanos
 
 ScopeType: TypeAlias = Connection | Dataset | Video
-ScopeTypeSpecifier: TypeAlias = Literal["connection", "dataset", "video"]
 
 logger = logging.getLogger(__name__)
 
 
-def _filter_scopes(
-    scopes: Sequence[scout_asset_api.DataScope], scope_type: ScopeTypeSpecifier
-) -> Sequence[scout_asset_api.DataScope]:
-    return [scope for scope in scopes if scope.data_source.type.lower() == scope_type]
-
-
-def _filter_scope_rids(
-    scopes: Sequence[scout_asset_api.DataScope], scope_type: ScopeTypeSpecifier
-) -> Mapping[str, str]:
-    return {
-        scope.data_scope_name: getattr(scope.data_source, scope_type) for scope in _filter_scopes(scopes, scope_type)
-    }
-
-
 @dataclass(frozen=True)
 class Asset(_DatasetWrapper, HasRid, RefreshableMixin[scout_asset_api.Asset]):
     rid: str
@@ -70,6 +59,7 @@ class Asset(_DatasetWrapper, HasRid, RefreshableMixin[scout_asset_api.Asset]):
         Video._Clients,
         Attachment._Clients,
         Event._Clients,
+        data_review.DataReview._Clients,
         HasScoutParams,
         Protocol,
     ):
@@ -94,11 +84,11 @@ class Asset(_DatasetWrapper, HasRid, RefreshableMixin[scout_asset_api.Asset]):
         return response[self.rid]
 
     def _list_dataset_scopes(self) -> Sequence[scout_asset_api.DataScope]:
-        return _filter_scopes(self._get_latest_api().data_scopes, "dataset")
+        return filter_scopes(self._get_latest_api().data_scopes, "dataset")
 
     def _scope_rids(self, scope_type: ScopeTypeSpecifier) -> Mapping[str, str]:
         asset = self._get_latest_api()
-        return _filter_scope_rids(asset.data_scopes, scope_type)
+        return filter_scope_rids(asset.data_scopes, scope_type)
 
     def update(
         self,
@@ -540,6 +530,32 @@ class Asset(_DatasetWrapper, HasRid, RefreshableMixin[scout_asset_api.Asset]):
             origin_types=origin_types,
         )
 
+    def search_data_reviews(
+        self,
+        runs: Sequence[Run | str] | None = None,
+    ) -> Sequence[data_review.DataReview]:
+        """Search for data reviews associated with this Asset. See nominal.core.client.search_data_reviews
+        for details.
+        """
+        return list(
+            data_review._iter_search_data_reviews(
+                self._clients,
+                assets=[self.rid],
+                runs=[rid_from_instance_or_string(run) for run in (runs or [])],
+            )
+        )
+
+    def list_streaming_checklists(self) -> Sequence[str]:
+        """List all Streaming Checklists associated with this Asset. See
+        nominal.core.client.list_streaming_checklists for details.
+        """
+        return list(
+            streaming_checklist._iter_list_streaming_checklists(
+                self._clients,
+                asset_rid=self.rid,
+            )
+        )
+
     def remove_attachments(self, attachments: Iterable[Attachment] | Iterable[str]) -> None:
         """Remove attachments from this asset.
         Does not remove the attachments from Nominal.

nominal/core/checklist.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from datetime import timedelta
-from typing import Literal, Mapping, Protocol, Sequence
+from typing import Mapping, Protocol, Sequence
 
 from nominal_api import (
-    scout_api,
+    event,
+    scout,
     scout_checklistexecution_api,
     scout_checks_api,
     scout_datareview_api,
@@ -13,11 +14,11 @@ from nominal_api import (
 )
 from typing_extensions import Self
 
+from nominal.core import run as core_run
 from nominal.core._clientsbunch import HasScoutParams
 from nominal.core._utils.api_tools import HasRid, rid_from_instance_or_string
 from nominal.core.asset import Asset
 from nominal.core.data_review import DataReview
-from nominal.core.run import Run
 from nominal.ts import _to_api_duration
 
 
@@ -30,13 +31,17 @@ class Checklist(HasRid):
     labels: Sequence[str]
     _clients: _Clients = field(repr=False)
 
-    class _Clients(DataReview._Clients, HasScoutParams, Protocol):
+    class _Clients(HasScoutParams, Protocol):
         @property
         def checklist(self) -> scout_checks_api.ChecklistService: ...
         @property
         def checklist_execution(self) -> scout_checklistexecution_api.ChecklistExecutionService: ...
         @property
         def datareview(self) -> scout_datareview_api.DataReviewService: ...
+        @property
+        def event(self) -> event.EventService: ...
+        @property
+        def run(self) -> scout.RunService: ...
 
     @classmethod
     def _from_conjure(cls, clients: _Clients, checklist: scout_checks_api.VersionedChecklist) -> Self:
@@ -53,7 +58,7 @@ class Checklist(HasRid):
             _clients=clients,
         )
 
-    def execute(self, run: Run | str, commit: str | None = None) -> DataReview:
+    def execute(self, run: core_run.Run | str, commit: str | None = None) -> DataReview:
         """Execute a checklist against a run.
 
         Args:
@@ -152,26 +157,7 @@ class Checklist(HasRid):
         """Returns a link to the page for this checklist in the Nominal app"""
         return f"{self._clients.app_base_url}/checklists/{self.rid}"
 
-    def preview_for_run_url(self, run: Run | str) -> str:
+    def preview_for_run_url(self, run: core_run.Run | str) -> str:
         """Returns a link to the page for previewing this checklist on a given run in the Nominal app"""
         run_rid = rid_from_instance_or_string(run)
         return f"{self.nominal_url}?previewRunRid={run_rid}"
-
-
-Priority = Literal[0, 1, 2, 3, 4]
-
-
-_priority_to_conjure_map: dict[Priority, scout_api.Priority] = {
-    0: scout_api.Priority.P0,
-    1: scout_api.Priority.P1,
-    2: scout_api.Priority.P2,
-    3: scout_api.Priority.P3,
-    4: scout_api.Priority.P4,
-}
-
-
-def _conjure_priority_to_priority(priority: scout_api.Priority) -> Priority:
-    inverted_map = {v: k for k, v in _priority_to_conjure_map.items()}
-    if priority in inverted_map:
-        return inverted_map[priority]
-    raise ValueError(f"unknown priority '{priority}', expected one of {_priority_to_conjure_map.values()}")

nominal/core/client.py

@@ -48,11 +48,8 @@ from nominal.core._utils.multipart import (
     upload_multipart_io,
 )
 from nominal.core._utils.pagination_tools import (
-    list_streaming_checklists_for_asset_paginated,
-    list_streaming_checklists_paginated,
     search_assets_paginated,
     search_checklists_paginated,
-    search_data_reviews_paginated,
     search_datasets_paginated,
     search_runs_by_asset_paginated,
     search_runs_paginated,
@@ -84,7 +81,7 @@ from nominal.core.containerized_extractors import (
     FileExtractionInput,
     FileOutputFormat,
 )
-from nominal.core.data_review import DataReview, DataReviewBuilder
+from nominal.core.data_review import DataReview, DataReviewBuilder, _iter_search_data_reviews
 from nominal.core.dataset import (
     Dataset,
     _create_dataset,
@@ -97,6 +94,7 @@ from nominal.core.exceptions import NominalConfigError, NominalError, NominalMet
 from nominal.core.filetype import FileType, FileTypes
 from nominal.core.run import Run, _create_run
 from nominal.core.secret import Secret
+from nominal.core.streaming_checklist import _iter_list_streaming_checklists
 from nominal.core.unit import Unit, _available_units
 from nominal.core.user import User
 from nominal.core.video import Video, _create_video
@@ -1162,21 +1160,17 @@ class NominalClient:
         )
         return list(self._iter_search_assets(query))
 
-    def _iter_list_streaming_checklists(self, asset: str | None) -> Iterable[str]:
-        if asset is None:
-            return list_streaming_checklists_paginated(self._clients.checklist_execution, self._clients.auth_header)
-        return list_streaming_checklists_for_asset_paginated(
-            self._clients.checklist_execution, self._clients.auth_header, asset
-        )
-
-    def list_streaming_checklists(self, asset: Asset | str | None = None) -> Iterable[str]:
+    def list_streaming_checklists(self, asset: Asset | str | None = None) -> Sequence[str]:
         """List all Streaming Checklists.
 
         Args:
             asset: if provided, only return checklists associated with the given asset.
+
+        Returns:
+            All streaming checklist RIDs that match the provided conditions
         """
-        asset = None if asset is None else rid_from_instance_or_string(asset)
-        return list(self._iter_list_streaming_checklists(asset))
+        asset_rid = None if asset is None else rid_from_instance_or_string(asset)
+        return list(_iter_list_streaming_checklists(self._clients, asset_rid))
 
     def data_review_builder(self) -> DataReviewBuilder:
         return DataReviewBuilder([], [], [], _clients=self._clients)
@@ -1220,27 +1214,29 @@ class NominalClient:
         responses = self._clients.event.batch_get_events(self._clients.auth_header, list(rids))
         return [Event._from_conjure(self._clients, response) for response in responses]
 
-    def _iter_search_data_reviews(
-        self,
-        assets: Sequence[Asset | str] | None = None,
-        runs: Sequence[Run | str] | None = None,
-    ) -> Iterable[DataReview]:
-        for review in search_data_reviews_paginated(
-            self._clients.datareview,
-            self._clients.auth_header,
-            assets=[rid_from_instance_or_string(asset) for asset in assets] if assets else None,
-            runs=[rid_from_instance_or_string(run) for run in runs] if runs else None,
-        ):
-            yield DataReview._from_conjure(self._clients, review)
-
     def search_data_reviews(
         self,
         assets: Sequence[Asset | str] | None = None,
         runs: Sequence[Run | str] | None = None,
     ) -> Sequence[DataReview]:
-        """Search for any data reviews present within a collection of runs and assets."""
+        """Search for data reviews meeting the specified filters.
+        Filters are ANDed together, e.g. `(data_review.asset == asset) AND (data_review.run == run)`
+
+        Args:
+            assets: List of assets that must be associated with a data review to be included.
+            runs: List of runs that must be associated with a data review to be included.
+
+        Returns:
+            All data reviews which match all of the provided conditions
+        """
         # TODO (drake-nominal): Expose checklist_refs to users
-        return list(self._iter_search_data_reviews(assets, runs))
+        return list(
+            _iter_search_data_reviews(
+                clients=self._clients,
+                assets=[rid_from_instance_or_string(asset) for asset in assets] if assets else None,
+                runs=[rid_from_instance_or_string(run) for run in runs] if runs else None,
+            )
+        )
 
     def search_events(
         self,

nominal/core/data_review.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from datetime import timedelta
 from time import sleep
-from typing import Protocol, Sequence
+from typing import TYPE_CHECKING, Iterable, Protocol, Sequence
 
 from nominal_api import (
     event as event_api,
@@ -18,14 +18,19 @@ from nominal_api import (
 )
 from typing_extensions import Self, deprecated
 
-from nominal.core import checklist, event
+from nominal.core._checklist_types import Priority, _conjure_priority_to_priority
 from nominal.core._clientsbunch import HasScoutParams
 from nominal.core._utils.api_tools import HasRid, rid_from_instance_or_string
-from nominal.core.asset import Asset
+from nominal.core._utils.pagination_tools import search_data_reviews_paginated
+from nominal.core.event import Event
 from nominal.core.exceptions import NominalMethodRemovedError
-from nominal.core.run import Run
 from nominal.ts import IntegralNanosecondsUTC, _SecondsNanos
 
+if TYPE_CHECKING:
+    from nominal.core.asset import Asset
+    from nominal.core.checklist import Checklist
+    from nominal.core.run import Run
+
 
 @dataclass(frozen=True)
 class DataReview(HasRid):
@@ -66,8 +71,10 @@ class DataReview(HasRid):
             _clients=clients,
         )
 
-    def get_checklist(self) -> checklist.Checklist:
-        return checklist.Checklist._from_conjure(
+    def get_checklist(self) -> "Checklist":
+        from nominal.core.checklist import Checklist
+
+        return Checklist._from_conjure(
             self._clients,
             self._clients.checklist.get(self._clients.auth_header, self.checklist_rid, commit=self.checklist_commit),
         )
@@ -83,7 +90,7 @@ class DataReview(HasRid):
             "use 'nominal.core.DataReview.get_events()' instead",
         )
 
-    def get_events(self) -> Sequence[event.Event]:
+    def get_events(self) -> Sequence[Event]:
         """Retrieves the list of events for the data review."""
         data_review_response = self._clients.datareview.get(self._clients.auth_header, self.rid).check_evaluations
         all_event_rids = [
@@ -93,7 +100,7 @@ class DataReview(HasRid):
             for event_rid in check.state._generated_alerts.event_rids
         ]
         event_response = self._clients.event.batch_get_events(self._clients.auth_header, all_event_rids)
-        return [event.Event._from_conjure(self._clients, data_review_event) for data_review_event in event_response]
+        return [Event._from_conjure(self._clients, data_review_event) for data_review_event in event_response]
 
     def reload(self) -> DataReview:
         """Reloads the data review from the server."""
@@ -137,7 +144,7 @@ class CheckViolation:
     name: str
     start: IntegralNanosecondsUTC
     end: IntegralNanosecondsUTC | None
-    priority: checklist.Priority | None
+    priority: Priority | None
 
     @classmethod
     def _from_conjure(cls, check_alert: scout_datareview_api.CheckAlert) -> CheckViolation:
@@ -147,7 +154,7 @@ class CheckViolation:
             name=check_alert.name,
             start=_SecondsNanos.from_api(check_alert.start).to_nanoseconds(),
             end=_SecondsNanos.from_api(check_alert.end).to_nanoseconds() if check_alert.end is not None else None,
-            priority=checklist._conjure_priority_to_priority(check_alert.priority)
+            priority=_conjure_priority_to_priority(check_alert.priority)
             if check_alert.priority is not scout_api.Priority.UNKNOWN
             else None,
         )
@@ -192,7 +199,7 @@ class DataReviewBuilder:
     def execute_checklist(
         self,
         run: str | Run,
-        checklist: str | checklist.Checklist,
+        checklist: str | Checklist,
         *,
         commit: str | None = None,
         asset: str | Asset | None = None,
@@ -273,3 +280,17 @@ def poll_until_completed(
     data_reviews: Sequence[DataReview], interval: timedelta = timedelta(seconds=2)
 ) -> Sequence[DataReview]:
     return [review.poll_for_completion(interval) for review in data_reviews]
+
+
+def _iter_search_data_reviews(
+    clients: DataReview._Clients,
+    assets: Sequence[str] | None = None,
+    runs: Sequence[str] | None = None,
+) -> Iterable[DataReview]:
+    for review in search_data_reviews_paginated(
+        clients.datareview,
+        clients.auth_header,
+        assets=assets,
+        runs=runs,
+    ):
+        yield DataReview._from_conjure(clients, review)

nominal/core/dataset_file.py

@@ -280,6 +280,8 @@ class IngestStatus(Enum):
     SUCCESS = "SUCCESS"
     IN_PROGRESS = "IN_PROGRESS"
     FAILED = "FAILED"
+    DELETION_IN_PROGRESS = "DELETION_IN_PROGRESS"
+    DELETED = "DELETED"
 
     @classmethod
     def _from_conjure(cls, status: api.IngestStatusV2) -> IngestStatus:
@@ -289,6 +291,10 @@ class IngestStatus(Enum):
             return cls.IN_PROGRESS
         elif status.error is not None:
             return cls.FAILED
+        elif status.deletion_in_progress is not None:
+            return cls.DELETION_IN_PROGRESS
+        elif status.deleted is not None:
+            return cls.DELETED
         raise ValueError(f"Unknown ingest status: {status.type}")
 
 

nominal/core/run.py

@@ -3,16 +3,17 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from types import MappingProxyType
-from typing import Iterable, Mapping, Protocol, Sequence, cast
+from typing import TYPE_CHECKING, Iterable, Mapping, Protocol, Sequence, cast
 
 from nominal_api import (
+    event,
+    scout,
     scout_asset_api,
+    scout_assets,
     scout_run_api,
 )
 from typing_extensions import Self
 
-from nominal.core import asset as core_asset
-from nominal.core._clientsbunch import HasScoutParams
 from nominal.core._event_types import EventType
 from nominal.core._utils.api_tools import (
     HasRid,
@@ -20,16 +21,20 @@ from nominal.core._utils.api_tools import (
     LinkDict,
     RefreshableMixin,
     create_links,
+    filter_scopes,
     rid_from_instance_or_string,
 )
-from nominal.core.asset import _filter_scopes
 from nominal.core.attachment import Attachment, _iter_get_attachments
 from nominal.core.connection import Connection, _get_connections
 from nominal.core.dataset import Dataset, _DatasetWrapper, _get_datasets
+from nominal.core.datasource import DataSource
 from nominal.core.event import Event, _create_event
 from nominal.core.video import Video, _get_video
 from nominal.ts import IntegralNanosecondsDuration, IntegralNanosecondsUTC, _SecondsNanos, _to_api_duration
 
+if TYPE_CHECKING:
+    from nominal.core.asset import Asset
+
 
 @dataclass(frozen=True)
 class Run(HasRid, RefreshableMixin[scout_run_api.Run], _DatasetWrapper):
@@ -48,11 +53,17 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run], _DatasetWrapper):
     _clients: _Clients = field(repr=False)
 
     class _Clients(
-        core_asset.Asset._Clients,
-        HasScoutParams,
+        Attachment._Clients,
+        DataSource._Clients,
+        Video._Clients,
         Protocol,
     ):
-        pass
+        @property
+        def assets(self) -> scout_assets.AssetService: ...
+        @property
+        def event(self) -> event.EventService: ...
+        @property
+        def run(self) -> scout.RunService: ...
 
     @property
     def nominal_url(self) -> str:
@@ -105,7 +116,7 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run], _DatasetWrapper):
         if len(api_run.assets) > 1:
             raise RuntimeError("Can't retrieve dataset scopes on multi-asset runs")
 
-        return _filter_scopes(api_run.asset_data_scopes, "dataset")
+        return filter_scopes(api_run.asset_data_scopes, "dataset")
 
     def _list_datasource_rids(
         self, datasource_type: str | None = None, property_name: str | None = None
@@ -350,13 +361,16 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run], _DatasetWrapper):
         """List a sequence of Attachments associated with this Run."""
         return list(self._iter_list_attachments())
 
-    def _iter_list_assets(self) -> Iterable[core_asset.Asset]:
+    def _iter_list_assets(self) -> Iterable["Asset"]:
+        from nominal.core.asset import Asset
+
+        clients = cast(Asset._Clients, self._clients)
         run = self._get_latest_api()
         assets = self._clients.assets.get_assets(self._clients.auth_header, run.assets)
         for a in assets.values():
-            yield core_asset.Asset._from_conjure(self._clients, a)
+            yield Asset._from_conjure(clients, a)
 
-    def list_assets(self) -> Sequence[core_asset.Asset]:
+    def list_assets(self) -> Sequence["Asset"]:
         """List assets associated with this run."""
         return list(self._iter_list_assets())
 

nominal/core/streaming_checklist.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Iterable, Protocol
+
+from nominal_api import scout_checklistexecution_api
+
+from nominal.core._clientsbunch import HasScoutParams
+from nominal.core._utils.pagination_tools import (
+    list_streaming_checklists_for_asset_paginated,
+    list_streaming_checklists_paginated,
+)
+
+
+class _Clients(HasScoutParams, Protocol):
+    @property
+    def checklist_execution(self) -> scout_checklistexecution_api.ChecklistExecutionService: ...
+
+
+def _iter_list_streaming_checklists(
+    clients: _Clients,
+    asset_rid: str | None = None,
+) -> Iterable[str]:
+    if asset_rid is None:
+        return list_streaming_checklists_paginated(clients.checklist_execution, clients.auth_header)
+    return list_streaming_checklists_for_asset_paginated(clients.checklist_execution, clients.auth_header, asset_rid)

nominal/core/video.py

@@ -8,9 +8,9 @@ from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from io import BytesIO, TextIOBase, TextIOWrapper
 from types import MappingProxyType
-from typing import BinaryIO, Mapping, Protocol, Sequence
+from typing import BinaryIO, Mapping, Protocol, Sequence, overload
 
-from nominal_api import api, ingest_api, scout_video, scout_video_api, upload_api
+from nominal_api import api, ingest_api, scout_catalog, scout_video, scout_video_api, upload_api
 from typing_extensions import Self
 
 from nominal.core._clientsbunch import HasScoutParams
@@ -44,6 +44,8 @@ class Video(HasRid, RefreshableMixin[scout_video_api.Video]):
         def ingest(self) -> ingest_api.IngestService: ...
         @property
         def video_file(self) -> scout_video.VideoFileService: ...
+        @property
+        def catalog(self) -> scout_catalog.CatalogService: ...
 
     def poll_until_ingestion_completed(self, interval: timedelta = timedelta(seconds=1)) -> None:
         """Block until video ingestion has completed.
@@ -117,18 +119,38 @@ class Video(HasRid, RefreshableMixin[scout_video_api.Video]):
         """Unarchives this video, allowing it to show up in the 'All Videos' pane in the UI."""
         self._clients.video.unarchive(self._clients.auth_header, self.rid)
 
+    @overload
+    def add_file(
+        self,
+        path: PathLike,
+        *,
+        start: datetime | IntegralNanosecondsUTC,
+        description: str | None = None,
+    ) -> VideoFile: ...
+
+    @overload
     def add_file(
         self,
         path: PathLike,
+        *,
+        frame_timestamps: Sequence[IntegralNanosecondsUTC],
+        description: str | None = None,
+    ) -> VideoFile: ...
+
+    def add_file(
+        self,
+        path: PathLike,
+        *,
         start: datetime | IntegralNanosecondsUTC | None = None,
         frame_timestamps: Sequence[IntegralNanosecondsUTC] | None = None,
         description: str | None = None,
     ) -> VideoFile:
-        """Append to a video from a file-path to H264-encoded video data.
+        """Append to a video from a file-path to H264-encoded video data. Only one of start or frame_timestamps
+        is allowed.
 
         Args:
             path: Path to the video file to add to an existing video within Nominal
-            start: Starting timestamp of the video file in absolute UTC time
+            start: Starting timestamp of the video file in absolute UTC time.
             frame_timestamps: Per-frame absolute nanosecond timestamps. Most usecases should instead use the 'start'
                 parameter, unless precise per-frame metadata is available and desired.
             description: Description of the video file.
@@ -141,16 +163,46 @@ class Video(HasRid, RefreshableMixin[scout_video_api.Video]):
         file_type = FileType.from_video(path)
 
         with path.open("rb") as video_file:
-            return self.add_from_io(
-                video_file,
-                name=path_upload_name(path, file_type),
-                start=start,
-                frame_timestamps=frame_timestamps,
-                description=description,
-                file_type=file_type,
-            )
+            if start is not None:
+                return self.add_from_io(
+                    video_file,
+                    name=path_upload_name(path, file_type),
+                    start=start,
+                    description=description,
+                    file_type=file_type,
+                )
+            elif frame_timestamps is not None:
+                return self.add_from_io(
+                    video_file,
+                    name=path_upload_name(path, file_type),
+                    frame_timestamps=frame_timestamps,
+                    description=description,
+                    file_type=file_type,
+                )
+            else:  # This should never be reached due to the validation above
+                raise ValueError("Either 'start' or 'frame_timestamps' must be provided")
 
-    add_file_to_video = add_file
+    @overload
+    def add_from_io(
+        self,
+        video: BinaryIO,
+        name: str,
+        *,
+        start: datetime | IntegralNanosecondsUTC,
+        description: str | None = None,
+        file_type: tuple[str, str] | FileType = FileTypes.MP4,
+    ) -> VideoFile: ...
+
+    @overload
+    def add_from_io(
+        self,
+        video: BinaryIO,
+        name: str,
+        *,
+        frame_timestamps: Sequence[IntegralNanosecondsUTC],
+        description: str | None = None,
+        file_type: tuple[str, str] | FileType = FileTypes.MP4,
+    ) -> VideoFile: ...
 
     def add_from_io(
         self,
@@ -179,6 +231,12 @@ class Video(HasRid, RefreshableMixin[scout_video_api.Video]):
         if isinstance(video, TextIOBase):
             raise TypeError(f"video {video} must be open in binary mode, rather than text mode")
 
+        # Validation: ensure exactly one of start or frame_timestamps is provided
+        if start is None and frame_timestamps is None:
+            raise ValueError("Either 'start' or 'frame_timestamps' must be provided")
+        if start is not None and frame_timestamps is not None:
+            raise ValueError("Only one of 'start' or 'frame_timestamps' may be provided")
+
         timestamp_manifest = _build_video_file_timestamp_manifest(
             self._clients.auth_header, self._clients.workspace_rid, self._clients.upload, start, frame_timestamps
         )

nominal/core/video_file.py

@@ -4,13 +4,14 @@ import logging
 import time
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
-from typing import Protocol
+from typing import Protocol, Tuple
 
-from nominal_api import scout_video, scout_video_api
+from nominal_api import scout_catalog, scout_video, scout_video_api
 from typing_extensions import Self
 
 from nominal.core._clientsbunch import HasScoutParams
 from nominal.core._utils.api_tools import HasRid, RefreshableMixin
+from nominal.core._video_types import McapVideoDetails, TimestampOptions
 from nominal.core.exceptions import NominalIngestError, NominalIngestFailed
 from nominal.ts import IntegralNanosecondsUTC, _SecondsNanos
 
@@ -28,6 +29,8 @@ class VideoFile(HasRid, RefreshableMixin[scout_video_api.VideoFile]):
     class _Clients(HasScoutParams, Protocol):
         @property
         def video_file(self) -> scout_video.VideoFileService: ...
+        @property
+        def catalog(self) -> scout_catalog.CatalogService: ...
 
     def archive(self) -> None:
         """Archive the video file, disallowing it to appear when playing back the video"""
@@ -128,6 +131,63 @@ class VideoFile(HasRid, RefreshableMixin[scout_video_api.VideoFile]):
 
             time.sleep(interval.total_seconds())
 
+    def _get_file_ingest_options(self) -> Tuple[McapVideoDetails | None, TimestampOptions | None]:
+        """Get ingest options metadata for this video file.
+
+        Retrieves metadata about the video file (such as timestamps, frame rate, and scale factor)
+        that can be used when ingesting this video into a video channel. The returned options
+        are either MCAP or MISC metadata depending on the video file type.
+
+        Returns:
+            Video file ingest options (either McapVideoFileMetadata or MiscVideoFileMetadata).
+
+        Raises:
+            ValueError: If the video file has an unexpected timestamp manifest type.
+        """
+        api_video_file = self._get_latest_api()
+        if api_video_file.origin_metadata.timestamp_manifest.type == "mcap":
+            mcap_manifest = api_video_file.origin_metadata.timestamp_manifest.mcap
+            topic = (
+                mcap_manifest.mcap_channel_locator.topic
+                if mcap_manifest and mcap_manifest.mcap_channel_locator and mcap_manifest.mcap_channel_locator.topic
+                else ""
+            )
+            mcap_video_details = McapVideoDetails(
+                mcap_channel_locator_topic=topic,
+            )
+            return (mcap_video_details, None)
+        else:
+            # TODO(sean): We need to add support for if starting timestamp isn't present, aka we have frame timestamps
+            # from S3.
+            if api_video_file.origin_metadata.timestamp_manifest.no_manifest is None:
+                raise NotImplementedError(
+                    f"Expected no_manifest timestamp manifest for non-MCAP video file, "
+                    f"but got type: {api_video_file._origin_metadata._timestamp_manifest._type}"
+                )
+            if api_video_file.segment_metadata is None:
+                raise ValueError(
+                    "Expected segment metadata for non-MCAP video file: %s", api_video_file.segment_metadata
+                )
+            if (
+                api_video_file.segment_metadata.max_absolute_timestamp is None
+                or api_video_file.segment_metadata.scale_factor is None
+                or api_video_file.segment_metadata.media_frame_rate is None
+            ):
+                raise ValueError(
+                    "Not all timestamp metadata is populated in segment metadata: %s", api_video_file.segment_metadata
+                )
+            video_file_ingest_options = TimestampOptions(
+                starting_timestamp=_SecondsNanos.from_api(
+                    api_video_file.origin_metadata.timestamp_manifest.no_manifest.starting_timestamp
+                ).to_nanoseconds(),
+                ending_timestamp=_SecondsNanos.from_api(
+                    api_video_file.segment_metadata.max_absolute_timestamp
+                ).to_nanoseconds(),
+                scaling_factor=api_video_file.segment_metadata.scale_factor,
+                true_framerate=api_video_file.segment_metadata.media_frame_rate,
+            )
+            return (None, video_file_ingest_options)
+
     @classmethod
     def _from_conjure(cls, clients: _Clients, video_file: scout_video_api.VideoFile) -> Self:
         return cls(

nominal/experimental/migration/migration_utils.py

@@ -4,7 +4,17 @@ import re
 import uuid
 from datetime import datetime, timedelta
 from pathlib import Path
-from typing import Any, BinaryIO, Iterable, Mapping, Sequence, TypeVar, Union, cast, overload
+from typing import (
+    Any,
+    BinaryIO,
+    Iterable,
+    Mapping,
+    Sequence,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
 
 import requests
 from conjure_python_client import ConjureBeanType, ConjureEnumType, ConjureUnionType
@@ -25,7 +35,10 @@ from nominal.core import (
 from nominal.core._event_types import EventType, SearchEventOriginType
 from nominal.core._utils.api_tools import Link, LinkDict
 from nominal.core.attachment import Attachment
+from nominal.core.filetype import FileTypes
 from nominal.core.run import Run
+from nominal.core.video import Video
+from nominal.core.video_file import VideoFile
 from nominal.experimental.dataset_utils import create_dataset_with_uuid
 from nominal.experimental.migration.migration_data_config import MigrationDatasetConfig
 from nominal.experimental.migration.migration_resources import MigrationResources
@@ -189,7 +202,10 @@ def _replace_uuids_in_obj(obj: Any, mapping: dict[str, str]) -> Any:
             elif isinstance(value, str):
                 parsed_value, was_json = _convert_if_json(value)
                 if was_json:
-                    new_obj[key] = json.dumps(_replace_uuids_in_obj(parsed_value, mapping), separators=(",", ":"))
+                    new_obj[key] = json.dumps(
+                        _replace_uuids_in_obj(parsed_value, mapping),
+                        separators=(",", ":"),
+                    )
                 else:
                     new_obj[key] = _replace_uuids_in_obj(value, mapping)
             else:
@@ -212,7 +228,9 @@ def _clone_conjure_objects_with_new_uuids(
 
 
 @overload
-def _clone_conjure_objects_with_new_uuids(objs: list[ConjureType]) -> list[ConjureType]: ...
+def _clone_conjure_objects_with_new_uuids(
+    objs: list[ConjureType],
+) -> list[ConjureType]: ...
 
 
 def _clone_conjure_objects_with_new_uuids(
@@ -303,7 +321,10 @@ def copy_workbook_template_from(
         "destination_client_workspace": destination_client.get_workspace(destination_client._clients.workspace_rid).rid
     }
     logger.debug(
-        "Cloning workbook template: %s (rid: %s)", source_template.title, source_template.rid, extra=log_extras
+        "Cloning workbook template: %s (rid: %s)",
+        source_template.title,
+        source_template.rid,
+        extra=log_extras,
     )
     raw_source_template = source_template._clients.template.get(
         source_template._clients.auth_header, source_template.rid
@@ -350,6 +371,140 @@ def copy_workbook_template_from(
     return new_workbook_template
 
 
+def copy_video_file_to_video_dataset(
+    source_video_file: VideoFile,
+    destination_video_dataset: Video,
+) -> VideoFile | None:
+    """Copy a video dataset file from the source to the destination dataset.
+
+    This method is specifically designed to handle video files, which may require special handling
+    due to their size and streaming nature. It retrieves the video file from the source dataset,
+    streams it, and uploads it to the destination dataset while maintaining all associated metadata.
+
+    Args:
+        source_video_file: The source VideoFile to copy. Must be a video file with S3 handle.
+        destination_video_dataset: The Video dataset to create the copied file in.
+
+    Returns:
+        The dataset file in the new dataset.
+    """
+    log_extras = {"destination_client_workspace": destination_video_dataset._clients.workspace_rid}
+    logger.debug("Copying video file: %s", source_video_file.name, extra=log_extras)
+
+    (mcap_video_details, timestamp_options) = source_video_file._get_file_ingest_options()
+
+    old_file_uri = source_video_file._clients.catalog.get_video_file_uri(
+        source_video_file._clients.auth_header, source_video_file.rid
+    ).uri
+
+    response = requests.get(old_file_uri, stream=True)
+    response.raise_for_status()
+
+    file_name = source_video_file.name
+    file_stem = Path(file_name).stem
+    if timestamp_options is not None:
+        new_file = destination_video_dataset.add_from_io(
+            video=cast(BinaryIO, response.raw),
+            name=file_stem,
+            start=timestamp_options.starting_timestamp,
+            description=source_video_file.description,
+        )
+        new_file.update(
+            starting_timestamp=timestamp_options.starting_timestamp,
+            ending_timestamp=timestamp_options.ending_timestamp,
+        )
+    elif mcap_video_details is not None:
+        new_file = destination_video_dataset.add_mcap_from_io(
+            mcap=cast(BinaryIO, response.raw),
+            name=file_stem,
+            topic=mcap_video_details.mcap_channel_locator_topic,
+            description=source_video_file.description,
+            file_type=FileTypes.MCAP,
+        )
+    else:
+        raise ValueError(
+            "Unsupported video file ingest options for copying video file. "
+            "Expected either _mcap_video_details or _timestamp_options to be set."
+        )
+    logger.debug(
+        "New video file created %s in video dataset: %s (rid: %s)",
+        new_file.name,
+        destination_video_dataset.name,
+        destination_video_dataset.rid,
+    )
+    return new_file
+
+
+def clone_video(source_video: Video, destination_client: NominalClient) -> Video:
+    """Clones a video, maintaining all properties and files.
+
+    Args:
+        source_video (Video): The video to copy from.
+        destination_client (NominalClient): The destination client.
+
+    Returns:
+        The cloned video.
+    """
+    return copy_video_from(
+        source_video=source_video,
+        destination_client=destination_client,
+        include_files=True,
+    )
+
+
+def copy_video_from(
+    source_video: Video,
+    destination_client: NominalClient,
+    *,
+    new_video_name: str | None = None,
+    new_video_description: str | None = None,
+    new_video_properties: dict[str, Any] | None = None,
+    new_video_labels: Sequence[str] | None = None,
+    include_files: bool = False,
+) -> Video:
+    """Copy a video from the source to the destination client.
+
+    Args:
+        source_video: The source Video to copy.
+        destination_client: The NominalClient to create the copied video in.
+        new_video_name: Optional new name for the copied video. If not provided, the original name is used.
+        new_video_description: Optional new description for the copied video.
+            If not provided, the original description is used.
+        new_video_properties: Optional new properties for the copied video. If not provided, the original
+            properties are used.
+        new_video_labels: Optional new labels for the copied video. If not provided, the original labels are used.
+        include_files: Whether to include files in the copied video.
+
+    Returns:
+        The newly created Video in the destination client.
+    """
+    log_extras = {
+        "destination_client_workspace": destination_client.get_workspace(destination_client._clients.workspace_rid).rid
+    }
+    logger.debug(
+        "Copying dataset %s (rid: %s)",
+        source_video.name,
+        source_video.rid,
+        extra=log_extras,
+    )
+    new_video = destination_client.create_video(
+        name=new_video_name if new_video_name is not None else source_video.name,
+        description=new_video_description if new_video_description is not None else source_video.description,
+        properties=new_video_properties if new_video_properties is not None else source_video.properties,
+        labels=new_video_labels if new_video_labels is not None else source_video.labels,
+    )
+    if include_files:
+        for source_file in source_video.list_files():
+            copy_video_file_to_video_dataset(source_file, new_video)
+    logger.debug(
+        "New video created: %s (rid: %s)",
+        new_video.name,
+        new_video.rid,
+        extra=log_extras,
+    )
+    return new_video
+
+
 def copy_file_to_dataset(
     source_file: DatasetFile,
     destination_dataset: Dataset,
@@ -403,7 +558,7 @@ def copy_file_to_dataset(
 
 
 def clone_dataset(source_dataset: Dataset, destination_client: NominalClient) -> Dataset:
-    """Clones a dataset, maintaining all properties and files.
+    """Clones a dataset, maintaining all properties, files, and channels.
 
     Args:
         source_dataset (Dataset): The dataset to copy from.
@@ -412,7 +567,11 @@ def clone_dataset(source_dataset: Dataset, destination_client: NominalClient) ->
     Returns:
         The cloned dataset.
     """
-    return copy_dataset_from(source_dataset=source_dataset, destination_client=destination_client, include_files=True)
+    return copy_dataset_from(
+        source_dataset=source_dataset,
+        destination_client=destination_client,
+        include_files=True,
+    )
 
 
 def copy_dataset_from(
@@ -482,10 +641,29 @@ def copy_dataset_from(
             labels=dataset_labels,
         )
 
+    if preserve_uuid:
+        channels_copied_count = 0
+        for source_channel in source_dataset.search_channels():
+            if source_channel.data_type is None:
+                logger.warning("Skipping channel %s: unknown data type", source_channel.name, extra=log_extras)
+                continue
+            new_dataset.add_channel(
+                name=source_channel.name,
+                data_type=source_channel.data_type,
+                description=source_channel.description,
+                unit=source_channel.unit,
+            )
+            channels_copied_count += 1
+        logger.info("Copied %d channels from dataset %s", channels_copied_count, source_dataset.name, extra=log_extras)
     if include_files:
         for source_file in source_dataset.list_files():
             copy_file_to_dataset(source_file, new_dataset)
-    logger.debug("New dataset created: %s (rid: %s)", new_dataset.name, new_dataset.rid, extra=log_extras)
+    logger.debug(
+        "New dataset created: %s (rid: %s)",
+        new_dataset.name,
+        new_dataset.rid,
+        extra=log_extras,
+    )
     return new_dataset
 
 
@@ -551,7 +729,12 @@ def copy_event_from(
         properties=new_properties or source_event.properties,
         labels=new_labels or source_event.labels,
     )
-    logger.debug("New event created: %s (rid: %s)", new_event.name, new_event.rid, extra=log_extras)
+    logger.debug(
+        "New event created: %s (rid: %s)",
+        new_event.name,
+        new_event.rid,
+        extra=log_extras,
+    )
     return new_event
 
 
@@ -643,6 +826,7 @@ def clone_asset(
         dataset_config=MigrationDatasetConfig(preserve_dataset_uuid=True, include_dataset_files=True),
         include_events=True,
         include_runs=True,
+        include_video=True,
     )
 
 
@@ -657,6 +841,7 @@ def copy_asset_from(
     dataset_config: MigrationDatasetConfig | None = None,
     include_events: bool = False,
     include_runs: bool = False,
+    include_video: bool = False,
 ) -> Asset:
     """Copy an asset from the source to the destination client.
 
@@ -670,6 +855,7 @@ def copy_asset_from(
         dataset_config: Configuration for dataset migration.
         include_events: Whether to include events in the copied dataset.
         include_runs: Whether to include runs in the copied asset.
+        include_video: Whether to include video in the copied asset.
 
     Returns:
         The new asset created.
@@ -677,7 +863,12 @@ def copy_asset_from(
     log_extras = {
         "destination_client_workspace": destination_client.get_workspace(destination_client._clients.workspace_rid).rid
     }
-    logger.debug("Copying asset %s (rid: %s)", source_asset.name, source_asset.rid, extra=log_extras)
+    logger.debug(
+        "Copying asset %s (rid: %s)",
+        source_asset.name,
+        source_asset.rid,
+        extra=log_extras,
+    )
     new_asset = destination_client.create_asset(
         name=new_asset_name if new_asset_name is not None else source_asset.name,
         description=new_asset_description if new_asset_description is not None else source_asset.description,
@@ -705,6 +896,18 @@ def copy_asset_from(
         for source_run in source_runs:
             copy_run_from(source_run, destination_client, new_assets=[new_asset])
 
+    if include_video:
+        for data_scope, video_dataset in source_asset.list_videos():
+            new_video_dataset = destination_client.create_video(
+                name=video_dataset.name,
+                description=video_dataset.description,
+                properties=video_dataset.properties,
+                labels=video_dataset.labels,
+            )
+            new_asset.add_video(data_scope, new_video_dataset)
+            for source_video_file in video_dataset.list_files():
+                copy_video_file_to_video_dataset(source_video_file, new_video_dataset)
+
     logger.debug("New asset created: %s (rid: %s)", new_asset, new_asset.rid, extra=log_extras)
     return new_asset
 
@@ -741,6 +944,7 @@ def copy_resources_to_destination_client(
             dataset_config=dataset_config,
             include_events=True,
             include_runs=True,
+            include_video=True,
         )
         new_assets.append(new_asset)
         new_data_scopes_and_datasets.extend(new_asset.list_datasets())

{nominal-1.108.0.dist-info → nominal-1.110.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal
-Version: 1.108.0
+Version: 1.110.0
 Summary: Automate Nominal workflows in Python
 Project-URL: Homepage, https://nominal.io
 Project-URL: Documentation, https://docs.nominal.io
@@ -20,7 +20,7 @@ Requires-Dist: cachetools>=6.1.0
 Requires-Dist: click<9,>=8
 Requires-Dist: conjure-python-client<4,>=3.1.0
 Requires-Dist: ffmpeg-python>=0.2.0
-Requires-Dist: nominal-api==0.1075.0
+Requires-Dist: nominal-api==0.1079.0
 Requires-Dist: nominal-streaming==0.5.8; platform_python_implementation == 'CPython' and python_version >= '3.10' and ((sys_platform == 'win32' and platform_machine == 'AMD64') or (sys_platform == 'darwin' and platform_machine == 'arm64') or (sys_platform == 'linux' and (platform_machine == 'x86_64' or platform_machine == 'armv7l')))
 Requires-Dist: openpyxl>=0.0.0
 Requires-Dist: pandas>=0.0.0

{nominal-1.108.0.dist-info → nominal-1.110.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-CHANGELOG.md,sha256=-ls_mO5aZCjyBFUqYkMVzrqOswFIEqKJFz7r0mqSziQ,89542
+CHANGELOG.md,sha256=Om-RWDZX7EQkqisCCqMAftphnIXM3nr7RwpP58_WZXE,90706
 LICENSE,sha256=zEGHG9mjDjaIS3I79O8mweQo-yiTbqx8jJvUPppVAwk,1067
 README.md,sha256=KKe0dxh_pHXCtB7I9G4qWGQYvot_BZU8yW6MJyuyUHM,311
 nominal/__init__.py,sha256=rbraORnXUrNn1hywLXM0XwSQCd9UmQt20PDYlsBalfE,2167
@@ -28,32 +28,35 @@ nominal/cli/util/verify_connection.py,sha256=KU17ejaDfKBLmLiZ3MZSVLyfrqNE7c6mFBv
 nominal/config/__init__.py,sha256=wV8cq8X3J4NTJ5H_uR5THaMT_NQpWQO5qCUGEb-rPnM,3157
 nominal/config/_config.py,sha256=yKq_H1iYJDoxRfLz2iXLbbVdoL0MTEY0FS4eVL12w0g,2004
 nominal/core/__init__.py,sha256=1MiCC44cxHYFofP4hf2fz4EIkepK-OAhDzpPFIzHbWw,2422
+nominal/core/_checklist_types.py,sha256=YcjvuUbQDIOYqqM5H1Eto9ws9Ivm4cPWEaeEF2Uwn1o,1361
 nominal/core/_clientsbunch.py,sha256=sn-ajYsJ2FuZGLiEYiPwkYCxLKr13w35aqWHE3TX5us,8633
 nominal/core/_constants.py,sha256=SrxgaSqAEB1MvTSrorgGam3eO29iCmRr6VIdajxX3gI,56
 nominal/core/_event_types.py,sha256=Cq_8x-zv_5EDvRo9UTbaOpenAy92bTfQxlsEuHPOhtE,3706
 nominal/core/_types.py,sha256=FktMmcQ5_rD2rbXv8_p-WISzSo8T2NtO-exsLm-iadU,122
-nominal/core/asset.py,sha256=-hNMGXiU1dPWfrzmOngbab-Hf6vfq2Rm_j0FP-woJ-s,23120
+nominal/core/_video_types.py,sha256=Cdl0sZxX3cyYtCXzsnnLWjK38hHp3_orMe6oiUU_dyc,465
+nominal/core/asset.py,sha256=S41KS_c14tFcxFLJzU3bnt958KpMSI_U524QcMCiSEE,23609
 nominal/core/attachment.py,sha256=yOtDUdkLY5MT_Rk9kUlr1yupIJN7a5pt5sJWx4RLQV8,4355
 nominal/core/bounds.py,sha256=742BWmGL3FBryRAjoiJRg2N6aVinjYkQLxN7kfnJ40Q,581
 nominal/core/channel.py,sha256=e0RtbjrXYMAqyt8noe610iIFzv30z2P7oqrwq08atD8,19558
-nominal/core/checklist.py,sha256=rO1RPDYV3o2miPKF7DcCiYpj6bUN-sdtZNhJkXzkfYE,7110
-nominal/core/client.py,sha256=Awt9WPkE-YXBfOwJMTL7Su8AZFJY3UMH7IKp5hI26YQ,68328
+nominal/core/checklist.py,sha256=TXEm9qNYCG6lU5NB5P3RAe-XmXdj1Tcsdbx_c5_spXI,6663
+nominal/core/client.py,sha256=RjMQCU8DmvHcp7lypVCFLY54caoTXu76EwN-oxaFjsw,68091
 nominal/core/connection.py,sha256=LYllr3a1H2xp8-i4MaX1M7yK8X-HnwuIkciyK9XgLtQ,5175
 nominal/core/containerized_extractors.py,sha256=fUz3-NHoNWYKqOCD15gLwGXDKVfdsW-x_kpXnkOI3BE,10224
-nominal/core/data_review.py,sha256=Z_W1Okp_FSQDiVCk6aKb9gV0EXbE2jtiQaPqc6TaL0g,11038
+nominal/core/data_review.py,sha256=8pyoJiP-6KCSSB4NE_LKjp1JfenEigHTmEVdF1xF1bA,11674
 nominal/core/dataset.py,sha256=LqofzNAlOd3S_3Aaw6b7DoY50rj6GyMHbUClIA2TmpY,46792
-nominal/core/dataset_file.py,sha256=8rCW6MO89MFbQ2NH0WtFWmJfRWeTxhmyuoGojuQQ4Qg,16545
+nominal/core/dataset_file.py,sha256=1cvEsf3IXGCOIr5kWIBBSwfHpZMAY-BEUEtewR6RjNc,16789
 nominal/core/datasource.py,sha256=i9db5OHNdfJyb3BJmhz2uJ398MfW8zx3Ek9pw5vYn3c,18739
 nominal/core/event.py,sha256=8trZXyuAqRlKedgcqSgDIimXAAJBmEfDLyHkOOBwUC0,7762
 nominal/core/exceptions.py,sha256=GUpwXRgdYamLl6684FE8ttCRHkBx6WEhOZ3NPE-ybD4,2671
 nominal/core/filetype.py,sha256=R8goHGW4SP0iO6AoQiUil2tNVuDgaQoHclftRbw44oc,5558
 nominal/core/log.py,sha256=z3hI3CIEyMwpUSWjwBsJ6a3JNGzBbsmrVusSU6uI7CY,3885
-nominal/core/run.py,sha256=IqXCP24UhdHKkss0LbXU_zAhx-7Pf2MIQI-lic_-quw,17987
+nominal/core/run.py,sha256=1mRMl4bfmhd0MUR-JkvgqqkJYU8_RDNtKX1Qh8xtNtY,18308
 nominal/core/secret.py,sha256=Ckq48m60i7rktxL9GY-nxHU5v8gHv9F1-JN7_MSf4bM,2863
+nominal/core/streaming_checklist.py,sha256=t7cilpW79hUQ86fJxiAr4Hocy9CdpLLP4azonjOi22o,844
 nominal/core/unit.py,sha256=Wa-Bvu0hD-nzxVaQJSnn5YqAfnhUd2kWw2SswXnbMHY,3161
 nominal/core/user.py,sha256=FV333TN4pQzcLh5b2CfxvBnnXyB1TrOP8Ppx1-XdaiE,481
-nominal/core/video.py,sha256=xQhDAiKzKuLsS3O6orKMvxejWVwDNK1ik56j4phMobE,16113
-nominal/core/video_file.py,sha256=dNAxFNAYwCBUiloCVt62fQymJtI_hK0NGgBXaVWqCXU,5669
+nominal/core/video.py,sha256=p5H46V-esDEEg-j6X0zKrX3_xe5yYA6PSM4MmW6z3a8,18126
+nominal/core/video_file.py,sha256=haq5Gf6V4HCP7iq-wObq5voGEx96ApJ2Ju3FPcTsv4U,8887
 nominal/core/workbook.py,sha256=lJo9ZaYm0TevAyIs239ZA-_1WUriTkj8i1lxvxH9TJw,8902
 nominal/core/workbook_template.py,sha256=PBgQjEDVVQdZMlVea99BbhHdAr_bawknSvNKhNtDAq0,7125
 nominal/core/workspace.py,sha256=_FmMu86xzIcxMt8_82oRSe3N4ss3law-rk0I0s8GMCQ,512
@@ -64,7 +67,7 @@ nominal/core/_stream/write_stream.py,sha256=Xd4VnWU9NANHu7hzknylv_d7qWoIiAOqzVtX
 nominal/core/_stream/write_stream_base.py,sha256=AxK3fAq3IBjNXZkxYFVXu3dGNWLCBhgknroMEyXqVJo,3787
 nominal/core/_utils/README.md,sha256=kWPQDc6kn-PjXFUsIH9u2nOA3RdGSXCOlxqeJSmUsPA,160
 nominal/core/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nominal/core/_utils/api_tools.py,sha256=Z--Et7NjpCH4if72WwGm45EyqyeqK2ambcBrtOSDMrY,2949
+nominal/core/_utils/api_tools.py,sha256=rFL_YsdsEhxHi8v1boDM1NCk1olngRSJjYLUd-9cG-s,3539
 nominal/core/_utils/multipart.py,sha256=0dA2XcTHuOQIyS0139O8WZiCjwePaD1sYDUmTgmWG9w,10243
 nominal/core/_utils/multipart_downloader.py,sha256=16OJEPqxCwOnfjptYdrlwQVuSUQYoe9_iiW60ZSjWos,13859
 nominal/core/_utils/networking.py,sha256=n9ZqYtnpwPCjz9C-4eixsTkrhFh-DW6lknBJlHckHhg,8200
@@ -91,7 +94,7 @@ nominal/experimental/logging/rich_log_handler.py,sha256=8yz_VtxNgJg2oiesnXz2iXoB
 nominal/experimental/migration/__init__.py,sha256=E2IgWJLwJ5bN6jbl8k5nHECKFx5aT11jKAzVYcyXn3o,460
 nominal/experimental/migration/migration_data_config.py,sha256=sPwZjyLmL-_pHvDZvQspxrfW6yNZhEsQjDVwKA8IaXM,522
 nominal/experimental/migration/migration_resources.py,sha256=Tf_7kNBeSaY8z2fTF7DAxk-9q3a7F8xXFVvxI8tTc9c,415
-nominal/experimental/migration/migration_utils.py,sha256=isvxBH7pOjvT9PuJRfoMNHGJR17TYsSapDPVSRESCys,31804
+nominal/experimental/migration/migration_utils.py,sha256=w__-709d_CDX1XrASAADYTiXb4T_Vd7lJ7sBC_f8Lto,38965
 nominal/experimental/rust_streaming/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nominal/experimental/rust_streaming/rust_write_stream.py,sha256=oQ6ixwm8ct8ZDc_qNB7AucDt8o5-_aBVlW2fFCQ_nmA,1541
 nominal/experimental/stream_v2/__init__.py,sha256=W39vK46pssx5sXvmsImMuJiEPs7iGtwrbYBI0bWnXCY,2313
@@ -110,8 +113,8 @@ nominal/thirdparty/polars/polars_export_handler.py,sha256=hGCSwXX9dC4MG01CmmjlTb
 nominal/thirdparty/tdms/__init__.py,sha256=6n2ImFr2Wiil6JM1P5Q7Mpr0VzLcnDkmup_ftNpPq-s,142
 nominal/thirdparty/tdms/_tdms.py,sha256=m4gxbpxB9MTLi2FuYvGlbUGSyDAZKFxbM3ia2x1wIz0,8746
 nominal/ts/__init__.py,sha256=hmd0ENvDhxRnzDKGLxIub6QG8LpcxCgcyAct029CaEs,21442
-nominal-1.108.0.dist-info/METADATA,sha256=BFL54ilX_SW2XErNJm9Q4kEow-SCxGdJcIVvqlJ0b5A,2307
-nominal-1.108.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nominal-1.108.0.dist-info/entry_points.txt,sha256=-mCLhxgg9R_lm5efT7vW9wuBH12izvY322R0a3TYxbE,66
-nominal-1.108.0.dist-info/licenses/LICENSE,sha256=zEGHG9mjDjaIS3I79O8mweQo-yiTbqx8jJvUPppVAwk,1067
-nominal-1.108.0.dist-info/RECORD,,
+nominal-1.110.0.dist-info/METADATA,sha256=3QUEWDIsDP87VsQbNKDgcBE238-wwKpGJFl4NSKGMi8,2307
+nominal-1.110.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nominal-1.110.0.dist-info/entry_points.txt,sha256=-mCLhxgg9R_lm5efT7vW9wuBH12izvY322R0a3TYxbE,66
+nominal-1.110.0.dist-info/licenses/LICENSE,sha256=zEGHG9mjDjaIS3I79O8mweQo-yiTbqx8jJvUPppVAwk,1067
+nominal-1.110.0.dist-info/RECORD,,