nominal-streaming 0.7.9__cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl

nominal_streaming/__init__.py

@@ -0,0 +1,4 @@
+from nominal_streaming._nominal_streaming import PyNominalStreamOpts
+from nominal_streaming.nominal_dataset_stream import NominalDatasetStream
+
+__all__ = ["PyNominalStreamOpts", "NominalDatasetStream"]

nominal_streaming/_nominal_streaming.pyi

@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import pathlib
+from types import TracebackType
+from typing import Sequence, Type
+
+from typing_extensions import Self
+
+from nominal_streaming.nominal_dataset_stream import DataType
+
+class PyNominalStreamOpts:
+    """Configuration options for Nominal data streaming.
+
+    This class configures how data points are batched, buffered, and dispatched
+    to the Nominal backend. It mirrors the Rust `NominalStreamOpts` structure,
+    providing Pythonic accessors and fluent builder-style methods.
+    """
+
+    def __init__(
+        self,
+        *,
+        max_points_per_batch: int = 250_000,
+        max_request_delay_secs: float = 0.1,
+        max_buffered_requests: int = 4,
+        num_upload_workers: int = 8,
+        num_runtime_workers: int = 8,
+        base_api_url: str = "https://api.gov.nominal.io/api",
+    ) -> None:
+        """Initialize a PyNominalStreamOpts instance.
+
+        Args:
+            max_points_per_batch: Maximum number of points per record before dispatching a request.
+            max_request_delay_secs: Maximum delay before a request is sent, even if it results in a partial request.
+            max_buffered_requests: Maximum number of buffered requests before applying backpressure.
+            num_upload_workers: Number of concurrent network dispatches to perform.
+                NOTE: should be less than the number of `num_runtime_workers`
+            num_runtime_workers: Number of runtime worker threads for concurrent processing.
+            base_api_url: Base URL of the Nominal API endpoint to stream data to.
+        """
+
+    @property
+    def max_points_per_batch(self) -> int:
+        """Maximum number of data points per record before dispatch.
+
+        Returns:
+            The configured upper bound on points per record.
+
+        Example:
+            >>> PyNominalStreamOpts.default().max_points_per_batch
+            50000
+        """
+
+    @property
+    def max_request_delay_secs(self) -> float:
+        """Maximum delay before forcing a request flush.
+
+        Returns:
+            The maximum time to wait before sending pending data, in seconds.
+
+        Example:
+            >>> PyNominalStreamOpts.default().max_request_delay > 0
+            True
+        """
+
+    @property
+    def max_buffered_requests(self) -> int:
+        """Maximum number of requests that may be buffered concurrently.
+
+        Returns:
+            The maximum number of buffered requests before backpressure is applied.
+
+        Example:
+            >>> PyNominalStreamOpts.default().max_buffered_requests >= 0
+            True
+        """
+
+    @property
+    def num_upload_workers(self) -> int:
+        """Number of concurrent dispatcher tasks used for network transmission.
+
+        Returns:
+            The number of dispatcher tasks.
+
+        Example:
+            >>> PyNominalStreamOpts.default().num_upload_workers >= 1
+            True
+        """
+
+    @property
+    def num_runtime_workers(self) -> int:
+        """Number of runtime worker threads for internal processing.
+
+        Returns:
+            The configured number of runtime workers.
+
+        Example:
+            >>> PyNominalStreamOpts.default().num_runtime_workers
+            8
+        """
+
+    @property
+    def base_api_url(self) -> str:
+        """Base URL for the Nominal API endpoint.
+
+        Returns:
+            The fully-qualified base API URL used for streaming requests.
+
+        Example:
+            >>> isinstance(PyNominalStreamOpts.default().base_api_url, str)
+            True
+        """
+
+    def with_max_points_per_batch(self, n: int) -> Self:
+        """Set the maximum number of points per record.
+
+        Args:
+            n: Maximum number of data points to include in a single record.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Example:
+            >>> opts = PyNominalStreamOpts.default().with_max_points_per_batch(1000)
+        """
+
+    def with_max_request_delay_secs(self, delay_secs: float) -> Self:
+        """Set the maximum delay before forcing a request flush.
+
+        Args:
+            delay_secs: Maximum time in seconds to wait before sending pending data.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Example:
+            >>> opts = PyNominalStreamOpts.default().with_max_request_delay_secs(1.0)
+        """
+
+    def with_max_buffered_requests(self, n: int) -> Self:
+        """Set the maximum number of requests that can be buffered concurrently.
+
+        Args:
+            n: Maximum number of buffered requests.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Example:
+            >>> opts = PyNominalStreamOpts.default().with_max_buffered_requests(200)
+        """
+
+    def with_num_upload_workers(self, n: int) -> Self:
+        """Set the number of asynchronous dispatcher tasks.
+
+        Args:
+            n: Number of dispatcher tasks responsible for request transmission.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Example:
+            >>> opts = PyNominalStreamOpts.default().with_num_upload_workers(8)
+        """
+
+    def with_num_runtime_workers(self, n: int) -> Self:
+        """Set the number of runtime worker threads.
+
+        Args:
+            n: Number of background worker threads used for internal processing.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Example:
+            >>> opts = PyNominalStreamOpts.default().with_num_runtime_workers(16)
+        """
+
+    def with_api_base_url(self, url: str) -> Self:
+        """Set the base URL for the Nominal API.
+
+        Args:
+            url: Fully-qualified base API URL for streaming requests.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Example:
+            >>> opts = PyNominalStreamOpts.default().with_api_base_url("https://staging.nominal.io")
+        """
+
+    def __repr__(self) -> str:
+        """Return a developer-friendly string representation of this configuration."""
+
+    def __str__(self) -> str:
+        """Return a human-readable summary of this configuration."""
+
+class PyNominalDatasetStream:
+    """High-throughput client for enqueueing dataset points to Nominal.
+
+    This is the Python-facing streaming client. It supports a fluent builder
+    API for configuration, lifecycle controls (`open`, `close`, `cancel`), and
+    multiple enqueue modes (single point, long series, and wide records).
+    """
+
+    def __init__(self, /, opts: PyNominalStreamOpts | None = None) -> None:
+        """Create a new stream builder.
+
+        Args:
+            opts: Optional stream options. If omitted, sensible defaults are used.
+
+        Example:
+            >>> from nominal_streaming import PyNominalStreamOpts
+            >>> stream = PyNominalDatasetStream(PyNominalStreamOpts())
+        """
+
+    def enable_logging(self, log_directive: str | None = None) -> Self:
+        """Enable client-side logging for diagnostics.
+
+        NOTE: must be applied before calling open()
+
+        Args:
+            log_directive: If provided, log directive (e.g. "trace" or "info") to configure logging with.
+                If not provided, searches for a `RUST_LOG` environment variable, or if not found,
+                defaults to debug level logging.
+
+        Returns:
+            The updated instance for fluent chaining.
+        """
+
+    def with_options(self, opts: PyNominalStreamOpts) -> Self:
+        """Attach or replace stream options.
+
+        NOTE: must be applied before calling open()
+
+        Args:
+            opts: Options for the underlying stream.
+
+        Returns:
+            The updated instance for fluent chaining.
+        """
+
+    def with_core_consumer(
+        self,
+        dataset_rid: str,
+        token: str | None = None,
+    ) -> Self:
+        """Send data to a Dataset in Nominal.
+
+        NOTE: Must be applied before calling open()
+
+        NOTE: Mutually exclusive with `to_file`.
+
+        Args:
+            dataset_rid: Resource identifier of the dataset.
+            token: Optional bearer token. If omitted, uses `NOMINAL_TOKEN` environment variable.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Raises:
+            RuntimeError: If called after `to_file`.
+        """
+
+    def to_file(self, path: pathlib.Path) -> Self:
+        """Write points to a local file (newline-delimited records).
+
+        Mutually exclusive with `with_core_consumer`.
+
+        Args:
+            path: Destination file path.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Raises:
+            RuntimeError: If already configured for core consumption.
+        """
+
+    def with_file_fallback(self, path: pathlib.Path) -> Self:
+        """If sending to core fails, fall back to writing to `path`.
+
+        NOTE: Requires that `with_core_consumer` has been configured.
+
+        NOTE: Not allowed with `to_file`.
+
+        Args:
+            path: Fallback file path.
+
+        Returns:
+            The updated instance for fluent chaining.
+
+        Raises:
+            RuntimeError: If core consumer is not configured.
+        """
+
+    def open(self) -> None:
+        """Start the runtime and accept enqueues.
+
+        NOTE: Safe to call multiple times; subsequent calls are no-ops.
+
+        NOTE: May raise if the builder is not fully configured.
+        """
+
+    def close(self) -> None:
+        """Gracefully drain pending data and stop the worker runtime.
+
+        NOTE: Blocks while joining internal threads. Safe to call multiple times.
+        """
+
+    def cancel(self) -> None:
+        """Fast cancellation of work without guaranteeing a full drain.
+
+        NOTE: Intended for signal handlers or rapid shutdown paths.
+        """
+
+    def enqueue(
+        self,
+        channel_name: str,
+        timestamp: int,
+        value: DataType,
+        tags: dict[str, str] | None = None,
+    ) -> None:
+        """Enqueue a single point.
+
+        Args:
+            channel_name: Channel name to stream to
+            timestamp: Timestamp for the enqueued value.
+                Accepts either integral nanoseconds since unix epoch or a datetime, which is presumed to be in UTC.
+            value: Data value to stream
+            tags: Optional tags to attach to the data.
+
+        Raises:
+            RuntimeError: If the stream is not open or has been cancelled.
+            TypeError: If `value` is not an `int`, `float`, or `str`.
+        """
+
+    def enqueue_batch(
+        self,
+        channel_name: str,
+        timestamps: Sequence[int],
+        values: Sequence[DataType],
+        tags: dict[str, str] | None = None,
+    ) -> None:
+        """Enqueue a series for a single channel.
+
+        Args:
+            channel_name: Channel name.
+            timestamps: Sequence of timestamps (same accepted forms as in `enqueue`).
+            values: Sequence of values (must be homogeneous: all must be float, int, or strings).
+            tags: Optional tags to attach to the values.
+
+        Raises:
+            RuntimeError: If the stream is not open or has been cancelled.
+            TypeError: If value types are heterogeneous or unsupported.
+            ValueError: If lengths of `timestamps` and `values` differ.
+        """
+
+    def enqueue_from_dict(
+        self,
+        timestamp: int,
+        channel_values: dict[str, DataType],
+        tags: dict[str, str] | None = None,
+    ) -> None:
+        """Enqueue a wide record: many channels at a single timestamp.
+
+        Args:
+            timestamp: Record timestamp (see `enqueue`).
+            channel_values: Mapping from channel name to value.
+            tags: Optional tags attach to all values in the record.
+
+        Raises:
+            RuntimeError: If the stream is not open or has been cancelled.
+            TypeError: If any value is not an `int`, `float`, or `str`.
+        """
+
+    def __enter__(self) -> Self: ...
+    def __exit__(
+        self, exc_type: Type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+    ) -> None: ...

