nominal-api 0.702.0__py3-none-any.whl → 0.703.0__py3-none-any.whl

nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.702.0"
+__version__ = "0.703.0"
 

nominal_api/_impl.py

@@ -38876,6 +38876,44 @@ scout_compute_api_DurationConstantVisitor.__qualname__ = "DurationConstantVisito
 scout_compute_api_DurationConstantVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_DurationFilterRanges(ConjureBeanType):
+    """
+    Filters a list of ranges down to only those satisfying a threshold condition on the range's duration.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_RangeSeries),
+            'threshold': ConjureFieldDefinition('threshold', scout_compute_api_DurationConstant),
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_ThresholdOperator)
+        }
+
+    __slots__: List[str] = ['_input', '_threshold', '_operator']
+
+    def __init__(self, input: "scout_compute_api_RangeSeries", operator: "scout_compute_api_ThresholdOperator", threshold: "scout_compute_api_DurationConstant") -> None:
+        self._input = input
+        self._threshold = threshold
+        self._operator = operator
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_RangeSeries":
+        return self._input
+
+    @builtins.property
+    def threshold(self) -> "scout_compute_api_DurationConstant":
+        return self._threshold
+
+    @builtins.property
+    def operator(self) -> "scout_compute_api_ThresholdOperator":
+        return self._operator
+
+
+scout_compute_api_DurationFilterRanges.__name__ = "DurationFilterRanges"
+scout_compute_api_DurationFilterRanges.__qualname__ = "DurationFilterRanges"
+scout_compute_api_DurationFilterRanges.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_EnumAggregationFunction(ConjureEnumType):
 
     MIN = 'MIN'
@@ -44315,6 +44353,7 @@ scout_compute_api_RangeMap.__module__ = "nominal_api.scout_compute_api"
 
 class scout_compute_api_RangeSeries(ConjureUnionType):
     _approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None
+    _duration_filter: Optional["scout_compute_api_DurationFilterRanges"] = None
     _enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None
     _enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None
     _function: Optional["scout_compute_api_RangesFunction"] = None
@@ -44337,6 +44376,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'approximate_threshold': ConjureFieldDefinition('approximateThreshold', scout_compute_api_ApproximateThresholdRanges),
+            'duration_filter': ConjureFieldDefinition('durationFilter', scout_compute_api_DurationFilterRanges),
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_api_EnumFilterRanges),
             'enum_series_equality_ranges_node': ConjureFieldDefinition('enumSeriesEqualityRangesNode', scout_compute_api_EnumSeriesEqualityRanges),
             'function': ConjureFieldDefinition('function', scout_compute_api_RangesFunction),
@@ -44359,6 +44399,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def __init__(
             self,
             approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None,
+            duration_filter: Optional["scout_compute_api_DurationFilterRanges"] = None,
             enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None,
             enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None,
             function: Optional["scout_compute_api_RangesFunction"] = None,
@@ -44379,12 +44420,15 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (approximate_threshold is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (function is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (approximate_threshold is not None) + (duration_filter is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (function is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if approximate_threshold is not None:
                 self._approximate_threshold = approximate_threshold
                 self._type = 'approximateThreshold'
+            if duration_filter is not None:
+                self._duration_filter = duration_filter
+                self._type = 'durationFilter'
             if enum_filter is not None:
                 self._enum_filter = enum_filter
                 self._type = 'enumFilter'
@@ -44442,6 +44486,11 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._approximate_threshold = approximate_threshold
             self._type = 'approximateThreshold'
+        elif type_of_union == 'durationFilter':
+            if duration_filter is None:
+                raise ValueError('a union value must not be None')
+            self._duration_filter = duration_filter
+            self._type = 'durationFilter'
         elif type_of_union == 'enumFilter':
             if enum_filter is None:
                 raise ValueError('a union value must not be None')
@@ -44532,6 +44581,10 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def approximate_threshold(self) -> Optional["scout_compute_api_ApproximateThresholdRanges"]:
         return self._approximate_threshold
 
+    @builtins.property
+    def duration_filter(self) -> Optional["scout_compute_api_DurationFilterRanges"]:
+        return self._duration_filter
+
     @builtins.property
     def enum_filter(self) -> Optional["scout_compute_api_EnumFilterRanges"]:
         return self._enum_filter
@@ -44611,6 +44664,8 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             raise ValueError('{} is not an instance of scout_compute_api_RangeSeriesVisitor'.format(visitor.__class__.__name__))
         if self._type == 'approximateThreshold' and self.approximate_threshold is not None:
             return visitor._approximate_threshold(self.approximate_threshold)
+        if self._type == 'durationFilter' and self.duration_filter is not None:
+            return visitor._duration_filter(self.duration_filter)
         if self._type == 'enumFilter' and self.enum_filter is not None:
             return visitor._enum_filter(self.enum_filter)
         if self._type == 'enumSeriesEqualityRangesNode' and self.enum_series_equality_ranges_node is not None:
@@ -44658,6 +44713,10 @@ class scout_compute_api_RangeSeriesVisitor:
     def _approximate_threshold(self, approximate_threshold: "scout_compute_api_ApproximateThresholdRanges") -> Any:
         pass
 
+    @abstractmethod
+    def _duration_filter(self, duration_filter: "scout_compute_api_DurationFilterRanges") -> Any:
+        pass
+
     @abstractmethod
     def _enum_filter(self, enum_filter: "scout_compute_api_EnumFilterRanges") -> Any:
         pass
@@ -50865,6 +50924,41 @@ scout_compute_resolved_api_DerivativeSeriesNode.__qualname__ = "DerivativeSeries
 scout_compute_resolved_api_DerivativeSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_DurationFilterRangesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_RangesNode),
+            'threshold': ConjureFieldDefinition('threshold', scout_run_api_Duration),
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_ThresholdOperator)
+        }
+
+    __slots__: List[str] = ['_input', '_threshold', '_operator']
+
+    def __init__(self, input: "scout_compute_resolved_api_RangesNode", operator: "scout_compute_api_ThresholdOperator", threshold: "scout_run_api_Duration") -> None:
+        self._input = input
+        self._threshold = threshold
+        self._operator = operator
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_RangesNode":
+        return self._input
+
+    @builtins.property
+    def threshold(self) -> "scout_run_api_Duration":
+        return self._threshold
+
+    @builtins.property
+    def operator(self) -> "scout_compute_api_ThresholdOperator":
+        return self._operator
+
+
+scout_compute_resolved_api_DurationFilterRangesNode.__name__ = "DurationFilterRangesNode"
+scout_compute_resolved_api_DurationFilterRangesNode.__qualname__ = "DurationFilterRangesNode"
+scout_compute_resolved_api_DurationFilterRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_EnumCountDuplicateSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -53544,6 +53638,7 @@ scout_compute_resolved_api_RangeMap.__module__ = "nominal_api.scout_compute_reso
 
 
 class scout_compute_resolved_api_RangesNode(ConjureUnionType):
+    _duration_filter: Optional["scout_compute_resolved_api_DurationFilterRangesNode"] = None
     _enum_equality: Optional["scout_compute_resolved_api_EnumEqualityRangesNode"] = None
     _enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None
     _extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None
@@ -53562,6 +53657,7 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
+            'duration_filter': ConjureFieldDefinition('durationFilter', scout_compute_resolved_api_DurationFilterRangesNode),
             'enum_equality': ConjureFieldDefinition('enumEquality', scout_compute_resolved_api_EnumEqualityRangesNode),
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_resolved_api_EnumFilterRangesNode),
             'extrema': ConjureFieldDefinition('extrema', scout_compute_resolved_api_ExtremaRangesNode),
@@ -53580,6 +53676,7 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
 
     def __init__(
             self,
+            duration_filter: Optional["scout_compute_resolved_api_DurationFilterRangesNode"] = None,
             enum_equality: Optional["scout_compute_resolved_api_EnumEqualityRangesNode"] = None,
             enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None,
             extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None,
@@ -53597,9 +53694,12 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (duration_filter is not None) + (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
+            if duration_filter is not None:
+                self._duration_filter = duration_filter
+                self._type = 'durationFilter'
             if enum_equality is not None:
                 self._enum_equality = enum_equality
                 self._type = 'enumEquality'
@@ -53643,6 +53743,11 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
                 self._union_range = union_range
                 self._type = 'unionRange'
 
+        elif type_of_union == 'durationFilter':
+            if duration_filter is None:
+                raise ValueError('a union value must not be None')
+            self._duration_filter = duration_filter
+            self._type = 'durationFilter'
         elif type_of_union == 'enumEquality':
             if enum_equality is None:
                 raise ValueError('a union value must not be None')
@@ -53714,6 +53819,10 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             self._union_range = union_range
             self._type = 'unionRange'
 
+    @builtins.property
+    def duration_filter(self) -> Optional["scout_compute_resolved_api_DurationFilterRangesNode"]:
+        return self._duration_filter
+
     @builtins.property
     def enum_equality(self) -> Optional["scout_compute_resolved_api_EnumEqualityRangesNode"]:
         return self._enum_equality
@@ -53773,6 +53882,8 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_RangesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_RangesNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'durationFilter' and self.duration_filter is not None:
+            return visitor._duration_filter(self.duration_filter)
         if self._type == 'enumEquality' and self.enum_equality is not None:
             return visitor._enum_equality(self.enum_equality)
         if self._type == 'enumFilter' and self.enum_filter is not None:
@@ -53810,6 +53921,10 @@ scout_compute_resolved_api_RangesNode.__module__ = "nominal_api.scout_compute_re
 
 class scout_compute_resolved_api_RangesNodeVisitor:
 
+    @abstractmethod
+    def _duration_filter(self, duration_filter: "scout_compute_resolved_api_DurationFilterRangesNode") -> Any:
+        pass
+
     @abstractmethod
     def _enum_equality(self, enum_equality: "scout_compute_resolved_api_EnumEqualityRangesNode") -> Any:
         pass
@@ -77198,6 +77313,163 @@ storage_writer_api_ArrayPointsVisitor.__qualname__ = "ArrayPointsVisitor"
 storage_writer_api_ArrayPointsVisitor.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_ColumnBatch(ConjureBeanType):
+    """
+    Batch of data to stream for a single channel with their associated timestamps.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
+            'values': ConjureFieldDefinition('values', storage_writer_api_ColumnValues)
+        }
+
+    __slots__: List[str] = ['_channel', '_tags', '_timestamps', '_values']
+
+    def __init__(self, channel: str, tags: Dict[str, str], timestamps: List["api_Timestamp"], values: "storage_writer_api_ColumnValues") -> None:
+        self._channel = channel
+        self._tags = tags
+        self._timestamps = timestamps
+        self._values = values
+
+    @builtins.property
+    def channel(self) -> str:
+        """
+        Channel within nominal to stream data to.
+        """
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        """
+        Mapping of key-value pairs to provide as tags to all points within the batch
+        """
+        return self._tags
+
+    @builtins.property
+    def timestamps(self) -> List["api_Timestamp"]:
+        """
+        List of timestamp values that correspond to the provided list of column values. The number of timestamps
+provided MUST match the number of columnar values provided, otherwise a 400 error will be returned.
+        """
+        return self._timestamps
+
+    @builtins.property
+    def values(self) -> "storage_writer_api_ColumnValues":
+        """
+        List of timeseries values that should be ingested to a single channel. The number of columnar values
+provided MUST match the number of timestamps provided, otherwise a 400 error will be returned.
+        """
+        return self._values
+
+
+storage_writer_api_ColumnBatch.__name__ = "ColumnBatch"
+storage_writer_api_ColumnBatch.__qualname__ = "ColumnBatch"
+storage_writer_api_ColumnBatch.__module__ = "nominal_api.storage_writer_api"
+
+
+class storage_writer_api_ColumnValues(ConjureUnionType):
+    """List of values that correspond to subsequent values to ingest from a single channel."""
+    _strings: Optional[List[str]] = None
+    _doubles: Optional[List[float]] = None
+    _ints: Optional[List[int]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'strings': ConjureFieldDefinition('strings', List[str]),
+            'doubles': ConjureFieldDefinition('doubles', List[float]),
+            'ints': ConjureFieldDefinition('ints', List[int])
+        }
+
+    def __init__(
+            self,
+            strings: Optional[List[str]] = None,
+            doubles: Optional[List[float]] = None,
+            ints: Optional[List[int]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (strings is not None) + (doubles is not None) + (ints is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if strings is not None:
+                self._strings = strings
+                self._type = 'strings'
+            if doubles is not None:
+                self._doubles = doubles
+                self._type = 'doubles'
+            if ints is not None:
+                self._ints = ints
+                self._type = 'ints'
+
+        elif type_of_union == 'strings':
+            if strings is None:
+                raise ValueError('a union value must not be None')
+            self._strings = strings
+            self._type = 'strings'
+        elif type_of_union == 'doubles':
+            if doubles is None:
+                raise ValueError('a union value must not be None')
+            self._doubles = doubles
+            self._type = 'doubles'
+        elif type_of_union == 'ints':
+            if ints is None:
+                raise ValueError('a union value must not be None')
+            self._ints = ints
+            self._type = 'ints'
+
+    @builtins.property
+    def strings(self) -> Optional[List[str]]:
+        return self._strings
+
+    @builtins.property
+    def doubles(self) -> Optional[List[float]]:
+        return self._doubles
+
+    @builtins.property
+    def ints(self) -> Optional[List[int]]:
+        return self._ints
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, storage_writer_api_ColumnValuesVisitor):
+            raise ValueError('{} is not an instance of storage_writer_api_ColumnValuesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'strings' and self.strings is not None:
+            return visitor._strings(self.strings)
+        if self._type == 'doubles' and self.doubles is not None:
+            return visitor._doubles(self.doubles)
+        if self._type == 'ints' and self.ints is not None:
+            return visitor._ints(self.ints)
+
+
+storage_writer_api_ColumnValues.__name__ = "ColumnValues"
+storage_writer_api_ColumnValues.__qualname__ = "ColumnValues"
+storage_writer_api_ColumnValues.__module__ = "nominal_api.storage_writer_api"
+
+
+class storage_writer_api_ColumnValuesVisitor:
+
+    @abstractmethod
+    def _strings(self, strings: List[str]) -> Any:
+        pass
+
+    @abstractmethod
+    def _doubles(self, doubles: List[float]) -> Any:
+        pass
+
+    @abstractmethod
+    def _ints(self, ints: List[int]) -> Any:
+        pass
+
+
+storage_writer_api_ColumnValuesVisitor.__name__ = "ColumnValuesVisitor"
+storage_writer_api_ColumnValuesVisitor.__qualname__ = "ColumnValuesVisitor"
+storage_writer_api_ColumnValuesVisitor.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_DirectNominalChannelWriterService(Service):
     """
     Writes data points directly to Nominal's managed database offering.
@@ -77425,6 +77697,42 @@ class storage_writer_api_NominalChannelWriterService(Service):
 
         return
 
+    def write_column_batches(self, auth_header: str, request: "storage_writer_api_WriteColumnBatchesRequest") -> None:
+        """
+        Synchronously writes batches of columns of data to a Nominal data source.
+
+This is a column-major variant of writeBatches (which is row-major) to optimize serialization and compression
+time for client applications streaming large numbers of points from a single column at a time. This has the
+tradeoff of slightly larger sizes post-gzipping of requests, so should be used in the particular case where
+the main bottleneck is in encoding columnar data into the row-based format found in writeBatches.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/storage/writer/v1/columnar'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
     def write_telegraf_batches(self, auth_header: str, data_source_rid: str, request: "storage_writer_api_WriteTelegrafBatchesRequest") -> None:
         """
         Synchronously writes batches of records to a Nominal data source.
@@ -78151,6 +78459,41 @@ storage_writer_api_WriteBatchesRequestExternal.__qualname__ = "WriteBatchesReque
 storage_writer_api_WriteBatchesRequestExternal.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_WriteColumnBatchesRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'batches': ConjureFieldDefinition('batches', List[storage_writer_api_ColumnBatch]),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceOrDatasetRid)
+        }
+
+    __slots__: List[str] = ['_batches', '_data_source_rid']
+
+    def __init__(self, batches: List["storage_writer_api_ColumnBatch"], data_source_rid: str) -> None:
+        self._batches = batches
+        self._data_source_rid = data_source_rid
+
+    @builtins.property
+    def batches(self) -> List["storage_writer_api_ColumnBatch"]:
+        """
+        Batches of columnar data to stream to Nominal. Each channel's data are provided as a column batch.
+        """
+        return self._batches
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        """
+        RID of the datasource (e.g., for a Connection) or dataset to stream data into.
+        """
+        return self._data_source_rid
+
+
+storage_writer_api_WriteColumnBatchesRequest.__name__ = "WriteColumnBatchesRequest"
+storage_writer_api_WriteColumnBatchesRequest.__qualname__ = "WriteColumnBatchesRequest"
+storage_writer_api_WriteColumnBatchesRequest.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_WriteLogsRequest(ConjureBeanType):
 
     @builtins.classmethod

nominal_api/scout_compute_api/__init__.py

@@ -86,6 +86,7 @@ from .._impl import (
     scout_compute_api_DriverSeries3d as DriverSeries3d,
     scout_compute_api_DurationConstant as DurationConstant,
     scout_compute_api_DurationConstantVisitor as DurationConstantVisitor,
+    scout_compute_api_DurationFilterRanges as DurationFilterRanges,
     scout_compute_api_EnumAggregationFunction as EnumAggregationFunction,
     scout_compute_api_EnumBucket as EnumBucket,
     scout_compute_api_EnumCountDuplicateSeries as EnumCountDuplicateSeries,

nominal_api/scout_compute_resolved_api/__init__.py

@@ -24,6 +24,7 @@ from .._impl import (
     scout_compute_resolved_api_CurveFitPlotTypeNode as CurveFitPlotTypeNode,
     scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor as CurveFitPlotTypeNodeVisitor,
     scout_compute_resolved_api_DerivativeSeriesNode as DerivativeSeriesNode,
+    scout_compute_resolved_api_DurationFilterRangesNode as DurationFilterRangesNode,
     scout_compute_resolved_api_EnumCountDuplicateSeriesNode as EnumCountDuplicateSeriesNode,
     scout_compute_resolved_api_EnumEqualityRangesNode as EnumEqualityRangesNode,
     scout_compute_resolved_api_EnumFilterRangesNode as EnumFilterRangesNode,

nominal_api/storage_writer_api/__init__.py

@@ -2,6 +2,9 @@
 from .._impl import (
     storage_writer_api_ArrayPoints as ArrayPoints,
     storage_writer_api_ArrayPointsVisitor as ArrayPointsVisitor,
+    storage_writer_api_ColumnBatch as ColumnBatch,
+    storage_writer_api_ColumnValues as ColumnValues,
+    storage_writer_api_ColumnValuesVisitor as ColumnValuesVisitor,
     storage_writer_api_DirectNominalChannelWriterService as DirectNominalChannelWriterService,
     storage_writer_api_DoubleArrayPoint as DoubleArrayPoint,
     storage_writer_api_DoublePoint as DoublePoint,
@@ -22,6 +25,7 @@ from .._impl import (
     storage_writer_api_TelegrafMetric as TelegrafMetric,
     storage_writer_api_WriteBatchesRequest as WriteBatchesRequest,
     storage_writer_api_WriteBatchesRequestExternal as WriteBatchesRequestExternal,
+    storage_writer_api_WriteColumnBatchesRequest as WriteColumnBatchesRequest,
     storage_writer_api_WriteLogsRequest as WriteLogsRequest,
     storage_writer_api_WriteTelegrafBatchesRequest as WriteTelegrafBatchesRequest,
 )

{nominal_api-0.702.0.dist-info → nominal_api-0.703.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nominal-api
-Version: 0.702.0
+Version: 0.703.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<3,>=2.8.0

{nominal_api-0.702.0.dist-info → nominal_api-0.703.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=OwHP7jV6t8-n1cjeaANjmtrsd0xd7ses8EfH1YHC-0k,1955
-nominal_api/_impl.py,sha256=_xfAcElsTIKDD3q3Qya8GapScvJ3QOk-WEcPL1IDpTI,3212968
+nominal_api/__init__.py,sha256=WOjXRrnGry8pj2oj5gmJqM3Xh6sbtmeY91YStK6f1kk,1955
+nominal_api/_impl.py,sha256=1LunadUC805ktmWRGX8mBu4pMpMRhOaRx5TLnWbgX3s,3226636
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=1oJPOuAMfV2uClPUW8Ie1nj2Y6j81TDpedcc3yUFTe0,1294
 nominal_api/api_ids/__init__.py,sha256=CAtt44XgNZEEUDv-BbEbYtuxQ8y1wqSZU-STjBYdZv8,80
@@ -30,9 +30,9 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=1_nOnCSWn7bniSvTfskQ
 nominal_api/scout_checks_api/__init__.py,sha256=cNCQHBX38YqQv2qJMXwqUhjpCbayA3R9FqMmtKwzA3U,5160
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=8BL5jE9NDxqCj9DyvZWSPhq6zw2J7xp6aLsl3x9rpyw,4530
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=1LCXQe64tDqqeMQixW8PI-R_edSz7F5X0x2_ufEuC8M,480
-nominal_api/scout_compute_api/__init__.py,sha256=hqFzmHW1b58r3otIul1aUb_Qr0mL4QzO0Jq-GA9A9qU,19868
+nominal_api/scout_compute_api/__init__.py,sha256=TFM96QwZOqvbkI1qa0BX7S7Iw0sRfo_t1lBg-QOoDmM,19936
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=RggSfc6C1VR1-kNXPWybpfw3hZbkQ1gvxEisFZCHdnM,3732
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=LJFZQR1u_EQbZLzLGWMQVS8sEsKsFSmsITrlYGI5JsA,10801
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=vw310PtjaDwccDihR26-5AkuLFZ-ZMxG-tZpbQYde_4,10886
 nominal_api/scout_dataexport_api/__init__.py,sha256=pWRQdQJOObD0jITRYLw3AxeDJSrJQqAdFZACxULqA4o,1487
 nominal_api/scout_datareview_api/__init__.py,sha256=sdD3rdI65ZlVWXHRwk2sAranMypVdStq090U0UOOwuY,8320
 nominal_api/scout_datasource/__init__.py,sha256=1NWMrEx-JOEb4Pmd2oAqcpSmQB3g3lxgxFenWEtcF2M,101
@@ -61,7 +61,7 @@ nominal_api/security_api_workspace/__init__.py,sha256=W-TKCfSPTZ5XvLP0xFhkjCLKUW
 nominal_api/storage_datasource_api/__init__.py,sha256=jh_OZE_b4nBNAvnyenBjw8aGZOnvIXR6qvUKd31fXOk,445
 nominal_api/storage_deletion_api/__init__.py,sha256=2bIuAU0tcnT_8lqae0fcII4R45A_RzfV0y_E-vTkpSQ,267
 nominal_api/storage_series_api/__init__.py,sha256=F2ctWx8yqb4-JtfHkLzCq74njNEpGwr69b9fWQp9UAQ,99
-nominal_api/storage_writer_api/__init__.py,sha256=gGXpDRA9WJYYZ6F6dujahrgmWIZ337gUl2X7TQryFgE,1488
+nominal_api/storage_writer_api/__init__.py,sha256=TmSnKSsv_ubvxN__SlDxSyAH9XierKm_7k50AB4vgZM,1738
 nominal_api/themes_api/__init__.py,sha256=w-G93T5f6_2zSSUi-ffyUHxH8QA_2oI9jM7YBSMFpwY,924
 nominal_api/timeseries_archetype/__init__.py,sha256=eKdgdZoOcZg_9pmec6J86NlgQdhxhi1282WUAFxghJ8,115
 nominal_api/timeseries_archetype_api/__init__.py,sha256=IREibRlChT9ugCAkeMKm7RiAChsKV4KJZ-DcKkVLC_U,1396
@@ -72,7 +72,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=Q9iZHurmyDsJIFbUg-Eb
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=U9EhlqdF9qzD1O9al0vcvcdgS_C5lq-lN3Kmr0K3g84,1191
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.702.0.dist-info/METADATA,sha256=SgrjFvg0l9Z6ndFXVZIk9pN10OglPnUGrm7AYCj_b1w,199
-nominal_api-0.702.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nominal_api-0.702.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.702.0.dist-info/RECORD,,
+nominal_api-0.703.0.dist-info/METADATA,sha256=LM52vVlig9wlHicdyWxsgJbu8Nr0bRr47eBuvBtcusk,199
+nominal_api-0.703.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nominal_api-0.703.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.703.0.dist-info/RECORD,,