nominal 1.100.0__py3-none-any.whl → 1.101.0__py3-none-any.whl

CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [1.101.0](https://github.com/nominal-io/nominal-client/compare/v1.100.0...v1.101.0) (2025-12-23)
+
+
+### Features
+
+* add search_events to asset ([#553](https://github.com/nominal-io/nominal-client/issues/553)) ([3d291b7](https://github.com/nominal-io/nominal-client/commit/3d291b7e4b851676de882ac88d7695e49e9da0d3))
+* added avi video file type ([#552](https://github.com/nominal-io/nominal-client/issues/552)) ([84bd35f](https://github.com/nominal-io/nominal-client/commit/84bd35ff83aa87cf8f7a718b5d71c1ca1445e9e9))
+* allow adding data directly to runs, assets ([#543](https://github.com/nominal-io/nominal-client/issues/543)) ([6630717](https://github.com/nominal-io/nominal-client/commit/6630717827a35d50ee6008ede14b9c8e355f239c))
+* allow creating events on runs, assets, _create_event helper method ([#540](https://github.com/nominal-io/nominal-client/issues/540)) ([dc84028](https://github.com/nominal-io/nominal-client/commit/dc84028d78df256f50ba58879416bb3b5f8752ed))
+* allow creating events on runs, assets, use helper method ([dc84028](https://github.com/nominal-io/nominal-client/commit/dc84028d78df256f50ba58879416bb3b5f8752ed))
+* reusable helper method for creating runs, create multi-asset runs in client ([#539](https://github.com/nominal-io/nominal-client/issues/539)) ([3118b43](https://github.com/nominal-io/nominal-client/commit/3118b43be4df552eb7418ffed08ed0afafbe88f4))
+
+
+### Bug Fixes
+
+* make rust streaming optional unless supported architecture ([#556](https://github.com/nominal-io/nominal-client/issues/556)) ([24a2b98](https://github.com/nominal-io/nominal-client/commit/24a2b98218d025affb171411a72ad80b2dd2dd87))
+
 ## [1.100.0](https://github.com/nominal-io/nominal-client/compare/v1.99.0...v1.100.0) (2025-12-19)
 
 

nominal/core/_utils/query_tools.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Iterable, Mapping, Sequence
+from typing import Mapping, Sequence
 
 from nominal_api import (
     api,
     authentication_api,
-    event,
     ingest_api,
     scout_asset_api,
     scout_catalog,
@@ -19,7 +18,6 @@ from nominal_api import (
     secrets_api,
 )
 
-from nominal.core.event import EventType
 from nominal.ts import IntegralNanosecondsUTC, _SecondsNanos
 
 
@@ -198,52 +196,6 @@ def create_search_datasets_query(
     return scout_catalog.SearchDatasetsQuery(and_=queries)
 
 
-def create_search_events_query(  # noqa: PLR0912
-    search_text: str | None = None,
-    after: str | datetime | IntegralNanosecondsUTC | None = None,
-    before: str | datetime | IntegralNanosecondsUTC | None = None,
-    assets: Iterable[str] | None = None,
-    labels: Iterable[str] | None = None,
-    properties: Mapping[str, str] | None = None,
-    created_by: str | None = None,
-    workbook: str | None = None,
-    data_review: str | None = None,
-    assignee: str | None = None,
-    event_type: EventType | None = None,
-    workspace_rid: str | None = None,
-) -> event.SearchQuery:
-    queries = []
-    if search_text is not None:
-        queries.append(event.SearchQuery(search_text=search_text))
-    if after is not None:
-        queries.append(event.SearchQuery(after=_SecondsNanos.from_flexible(after).to_api()))
-    if before is not None:
-        queries.append(event.SearchQuery(before=_SecondsNanos.from_flexible(before).to_api()))
-    if assets:
-        for asset in assets:
-            queries.append(event.SearchQuery(asset=asset))
-    if labels:
-        for label in labels:
-            queries.append(event.SearchQuery(label=label))
-    if properties:
-        for name, value in properties.items():
-            queries.append(event.SearchQuery(property=api.Property(name=name, value=value)))
-    if created_by:
-        queries.append(event.SearchQuery(created_by=created_by))
-    if workbook is not None:
-        queries.append(event.SearchQuery(workbook=workbook))
-    if data_review is not None:
-        queries.append(event.SearchQuery(data_review=data_review))
-    if assignee is not None:
-        queries.append(event.SearchQuery(assignee=assignee))
-    if event_type is not None:
-        queries.append(event.SearchQuery(event_type=event_type._to_api_event_type()))
-    if workspace_rid is not None:
-        queries.append(event.SearchQuery(workspace=workspace_rid))
-
-    return event.SearchQuery(and_=queries)
-
-
 def create_search_runs_query(
     start: str | datetime | IntegralNanosecondsUTC | None = None,
     end: str | datetime | IntegralNanosecondsUTC | None = None,

nominal/core/asset.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+import datetime
 import logging
 from dataclasses import dataclass, field
 from types import MappingProxyType
 from typing import Iterable, Literal, Mapping, Protocol, Sequence, TypeAlias, cast
 
 from nominal_api import (
+    event,
     scout,
     scout_asset_api,
     scout_assets,
@@ -18,18 +20,26 @@ from nominal.core._utils.api_tools import HasRid, Link, RefreshableMixin, create
 from nominal.core._utils.pagination_tools import search_runs_by_asset_paginated
 from nominal.core.attachment import Attachment, _iter_get_attachments
 from nominal.core.connection import Connection, _get_connections
-from nominal.core.dataset import Dataset, _create_dataset, _get_datasets
+from nominal.core.dataset import Dataset, _create_dataset, _DatasetWrapper, _get_datasets
 from nominal.core.datasource import DataSource
+from nominal.core.event import Event, EventType, _create_event, _search_events
 from nominal.core.video import Video, _create_video, _get_video
-from nominal.ts import IntegralNanosecondsUTC, _SecondsNanos
+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]
+
+
 @dataclass(frozen=True)
-class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
+class Asset(_DatasetWrapper, HasRid, RefreshableMixin[scout_asset_api.Asset]):
     rid: str
     name: str
     description: str | None
@@ -43,6 +53,7 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
         DataSource._Clients,
         Video._Clients,
         Attachment._Clients,
+        Event._Clients,
         HasScoutParams,
         Protocol,
     ):
@@ -50,6 +61,8 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
         def assets(self) -> scout_assets.AssetService: ...
         @property
         def run(self) -> scout.RunService: ...
+        @property
+        def event(self) -> event.EventService: ...
 
     @property
     def nominal_url(self) -> str:
@@ -64,6 +77,17 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
             raise ValueError(f"multiple assets found with RID {self.rid!r}: {response!r}")
         return response[self.rid]
 
+    def _list_dataset_scopes(self) -> Sequence[scout_asset_api.DataScope]:
+        return _filter_scopes(self._get_latest_api().data_scopes, "dataset")
+
+    def _scope_rid(self, stype: Literal["dataset", "video", "connection"]) -> dict[str, str]:
+        asset = self._get_latest_api()
+        return {
+            scope.data_scope_name: cast(str, getattr(scope.data_source, stype))
+            for scope in asset.data_scopes
+            if scope.data_source.type.lower() == stype
+        }
+
     def update(
         self,
         *,
@@ -97,14 +121,6 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
         api_asset = self._clients.assets.update_asset(self._clients.auth_header, request, self.rid)
         return self._refresh_from_api(api_asset)
 
-    def _scope_rid(self, stype: Literal["dataset", "video", "connection"]) -> dict[str, str]:
-        asset = self._get_latest_api()
-        return {
-            scope.data_scope_name: cast(str, getattr(scope.data_source, stype))
-            for scope in asset.data_scopes
-            if scope.data_source.type.lower() == stype
-        }
-
     def promote(self) -> Self:
         """Promote this asset to be a standard, searchable, and displayable asset.
 
@@ -329,6 +345,43 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
             self.add_video(data_scope_name, video)
             return video
 
+    def create_event(
+        self,
+        name: str,
+        type: EventType,
+        start: datetime.datetime | IntegralNanosecondsUTC,
+        duration: datetime.timedelta | IntegralNanosecondsDuration = 0,
+        *,
+        description: str | None = None,
+        properties: Mapping[str, str] | None = None,
+        labels: Sequence[str] | None = None,
+    ) -> Event:
+        """Create an event associated with this Asset at a given point in time.
+
+        Args:
+            name: Name of the event
+            type: Verbosity level of the event.
+            start: Starting timestamp of the event
+            duration: Duration of the event, or 0 for an event without duration.
+            description: Optionally, a human readable description of the event to create
+            properties: Key-value pairs to use as properties on the created event
+            labels: Sequence of labels to use on the created event.
+
+        Returns:
+            The created event that is associated with the asset.
+        """
+        return _create_event(
+            self._clients,
+            name=name,
+            type=type,
+            start=start,
+            duration=duration,
+            description=description,
+            assets=[self],
+            properties=properties,
+            labels=labels,
+        )
+
     def get_dataset(self, data_scope_name: str) -> Dataset:
         """Retrieve a dataset by data scope name, or raise ValueError if one is not found."""
         dataset = self.get_data_scope(data_scope_name)
@@ -411,6 +464,36 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
             )
         ]
 
+    def search_events(
+        self,
+        *,
+        search_text: str | None = None,
+        after: str | datetime.datetime | IntegralNanosecondsUTC | None = None,
+        before: str | datetime.datetime | IntegralNanosecondsUTC | None = None,
+        labels: Iterable[str] | None = None,
+        properties: Mapping[str, str] | None = None,
+        created_by_rid: str | None = None,
+        workbook_rid: str | None = None,
+        data_review_rid: str | None = None,
+        assignee_rid: str | None = None,
+        event_type: EventType | None = None,
+    ) -> Sequence[Event]:
+        """Search for events associated with this Asset. See nominal.core.event._search_events for details."""
+        return _search_events(
+            self._clients,
+            search_text=search_text,
+            after=after,
+            before=before,
+            asset_rids=[self.rid],
+            labels=labels,
+            properties=properties,
+            created_by_rid=created_by_rid,
+            workbook_rid=workbook_rid,
+            data_review_rid=data_review_rid,
+            assignee_rid=assignee_rid,
+            event_type=event_type,
+        )
+
     def remove_attachments(self, attachments: Iterable[Attachment] | Iterable[str]) -> None:
         """Remove attachments from this asset.
         Does not remove the attachments from Nominal.

nominal/core/client.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from io import TextIOBase
 from pathlib import Path
-from typing import BinaryIO, Iterable, Mapping, Sequence
+from typing import BinaryIO, Iterable, Mapping, Sequence, overload
 
 import certifi
 import conjure_python_client
@@ -16,7 +16,6 @@ from nominal_api import (
     api,
     attachments_api,
     authentication_api,
-    event,
     ingest_api,
     scout_asset_api,
     scout_catalog,
@@ -24,7 +23,6 @@ from nominal_api import (
     scout_datasource_connection_api,
     scout_layout_api,
     scout_notebook_api,
-    scout_run_api,
     scout_template_api,
     scout_video_api,
     scout_workbookcommon_api,
@@ -34,6 +32,7 @@ from nominal_api import (
 from typing_extensions import Self, deprecated
 
 from nominal import ts
+from nominal._utils.deprecation_tools import warn_on_deprecated_argument
 from nominal.config import NominalConfig, _config
 from nominal.core._clientsbunch import ClientsBunch
 from nominal.core._constants import DEFAULT_API_BASE_URL
@@ -41,7 +40,6 @@ from nominal.core._utils.api_tools import (
     Link,
     LinkDict,
     construct_user_agent_string,
-    create_links,
     rid_from_instance_or_string,
 )
 from nominal.core._utils.multipart import (
@@ -55,7 +53,6 @@ from nominal.core._utils.pagination_tools import (
     search_checklists_paginated,
     search_data_reviews_paginated,
     search_datasets_paginated,
-    search_events_paginated,
     search_runs_by_asset_paginated,
     search_runs_paginated,
     search_secrets_paginated,
@@ -69,7 +66,6 @@ from nominal.core._utils.query_tools import (
     create_search_checklists_query,
     create_search_containerized_extractors_query,
     create_search_datasets_query,
-    create_search_events_query,
     create_search_runs_query,
     create_search_secrets_query,
     create_search_users_query,
@@ -95,10 +91,10 @@ from nominal.core.dataset import (
     _get_datasets,
 )
 from nominal.core.datasource import DataSource
-from nominal.core.event import Event, EventType
+from nominal.core.event import Event, EventType, _create_event, _search_events
 from nominal.core.exceptions import NominalConfigError, NominalError, NominalIngestError, NominalMethodRemovedError
 from nominal.core.filetype import FileType, FileTypes
-from nominal.core.run import Run
+from nominal.core.run import Run, _create_run
 from nominal.core.secret import Secret
 from nominal.core.unit import Unit, _available_units
 from nominal.core.user import User
@@ -109,8 +105,6 @@ from nominal.core.workspace import Workspace
 from nominal.ts import (
     IntegralNanosecondsDuration,
     IntegralNanosecondsUTC,
-    _SecondsNanos,
-    _to_api_duration,
     _to_typed_timestamp_type,
 )
 
@@ -492,6 +486,7 @@ class NominalClient:
         )
         return list(self._iter_search_videos(query))
 
+    @overload
     def create_run(
         self,
         name: str,
@@ -503,24 +498,96 @@ class NominalClient:
         labels: Sequence[str] = (),
         links: Sequence[str | Link | LinkDict] = (),
         attachments: Iterable[Attachment] | Iterable[str] = (),
+    ) -> Run: ...
+    @overload
+    def create_run(
+        self,
+        name: str,
+        start: datetime | IntegralNanosecondsUTC,
+        end: datetime | IntegralNanosecondsUTC | None,
+        description: str | None = None,
+        *,
+        properties: Mapping[str, str] | None = None,
+        labels: Sequence[str] = (),
+        links: Sequence[str | Link | LinkDict] = (),
+        attachments: Iterable[Attachment] | Iterable[str] = (),
+        asset: Asset | str,
+    ) -> Run: ...
+    @overload
+    def create_run(
+        self,
+        name: str,
+        start: datetime | IntegralNanosecondsUTC,
+        end: datetime | IntegralNanosecondsUTC | None,
+        description: str | None = None,
+        *,
+        properties: Mapping[str, str] | None = None,
+        labels: Sequence[str] = (),
+        links: Sequence[str | Link | LinkDict] = (),
+        attachments: Iterable[Attachment] | Iterable[str] = (),
+        assets: Sequence[Asset | str],
+    ) -> Run: ...
+    @warn_on_deprecated_argument(
+        "asset", "The 'asset' parameter is deprecated and will be removed in a future release. Use 'assets' instead."
+    )
+    def create_run(
+        self,
+        name: str,
+        start: datetime | IntegralNanosecondsUTC,
+        end: datetime | IntegralNanosecondsUTC | None,
+        description: str | None = None,
+        *,
+        properties: Mapping[str, str] | None = None,
+        labels: Sequence[str] | None = None,
+        links: Sequence[str | Link | LinkDict] | None = None,
+        attachments: Iterable[Attachment] | Iterable[str] | None = None,
         asset: Asset | str | None = None,
+        assets: Sequence[Asset | str] | None = None,
     ) -> Run:
-        """Create a run."""
-        request = scout_run_api.CreateRunRequest(
-            attachments=[rid_from_instance_or_string(a) for a in attachments],
-            data_sources={},
-            description=description or "",
-            labels=list(labels),
-            links=create_links(links),
-            properties={} if properties is None else dict(properties),
-            start_time=_SecondsNanos.from_flexible(start).to_scout_run_api(),
-            title=name,
-            end_time=None if end is None else _SecondsNanos.from_flexible(end).to_scout_run_api(),
-            assets=[] if asset is None else [rid_from_instance_or_string(asset)],
-            workspace=self._clients.workspace_rid,
+        """Create a run, which is is effectively a slice of time across a collection of assets and datasources.
+
+        Args:
+            name: Name of the run to create
+            start: Starting timestamp of the run to create
+            end: Ending timestamp of the run to create, or None for an unbounded run.
+            description: Optional description of the run to create
+            properties: Optional key-value pairs to use as properties on the created run
+            labels: Optional sequence of labels for the created run
+            links: Link metadata to add to the created run
+            attachments: Attachments to associate with the created run
+            asset: Singular asset to associate with the run
+                NOTE: mutually exclusive with `assets`
+                NOTE: deprecated-- use `assets` instead.
+            assets: Sequence of assets to associate with the run
+                NOTE: mutually exclusive with `asset`
+
+        Returns:
+            Reference to the created run object
+
+        Raises:
+            ValueError: both `asset` and `assets` provided
+            ConjureHTTPError: error making request
+
+        """
+        if asset and assets:
+            raise ValueError("Only one of 'asset' and 'assets' may be provided")
+        elif asset:
+            assets = [asset]
+        elif assets is None:
+            assets = []
+
+        return _create_run(
+            self._clients,
+            name=name,
+            start=start,
+            end=end,
+            description=description,
+            properties=properties,
+            labels=labels,
+            links=links,
+            attachments=attachments,
+            asset_rids=[rid_from_instance_or_string(asset) for asset in assets],
         )
-        response = self._clients.run.create_run(self._clients.auth_header, request)
-        return Run._from_conjure(self._clients, response)
 
     def get_run(self, rid: str) -> Run:
         """Retrieve a run by its RID."""
@@ -1158,19 +1225,17 @@ class NominalClient:
         properties: Mapping[str, str] | None = None,
         labels: Iterable[str] = (),
     ) -> Event:
-        request = event.CreateEvent(
+        return _create_event(
+            clients=self._clients,
             name=name,
+            type=type,
+            start=start,
+            duration=duration,
             description=description,
-            asset_rids=[rid_from_instance_or_string(asset) for asset in assets],
-            timestamp=_SecondsNanos.from_flexible(start).to_api(),
-            duration=_to_api_duration(duration),
-            origins=[],
-            properties=dict(properties) if properties else {},
-            labels=list(labels),
-            type=type._to_api_event_type(),
+            assets=assets,
+            properties=properties,
+            labels=labels,
         )
-        response = self._clients.event.create_event(self._clients.auth_header, request)
-        return Event._from_conjure(self._clients, response)
 
     def get_event(self, rid: str) -> Event:
         events = self.get_events([rid])
@@ -1205,10 +1270,6 @@ class NominalClient:
         # TODO (drake-nominal): Expose checklist_refs to users
         return list(self._iter_search_data_reviews(assets, runs))
 
-    def _iter_search_events(self, query: event.SearchQuery) -> Iterable[Event]:
-        for e in search_events_paginated(self._clients.event, self._clients.auth_header, query):
-            yield Event._from_conjure(self._clients, e)
-
     def search_events(
         self,
         *,
@@ -1251,21 +1312,21 @@ class NominalClient:
         Returns:
             All events which match all of the provided conditions
         """
-        query = create_search_events_query(
+        return _search_events(
+            clients=self._clients,
             search_text=search_text,
             after=after,
             before=before,
-            assets=None if assets is None else [rid_from_instance_or_string(asset) for asset in assets],
+            asset_rids=[rid_from_instance_or_string(asset) for asset in assets] if assets else None,
             labels=labels,
             properties=properties,
-            created_by=rid_from_instance_or_string(created_by) if created_by else None,
-            workbook=rid_from_instance_or_string(workbook) if workbook else None,
-            data_review=rid_from_instance_or_string(data_review) if data_review else None,
-            assignee=rid_from_instance_or_string(assignee) if assignee else None,
+            created_by_rid=rid_from_instance_or_string(created_by) if created_by else None,
+            workbook_rid=rid_from_instance_or_string(workbook) if workbook else None,
+            data_review_rid=rid_from_instance_or_string(data_review) if data_review else None,
+            assignee_rid=rid_from_instance_or_string(assignee) if assignee else None,
             event_type=event_type,
             workspace_rid=self._workspace_rid_for_search(workspace or WorkspaceSearchType.ALL),
         )
-        return list(self._iter_search_events(query))
 
     def get_containerized_extractor(self, rid: str) -> ContainerizedExtractor:
         return ContainerizedExtractor._from_conjure(

nominal/core/dataset.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import abc
 import logging
 from dataclasses import dataclass
 from datetime import timedelta
@@ -8,7 +9,7 @@ from pathlib import Path
 from types import MappingProxyType
 from typing import BinaryIO, Iterable, Mapping, Sequence, TypeAlias, overload
 
-from nominal_api import api, ingest_api, scout_catalog
+from nominal_api import api, ingest_api, scout_asset_api, scout_catalog
 from typing_extensions import Self, deprecated
 
 from nominal.core._stream.batch_processor import process_log_batch
@@ -646,6 +647,288 @@ class Dataset(DataSource, RefreshableMixin[scout_catalog.EnrichedDataset]):
         )
 
 
+def _unify_tags(datascope_tags: Mapping[str, str], provided_tags: Mapping[str, str] | None) -> Mapping[str, str]:
+    return {**datascope_tags, **(provided_tags or {})}
+
+
+class _DatasetWrapper(abc.ABC):
+    """A lightweight façade over `nominal.core.Dataset` that routes ingest calls through a *data scope*.
+
+    `_DatasetWrapper` resolves `data_scope_name` to a backing `nominal.core.Dataset` and then delegates to the
+    corresponding `Dataset` method.
+
+    How this differs from `Dataset`
+    -------------------------------
+    - All "add data" methods take an extra first argument, `data_scope_name`, which selects the target dataset.
+    - For methods that accept `tags`, this wrapper merges the scope's required tags into the provided tags.
+      User-provided tags take precedence on key collisions.
+    - Some formats cannot be safely tagged with scope tags; those wrapper methods raise `RuntimeError` when the selected
+      scope requires tags.
+
+    Subclasses must implement `_list_dataset_scopes`, which is used to resolve scopes.
+    """
+
+    # static typing for required field
+    _clients: Dataset._Clients
+
+    @abc.abstractmethod
+    def _list_dataset_scopes(self) -> Sequence[scout_asset_api.DataScope]:
+        """Return the data scopes available to this wrapper.
+
+        Subclasses provide the authoritative list of `scout_asset_api.DataScope` objects used to
+        resolve `data_scope_name` in wrapper methods.
+        """
+
+    def _get_dataset_scope(self, data_scope_name: str) -> tuple[Dataset, Mapping[str, str]]:
+        """Resolve a data scope name to its backing dataset and required series tags.
+
+        Returns:
+            A tuple of the resolved `Dataset` and the scope's required `series_tags`.
+
+        Raises:
+            ValueError: If no scope exists with the given `data_scope_name`, or if the scope is not backed by a dataset.
+        """
+        dataset_scopes = {scope.data_scope_name: scope for scope in self._list_dataset_scopes()}
+        data_scope = dataset_scopes.get(data_scope_name)
+        if data_scope is None:
+            raise ValueError(f"No such data scope found with data_scope_name {data_scope_name}")
+        elif data_scope.data_source.dataset is None:
+            raise ValueError(f"Datascope {data_scope_name} is not a dataset!")
+
+        dataset = Dataset._from_conjure(
+            self._clients,
+            _get_dataset(self._clients.auth_header, self._clients.catalog, data_scope.data_source.dataset),
+        )
+        return dataset, data_scope.series_tags
+
+    ################
+    # Add Data API #
+    ################
+
+    def add_tabular_data(
+        self,
+        data_scope_name: str,
+        path: Path | str,
+        *,
+        timestamp_column: str,
+        timestamp_type: _AnyTimestampType,
+        tag_columns: Mapping[str, str] | None = None,
+        tags: Mapping[str, str] | None = None,
+    ) -> DatasetFile:
+        """Append tabular data on-disk to the dataset selected by `data_scope_name`.
+
+        This method behaves like `nominal.core.Dataset.add_tabular_data`, except that the data scope's required
+        tags are merged into `tags` before ingest (with user-provided tags taking precedence on key collisions).
+
+        For supported file types, argument semantics, and return value details, see
+        `nominal.core.Dataset.add_tabular_data`.
+        """
+        dataset, scope_tags = self._get_dataset_scope(data_scope_name)
+        return dataset.add_tabular_data(
+            path,
+            timestamp_column=timestamp_column,
+            timestamp_type=timestamp_type,
+            tag_columns=tag_columns,
+            tags=_unify_tags(scope_tags, tags),
+        )
+
+    def add_avro_stream(
+        self,
+        data_scope_name: str,
+        path: Path | str,
+    ) -> DatasetFile:
+        """Upload an avro stream file to the dataset selected by `data_scope_name`.
+
+        This method behaves like `nominal.core.Dataset.add_avro_stream`, with one important difference:
+        avro stream ingestion does not support applying scope tags. If the selected scope requires tags, this method
+        raises `RuntimeError` rather than ingesting (potentially) untagged data. This file may still be ingested
+        directly on the dataset itself if it is known to contain the correct set of tags.
+
+        For schema requirements and return value details, see
+        `nominal.core.Dataset.add_avro_stream`.
+        """
+        dataset, scope_tags = self._get_dataset_scope(data_scope_name)
+
+        # TODO(drake): remove once avro stream supports ingest with tags
+        if scope_tags:
+            raise RuntimeError(
+                f"Cannot add avro files to datascope {data_scope_name}-- data would not get "
+                f"tagged with required tags: {scope_tags}"
+            )
+
+        return dataset.add_avro_stream(path)
+
+    def add_journal_json(
+        self,
+        data_scope_name: str,
+        path: Path | str,
+    ) -> DatasetFile:
+        """Add a journald json file to the dataset selected by `data_scope_name`.
+
+        This method behaves like `nominal.core.Dataset.add_journal_json`, with one important difference:
+        journal json ingestion does not support applying scope tags as args. If the selected scope requires tags,
+        this method raises `RuntimeError` rather than potentially ingesting untagged data. This file may still be
+        ingested directly on the dataset itself if it is known to contain the correct set of args.
+
+        For file expectations and return value details, see
+        `nominal.core.Dataset.add_journal_json`.
+        """
+        dataset, scope_tags = self._get_dataset_scope(data_scope_name)
+
+        # TODO(drake): remove once journal json supports ingest with tags
+        if scope_tags:
+            raise RuntimeError(
+                f"Cannot add journal json files to datascope {data_scope_name}-- data would not get "
+                f"tagged with required arguments: {scope_tags}"
+            )
+
+        return dataset.add_journal_json(path)
+
+    def add_mcap(
+        self,
+        data_scope_name: str,
+        path: Path | str,
+        *,
+        include_topics: Iterable[str] | None = None,
+        exclude_topics: Iterable[str] | None = None,
+    ) -> DatasetFile:
+        """Add an MCAP file to the dataset selected by `data_scope_name`.
+
+        This method behaves like `nominal.core.Dataset.add_mcap`, with one important difference:
+        MCAP ingestion does not support applying scope tags. If the selected scope requires tags, this method raises
+        `RuntimeError` rather than ingesting untagged data.
+
+        For topic-filtering semantics and return value details, see
+        `nominal.core.Dataset.add_mcap`.
+        """
+        dataset, scope_tags = self._get_dataset_scope(data_scope_name)
+
+        # TODO(drake): remove once MCAP supports ingest with tags
+        if scope_tags:
+            raise RuntimeError(
+                f"Cannot add mcap files to datascope {data_scope_name}-- data would not get "
+                f"tagged with required tags: {scope_tags}"
+            )
+
+        return dataset.add_mcap(path, include_topics=include_topics, exclude_topics=exclude_topics)
+
+    def add_ardupilot_dataflash(
+        self,
+        data_scope_name: str,
+        path: Path | str,
+        tags: Mapping[str, str] | None = None,
+    ) -> DatasetFile:
+        """Add a Dataflash file to the dataset selected by `data_scope_name`.
+
+        This method behaves like `nominal.core.Dataset.add_ardupilot_dataflash`, except that the data scope's
+        required tags are merged into `tags` before ingest (with user-provided tags taking precedence on key
+        collisions).
+
+        For file expectations and return value details, see
+        `nominal.core.Dataset.add_ardupilot_dataflash`.
+        """
+        dataset, scope_tags = self._get_dataset_scope(data_scope_name)
+        return dataset.add_ardupilot_dataflash(path, tags=_unify_tags(scope_tags, tags))
+
+    @overload
+    def add_containerized(
+        self,
+        data_scope_name: str,
+        extractor: str | ContainerizedExtractor,
+        sources: Mapping[str, Path | str],
+        *,
+        tag: str | None = None,
+        tags: Mapping[str, str] | None = None,
+    ) -> DatasetFile: ...
+    @overload
+    def add_containerized(
+        self,
+        data_scope_name: str,
+        extractor: str | ContainerizedExtractor,
+        sources: Mapping[str, Path | str],
+        *,
+        tag: str | None = None,
+        tags: Mapping[str, str] | None = None,
+        timestamp_column: str,
+        timestamp_type: _AnyTimestampType,
+    ) -> DatasetFile: ...
+    def add_containerized(
+        self,
+        data_scope_name: str,
+        extractor: str | ContainerizedExtractor,
+        sources: Mapping[str, Path | str],
+        *,
+        tag: str | None = None,
+        tags: Mapping[str, str] | None = None,
+        timestamp_column: str | None = None,
+        timestamp_type: _AnyTimestampType | None = None,
+    ) -> DatasetFile:
+        """Add data from proprietary formats using a pre-registered custom extractor.
+
+        This method behaves like `nominal.core.Dataset.add_containerized`, except that the data scope's required
+        tags are merged into `tags` before ingest (with user-provided tags taking precedence on key collisions).
+
+        This wrapper also enforces that `timestamp_column` and `timestamp_type` are provided together (or omitted
+        together) before delegating.
+
+        For extractor inputs, tagging semantics, timestamp metadata behavior, and return value details, see
+        `nominal.core.Dataset.add_containerized`.
+        """
+        dataset, scope_tags = self._get_dataset_scope(data_scope_name)
+        if timestamp_column is None and timestamp_type is None:
+            return dataset.add_containerized(
+                extractor,
+                sources,
+                tag=tag,
+                tags=_unify_tags(scope_tags, tags),
+            )
+        elif timestamp_column is not None and timestamp_type is not None:
+            return dataset.add_containerized(
+                extractor,
+                sources,
+                tag=tag,
+                tags=_unify_tags(scope_tags, tags),
+                timestamp_column=timestamp_column,
+                timestamp_type=timestamp_type,
+            )
+        else:
+            raise ValueError(
+                "Only one of `timestamp_column` and `timestamp_type` were provided to `add_containerized`, "
+                "either both must or neither must be provided."
+            )
+
+    def add_from_io(
+        self,
+        data_scope_name: str,
+        data_stream: BinaryIO,
+        file_type: tuple[str, str] | FileType,
+        *,
+        timestamp_column: str,
+        timestamp_type: _AnyTimestampType,
+        file_name: str | None = None,
+        tag_columns: Mapping[str, str] | None = None,
+        tags: Mapping[str, str] | None = None,
+    ) -> DatasetFile:
+        """Append to the dataset selected by `data_scope_name` from a file-like object.
+
+        This method behaves like `nominal.core.Dataset.add_from_io`, except that the data scope's required tags
+        are merged into `tags` before ingest (with user-provided tags taking precedence on key collisions).
+
+        For stream requirements, supported file types, argument semantics, and return value details, see
+        `nominal.core.Dataset.add_from_io`.
+        """
+        dataset, scope_tags = self._get_dataset_scope(data_scope_name)
+        return dataset.add_from_io(
+            data_stream,
+            timestamp_column=timestamp_column,
+            timestamp_type=timestamp_type,
+            file_type=file_type,
+            file_name=file_name,
+            tag_columns=tag_columns,
+            tags=_unify_tags(scope_tags, tags),
+        )
+
+
 @deprecated(
     "poll_until_ingestion_completed() is deprecated and will be removed in a future release. "
     "Instead, call poll_until_ingestion_completed() on individual DatasetFiles."

nominal/core/datasource.py

@@ -396,7 +396,12 @@ def _get_write_stream(
         )
     elif data_format == "rust_experimental":
         # Delayed import intentionally in case of any issues with experimental and pre-compiled binaries
-        from nominal.experimental.rust_streaming.rust_write_stream import RustWriteStream
+        try:
+            from nominal.experimental.rust_streaming.rust_write_stream import RustWriteStream
+        except ImportError as ex:
+            raise ImportError(
+                "nominal-streaming is required to use get_write_stream with data_format='rust_experimental'"
+            ) from ex
 
         return RustWriteStream._from_datasource(
             write_rid,

nominal/core/event.py

@@ -6,12 +6,13 @@ from datetime import datetime, timedelta
 from enum import Enum
 from typing import Iterable, Mapping, Protocol, Sequence
 
-from nominal_api import event
+from nominal_api import api, event
 from typing_extensions import Self
 
+from nominal.core import asset as core_asset
 from nominal.core._clientsbunch import HasScoutParams
 from nominal.core._utils.api_tools import HasRid, RefreshableMixin, rid_from_instance_or_string
-from nominal.core.asset import Asset
+from nominal.core._utils.pagination_tools import search_events_paginated
 from nominal.ts import IntegralNanosecondsDuration, IntegralNanosecondsUTC, _SecondsNanos, _to_api_duration
 
 
@@ -50,7 +51,7 @@ class Event(HasRid, RefreshableMixin[event.Event]):
         *,
         name: str | None = None,
         description: str | None = None,
-        assets: Iterable[Asset | str] | None = None,
+        assets: Iterable[core_asset.Asset | str] | None = None,
         start: datetime | IntegralNanosecondsUTC | None = None,
         duration: timedelta | IntegralNanosecondsDuration | None = None,
         properties: Mapping[str, str] | None = None,
@@ -154,3 +155,114 @@ class EventType(Enum):
             return event.EventType.SUCCESS
         else:
             return event.EventType.UNKNOWN
+
+
+def _create_event(
+    clients: Event._Clients,
+    *,
+    name: str,
+    type: EventType,
+    start: datetime | IntegralNanosecondsUTC,
+    duration: timedelta | IntegralNanosecondsDuration,
+    assets: Iterable[core_asset.Asset | str] | None,
+    description: str | None,
+    properties: Mapping[str, str] | None,
+    labels: Iterable[str] | None,
+) -> Event:
+    request = event.CreateEvent(
+        name=name,
+        description=description,
+        asset_rids=[rid_from_instance_or_string(asset) for asset in (assets or [])],
+        timestamp=_SecondsNanos.from_flexible(start).to_api(),
+        duration=_to_api_duration(duration),
+        origins=[],
+        properties=dict(properties or {}),
+        labels=list(labels or []),
+        type=type._to_api_event_type(),
+    )
+    response = clients.event.create_event(clients.auth_header, request)
+    return Event._from_conjure(clients, response)
+
+
+def _iter_search_events(clients: Event._Clients, query: event.SearchQuery) -> Iterable[Event]:
+    for e in search_events_paginated(clients.event, clients.auth_header, query):
+        yield Event._from_conjure(clients, e)
+
+
+def _search_events(
+    clients: Event._Clients,
+    *,
+    search_text: str | None = None,
+    after: str | datetime | IntegralNanosecondsUTC | None = None,
+    before: str | datetime | IntegralNanosecondsUTC | None = None,
+    asset_rids: Iterable[str] | None = None,
+    labels: Iterable[str] | None = None,
+    properties: Mapping[str, str] | None = None,
+    created_by_rid: str | None = None,
+    workbook_rid: str | None = None,
+    data_review_rid: str | None = None,
+    assignee_rid: str | None = None,
+    event_type: EventType | None = None,
+    workspace_rid: str | None = None,
+) -> Sequence[Event]:
+    query = _create_search_events_query(
+        asset_rids=asset_rids,
+        search_text=search_text,
+        after=after,
+        before=before,
+        labels=labels,
+        properties=properties,
+        created_by_rid=created_by_rid,
+        workbook_rid=workbook_rid,
+        data_review_rid=data_review_rid,
+        assignee_rid=assignee_rid,
+        event_type=event_type,
+        workspace_rid=workspace_rid,
+    )
+    return list(_iter_search_events(clients, query))
+
+
+def _create_search_events_query(  # noqa: PLR0912
+    search_text: str | None = None,
+    after: str | datetime | IntegralNanosecondsUTC | None = None,
+    before: str | datetime | IntegralNanosecondsUTC | None = None,
+    asset_rids: Iterable[str] | None = None,
+    labels: Iterable[str] | None = None,
+    properties: Mapping[str, str] | None = None,
+    created_by_rid: str | None = None,
+    workbook_rid: str | None = None,
+    data_review_rid: str | None = None,
+    assignee_rid: str | None = None,
+    event_type: EventType | None = None,
+    workspace_rid: str | None = None,
+) -> event.SearchQuery:
+    queries = []
+    if search_text is not None:
+        queries.append(event.SearchQuery(search_text=search_text))
+    if after is not None:
+        queries.append(event.SearchQuery(after=_SecondsNanos.from_flexible(after).to_api()))
+    if before is not None:
+        queries.append(event.SearchQuery(before=_SecondsNanos.from_flexible(before).to_api()))
+    if asset_rids:
+        for asset in asset_rids:
+            queries.append(event.SearchQuery(asset=asset))
+    if labels:
+        for label in labels:
+            queries.append(event.SearchQuery(label=label))
+    if properties:
+        for name, value in properties.items():
+            queries.append(event.SearchQuery(property=api.Property(name=name, value=value)))
+    if created_by_rid:
+        queries.append(event.SearchQuery(created_by=created_by_rid))
+    if workbook_rid is not None:
+        queries.append(event.SearchQuery(workbook=workbook_rid))
+    if data_review_rid is not None:
+        queries.append(event.SearchQuery(data_review=data_review_rid))
+    if assignee_rid is not None:
+        queries.append(event.SearchQuery(assignee=assignee_rid))
+    if event_type is not None:
+        queries.append(event.SearchQuery(event_type=event_type._to_api_event_type()))
+    if workspace_rid is not None:
+        queries.append(event.SearchQuery(workspace=workspace_rid))
+
+    return event.SearchQuery(and_=queries)

nominal/core/filetype.py

@@ -111,6 +111,7 @@ class FileType(NamedTuple):
 
 
 class FileTypes:
+    AVI: FileType = FileType(".avi", "video/x-msvideo")
     AVRO_STREAM: FileType = FileType(".avro", "application/avro")
     BINARY: FileType = FileType("", "application/octet-stream")
     CSV: FileType = FileType(".csv", "text/csv")
@@ -134,4 +135,4 @@ class FileTypes:
     _PARQUET_FILE_TYPES = (PARQUET_GZ, PARQUET)
     _PARQUET_ARCHIVE_TYPES = (PARQUET_TAR_GZ, PARQUET_TAR, PARQUET_ZIP)
     _JOURNAL_TYPES = (JOURNAL_JSONL, JOURNAL_JSONL_GZ)
-    _VIDEO_TYPES = (MKV, MP4, TS)
+    _VIDEO_TYPES = (AVI, MKV, MP4, TS)

nominal/core/run.py

@@ -6,6 +6,7 @@ from types import MappingProxyType
 from typing import Iterable, Mapping, Protocol, Sequence, cast
 
 from nominal_api import (
+    scout_asset_api,
     scout_run_api,
 )
 from typing_extensions import Self
@@ -20,15 +21,17 @@ from nominal.core._utils.api_tools import (
     create_links,
     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, _get_datasets
+from nominal.core.dataset import Dataset, _DatasetWrapper, _get_datasets
+from nominal.core.event import Event, EventType, _create_event
 from nominal.core.video import Video, _get_video
 from nominal.ts import IntegralNanosecondsDuration, IntegralNanosecondsUTC, _SecondsNanos, _to_api_duration
 
 
 @dataclass(frozen=True)
-class Run(HasRid, RefreshableMixin[scout_run_api.Run]):
+class Run(HasRid, RefreshableMixin[scout_run_api.Run], _DatasetWrapper):
     rid: str
     name: str
     description: str
@@ -96,6 +99,13 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run]):
         updated_run = self._clients.run.update_run(self._clients.auth_header, request, self.rid)
         return self._refresh_from_api(updated_run)
 
+    def _list_dataset_scopes(self) -> Sequence[scout_asset_api.DataScope]:
+        api_run = self._get_latest_api()
+        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")
+
     def _list_datasource_rids(
         self, datasource_type: str | None = None, property_name: str | None = None
     ) -> Mapping[str, str]:
@@ -148,6 +158,43 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run]):
         )
         self._refresh_from_api(updated_run)
 
+    def create_event(
+        self,
+        name: str,
+        type: EventType,
+        start: datetime | IntegralNanosecondsUTC,
+        duration: timedelta | IntegralNanosecondsDuration = 0,
+        *,
+        description: str | None = None,
+        properties: Mapping[str, str] | None = None,
+        labels: Iterable[str] = (),
+    ) -> Event:
+        """Create an event associated with all associated assets of this run at a given point in time.
+
+        Args:
+            name: Name of the event
+            type: Verbosity level of the event.
+            start: Starting timestamp of the event
+            duration: Duration of the event, or 0 for an event without duration.
+            description: Optionally, a human readable description of the event to create
+            properties: Key-value pairs to use as properties on the created event
+            labels: Sequence of labels to use on the created event.
+
+        Returns:
+            The created event that is associated with all of the assets associated with this run..
+        """
+        return _create_event(
+            self._clients,
+            name=name,
+            type=type,
+            start=start,
+            duration=duration,
+            description=description,
+            assets=self.assets,
+            properties=properties,
+            labels=labels,
+        )
+
     def add_dataset(
         self,
         ref_name: str,
@@ -349,3 +396,34 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run]):
             created_at=_SecondsNanos.from_flexible(run.created_at).to_nanoseconds(),
             _clients=clients,
         )
+
+
+def _create_run(
+    clients: Run._Clients,
+    *,
+    name: str,
+    start: datetime | IntegralNanosecondsUTC,
+    end: datetime | IntegralNanosecondsUTC | None,
+    description: str | None,
+    properties: Mapping[str, str] | None,
+    labels: Sequence[str] | None,
+    links: Sequence[str | Link | LinkDict] | None,
+    attachments: Iterable[Attachment] | Iterable[str] | None,
+    asset_rids: Sequence[str] | None,
+) -> Run:
+    """Create a run."""
+    request = scout_run_api.CreateRunRequest(
+        attachments=[rid_from_instance_or_string(a) for a in attachments or ()],
+        data_sources={},
+        description=description or "",
+        labels=[] if labels is None else list(labels),
+        links=[] if links is None else create_links(links),
+        properties={} if properties is None else dict(properties),
+        start_time=_SecondsNanos.from_flexible(start).to_scout_run_api(),
+        title=name,
+        end_time=None if end is None else _SecondsNanos.from_flexible(end).to_scout_run_api(),
+        assets=[] if asset_rids is None else list(asset_rids),
+        workspace=clients.workspace_rid,
+    )
+    response = clients.run.create_run(clients.auth_header, request)
+    return Run._from_conjure(clients, response)

nominal/experimental/rust_streaming/rust_write_stream.py

@@ -5,9 +5,7 @@ import pathlib
 
 from nominal_streaming import NominalDatasetStream
 
-from nominal.core._stream.write_stream import (
-    DataStream,
-)
+from nominal.core._stream.write_stream import DataStream
 from nominal.core.datasource import DataSource
 
 

{nominal-1.100.0.dist-info → nominal-1.101.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal
-Version: 1.100.0
+Version: 1.101.0
 Summary: Automate Nominal workflows in Python
 Project-URL: Homepage, https://nominal.io
 Project-URL: Documentation, https://docs.nominal.io
@@ -21,7 +21,7 @@ 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.1032.0
-Requires-Dist: nominal-streaming==0.5.8
+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
 Requires-Dist: polars>=0.0.0

{nominal-1.100.0.dist-info → nominal-1.101.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-CHANGELOG.md,sha256=jvj73GmZ1DOpXVyEcRVZ7Wm2ejFmH2UhBPO66Yt8wu0,83100
+CHANGELOG.md,sha256=95CbjI-NMgs9Jf26PjTGicKnbcm3SLZXRgXjPSLpn58,84741
 LICENSE,sha256=zEGHG9mjDjaIS3I79O8mweQo-yiTbqx8jJvUPppVAwk,1067
 README.md,sha256=KKe0dxh_pHXCtB7I9G4qWGQYvot_BZU8yW6MJyuyUHM,311
 nominal/__init__.py,sha256=rbraORnXUrNn1hywLXM0XwSQCd9UmQt20PDYlsBalfE,2167
@@ -30,23 +30,23 @@ nominal/config/_config.py,sha256=yKq_H1iYJDoxRfLz2iXLbbVdoL0MTEY0FS4eVL12w0g,200
 nominal/core/__init__.py,sha256=5eC2J0lzpV7JcuKDUimJCfgXuVL7HNgHrLhqxcy5NCc,2333
 nominal/core/_clientsbunch.py,sha256=YwciugX7rQ9AOPHyvKuavG7b9SlX1PURRquP37nvLqE,8458
 nominal/core/_constants.py,sha256=SrxgaSqAEB1MvTSrorgGam3eO29iCmRr6VIdajxX3gI,56
-nominal/core/asset.py,sha256=vWi_5jNm1sBo4jCa4wTrL65IQ7b_lefZTLRsakoW7ro,18355
+nominal/core/asset.py,sha256=48Znq-KaDZfTBcdXaBn3zlF22EOCHEEz8D3boB2MM6o,21544
 nominal/core/attachment.py,sha256=iJaDyF6JXsKxxBLA03I0WMmQF8U0bA-wRwvXMEhfWLU,4284
 nominal/core/bounds.py,sha256=742BWmGL3FBryRAjoiJRg2N6aVinjYkQLxN7kfnJ40Q,581
 nominal/core/channel.py,sha256=dbe8wpfMiWqHu98x66w6GOmC9Ro33Wv9AhBVx2DvtVk,18970
 nominal/core/checklist.py,sha256=rO1RPDYV3o2miPKF7DcCiYpj6bUN-sdtZNhJkXzkfYE,7110
-nominal/core/client.py,sha256=zTaayeJf8IFA7BlNoVCaVpDA6cXIBaZGP934Tg6OhDI,67568
+nominal/core/client.py,sha256=Csmu5dlQBmLFZcJDODPJytne4WQgM42a6W2UWSm34Go,69523
 nominal/core/connection.py,sha256=ySbPN_a2takVa8wIU9mK4fB6vYLyZnN-qSmXVkLUxAY,5157
 nominal/core/containerized_extractors.py,sha256=fUz3-NHoNWYKqOCD15gLwGXDKVfdsW-x_kpXnkOI3BE,10224
 nominal/core/data_review.py,sha256=bEnRsd8LI4x9YOBPcF2H3h5-e12A7Gh8gQfsNUAZmPQ,7922
-nominal/core/dataset.py,sha256=SUsn6qsbuceVLRYF47IquY_sW6OBRp4aExL1F3Bsaec,34802
+nominal/core/dataset.py,sha256=Rt20H2ekUbF0_YyF-OkJhs3KaRTqQzNNxyneRjIEOJk,46627
 nominal/core/dataset_file.py,sha256=oENANJ17A4K63cZ8Fr7lUm_kVPyA4fL2rUsZ3oXXk2U,16396
-nominal/core/datasource.py,sha256=D9jHirAzUZ0pc3nW1XIURpw1UqQoA2E-nUUylZR1jbE,16707
-nominal/core/event.py,sha256=D8qIX_dTjfSHN7jFW8vV-9htbQTaqk9VvRfK7t-sbbw,5891
+nominal/core/datasource.py,sha256=k13B6u6uw5pd49SuVM3gXtATgqO_BUnqGUMGiiW6Moc,16920
+nominal/core/event.py,sha256=eQY_Csa5_6K0vrWfeOFBO4PVmFS8QhzhXfQ4wbb8Oy0,10215
 nominal/core/exceptions.py,sha256=GUpwXRgdYamLl6684FE8ttCRHkBx6WEhOZ3NPE-ybD4,2671
-nominal/core/filetype.py,sha256=jAPe6F7pDT8ixsD2-Y8eJdHOxgimdEQte4RQybWwsos,5465
+nominal/core/filetype.py,sha256=uzKe4iNHSv27mvz8-5EJEsvGOn3msEm_IhCj8OsCAPY,5526
 nominal/core/log.py,sha256=z3hI3CIEyMwpUSWjwBsJ6a3JNGzBbsmrVusSU6uI7CY,3885
-nominal/core/run.py,sha256=Rqy2o6sLE5RsAvvNnle7jRPJ-8UNfHmD-pdsRTOjA8Y,14792
+nominal/core/run.py,sha256=uVBQevkD_Q3AWZ_pNt-jD5Y4hHfHGBexKEhobF9Se50,17857
 nominal/core/secret.py,sha256=Ckq48m60i7rktxL9GY-nxHU5v8gHv9F1-JN7_MSf4bM,2863
 nominal/core/unit.py,sha256=Wa-Bvu0hD-nzxVaQJSnn5YqAfnhUd2kWw2SswXnbMHY,3161
 nominal/core/user.py,sha256=FV333TN4pQzcLh5b2CfxvBnnXyB1TrOP8Ppx1-XdaiE,481
@@ -67,7 +67,7 @@ nominal/core/_utils/multipart.py,sha256=0dA2XcTHuOQIyS0139O8WZiCjwePaD1sYDUmTgmW
 nominal/core/_utils/multipart_downloader.py,sha256=16OJEPqxCwOnfjptYdrlwQVuSUQYoe9_iiW60ZSjWos,13859
 nominal/core/_utils/networking.py,sha256=n9ZqYtnpwPCjz9C-4eixsTkrhFh-DW6lknBJlHckHhg,8200
 nominal/core/_utils/pagination_tools.py,sha256=cEBY1WiA1d3cWJEM0myYF_pX8JdQ_e-5asngVXrUc_Y,12152
-nominal/core/_utils/query_tools.py,sha256=rabmhqUYw0POybZtGDoMyAwwXh4VMuYM6mMf-iAfWdc,15860
+nominal/core/_utils/query_tools.py,sha256=wcEVvanF_kNCVGEEHI6WjFs1uDyOw9kCh0qHnlyKLBc,13860
 nominal/core/_utils/queueing.py,sha256=3qljc7dFI1UahlKjCaRVybM4poMCV5SayjyRPyXcPxg,3654
 nominal/exceptions/__init__.py,sha256=W2r_GWJkZQQ6t3HooFjGRdhIgJq3fBvRV7Yn6gseoO0,415
 nominal/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -87,7 +87,7 @@ nominal/experimental/logging/rich_log_handler.py,sha256=8yz_VtxNgJg2oiesnXz2iXoB
 nominal/experimental/migration/__init__.py,sha256=E2IgWJLwJ5bN6jbl8k5nHECKFx5aT11jKAzVYcyXn3o,460
 nominal/experimental/migration/migration_utils.py,sha256=j4In_sU_cWW1kScneMP2G8B7LHDcnY2YDE0fwIv8BiY,22831
 nominal/experimental/rust_streaming/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nominal/experimental/rust_streaming/rust_write_stream.py,sha256=UoJEujzRAPlsAq2c24fgrub3c0DO0HM10SGsIgZjPKk,1499
+nominal/experimental/rust_streaming/rust_write_stream.py,sha256=E-L5JtcwPWnCEm0o4_k-AVzw173sRSgElzKrgHoYwbs,1490
 nominal/experimental/stream_v2/__init__.py,sha256=W39vK46pssx5sXvmsImMuJiEPs7iGtwrbYBI0bWnXCY,2313
 nominal/experimental/stream_v2/_serializer.py,sha256=DcGimcY1LsXNeCzOWrel3SwuvoRV4XLdOFjqjM7MgPY,1035
 nominal/experimental/stream_v2/_write_stream.py,sha256=-EncNPXUDYaL1YpFlJFEkuLgcxMdyKEXS5JJzP_2LlI,9981
@@ -104,8 +104,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=eiHFTUviyDPDClckNldjs_jTTSH_sdmboKDq0oIGChQ,8711
 nominal/ts/__init__.py,sha256=hmd0ENvDhxRnzDKGLxIub6QG8LpcxCgcyAct029CaEs,21442
-nominal-1.100.0.dist-info/METADATA,sha256=v6eSXRLbr-cRBxvxBm3hsi5cfAQavQ2Zhng00SrS3xc,1981
-nominal-1.100.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nominal-1.100.0.dist-info/entry_points.txt,sha256=-mCLhxgg9R_lm5efT7vW9wuBH12izvY322R0a3TYxbE,66
-nominal-1.100.0.dist-info/licenses/LICENSE,sha256=zEGHG9mjDjaIS3I79O8mweQo-yiTbqx8jJvUPppVAwk,1067
-nominal-1.100.0.dist-info/RECORD,,
+nominal-1.101.0.dist-info/METADATA,sha256=OO0vRe9USFPos10KdaDORhPL1M1BO1h5aLnsX1dA09E,2277
+nominal-1.101.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nominal-1.101.0.dist-info/entry_points.txt,sha256=-mCLhxgg9R_lm5efT7vW9wuBH12izvY322R0a3TYxbE,66
+nominal-1.101.0.dist-info/licenses/LICENSE,sha256=zEGHG9mjDjaIS3I79O8mweQo-yiTbqx8jJvUPppVAwk,1067
+nominal-1.101.0.dist-info/RECORD,,