nominal_streaming/nominal_dataset_stream.py

@@ -0,0 +1,301 @@
+"""Python-facing API for the streaming client.
+
+Example:
+-------
+import pathlib
+from datetime import datetime, timedelta, timezone
+
+from nominal_streaming import PyNominalStreamOpts, NominalDatasetStream
+
+# NOTE: may also use PyNominalStreamOpts() for sensible defaults that may be customized
+opts = PyNominalStreamOpts(
+    max_points_per_batch=250_000,
+    max_request_delay=timedelta(seconds=0.1),
+    max_buffered_requests=4,
+    num_upload_workers=8,
+    base_api_url="https://api.gov.nominal.io/api",
+    runtime_workers=8,
+)
+
+with (
+    NominalDatasetStream("api_key", opts)
+    .with_core_consumer("ri.catalog.dataset...")
+    .with_file_fallback(pathlib.Path("/tmp/fallback.avro")) as stream
+):
+    stream.enqueue("chanA", datetime.now(timezone.utc), 1.23, tags={"site": "a1"})
+    stream.enqueue_batch("chanB", [0, 1_000_000_000], [5, 6], tags={"phase": "prod"})
+    stream.enqueue_from_dict(0, {"chanC": "ok", "chanD": 7}, tags={"who": "tester"})
+
+"""
+
+from __future__ import annotations
+
+import datetime
+import logging
+import pathlib
+import signal
+from types import TracebackType
+from typing import Mapping, Sequence, Type
+
+import dateutil
+from typing_extensions import Self
+
+from nominal_streaming._nominal_streaming import (
+    PyNominalDatasetStream,
+    PyNominalStreamOpts,
+)
+
+logger = logging.getLogger(__name__)
+
+TimestampLike = str | int | datetime.datetime
+DataType = int | float | str
+
+
+def _parse_timestamp(ts: str | int | datetime.datetime) -> int:
+    if isinstance(ts, int):
+        return ts
+    elif isinstance(ts, datetime.datetime):
+        secs = ts.astimezone(datetime.timezone.utc).timestamp()
+        return int(secs * 1e9)
+    else:
+        # TODO(drake): by involving dateutil, this chops off any nano level precision provided
+        #              in the timestamp. Update to not lose precision when converting to absolute nanos.
+        secs = dateutil.parser.parse(ts).astimezone(datetime.timezone.utc).timestamp()
+        return int(secs * 1e9)
+
+
+class NominalDatasetStream:
+    """Top-level python wrapper for the Rust streaming client to Nominal."""
+
+    def __init__(self, auth_header: str, opts: PyNominalStreamOpts):
+        """Initializer for dataset stream.
+
+        Args:
+            auth_header: API key or access token to the Nominal API
+            opts: Optional options for the underlying stream
+        """
+        self._auth_header = auth_header
+        self._opts = opts
+        self._impl = PyNominalDatasetStream(self._opts)
+        self._old_sigint = None
+
+    @classmethod
+    def create(
+        cls,
+        auth_header: str,
+        base_api_url: str,
+        max_points_per_batch: int = 250_000,
+        max_request_delay_secs: float = 0.1,
+        max_buffered_requests: int = 4,
+        num_upload_workers: int = 8,
+        num_runtime_workers: int = 8,
+    ) -> Self:
+        """Factory constructor to build a NominalDatasetStream using optional overrides for configuration options
+
+        Args:
+            auth_header: API Key or Personal Access Token for accessing the Nominal API
+            base_api_url: Base API URL for hitting the Nominal API with.
+            max_points_per_batch: Overrides the default number of points that may be sent in a single batch
+            max_request_delay_secs: Overrides the default maximum buffering time for data between flushes.
+                NOTE: if the amount of data being streamed is greater than available bandwidth, data may be
+                      buffered longer than the configured duration.
+            max_buffered_requests: Overrides the default number of requests that may be buffered between encoding
+                threads and upload threads. Increasing this may prevent blocking threads in situations with spotty
+                internet, but increase teardown time (e.g. when pressing ctrl + c)
+            num_upload_workers: Overrides the default number of upload worker threads
+                NOTE: must be set as low as the number of runtime workers.
+            num_runtime_workers: Overrides the default number of runtime worker threads
+                NOTE: must be set as high as the number of upload workers.
+
+        """
+        opts = PyNominalStreamOpts(
+            max_points_per_batch=max_points_per_batch,
+            max_request_delay_secs=max_request_delay_secs,
+            max_buffered_requests=max_buffered_requests,
+            num_upload_workers=num_upload_workers,
+            num_runtime_workers=num_runtime_workers,
+            base_api_url=base_api_url,
+        )
+        return cls(auth_header, opts)
+
+    def enable_logging(self, log_directive: str = "debug") -> Self:
+        """Enable logging with the given verbosity level
+
+        Args:
+            log_directive: Log verbosity level to expose from Rust code. Defaults to verbose debug logging.
+                See the following for valid values: https://docs.rs/env_logger/latest/env_logger/#enabling-logging
+        """
+        logger.info("Setting rust log verbosity to '%s'", log_directive)
+        self._impl = self._impl.enable_logging(log_directive)
+        return self
+
+    def with_core_consumer(self, dataset_rid: str) -> Self:
+        """Enables streaming to a Dataset in Core
+
+        Args:
+            dataset_rid: RID of the Dataset in Nominal to stream to
+        """
+        self._impl = self._impl.with_core_consumer(dataset_rid, self._auth_header)
+        return self
+
+    def to_file(self, path: pathlib.Path) -> Self:
+        """Target streaming towards a local `.avro` file
+
+        The written file will contain snappy-compressed avro data. This can be read as follows:
+
+            ```python
+            from fastavro import reader
+
+            with open("test.avro", "rb") as f:
+                for record in reader(f):
+                    channel_name = record["channel"]
+                    tags = record["tags"]
+                    timestamps = record["timestamps"]
+                    values = record["values"]
+            ```
+        """
+        self._impl = self._impl.to_file(path)
+        return self
+
+    def with_file_fallback(self, path: pathlib.Path) -> Self:
+        """Setup file fallback for streaming to core
+
+        The written file will contain snappy-compressed avro data for any batches of data that were unable to make
+        it to the backend successfully. This can be read as follows:
+
+            ```python
+            from fastavro import reader
+
+            with open("test.avro", "rb") as f:
+                for record in reader(f):
+                    channel_name = record["channel"]
+                    tags = record["tags"]
+                    timestamps = record["timestamps"]
+                    values = record["values"]
+            ```
+        """
+        self._impl = self._impl.with_file_fallback(path)
+        return self
+
+    def open(self) -> Self:
+        """Create the stream as a context manager.
+
+        NOTE: installs a sigint handler to enable more graceful shutdown.
+              This is restored upon exit.
+        """
+        if self._old_sigint is not None:
+            raise RuntimeError("Stream already opened!")
+
+        logger.info("Opening underlying stream")
+        self._impl.open()
+
+        # Map Ctrl+C → fast cancel; keep handler tiny and re-raise KeyboardInterrupt.
+        def _on_sigint(signum, frame):  # type: ignore[no-untyped-def]
+            logger.debug("Cancelling underlying stream")
+            try:
+                self._impl.cancel()
+            finally:
+                raise KeyboardInterrupt
+
+        logger.info("Installing sigint handler")
+        self._old_sigint = signal.getsignal(signal.SIGINT)  # type: ignore[assignment]
+        signal.signal(signal.SIGINT, _on_sigint)
+        return self
+
+    def __enter__(self) -> Self:
+        """Create the stream as a context manager.
+
+        NOTE: installs a sigint handler to enable more graceful shutdown.
+              This is restored upon exit.
+        """
+        return self.open()
+
+    def close(self, wait: bool = True) -> None:
+        """Exit the stream and close out any used system resources.
+
+        NOTE: uninstalls the installed sigint handler and restores any pre-existing sigint handlers
+        """
+        try:
+            if wait:
+                logger.info("Awaiting graceful shutdown")
+                self._impl.close()
+            else:
+                logger.info("Quickly shutting down")
+                self._impl.cancel()
+        finally:
+            if self._old_sigint is not None:
+                logger.info("Restoring original sigint handler")
+                signal.signal(signal.SIGINT, self._old_sigint)
+                self._old_sigint = None
+
+    def __exit__(
+        self,
+        exc_type: Type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Exit the stream and close out any used system resources.
+
+        NOTE: uninstalls the installed sigint handler and restores any pre-existing sigint handlers
+        """
+        self.close()
+
+    def enqueue(
+        self,
+        channel_name: str,
+        timestamp: TimestampLike,
+        value: DataType,
+        tags: Mapping[str, str] | None = None,
+    ) -> None:
+        """Write a single value to the stream
+
+        Args:
+            channel_name: Name of the channel to upload data for.
+            timestamp: Absolute UTC timestamp of the data being uploaded.
+            value: Value to write to the specified channel.
+            tags: Key-value tags associated with the data being uploaded.
+        """
+        self._impl.enqueue(channel_name, _parse_timestamp(timestamp), value, {**tags} if tags else None)
+
+    def enqueue_batch(
+        self,
+        channel_name: str,
+        timestamps: Sequence[TimestampLike],
+        values: Sequence[DataType],
+        tags: Mapping[str, str] | None = None,
+    ) -> None:
+        """Add a sequence of messages to the queue to upload to Nominal.
+
+        Messages are added one-by-one (with timestamp normalization) and flushed
+        based on the batch conditions.
+
+        NOTE: assumes that all values have the same type as the first value in the batch--
+              ensure that any provided value arrays are homogenously typed
+
+        Args:
+            channel_name: Name of the channel to upload data for.
+            timestamps: Absolute UTC timestamps of the data being uploaded.
+            values: Values to write to the specified channel.
+            tags: Key-value tags associated with the data being uploaded.
+        """
+        self._impl.enqueue_batch(
+            channel_name, [_parse_timestamp(ts) for ts in timestamps], values, {**tags} if tags else None
+        )
+
+    def enqueue_from_dict(
+        self,
+        timestamp: TimestampLike,
+        channel_values: Mapping[str, DataType],
+        tags: Mapping[str, str] | None = None,
+    ) -> None:
+        """Write multiple channel values at a given timestamp using a flattened dictionary.
+
+        Each key in the dictionary is treated as a channel name and the corresponding value
+        is enqueued with the given timestamp.
+
+        Args:
+            timestamp: The shared absolute UTC timestamp to use for all items to enqueue.
+            channel_values: A dictionary mapping channel names to their respective values.
+            tags: Key-value tags associated with the data being uploaded.
+        """
+        self._impl.enqueue_from_dict(_parse_timestamp(timestamp), {**channel_values}, {**tags} if tags else None)

nominal_streaming-0.7.9.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: nominal-streaming
+Version: 0.7.9
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Dist: typing-extensions>=4,<5
+Requires-Dist: python-dateutil>=0.0.0
+Summary: Python bindings for the Nominal Rust streaming client
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source Code, https://github.com/nominal-io/nominal-streaming
+
+# nominal-streaming Python Bindings
+
+`nominal-streaming` is a thin python wrapper around the existing [nominal-streaming rust crate](https://crates.io/crates/nominal-streaming).
+Usage semantics remain largely the same, but with some slight alterations to allow for a more pythonic interface.
+
+The library aims to balance three concerns:
+
+1. Data should exist in-memory only for a limited, configurable amount of time before it's sent to Core.
+1. Writes should fall back to disk if there are network failures.
+1. Backpressure should be applied to incoming requests when network throughput is saturated.
+
+This library streams data to Nominal Core, to a file, or to Nominal Core with a file as backup (recommended to protect against network failures).
+It also provides configuration to manage the tradeoff between above listed concerns.
+
+> [!WARNING]
+> This library is still under active development and may make breaking changes.
+
+## Usage example: streaming from memory to Nominal Core with file fallback
+
+```python
+import pathlib
+import time
+
+from nominal.core import NominalClient
+from nominal_streaming import NominalDatasetStream, PyNominalStreamOpts
+
+if __name__ == "__main__":
+    num_points = 100_000
+    stream = (
+        NominalDatasetStream(
+            auth_header="<api key>",
+            opts=PyNominalStreamOpts(),
+        )
+        .enable_logging("info") # can set debug, warn, etc.
+        .with_core_consumer("<dataset rid>")
+        .with_file_fallback(pathlib.Path("local_fallback.avro"))
+    )
+
+    with stream:
+        # Stream 100_000 live readings (made up values)
+        for idx in range(num_points):
+            time_ns = int(time.time() * 1e9)
+            value = (idx % 50) + 0.5
+            stream.enqueue("channel_name", time_ns, value, tags={"tag_key": "tag_value"})
+
+        # Stream 100_000 points in one batch
+        start_time = int(time.time() * 1e9)
+        timestamp_offsets = int(1e9 / 1600)
+        timestamps = [start_time + timestamp_offsets * idx for idx in range(num_points)]
+        values = [(idx % 50) + 0.5 for idx in range(num_points)]
+        stream.enqueue_batch(
+            "channel_name",
+            timestamps,
+            values,
+            tags={"tag_key": "tag_value"}
+        )
+```
+

nominal_streaming-0.7.9.dist-info/RECORD

@@ -0,0 +1,8 @@
+nominal_streaming-0.7.9.dist-info/METADATA,sha256=U9EAg2XGHXpwtWdLIq6J5SvGO9qnklcdc2TlfVipsUM,2814
+nominal_streaming-0.7.9.dist-info/WHEEL,sha256=M-9xdoymxPeMYqxLovGnzRp1139eX1kg457fDCQ3bmM,128
+nominal_streaming/__init__.py,sha256=7isEI7NFTEnTNEmxjtDgehQQPPRM-ByrH903VBWrulQ,202
+nominal_streaming/_nominal_streaming.abi3.so,sha256=tSkq8_gy40vSl2iviImZd9lgVVoAqir0RQlefOCsXLg,6681308
+nominal_streaming/_nominal_streaming.pyi,sha256=hZ5TpAFFMZzajSu13yh-klEh81ItvF5C5f_3i0rMfkM,12093
+nominal_streaming/nominal_dataset_stream.py,sha256=0OXLiGDhyT9Q4z0QJlXaV7H3Nd3OWMPi2bjQJKcM5eE,11507
+nominal_streaming/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nominal_streaming-0.7.9.dist-info/RECORD,,

nominal_streaming-0.7.9.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.9.3)
+Root-Is-Purelib: false
+Tag: cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l