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

CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [1.100.0](https://github.com/nominal-io/nominal-client/compare/v1.99.0...v1.100.0) (2025-12-19)
+
+
+### Features
+
+* add args and timestamp types for containerized ingest ([#551](https://github.com/nominal-io/nominal-client/issues/551)) ([1dd259a](https://github.com/nominal-io/nominal-client/commit/1dd259a299d83c55b482f443542f7feb63896795))
+* add clone/copy_from methods for assets, datasets, templates ([#548](https://github.com/nominal-io/nominal-client/issues/548)) ([f04c468](https://github.com/nominal-io/nominal-client/commit/f04c46800569da0ad6fb9440a336a7d8cac3542a))
+* added prefix_tree_delimiter parameter to get_or_create_dataset method ([#550](https://github.com/nominal-io/nominal-client/issues/550)) ([c204d94](https://github.com/nominal-io/nominal-client/commit/c204d9450d33a9742c0ae6b6a2d78e8baa796d2c))
+* allow listing runs on asset, deprecate search run by asset in client ([#541](https://github.com/nominal-io/nominal-client/issues/541)) ([35464e5](https://github.com/nominal-io/nominal-client/commit/35464e56ebc81577094b4ce0862d830e7d7bc92e))
+* allow promoting assets ([#542](https://github.com/nominal-io/nominal-client/issues/542)) ([1ce1082](https://github.com/nominal-io/nominal-client/commit/1ce1082dd025371bed4920c0e10d5ec93ac37687))
+* allow using truststore for ssl bypass ([#472](https://github.com/nominal-io/nominal-client/issues/472)) ([55a43c2](https://github.com/nominal-io/nominal-client/commit/55a43c23cb5a32b6cf90b2d50c5f0e79eeafaca7))
+* create new clone workbook and associated helpers in experimental ([#546](https://github.com/nominal-io/nominal-client/issues/546)) ([aeffb44](https://github.com/nominal-io/nominal-client/commit/aeffb44827b46e90101404d4a9a18d036aac49ab))
+* expose truststore.SSLContext across requests usage to permit usage in corporate networks ([55a43c2](https://github.com/nominal-io/nominal-client/commit/55a43c23cb5a32b6cf90b2d50c5f0e79eeafaca7))
+
+
+### Bug Fixes
+
+* fix log message missing argument ([#547](https://github.com/nominal-io/nominal-client/issues/547)) ([c684caa](https://github.com/nominal-io/nominal-client/commit/c684caa559544f7c5c2f13e6d94fd8f2e718827c))
+
+## [1.99.0](https://github.com/nominal-io/nominal-client/compare/v1.98.0...v1.99.0) (2025-12-04)
+
+
+### Features
+
+* allow ingesting .avro files ([#544](https://github.com/nominal-io/nominal-client/issues/544)) ([f5c4561](https://github.com/nominal-io/nominal-client/commit/f5c4561e1db6174a56d6b32b388ed7ad94679fdf))
+
 ## [1.98.0](https://github.com/nominal-io/nominal-client/compare/v1.97.0...v1.98.0) (2025-12-04)
 
 

nominal/core/_utils/multipart.py

@@ -11,6 +11,7 @@ from typing import BinaryIO, Iterable
 import requests
 from nominal_api import ingest_api, upload_api
 
+from nominal.core._utils.networking import create_multipart_request_session
 from nominal.core.exceptions import NominalMultipartUploadFailed
 from nominal.core.filetype import FileType
 
@@ -22,6 +23,7 @@ DEFAULT_NUM_WORKERS = 8
 
 def _sign_and_upload_part_job(
     upload_client: upload_api.UploadService,
+    multipart_session: requests.Session,
     auth_header: str,
     key: str,
     upload_id: str,
@@ -45,8 +47,8 @@ def _sign_and_upload_part_job(
                     extra={"response.url": sign_response.url, **log_extras},
                 )
 
-                logger.debug("Pushing part %d for multipart upload", extra=log_extras)
-                put_response = requests.put(
+                logger.debug("Pushing part %d for multipart upload", part, extra=log_extras)
+                put_response = multipart_session.put(
                     sign_response.url,
                     data=data,
                     headers=sign_response.headers,
@@ -141,7 +143,10 @@ def put_multipart_upload(
     )
     initiate_response = upload_client.initiate_multipart_upload(auth_header, initiate_request)
     key, upload_id = initiate_response.key, initiate_response.upload_id
-    _sign_and_upload_part = partial(_sign_and_upload_part_job, upload_client, auth_header, key, upload_id, q)
+    multipart_session = create_multipart_request_session(pool_size=max_workers)
+    _sign_and_upload_part = partial(
+        _sign_and_upload_part_job, upload_client, multipart_session, auth_header, key, upload_id, q
+    )
 
     jobs: list[concurrent.futures.Future[requests.Response]] = []
 

nominal/core/_utils/multipart_downloader.py

@@ -13,11 +13,10 @@ from types import TracebackType
 from typing import Callable, Iterable, Mapping, Sequence, Type
 
 import requests
-from requests.adapters import HTTPAdapter
 from typing_extensions import Self
-from urllib3.util.retry import Retry
 
 from nominal.core._utils.multipart import DEFAULT_CHUNK_SIZE
+from nominal.core._utils.networking import create_multipart_request_session
 
 logger = logging.getLogger(__name__)
 
@@ -129,25 +128,12 @@ class MultipartFileDownloader:
             max_workers = multiprocessing.cpu_count()
             logger.info("Inferring core count as %d", max_workers)
 
-        session = cls._make_session(max_workers)
+        session = create_multipart_request_session(pool_size=max_workers)
         pool = ThreadPoolExecutor(max_workers=max_workers)
         return cls(max_workers, timeout, max_part_retries, _session=session, _pool=pool, _closed=False)
 
     # ---- lifecycle ----
 
-    @staticmethod
-    def _make_session(pool_size: int) -> requests.Session:
-        retries = Retry(
-            total=5,
-            backoff_factor=0.5,
-            status_forcelist=(429, 500, 502, 503, 504),
-            allowed_methods=frozenset(["GET", "HEAD"]),
-        )
-        s = requests.Session()
-        adapter = HTTPAdapter(max_retries=retries, pool_maxsize=pool_size)
-        s.mount("https://", adapter)
-        return s
-
     def close(self) -> None:
         if not self._closed:
             try:

nominal/core/_utils/networking.py

@@ -1,20 +1,69 @@
 from __future__ import annotations
 
 import gzip
+import logging
 import os
+import ssl
 from typing import Any, Callable, Mapping, Type, TypeVar
 
 import requests
+import truststore
 from conjure_python_client import ServiceConfiguration
-from conjure_python_client._http.requests_client import RetryWithJitter, TransportAdapter
-from requests.adapters import CaseInsensitiveDict
+from conjure_python_client._http.requests_client import KEEP_ALIVE_SOCKET_OPTIONS, RetryWithJitter
+from requests.adapters import DEFAULT_POOLSIZE, CaseInsensitiveDict, HTTPAdapter
+from urllib3.connection import HTTPConnection
+from urllib3.util.retry import Retry
+
+logger = logging.getLogger(__name__)
 
 T = TypeVar("T")
 
 GZIP_COMPRESSION_LEVEL = 1
 
 
-class GzipRequestsAdapter(TransportAdapter):
+class SslBypassRequestsAdapter(HTTPAdapter):
+    """Transport adapter that allows customizing SSL options and forwarding host truststore.
+
+    NOTE: based on a combination of injecting `truststore.SSLContext` into
+        `conjure_python_client._http.requests_client.TransportAdapter`.
+    """
+
+    ENABLE_KEEP_ALIVE_ATTR = "_enable_keep_alive"
+    __attrs__ = [*HTTPAdapter.__attrs__, ENABLE_KEEP_ALIVE_ATTR]
+
+    def __init__(self, *args: Any, enable_keep_alive: bool = False, **kwargs: Any):
+        self._enable_keep_alive = enable_keep_alive
+        super().__init__(*args, **kwargs)
+
+    def init_poolmanager(
+        self,
+        connections: int,
+        maxsize: int,
+        block: bool = False,
+        **pool_kwargs: Mapping[str, Any],
+    ) -> None:
+        """Wrapper around the standard init_poolmanager from HTTPAdapter with modifications
+        to support keep-alive settings and injecting SSL context.
+        """
+        if self._enable_keep_alive:
+            keep_alive_kwargs: dict[str, Any] = {
+                "socket_options": [
+                    *HTTPConnection.default_socket_options,
+                    *KEEP_ALIVE_SOCKET_OPTIONS,
+                ]
+            }
+            pool_kwargs = {**pool_kwargs, **keep_alive_kwargs}
+
+        pool_kwargs["ssl_context"] = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+
+        super().init_poolmanager(connections, maxsize, block, **pool_kwargs)  # type: ignore[no-untyped-call]
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        state[self.ENABLE_KEEP_ALIVE_ATTR] = state.get(self.ENABLE_KEEP_ALIVE_ATTR, False)
+        super().__setstate__(state)  # type: ignore[misc]
+
+
+class NominalRequestsAdapter(SslBypassRequestsAdapter):
     """Adapter used with `requests` library for sending gzip-compressed data.
 
     Based on: https://github.com/psf/requests/issues/1753#issuecomment-417806737
@@ -69,7 +118,7 @@ class GzipRequestsAdapter(TransportAdapter):
         return super().send(request, stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies)
 
 
-def create_gzip_service_client(
+def create_conjure_service_client(
     service_class: Type[T],
     user_agent: str,
     service_config: ServiceConfiguration,
@@ -104,7 +153,7 @@ def create_gzip_service_client(
         status_forcelist=[308, 429, 503],
         backoff_factor=float(service_config.backoff_slot_size) / 1000,
     )
-    transport_adapter = GzipRequestsAdapter(max_retries=retry)
+    transport_adapter = NominalRequestsAdapter(max_retries=retry)
     # create a session, for shared connection polling, user agent, etc
     session = requests.Session()
     session.headers = CaseInsensitiveDict({"User-Agent": user_agent})
@@ -131,11 +180,11 @@ def create_conjure_client_factory(
 ) -> Callable[[Type[T]], T]:
     """Create factory method for creating conjure clients given the respective conjure service type
 
-    See `create_gzip_service_client` for documentation on parameters.
+    See `create_conjure_service_client` for documentation on parameters.
     """
 
     def factory(service_class: Type[T]) -> T:
-        return create_gzip_service_client(
+        return create_conjure_service_client(
             service_class,
             user_agent=user_agent,
             service_config=service_config,
@@ -143,3 +192,19 @@ def create_conjure_client_factory(
         )
 
     return factory
+
+
+def create_multipart_request_session(
+    *,
+    pool_size: int = DEFAULT_POOLSIZE,
+    num_retries: int = 5,
+) -> requests.Session:
+    retries = Retry(
+        total=num_retries,
+        backoff_factor=0.5,
+        status_forcelist=(429, 500, 502, 503, 504),
+    )
+    session = requests.Session()
+    adapter = SslBypassRequestsAdapter(max_retries=retries, pool_maxsize=pool_size)
+    session.mount("https://", adapter)
+    return session

nominal/core/asset.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
 
+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 (
+    scout,
     scout_asset_api,
     scout_assets,
     scout_run_api,
@@ -13,6 +15,7 @@ from typing_extensions import Self
 
 from nominal.core._clientsbunch import HasScoutParams
 from nominal.core._utils.api_tools import HasRid, Link, RefreshableMixin, create_links, rid_from_instance_or_string
+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
@@ -22,6 +25,8 @@ from nominal.ts import IntegralNanosecondsUTC, _SecondsNanos
 
 ScopeType: TypeAlias = Connection | Dataset | Video
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
@@ -43,6 +48,8 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
     ):
         @property
         def assets(self) -> scout_assets.AssetService: ...
+        @property
+        def run(self) -> scout.RunService: ...
 
     @property
     def nominal_url(self) -> str:
@@ -98,6 +105,22 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
             if scope.data_source.type.lower() == stype
         }
 
+    def promote(self) -> Self:
+        """Promote this asset to be a standard, searchable, and displayable asset.
+
+        This method is only useful for assets that were created implicitly from creating a run directly on a dataset.
+        Nothing will happen from calling this method (aside from a logged warning) if called on a non-staged
+        asset (e.g. an asset created by create_asset, or an asset that's already been promoted).
+        """
+        if self._get_latest_api().is_staged:
+            request = scout_asset_api.UpdateAssetRequest(is_staged=False)
+            updated_asset = self._clients.assets.update_asset(self._clients.auth_header, request, self.rid)
+            self._refresh_from_api(updated_asset)
+        else:
+            logger.warning("Not promoting asset %s-- already promoted!", self.rid)
+
+        return self
+
     def get_data_scope(self, data_scope_name: str) -> ScopeType:
         """Retrieve a datascope by data scope name, or raise ValueError if one is not found."""
         for scope, data in self.list_data_scopes():
@@ -257,6 +280,7 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
         description: str | None = None,
         labels: Sequence[str] = (),
         properties: Mapping[str, str] | None = None,
+        prefix_tree_delimiter: str | None = None,
     ) -> Dataset:
         """Retrieve a dataset by data scope name, or create a new one if it does not exist."""
         try:
@@ -272,6 +296,10 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
                 workspace_rid=self._clients.workspace_rid,
             )
             dataset = Dataset._from_conjure(self._clients, enriched_dataset)
+
+            if prefix_tree_delimiter is not None:
+                dataset.set_channel_prefix_tree(prefix_tree_delimiter)
+
             self.add_dataset(data_scope_name, dataset)
             return dataset
 
@@ -372,6 +400,17 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
     def list_attachments(self) -> Sequence[Attachment]:
         return list(self._iter_list_attachments())
 
+    def list_runs(self) -> Sequence[Run]:
+        """List all runs associated with this Asset."""
+        return [
+            Run._from_conjure(self._clients, run)
+            for run in search_runs_by_asset_paginated(
+                self._clients.run,
+                self._clients.auth_header,
+                self.rid,
+            )
+        ]
+
     def remove_attachments(self, attachments: Iterable[Attachment] | Iterable[str]) -> None:
         """Remove attachments from this asset.
         Does not remove the attachments from Nominal.
@@ -403,3 +442,7 @@ class Asset(HasRid, RefreshableMixin[scout_asset_api.Asset]):
             created_at=_SecondsNanos.from_flexible(asset.created_at).to_nanoseconds(),
             _clients=clients,
         )
+
+
+# Moving to bottom to deal with circular dependencies
+from nominal.core.run import Run  # noqa: E402

nominal/core/client.py

@@ -608,6 +608,10 @@ class NominalClient:
             )
         )
 
+    @deprecated(
+        "NominalClient.search_runs_by_asset is deprecated and will be removed in a future version. "
+        "Use Asset.list_runs() instead."
+    )
     def search_runs_by_asset(self, asset: Asset | str) -> Sequence[Run]:
         """Search for all runs associated with a given asset:
 

nominal/core/containerized_extractors.py

@@ -5,7 +5,7 @@ from enum import Enum
 from typing import Mapping, Protocol, Sequence
 
 from nominal_api import ingest_api
-from typing_extensions import Self
+from typing_extensions import Self, deprecated
 
 from nominal._utils.dataclass_tools import update_dataclass
 from nominal.core._clientsbunch import HasScoutParams
@@ -203,9 +203,22 @@ class ContainerizedExtractor(HasRid):
     inputs: Sequence[FileExtractionInput]
     properties: Mapping[str, str]
     labels: Sequence[str]
-    timestamp_metadata: TimestampMetadata
+    default_timestamp_metadata: TimestampMetadata | None
     _clients: _Clients = field(repr=False)
 
+    @property
+    @deprecated(
+        "The `timestamp_metadata` field of a ContainerizedExtractor is deprecated and will be removed in a future "
+        "release. Use the `default_timestamp_metadata` field instead."
+    )
+    def timestamp_metadata(self) -> TimestampMetadata:
+        if self.default_timestamp_metadata is None:
+            raise ValueError(
+                f"Containerized extractor {self.name} ({self.rid}) has no default configured timestamp metadata"
+            )
+
+        return self.default_timestamp_metadata
+
     class _Clients(HasScoutParams, Protocol):
         @property
         def containerized_extractors(self) -> ingest_api.ContainerizedExtractorService: ...
@@ -251,6 +264,12 @@ class ContainerizedExtractor(HasRid):
 
     @classmethod
     def _from_conjure(cls, clients: _Clients, raw_extractor: ingest_api.ContainerizedExtractor) -> Self:
+        timestamp_metadata = (
+            None
+            if raw_extractor.timestamp_metadata is None
+            else TimestampMetadata._from_conjure(raw_extractor.timestamp_metadata)
+        )
+
         return cls(
             rid=raw_extractor.rid,
             name=raw_extractor.name,
@@ -259,6 +278,6 @@ class ContainerizedExtractor(HasRid):
             inputs=[FileExtractionInput._from_conjure(raw_input) for raw_input in raw_extractor.inputs],
             properties=raw_extractor.properties,
             labels=raw_extractor.labels,
-            timestamp_metadata=TimestampMetadata._from_conjure(raw_extractor.timestamp_metadata),
+            default_timestamp_metadata=timestamp_metadata,
             _clients=clients,
         )

nominal/core/dataset.py

@@ -6,7 +6,7 @@ from datetime import timedelta
 from io import TextIOBase
 from pathlib import Path
 from types import MappingProxyType
-from typing import BinaryIO, Iterable, Mapping, Sequence, TypeAlias
+from typing import BinaryIO, Iterable, Mapping, Sequence, TypeAlias, overload
 
 from nominal_api import api, ingest_api, scout_catalog
 from typing_extensions import Self, deprecated
@@ -203,6 +203,78 @@ class Dataset(DataSource, RefreshableMixin[scout_catalog.EnrichedDataset]):
     # Backward compatibility
     add_to_dataset_from_io = add_from_io
 
+    def add_avro_stream(
+        self,
+        path: Path | str,
+    ) -> DatasetFile:
+        """Upload an avro stream file with a specific schema, described below.
+
+        This is a "stream-like" file format to support
+        use cases where a columnar/tabular format does not make sense. This closely matches Nominal's streaming
+        API, making it useful for use cases where network connection drops during streaming and a backup file needs
+        to be created.
+
+        If this schema is not used, will result in a failed ingestion.
+        {
+            "type": "record",
+            "name": "AvroStream",
+            "namespace": "io.nominal.ingest",
+            "fields": [
+                {
+                    "name": "channel",
+                    "type": "string",
+                    "doc": "Channel/series name (e.g., 'vehicle_id', 'col_1', 'temperature')",
+                },
+                {
+                    "name": "timestamps",
+                    "type": {"type": "array", "items": "long"},
+                    "doc": "Array of Unix timestamps in nanoseconds",
+                },
+                {
+                    "name": "values",
+                    "type": {"type": "array", "items": ["double", "string"]},
+                    "doc": "Array of values. Can either be doubles or strings",
+                },
+                {
+                    "name": "tags",
+                    "type": {"type": "map", "values": "string"},
+                    "default": {},
+                    "doc": "Key-value metadata tags",
+                },
+            ],
+        }
+
+        Args:
+            path: Path to the .avro file to upload
+
+        Returns:
+            Reference to the ingesting DatasetFile
+
+        """
+        avro_path = Path(path)
+        s3_path = upload_multipart_file(
+            self._clients.auth_header,
+            self._clients.workspace_rid,
+            avro_path,
+            self._clients.upload,
+            file_type=FileTypes.AVRO_STREAM,
+        )
+        target = ingest_api.DatasetIngestTarget(
+            existing=ingest_api.ExistingDatasetIngestDestination(dataset_rid=self.rid)
+        )
+        resp = self._clients.ingest.ingest(
+            self._clients.auth_header,
+            ingest_api.IngestRequest(
+                options=ingest_api.IngestOptions(
+                    avro_stream=ingest_api.AvroStreamOpts(
+                        source=ingest_api.IngestSource(s3=ingest_api.S3IngestSource(s3_path)),
+                        target=target,
+                    )
+                )
+            ),
+        )
+        return self._handle_ingest_response(resp)
+
     def add_journal_json(
         self,
         path: Path | str,
@@ -338,11 +410,38 @@ class Dataset(DataSource, RefreshableMixin[scout_catalog.EnrichedDataset]):
     # Backward compatibility
     add_ardupilot_dataflash_to_dataset = add_ardupilot_dataflash
 
+    @overload
     def add_containerized(
         self,
         extractor: str | ContainerizedExtractor,
         sources: Mapping[str, Path | str],
         tag: str | None = None,
+        *,
+        arguments: Mapping[str, str] | None = None,
+        tags: Mapping[str, str] | None = None,
+    ) -> DatasetFile: ...
+    @overload
+    def add_containerized(
+        self,
+        extractor: str | ContainerizedExtractor,
+        sources: Mapping[str, Path | str],
+        tag: str | None = None,
+        *,
+        arguments: Mapping[str, str] | None = None,
+        tags: Mapping[str, str] | None = None,
+        timestamp_column: str,
+        timestamp_type: _AnyTimestampType,
+    ) -> DatasetFile: ...
+    def add_containerized(
+        self,
+        extractor: str | ContainerizedExtractor,
+        sources: Mapping[str, Path | str],
+        tag: str | None = None,
+        *,
+        arguments: Mapping[str, str] | None = None,
+        tags: Mapping[str, str] | None = None,
+        timestamp_column: str | None = None,
+        timestamp_type: _AnyTimestampType | None = None,
     ) -> DatasetFile:
         """Add data from proprietary data formats using a pre-registered custom extractor.
 
@@ -352,7 +451,24 @@ class Dataset(DataSource, RefreshableMixin[scout_catalog.EnrichedDataset]):
                 NOTE: these must match the registered inputs of the containerized extractor exactly
             tag: Tag of the Docker container which hosts the extractor.
                 NOTE: if not provided, the default registered docker tag will be used.
+            arguments: Mapping of key-value pairs of input arguments to the extractor.
+            tags: Key-value pairs of tags to apply to all data ingested from the containerized extractor run.
+            timestamp_column: the column in the dataset that contains the timestamp data.
+                NOTE: this is applied uniformly to all output files
+                NOTE: must be provided with a `timestamp_type` or a ValueError will be raised
+            timestamp_type: the type of timestamp data in the dataset.
+                NOTE: this is applied uniformly to all output files
+                NOTE: must be provided with a `timestamp_column` or a ValueError will be raised
         """
+        timestamp_metadata = None
+        if timestamp_column is not None and timestamp_type is not None:
+            timestamp_metadata = ingest_api.TimestampMetadata(
+                series_name=timestamp_column,
+                timestamp_type=_to_typed_timestamp_type(timestamp_type)._to_conjure_ingest_api(),
+            )
+        elif None in (timestamp_column, timestamp_type):
+            raise ValueError("Only one of `timestamp_column` and `timestamp_type` provided!")
+
         if isinstance(extractor, str):
             extractor = ContainerizedExtractor._from_conjure(
                 self._clients,
@@ -379,13 +495,14 @@ class Dataset(DataSource, RefreshableMixin[scout_catalog.EnrichedDataset]):
             )
             logger.info("Uploaded %s -> %s", source_path, s3_path)
             s3_inputs[source] = s3_path
+
         logger.info("Triggering custom extractor %s (tag=%s) with %s", extractor.name, tag, s3_inputs)
         resp = self._clients.ingest.ingest(
             self._clients.auth_header,
             trigger_ingest=ingest_api.IngestRequest(
                 options=ingest_api.IngestOptions(
                     containerized=ingest_api.ContainerizedOpts(
-                        arguments={},
+                        arguments={**(arguments or {})},
                         extractor_rid=extractor.rid,
                         sources={
                             source: ingest_api.IngestSource(s3=ingest_api.S3IngestSource(path=s3_path))
@@ -395,6 +512,8 @@ class Dataset(DataSource, RefreshableMixin[scout_catalog.EnrichedDataset]):
                             existing=ingest_api.ExistingDatasetIngestDestination(self.rid)
                         ),
                         tag=tag,
+                        additional_file_tags={**(tags or {})},
+                        timestamp_metadata=timestamp_metadata,
                     )
                 )
             ),

nominal/core/filetype.py

@@ -111,6 +111,7 @@ class FileType(NamedTuple):
 
 
 class FileTypes:
+    AVRO_STREAM: FileType = FileType(".avro", "application/avro")
     BINARY: FileType = FileType("", "application/octet-stream")
     CSV: FileType = FileType(".csv", "text/csv")
     CSV_GZ: FileType = FileType(".csv.gz", "text/csv")

nominal/core/run.py

@@ -6,11 +6,11 @@ from types import MappingProxyType
 from typing import Iterable, Mapping, Protocol, Sequence, cast
 
 from nominal_api import (
-    scout,
     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._utils.api_tools import (
     HasRid,
@@ -20,7 +20,6 @@ from nominal.core._utils.api_tools import (
     create_links,
     rid_from_instance_or_string,
 )
-from nominal.core.asset import Asset
 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
@@ -45,12 +44,11 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run]):
     _clients: _Clients = field(repr=False)
 
     class _Clients(
-        Asset._Clients,
+        core_asset.Asset._Clients,
         HasScoutParams,
         Protocol,
     ):
-        @property
-        def run(self) -> scout.RunService: ...
+        pass
 
     @property
     def nominal_url(self) -> str:
@@ -304,13 +302,13 @@ class Run(HasRid, RefreshableMixin[scout_run_api.Run]):
         """List a sequence of Attachments associated with this Run."""
         return list(self._iter_list_attachments())
 
-    def _iter_list_assets(self) -> Iterable[Asset]:
+    def _iter_list_assets(self) -> Iterable[core_asset.Asset]:
         run = self._get_latest_api()
         assets = self._clients.assets.get_assets(self._clients.auth_header, run.assets)
         for a in assets.values():
-            yield Asset._from_conjure(self._clients, a)
+            yield core_asset.Asset._from_conjure(self._clients, a)
 
-    def list_assets(self) -> Sequence[Asset]:
+    def list_assets(self) -> Sequence[core_asset.Asset]:
         """List assets associated with this run."""
         return list(self._iter_list_assets())
 

nominal/experimental/migration/__init__.py

@@ -0,0 +1,19 @@
+from nominal.experimental.migration.migration_utils import (
+    clone_asset,
+    clone_dataset,
+    clone_workbook_template,
+    copy_asset_from,
+    copy_dataset_from,
+    copy_resources_to_destination_client,
+    copy_workbook_template_from,
+)
+
+__all__ = [
+    "clone_asset",
+    "clone_dataset",
+    "clone_workbook_template",
+    "copy_asset_from",
+    "copy_dataset_from",
+    "copy_resources_to_destination_client",
+    "copy_workbook_template_from",
+]

nominal/experimental/migration/migration_utils.py

@@ -0,0 +1,552 @@
+import json
+import logging
+import re
+import uuid
+from pathlib import Path
+from typing import Any, BinaryIO, Mapping, Sequence, TypeVar, Union, cast, overload
+
+import requests
+from conjure_python_client import ConjureBeanType, ConjureEnumType, ConjureUnionType
+from conjure_python_client._serde.decoder import ConjureDecoder
+from conjure_python_client._serde.encoder import ConjureEncoder
+from nominal_api import scout_layout_api, scout_template_api, scout_workbookcommon_api
+
+from nominal.core import Asset, Dataset, DatasetFile, FileType, NominalClient, Workbook, WorkbookTemplate
+
+logger = logging.getLogger(__name__)
+
+ConjureType = Union[ConjureBeanType, ConjureUnionType, ConjureEnumType]
+
+# Regex pattern to match strings that have a UUID format with a prefix.
+UUID_PATTERN = re.compile(r"^(.*)([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$")
+
+# Keeping tight control over ids we consider to be UUIDs.
+UUID_KEYS = ("id", "rid", "functionUuid", "plotId", "yAxisId", "chartRid")
+
+
+def _convert_if_json(s: str) -> tuple[Any, bool]:
+    """If the string is a valid JSON, convert it. Otherwise, return original object.
+
+    Args:
+        s: The string to to convert or return as is.
+
+    Returns:
+        The parsed JSON object if s is valid JSON, else the original string. Also returns the action taken in a boolean.
+    """
+    try:
+        return (json.loads(s), True)
+    except (ValueError, TypeError):
+        return (s, False)
+
+
+def _check_and_add_uuid_to_mapping(input_str: str, mapping: dict[str, str]) -> None:
+    """Check if a string matches the UUID pattern and add to mapping if not already present.
+
+    Args:
+        input_str: The string to check for UUID pattern.
+        mapping: The mapping dictionary to add to if a new UUID is found.
+    """
+    match = UUID_PATTERN.search(input_str)
+    if match and input_str not in mapping:
+        mapping[input_str] = f"{match.group(1)}{str(uuid.uuid4())}"
+        logger.debug("Found UUID and added to mapping: %s -> %s", input_str, mapping[input_str])
+
+
+def _extract_uuids_from_obj(obj: Any, mapping: dict[str, str]) -> None:
+    """Recursively extract UUIDs from a nested JSON object, and populate the mapping.
+
+    Searches for UUIDs in:
+    - Values of specific keys (defined in UUID_KEYS)
+    - Dictionary keys that match the UUID pattern
+    - Nested JSON strings that are parsed and searched recursively
+
+    Args:
+        obj: The object to search (dict, list, or primitive).
+        mapping: Dictionary to populate with found UUIDs as keys.
+    """
+    # TODO (Sean): Refactor to remove expensive recursion strategy.
+    if isinstance(obj, dict):
+        for key, value in obj.items():
+            if key in UUID_KEYS and isinstance(value, str):
+                _check_and_add_uuid_to_mapping(value, mapping)
+            else:
+                _check_and_add_uuid_to_mapping(key, mapping)
+            # Some values may be JSON strings that need to be parsed.
+            _extract_uuids_from_obj(_convert_if_json(value)[0] if isinstance(value, str) else value, mapping)
+    elif isinstance(obj, list):
+        for item in obj:
+            _extract_uuids_from_obj(item, mapping)
+
+
+def _generate_uuid_mapping(objs: list[Any]) -> dict[str, str]:
+    """Search for all UUIDs in a list of objects and generate a mapping to new UUIDs.
+
+    Args:
+        objs: List of objects to search for UUIDs.
+
+    Returns:
+        A mapping of all UUIDs found in the objects with their new generated UUIDs.
+    """
+    mapping: dict[str, str] = {}
+    for obj in objs:
+        _extract_uuids_from_obj(obj, mapping)
+    return mapping
+
+
+def create_workbook_template_with_content_and_layout(
+    client: NominalClient,
+    title: str,
+    layout: scout_layout_api.WorkbookLayout,
+    content: scout_workbookcommon_api.WorkbookContent,
+    workspace_rid: str,
+    *,
+    description: str | None = None,
+    labels: Sequence[str] | None = None,
+    properties: Mapping[str, str] | None = None,
+    commit_message: str | None = None,
+) -> WorkbookTemplate:
+    """Create a workbook template with specified content and layout.
+
+    This is a helper method that constructs and creates a workbook template
+    request with the provided parameters, including layout and content.  Method is considered experimental and may
+    change in future releases. The template is created in the target workspace and is not discoverable by default.
+
+    Args:
+        client: The NominalClient to use for creating the template.
+        title: The title of the template.
+        layout: The workbook layout to use.
+        content: The workbook content to use.
+        workspace_rid: The resource ID of the workspace to create the template in.
+        description: The description of the template.
+        labels: List of labels to apply to the template.
+        properties: Dictionary of properties for the template.
+        commit_message: The commit message for the template creation.
+
+    Returns:
+        The newly created WorkbookTemplate.
+    """
+    request = scout_template_api.CreateTemplateRequest(
+        title=title,
+        description=description if description is not None else "",
+        labels=list(labels) if labels is not None else [],
+        properties=dict(properties) if properties is not None else {},
+        is_published=False,
+        layout=layout,
+        content=content,
+        message=commit_message if commit_message is not None else "",
+        workspace=client._workspace_rid_for_search(workspace_rid),
+    )
+
+    template = client._clients.template.create(client._clients.auth_header, request)
+    return WorkbookTemplate._from_conjure(client._clients, template)
+
+
+def _replace_uuids_in_obj(obj: Any, mapping: dict[str, str]) -> Any:
+    """Recursively replace UUIDs in a nested JSON object.
+
+    Replaces UUIDs found in:
+    - Dictionary keys that match UUID pattern and are in the mapping
+    - String values that are in the mapping
+    - Nested JSON strings that are parsed, processed, and re-serialized
+
+    Args:
+        obj: The object to process (dict, list, or primitive).
+        mapping: Dictionary mapping old UUIDs to new UUIDs.
+
+    Returns:
+        A new object with all UUIDs replaced according to the mapping.
+        Primitive values are returned unchanged if they don't match any UUIDs.
+    """
+    if isinstance(obj, dict):
+        new_obj = {}
+        for key, value in obj.items():
+            if isinstance(key, str) and re.search(UUID_PATTERN, key) and key in mapping:
+                new_key = mapping[key]
+                new_obj[new_key] = _replace_uuids_in_obj(value, mapping)
+            elif isinstance(value, str) and value in mapping:
+                new_obj[key] = mapping[value]
+            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=(",", ":"))
+                else:
+                    new_obj[key] = _replace_uuids_in_obj(value, mapping)
+            else:
+                new_obj[key] = _replace_uuids_in_obj(value, mapping)
+        return new_obj
+    elif isinstance(obj, list):
+        return [_replace_uuids_in_obj(item, mapping) for item in obj]
+    else:
+        return obj
+
+
+T1 = TypeVar("T1", bound=ConjureType)
+T2 = TypeVar("T2", bound=ConjureType)
+
+
+@overload
+def _clone_conjure_objects_with_new_uuids(
+    objs: tuple[T1, T2],
+) -> tuple[T1, T2]: ...
+
+
+@overload
+def _clone_conjure_objects_with_new_uuids(objs: list[ConjureType]) -> list[ConjureType]: ...
+
+
+def _clone_conjure_objects_with_new_uuids(
+    objs: tuple[ConjureType, ...] | list[ConjureType],
+) -> tuple[ConjureType, ...] | list[ConjureType]:
+    """Clone Conjure objects by replacing all UUIDs with new ones.
+
+    This function:
+    1. Converts Conjure objects to JSON
+    2. Finds all UUIDs in the JSON structures, according to defined keys
+    3. Generates new UUIDs for each old UUID, maintaining prefixes
+    4. Replaces all UUIDs in the objects
+    5. Returns the cloned objects with new UUIDs
+
+    Args:
+        objs: List of Conjure objects to clone.
+
+    Returns:
+        List of cloned Conjure objects with new UUIDs. The structure and content
+        are identical to the originals, but all UUIDs have been replaced.
+    """
+    original_types = [type(obj) for obj in objs]
+
+    json_objs = [ConjureEncoder.do_encode(obj) for obj in objs]
+
+    mapping = _generate_uuid_mapping(json_objs)
+
+    new_json_objs = [_replace_uuids_in_obj(json_obj, mapping) for json_obj in json_objs]
+
+    # Deserialize each dict back to its original type
+    decoder = ConjureDecoder()
+    result = [
+        decoder.do_decode(new_json_obj, obj_type) for new_json_obj, obj_type in zip(new_json_objs, original_types)
+    ]
+
+    return tuple(result) if isinstance(objs, tuple) else result
+
+
+# TODO (Sean): Once we move this out of experimental, make clone/copy_resource_from abstract methods in the HasRid class
+def clone_workbook_template(
+    source_template: WorkbookTemplate,
+    destination_client: NominalClient,
+) -> WorkbookTemplate:
+    """Clones a workbook template, maintaining all properties and content.
+
+    Args:
+        source_template (WorkbookTemplate): The template to copy
+        destination_client (NominalClient): The client to copy to
+    Returns:
+        The cloned template.
+    """
+    return copy_workbook_template_from(
+        source_template=source_template,
+        destination_client=destination_client,
+        include_content_and_layout=True,
+    )
+
+
+def copy_workbook_template_from(
+    source_template: WorkbookTemplate,
+    destination_client: NominalClient,
+    *,
+    new_template_title: str | None = None,
+    new_template_description: str | None = None,
+    new_template_labels: Sequence[str] | None = None,
+    new_template_properties: Mapping[str, str] | None = None,
+    include_content_and_layout: bool = False,
+) -> WorkbookTemplate:
+    """Clone a workbook template from the source to the target workspace.
+
+    Retrieves the source template, clones its layout and content.  For safety, we replace
+    all unique identifiers with new UUIDs. We then creates a new template in the target workspace.
+    The cloned template maintains all metadata (title, description, labels, properties).
+
+    Args:
+        source_template: The source WorkbookTemplate to clone.
+        destination_client: The NominalClient to create the cloned template in.
+        new_template_title: Optional new name for the cloned template. If not provided, the original is used.
+        new_template_description: Optional new name for the cloned template. If not provided, the original is used.
+        new_template_labels: Optional new labels for the cloned template. If not provided, the original is used.
+        new_template_properties: Optional new properties for the cloned template. If not provided, the original is used.
+        include_content_and_layout: If True, copy layout and content from template. Otherwise, use blank content.
+
+    Returns:
+        The newly created WorkbookTemplate in the target workspace.
+    """
+    log_extras = {"destination_client_workspace": destination_client.get_workspace().rid}
+    logger.debug(
+        "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
+    )
+
+    if include_content_and_layout:
+        template_layout = raw_source_template.layout
+        template_content = raw_source_template.content
+        (new_template_layout, new_workbook_content) = _clone_conjure_objects_with_new_uuids(
+            (template_layout, template_content)
+        )
+    else:
+        new_template_layout = scout_layout_api.WorkbookLayout(
+            v1=scout_layout_api.WorkbookLayoutV1(
+                root_panel=scout_layout_api.Panel(
+                    tabbed=scout_layout_api.TabbedPanel(
+                        v1=scout_layout_api.TabbedPanelV1(
+                            id=str(uuid.uuid4()),
+                            tabs=[],
+                        )
+                    )
+                )
+            )
+        )
+        new_workbook_content = scout_workbookcommon_api.WorkbookContent(channel_variables={}, charts={})
+    new_workbook_template = create_workbook_template_with_content_and_layout(
+        client=destination_client,
+        title=new_template_title or raw_source_template.metadata.title,
+        description=new_template_description or raw_source_template.metadata.description,
+        labels=new_template_labels or raw_source_template.metadata.labels,
+        properties=new_template_properties or raw_source_template.metadata.properties,
+        layout=new_template_layout,
+        content=new_workbook_content,
+        commit_message="Cloned from template",
+        workspace_rid=destination_client.get_workspace().rid,
+    )
+    logger.debug(
+        "New workbook template created %s from %s (rid: %s)",
+        new_workbook_template.title,
+        source_template.title,
+        source_template.rid,
+        extra=log_extras,
+    )
+    return new_workbook_template
+
+
+def copy_file_to_dataset(
+    source_file: DatasetFile,
+    destination_dataset: Dataset,
+) -> DatasetFile:
+    """Copy a dataset file from the source to the destination dataset.
+
+    Args:
+        source_file: The source DatasetFile to copy.
+        destination_dataset: The Dataset to create the copied file in.
+
+    Returns:
+        The dataset file in the new dataset.
+    """
+    log_extras = {"destination_client_workspace": destination_dataset._clients.workspace_rid}
+    logger.debug("Copying dataset file: %s", source_file.name, extra=log_extras)
+    source_api_file = source_file._get_latest_api()
+    if (
+        source_api_file.handle.s3 is not None
+        and source_file.timestamp_channel is not None
+        and source_file.timestamp_type is not None
+    ):
+        old_file_uri = source_file._clients.catalog.get_dataset_file_uri(
+            source_file._clients.auth_header, source_file.dataset_rid, source_file.id
+        ).uri
+
+        response = requests.get(old_file_uri, stream=True)
+        response.raise_for_status()
+
+        file_name = source_api_file.handle.s3.key.split("/")[-1]
+        file_type = FileType.from_path(file_name)
+        file_stem = Path(file_name).stem
+
+        new_file = destination_dataset.add_from_io(
+            dataset=cast(BinaryIO, response.raw),
+            timestamp_column=source_file.timestamp_channel,
+            timestamp_type=source_file.timestamp_type,
+            file_type=file_type,
+            file_name=file_stem,
+            tag_columns=source_file.tag_columns,
+            tags=source_file.file_tags,
+        )
+        logger.debug(
+            "New file created %s in dataset: %s (rid: %s)",
+            new_file.name,
+            destination_dataset.name,
+            destination_dataset.rid,
+        )
+        return new_file
+    else:  # Because these fields are optional, need to check for None. We shouldn't ever run into this.
+        raise ValueError("Unsupported file handle type or missing timestamp information.")
+
+
+def clone_dataset(source_dataset: Dataset, destination_client: NominalClient) -> Dataset:
+    """Clones a dataset, maintaining all properties and files.
+
+    Args:
+        source_dataset (Dataset): The dataset to copy from.
+        destination_client (NominalClient): The destination client.
+
+    Returns:
+        The cloned dataset.
+    """
+    return copy_dataset_from(source_dataset=source_dataset, destination_client=destination_client, include_files=True)
+
+
+def copy_dataset_from(
+    source_dataset: Dataset,
+    destination_client: NominalClient,
+    *,
+    new_dataset_name: str | None = None,
+    new_dataset_description: str | None = None,
+    new_dataset_properties: dict[str, Any] | None = None,
+    new_dataset_labels: Sequence[str] | None = None,
+    include_files: bool = False,
+) -> Dataset:
+    """Copy a dataset from the source to the destination client.
+
+    Args:
+        source_dataset: The source Dataset to copy.
+        destination_client: The NominalClient to create the copied dataset in.
+        new_dataset_name: Optional new name for the copied dataset. If not provided, the original name is used.
+        new_dataset_description: Optional new description for the copied dataset.
+            If not provided, the original description is used.
+        new_dataset_properties: Optional new properties for the copied dataset. If not provided, the original
+            properties are used.
+        new_dataset_labels: Optional new labels for the copied dataset. If not provided, the original labels are used.
+        include_files: Whether to include files in the copied dataset.
+
+    Returns:
+        The newly created Dataset in the destination client.
+    """
+    log_extras = {"destination_client_workspace": destination_client.get_workspace().rid}
+    logger.debug(
+        "Copying dataset %s (rid: %s)",
+        source_dataset.name,
+        source_dataset.rid,
+        extra=log_extras,
+    )
+    new_dataset = destination_client.create_dataset(
+        name=new_dataset_name if new_dataset_name is not None else source_dataset.name,
+        description=new_dataset_description if new_dataset_description is not None else source_dataset.description,
+        properties=new_dataset_properties if new_dataset_properties is not None else source_dataset.properties,
+        labels=new_dataset_labels if new_dataset_labels is not None else source_dataset.labels,
+    )
+    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)
+    return new_dataset
+
+
+def clone_asset(
+    source_asset: Asset,
+    destination_client: NominalClient,
+) -> Asset:
+    """Clone an asset from the source to the target client.
+
+    Args:
+        source_asset: The source Asset to clone.
+        destination_client: The NominalClient to create the cloned asset in.
+
+    Returns:
+        The newly created Asset in the target client.
+    """
+    return copy_asset_from(source_asset=source_asset, destination_client=destination_client, include_data=True)
+
+
+def copy_asset_from(
+    source_asset: Asset,
+    destination_client: NominalClient,
+    *,
+    new_asset_name: str | None = None,
+    new_asset_description: str | None = None,
+    new_asset_properties: dict[str, Any] | None = None,
+    new_asset_labels: Sequence[str] | None = None,
+    include_data: bool = False,
+) -> Asset:
+    """Copy an asset from the source to the destination client.
+
+    Args:
+        source_asset: The source Asset to copy.
+        destination_client: The NominalClient to create the copied asset in.
+        new_asset_name: Optional new name for the copied asset. If not provided, the original name is used.
+        new_asset_description: Optional new description for the copied asset. If not provided, original description used
+        new_asset_properties: Optional new properties for the copied asset. If not provided, original properties used.
+        new_asset_labels: Optional new labels for the copied asset. If not provided, the original labels are used.
+        include_data: Whether to include data in the copied asset.
+
+    Returns:
+        The new asset created.
+    """
+    log_extras = {"destination_client_workspace": destination_client.get_workspace().rid}
+    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,
+        properties=new_asset_properties if new_asset_properties is not None else source_asset.properties,
+        labels=new_asset_labels if new_asset_labels is not None else source_asset.labels,
+    )
+    if include_data:
+        source_datasets = source_asset.list_datasets()
+        new_datasets = []
+        for data_scope, source_dataset in source_datasets:
+            new_dataset = clone_dataset(
+                source_dataset=source_dataset,
+                destination_client=destination_client,
+            )
+            new_datasets.append(new_dataset)
+            new_asset.add_dataset(data_scope, new_dataset)
+    logger.debug("New asset created: %s (rid: %s)", new_asset, new_asset.rid, extra=log_extras)
+    return new_asset
+
+
+def copy_resources_to_destination_client(
+    destination_client: NominalClient,
+    source_assets: Sequence[Asset],
+    source_workbook_templates: Sequence[WorkbookTemplate],
+) -> tuple[Sequence[tuple[str, Dataset]], Sequence[Asset], Sequence[WorkbookTemplate], Sequence[Workbook]]:
+    """Based on a list of assets and workbook templates, copy resources to destination client, creating
+       new datasets, datafiles, and workbooks along the way.
+
+    Args:
+        destination_client (NominalClient): client of the tenant/workspace to copy resources to.
+        source_assets (Sequence[Asset]): a list of assets to copy (with data)
+        source_workbook_templates (Sequence[WorkbookTemplate]): a list of workbook templates to clone
+        and create workbooks from.
+
+    Returns:
+        All of the created resources.
+    """
+    log_extras = {
+        "destination_client_workspace": destination_client.get_workspace().rid,
+    }
+
+    if len(source_assets) != 1:
+        raise ValueError("Currently, only single asset can be used to create workbook from template")
+
+    new_assets = []
+    new_data_scopes_and_datasets: list[tuple[str, Dataset]] = []
+    for source_asset in source_assets:
+        new_asset = clone_asset(source_asset, destination_client)
+        new_assets.append(new_asset)
+        new_data_scopes_and_datasets.extend(new_asset.list_datasets())
+    new_templates = []
+    new_workbooks = []
+
+    for source_workbook_template in source_workbook_templates:
+        new_template = clone_workbook_template(source_workbook_template, destination_client)
+        new_templates.append(new_template)
+        new_workbook = new_template.create_workbook(
+            title=new_template.title, description=new_template.description, asset=new_assets[0]
+        )
+        logger.debug(
+            "Created new workbook %s (rid: %s) from template %s (rid: %s)",
+            new_workbook.title,
+            new_workbook.rid,
+            new_template.title,
+            new_template.rid,
+            extra=log_extras,
+        )
+        new_workbooks.append(new_workbook)
+
+    return (new_data_scopes_and_datasets, new_assets, new_templates, new_workbooks)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal
-Version: 1.98.0
+Version: 1.100.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.1019.0
+Requires-Dist: nominal-api==0.1032.0
 Requires-Dist: nominal-streaming==0.5.8
 Requires-Dist: openpyxl>=0.0.0
 Requires-Dist: pandas>=0.0.0
@@ -30,6 +30,7 @@ Requires-Dist: pyyaml>=0.0.0
 Requires-Dist: requests>=0.0.0
 Requires-Dist: rich>=14.1.0
 Requires-Dist: tabulate<0.10,>=0.9.0
+Requires-Dist: truststore>=0.10.4
 Requires-Dist: types-cachetools>=6.0.0.20250525
 Requires-Dist: typing-extensions<5,>=4
 Provides-Extra: protos

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

@@ -1,4 +1,4 @@
-CHANGELOG.md,sha256=gqkvZQ_HzybFgggDMLGPXEt7eyGDq6jDf26HGFVlKLY,80650
+CHANGELOG.md,sha256=jvj73GmZ1DOpXVyEcRVZ7Wm2ejFmH2UhBPO66Yt8wu0,83100
 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=Kq3RvdFSdAK-ViACpd_-H30fz1lnOaGU3zgFt13ag20,16674
+nominal/core/asset.py,sha256=vWi_5jNm1sBo4jCa4wTrL65IQ7b_lefZTLRsakoW7ro,18355
 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=L6IQVEPTiKbOjtbn4G0_R90jbVeOOxpHBHmminGQ3FE,67403
+nominal/core/client.py,sha256=zTaayeJf8IFA7BlNoVCaVpDA6cXIBaZGP934Tg6OhDI,67568
 nominal/core/connection.py,sha256=ySbPN_a2takVa8wIU9mK4fB6vYLyZnN-qSmXVkLUxAY,5157
-nominal/core/containerized_extractors.py,sha256=HrcMJzdE-hH66AgYIA0LTeFELsBHa0Sm0vlsKMiIzDU,9501
+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=gbQYtAYx-fHaewOZUSC7P9CHlMfmdchtTv1XUuNKg3Y,29933
+nominal/core/dataset.py,sha256=SUsn6qsbuceVLRYF47IquY_sW6OBRp4aExL1F3Bsaec,34802
 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/exceptions.py,sha256=GUpwXRgdYamLl6684FE8ttCRHkBx6WEhOZ3NPE-ybD4,2671
-nominal/core/filetype.py,sha256=OgUWR9Ebr-KGVNoXZCnxlHZh9Tp3g9kY1VeTv4TULPQ,5399
+nominal/core/filetype.py,sha256=jAPe6F7pDT8ixsD2-Y8eJdHOxgimdEQte4RQybWwsos,5465
 nominal/core/log.py,sha256=z3hI3CIEyMwpUSWjwBsJ6a3JNGzBbsmrVusSU6uI7CY,3885
-nominal/core/run.py,sha256=IvKyvyQ9sOefQQorDbOo1KHSGNtNN_9OnsJajlgoRSg,14803
+nominal/core/run.py,sha256=Rqy2o6sLE5RsAvvNnle7jRPJ-8UNfHmD-pdsRTOjA8Y,14792
 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
@@ -63,9 +63,9 @@ nominal/core/_stream/write_stream_base.py,sha256=AxK3fAq3IBjNXZkxYFVXu3dGNWLCBhg
 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/multipart.py,sha256=YZb6SDJG9eM9AmSHikMbkEOtxy1DTOi9ggVUVzO0Ur4,9998
-nominal/core/_utils/multipart_downloader.py,sha256=zS6wxecAZYeWBfiOjtscoUVPaSiUYTI_Ckn4sknSxMM,14275
-nominal/core/_utils/networking.py,sha256=0cted8IF52WdYAPtiAy9IeosmQkoytXOnazJkdYRkk8,5862
+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
 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/queueing.py,sha256=3qljc7dFI1UahlKjCaRVybM4poMCV5SayjyRPyXcPxg,3654
@@ -84,6 +84,8 @@ nominal/experimental/logging/__init__.py,sha256=9HrTkk_eyHv_w7EwqwOE1lf1Sa1Cm0cA
 nominal/experimental/logging/click_log_handler.py,sha256=ANLf4IGgmh95V0kJlr756wQrjmQKp6DEpc9Cj7J5qHM,2331
 nominal/experimental/logging/nominal_log_handler.py,sha256=hyTxyjsvFnE7vtyrDJpunAqADHmXekNWALwxXPIJGCk,5120
 nominal/experimental/logging/rich_log_handler.py,sha256=8yz_VtxNgJg2oiesnXz2iXoBvQrUP5pAsYkxknOXgXA,1231
+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/stream_v2/__init__.py,sha256=W39vK46pssx5sXvmsImMuJiEPs7iGtwrbYBI0bWnXCY,2313
@@ -102,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.98.0.dist-info/METADATA,sha256=av9CrAtGvlkkUC6pdW1oC7TazjZD1tJNIN46C4G4Jng,1946
-nominal-1.98.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nominal-1.98.0.dist-info/entry_points.txt,sha256=-mCLhxgg9R_lm5efT7vW9wuBH12izvY322R0a3TYxbE,66
-nominal-1.98.0.dist-info/licenses/LICENSE,sha256=zEGHG9mjDjaIS3I79O8mweQo-yiTbqx8jJvUPppVAwk,1067
-nominal-1.98.0.dist-info/RECORD,,
+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,,