nominal-api 0.944.1__tar.gz → 0.945.0__tar.gz

{nominal_api-0.944.1 → nominal_api-0.945.0}/PKG-INFO

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

{nominal_api-0.944.1 → nominal_api-0.945.0}/nominal_api/__init__.py

@@ -81,5 +81,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.944.1"
+__version__ = "0.945.0"
 

{nominal_api-0.944.1 → nominal_api-0.945.0}/nominal_api/_impl.py

@@ -17729,6 +17729,8 @@ class persistent_compute_api_InvalidComputationType(ConjureEnumType):
     '''CURVE_FITTING'''
     PAGE_SUMMARIZATION_STRATEGY = 'PAGE_SUMMARIZATION_STRATEGY'
     '''PAGE_SUMMARIZATION_STRATEGY'''
+    TRUNCATE_SUMMARIZATION_STRATEGY = 'TRUNCATE_SUMMARIZATION_STRATEGY'
+    '''TRUNCATE_SUMMARIZATION_STRATEGY'''
     LOG_SERIES = 'LOG_SERIES'
     '''LOG_SERIES'''
     LITERAL_RANGES = 'LITERAL_RANGES'
@@ -40845,38 +40847,38 @@ scout_compute_api_ArraySeriesVisitor.__module__ = "nominal_api.scout_compute_api
 
 
 class scout_compute_api_ArrowArrayPlot(ConjureUnionType):
-    _paged_numeric: Optional["scout_compute_api_PagedNumericArrayPlot"] = None
-    _paged_enum: Optional["scout_compute_api_PagedEnumArrayPlot"] = None
+    _numeric_array_series: Optional["scout_compute_api_NumericArrayPlot"] = None
+    _enum_array_series: Optional["scout_compute_api_EnumArrayPlot"] = None
     _bucketed_numeric: Optional["scout_compute_api_BucketedNumericArrayPlot"] = None
     _bucketed_enum: Optional["scout_compute_api_BucketedEnumArrayPlot"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'paged_numeric': ConjureFieldDefinition('pagedNumeric', scout_compute_api_PagedNumericArrayPlot),
-            'paged_enum': ConjureFieldDefinition('pagedEnum', scout_compute_api_PagedEnumArrayPlot),
+            'numeric_array_series': ConjureFieldDefinition('numericArraySeries', scout_compute_api_NumericArrayPlot),
+            'enum_array_series': ConjureFieldDefinition('enumArraySeries', scout_compute_api_EnumArrayPlot),
             'bucketed_numeric': ConjureFieldDefinition('bucketedNumeric', scout_compute_api_BucketedNumericArrayPlot),
             'bucketed_enum': ConjureFieldDefinition('bucketedEnum', scout_compute_api_BucketedEnumArrayPlot)
         }
 
     def __init__(
             self,
-            paged_numeric: Optional["scout_compute_api_PagedNumericArrayPlot"] = None,
-            paged_enum: Optional["scout_compute_api_PagedEnumArrayPlot"] = None,
+            numeric_array_series: Optional["scout_compute_api_NumericArrayPlot"] = None,
+            enum_array_series: Optional["scout_compute_api_EnumArrayPlot"] = None,
             bucketed_numeric: Optional["scout_compute_api_BucketedNumericArrayPlot"] = None,
             bucketed_enum: Optional["scout_compute_api_BucketedEnumArrayPlot"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (paged_numeric is not None) + (paged_enum is not None) + (bucketed_numeric is not None) + (bucketed_enum is not None) != 1:
+            if (numeric_array_series is not None) + (enum_array_series is not None) + (bucketed_numeric is not None) + (bucketed_enum is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if paged_numeric is not None:
-                self._paged_numeric = paged_numeric
-                self._type = 'pagedNumeric'
-            if paged_enum is not None:
-                self._paged_enum = paged_enum
-                self._type = 'pagedEnum'
+            if numeric_array_series is not None:
+                self._numeric_array_series = numeric_array_series
+                self._type = 'numericArraySeries'
+            if enum_array_series is not None:
+                self._enum_array_series = enum_array_series
+                self._type = 'enumArraySeries'
             if bucketed_numeric is not None:
                 self._bucketed_numeric = bucketed_numeric
                 self._type = 'bucketedNumeric'
@@ -40884,16 +40886,16 @@ class scout_compute_api_ArrowArrayPlot(ConjureUnionType):
                 self._bucketed_enum = bucketed_enum
                 self._type = 'bucketedEnum'
 
-        elif type_of_union == 'pagedNumeric':
-            if paged_numeric is None:
+        elif type_of_union == 'numericArraySeries':
+            if numeric_array_series is None:
                 raise ValueError('a union value must not be None')
-            self._paged_numeric = paged_numeric
-            self._type = 'pagedNumeric'
-        elif type_of_union == 'pagedEnum':
-            if paged_enum is None:
+            self._numeric_array_series = numeric_array_series
+            self._type = 'numericArraySeries'
+        elif type_of_union == 'enumArraySeries':
+            if enum_array_series is None:
                 raise ValueError('a union value must not be None')
-            self._paged_enum = paged_enum
-            self._type = 'pagedEnum'
+            self._enum_array_series = enum_array_series
+            self._type = 'enumArraySeries'
         elif type_of_union == 'bucketedNumeric':
             if bucketed_numeric is None:
                 raise ValueError('a union value must not be None')
@@ -40906,12 +40908,12 @@ class scout_compute_api_ArrowArrayPlot(ConjureUnionType):
             self._type = 'bucketedEnum'
 
     @builtins.property
-    def paged_numeric(self) -> Optional["scout_compute_api_PagedNumericArrayPlot"]:
-        return self._paged_numeric
+    def numeric_array_series(self) -> Optional["scout_compute_api_NumericArrayPlot"]:
+        return self._numeric_array_series
 
     @builtins.property
-    def paged_enum(self) -> Optional["scout_compute_api_PagedEnumArrayPlot"]:
-        return self._paged_enum
+    def enum_array_series(self) -> Optional["scout_compute_api_EnumArrayPlot"]:
+        return self._enum_array_series
 
     @builtins.property
     def bucketed_numeric(self) -> Optional["scout_compute_api_BucketedNumericArrayPlot"]:
@@ -40924,10 +40926,10 @@ class scout_compute_api_ArrowArrayPlot(ConjureUnionType):
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_ArrowArrayPlotVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_ArrowArrayPlotVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'pagedNumeric' and self.paged_numeric is not None:
-            return visitor._paged_numeric(self.paged_numeric)
-        if self._type == 'pagedEnum' and self.paged_enum is not None:
-            return visitor._paged_enum(self.paged_enum)
+        if self._type == 'numericArraySeries' and self.numeric_array_series is not None:
+            return visitor._numeric_array_series(self.numeric_array_series)
+        if self._type == 'enumArraySeries' and self.enum_array_series is not None:
+            return visitor._enum_array_series(self.enum_array_series)
         if self._type == 'bucketedNumeric' and self.bucketed_numeric is not None:
             return visitor._bucketed_numeric(self.bucketed_numeric)
         if self._type == 'bucketedEnum' and self.bucketed_enum is not None:
@@ -40942,11 +40944,11 @@ scout_compute_api_ArrowArrayPlot.__module__ = "nominal_api.scout_compute_api"
 class scout_compute_api_ArrowArrayPlotVisitor:
 
     @abstractmethod
-    def _paged_numeric(self, paged_numeric: "scout_compute_api_PagedNumericArrayPlot") -> Any:
+    def _numeric_array_series(self, numeric_array_series: "scout_compute_api_NumericArrayPlot") -> Any:
         pass
 
     @abstractmethod
-    def _paged_enum(self, paged_enum: "scout_compute_api_PagedEnumArrayPlot") -> Any:
+    def _enum_array_series(self, enum_array_series: "scout_compute_api_EnumArrayPlot") -> Any:
         pass
 
     @abstractmethod
@@ -45859,6 +45861,40 @@ scout_compute_api_EnumAggregationFunction.__qualname__ = "EnumAggregationFunctio
 scout_compute_api_EnumAggregationFunction.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_EnumArrayPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'arrow_binary': ConjureFieldDefinition('arrowBinary', BinaryType),
+            'group_by_keys': ConjureFieldDefinition('groupByKeys', OptionalTypeWrapper[List[str]])
+        }
+
+    __slots__: List[str] = ['_arrow_binary', '_group_by_keys']
+
+    def __init__(self, arrow_binary: Any, group_by_keys: Optional[List[str]] = None) -> None:
+        self._arrow_binary = arrow_binary
+        self._group_by_keys = group_by_keys
+
+    @builtins.property
+    def arrow_binary(self) -> Any:
+        """The raw binary containing Arrow IPC stream for the first n rows of an enum array plot sorted by timestamp.
+        """
+        return self._arrow_binary
+
+    @builtins.property
+    def group_by_keys(self) -> Optional[List[str]]:
+        """This field specifies the tags that the final output is grouped by. When you combine multiple channels, 
+this list represents the superset of all group by keys used across every individual channel.
+        """
+        return self._group_by_keys
+
+
+scout_compute_api_EnumArrayPlot.__name__ = "EnumArrayPlot"
+scout_compute_api_EnumArrayPlot.__qualname__ = "EnumArrayPlot"
+scout_compute_api_EnumArrayPlot.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_EnumBucket(ConjureBeanType):
 
     @builtins.classmethod
@@ -49473,6 +49509,40 @@ scout_compute_api_NumericApproximateFilterSeries.__qualname__ = "NumericApproxim
 scout_compute_api_NumericApproximateFilterSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_NumericArrayPlot(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'arrow_binary': ConjureFieldDefinition('arrowBinary', BinaryType),
+            'group_by_keys': ConjureFieldDefinition('groupByKeys', OptionalTypeWrapper[List[str]])
+        }
+
+    __slots__: List[str] = ['_arrow_binary', '_group_by_keys']
+
+    def __init__(self, arrow_binary: Any, group_by_keys: Optional[List[str]] = None) -> None:
+        self._arrow_binary = arrow_binary
+        self._group_by_keys = group_by_keys
+
+    @builtins.property
+    def arrow_binary(self) -> Any:
+        """The raw binary containing Arrow IPC stream for the first n rows of a numeric array plot sorted by timestamp.
+        """
+        return self._arrow_binary
+
+    @builtins.property
+    def group_by_keys(self) -> Optional[List[str]]:
+        """This field specifies the tags that the final output is grouped by. When you combine multiple channels, 
+this list represents the superset of all group by keys used across every individual channel.
+        """
+        return self._group_by_keys
+
+
+scout_compute_api_NumericArrayPlot.__name__ = "NumericArrayPlot"
+scout_compute_api_NumericArrayPlot.__qualname__ = "NumericArrayPlot"
+scout_compute_api_NumericArrayPlot.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_NumericBucket(ConjureBeanType):
 
     @builtins.classmethod
@@ -51347,50 +51417,6 @@ scout_compute_api_PageTokenVisitor.__qualname__ = "PageTokenVisitor"
 scout_compute_api_PageTokenVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_PagedEnumArrayPlot(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'arrow_binary': ConjureFieldDefinition('arrowBinary', BinaryType),
-            'group_by_keys': ConjureFieldDefinition('groupByKeys', OptionalTypeWrapper[List[str]]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_compute_api_PageToken])
-        }
-
-    __slots__: List[str] = ['_arrow_binary', '_group_by_keys', '_next_page_token']
-
-    def __init__(self, arrow_binary: Any, group_by_keys: Optional[List[str]] = None, next_page_token: Optional["scout_compute_api_PageToken"] = None) -> None:
-        self._arrow_binary = arrow_binary
-        self._group_by_keys = group_by_keys
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def arrow_binary(self) -> Any:
-        """The raw binary containing Arrow IPC stream for a page of an N-dimensional enum array plot.
-        """
-        return self._arrow_binary
-
-    @builtins.property
-    def group_by_keys(self) -> Optional[List[str]]:
-        """This field specifies the tags that the final output is grouped by. When you combine multiple channels, 
-this list represents the superset of all group by keys used across every individual channel.
-        """
-        return self._group_by_keys
-
-    @builtins.property
-    def next_page_token(self) -> Optional["scout_compute_api_PageToken"]:
-        """The token to retrieve the next page of arrays in the direction originally requested (exclusive - not
-included in these results). May be empty if there are no further values in the requested time range in the
-direction originally requested.
-        """
-        return self._next_page_token
-
-
-scout_compute_api_PagedEnumArrayPlot.__name__ = "PagedEnumArrayPlot"
-scout_compute_api_PagedEnumArrayPlot.__qualname__ = "PagedEnumArrayPlot"
-scout_compute_api_PagedEnumArrayPlot.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_PagedLogPlot(ConjureBeanType):
 
     @builtins.classmethod
@@ -51430,50 +51456,6 @@ scout_compute_api_PagedLogPlot.__qualname__ = "PagedLogPlot"
 scout_compute_api_PagedLogPlot.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_PagedNumericArrayPlot(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'arrow_binary': ConjureFieldDefinition('arrowBinary', BinaryType),
-            'group_by_keys': ConjureFieldDefinition('groupByKeys', OptionalTypeWrapper[List[str]]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_compute_api_PageToken])
-        }
-
-    __slots__: List[str] = ['_arrow_binary', '_group_by_keys', '_next_page_token']
-
-    def __init__(self, arrow_binary: Any, group_by_keys: Optional[List[str]] = None, next_page_token: Optional["scout_compute_api_PageToken"] = None) -> None:
-        self._arrow_binary = arrow_binary
-        self._group_by_keys = group_by_keys
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def arrow_binary(self) -> Any:
-        """The raw binary containing Arrow IPC stream for a page of an N-dimensional numeric array plot.
-        """
-        return self._arrow_binary
-
-    @builtins.property
-    def group_by_keys(self) -> Optional[List[str]]:
-        """This field specifies the tags that the final output is grouped by. When you combine multiple channels, 
-this list represents the superset of all group by keys used across every individual channel.
-        """
-        return self._group_by_keys
-
-    @builtins.property
-    def next_page_token(self) -> Optional["scout_compute_api_PageToken"]:
-        """The token to retrieve the next page of arrays in the direction originally requested (exclusive - not
-included in these results). May be empty if there are no further values in the requested time range in the
-direction originally requested.
-        """
-        return self._next_page_token
-
-
-scout_compute_api_PagedNumericArrayPlot.__name__ = "PagedNumericArrayPlot"
-scout_compute_api_PagedNumericArrayPlot.__qualname__ = "PagedNumericArrayPlot"
-scout_compute_api_PagedNumericArrayPlot.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_ParameterInput(ConjureBeanType):
 
     @builtins.classmethod
@@ -54773,22 +54755,25 @@ scout_compute_api_SumSeries.__module__ = "nominal_api.scout_compute_api"
 class scout_compute_api_SummarizationStrategy(ConjureUnionType):
     _decimate: Optional["scout_compute_api_DecimateStrategy"] = None
     _page: Optional["scout_compute_api_PageStrategy"] = None
+    _truncate: Optional["scout_compute_api_TruncateStrategy"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'decimate': ConjureFieldDefinition('decimate', scout_compute_api_DecimateStrategy),
-            'page': ConjureFieldDefinition('page', scout_compute_api_PageStrategy)
+            'page': ConjureFieldDefinition('page', scout_compute_api_PageStrategy),
+            'truncate': ConjureFieldDefinition('truncate', scout_compute_api_TruncateStrategy)
         }
 
     def __init__(
             self,
             decimate: Optional["scout_compute_api_DecimateStrategy"] = None,
             page: Optional["scout_compute_api_PageStrategy"] = None,
+            truncate: Optional["scout_compute_api_TruncateStrategy"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (decimate is not None) + (page is not None) != 1:
+            if (decimate is not None) + (page is not None) + (truncate is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if decimate is not None:
@@ -54797,6 +54782,9 @@ class scout_compute_api_SummarizationStrategy(ConjureUnionType):
             if page is not None:
                 self._page = page
                 self._type = 'page'
+            if truncate is not None:
+                self._truncate = truncate
+                self._type = 'truncate'
 
         elif type_of_union == 'decimate':
             if decimate is None:
@@ -54808,6 +54796,11 @@ class scout_compute_api_SummarizationStrategy(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._page = page
             self._type = 'page'
+        elif type_of_union == 'truncate':
+            if truncate is None:
+                raise ValueError('a union value must not be None')
+            self._truncate = truncate
+            self._type = 'truncate'
 
     @builtins.property
     def decimate(self) -> Optional["scout_compute_api_DecimateStrategy"]:
@@ -54819,6 +54812,10 @@ class scout_compute_api_SummarizationStrategy(ConjureUnionType):
         """
         return self._page
 
+    @builtins.property
+    def truncate(self) -> Optional["scout_compute_api_TruncateStrategy"]:
+        return self._truncate
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_SummarizationStrategyVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_SummarizationStrategyVisitor'.format(visitor.__class__.__name__))
@@ -54826,6 +54823,8 @@ class scout_compute_api_SummarizationStrategy(ConjureUnionType):
             return visitor._decimate(self.decimate)
         if self._type == 'page' and self.page is not None:
             return visitor._page(self.page)
+        if self._type == 'truncate' and self.truncate is not None:
+            return visitor._truncate(self.truncate)
 
 
 scout_compute_api_SummarizationStrategy.__name__ = "SummarizationStrategy"
@@ -54843,6 +54842,10 @@ class scout_compute_api_SummarizationStrategyVisitor:
     def _page(self, page: "scout_compute_api_PageStrategy") -> Any:
         pass
 
+    @abstractmethod
+    def _truncate(self, truncate: "scout_compute_api_TruncateStrategy") -> Any:
+        pass
+
 
 scout_compute_api_SummarizationStrategyVisitor.__name__ = "SummarizationStrategyVisitor"
 scout_compute_api_SummarizationStrategyVisitor.__qualname__ = "SummarizationStrategyVisitor"
@@ -55660,6 +55663,64 @@ scout_compute_api_TimestampConstantVisitor.__qualname__ = "TimestampConstantVisi
 scout_compute_api_TimestampConstantVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_TruncateStrategy(ConjureUnionType):
+    _max_points_to_return: Optional[int] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'max_points_to_return': ConjureFieldDefinition('maxPointsToReturn', int)
+        }
+
+    def __init__(
+            self,
+            max_points_to_return: Optional[int] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (max_points_to_return is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if max_points_to_return is not None:
+                self._max_points_to_return = max_points_to_return
+                self._type = 'maxPointsToReturn'
+
+        elif type_of_union == 'maxPointsToReturn':
+            if max_points_to_return is None:
+                raise ValueError('a union value must not be None')
+            self._max_points_to_return = max_points_to_return
+            self._type = 'maxPointsToReturn'
+
+    @builtins.property
+    def max_points_to_return(self) -> Optional[int]:
+        """Maximum number of points to return before truncating, ordered by timestamp. Throws if greater than 10,000
+        """
+        return self._max_points_to_return
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_TruncateStrategyVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_TruncateStrategyVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'maxPointsToReturn' and self.max_points_to_return is not None:
+            return visitor._max_points_to_return(self.max_points_to_return)
+
+
+scout_compute_api_TruncateStrategy.__name__ = "TruncateStrategy"
+scout_compute_api_TruncateStrategy.__qualname__ = "TruncateStrategy"
+scout_compute_api_TruncateStrategy.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_TruncateStrategyVisitor:
+
+    @abstractmethod
+    def _max_points_to_return(self, max_points_to_return: int) -> Any:
+        pass
+
+
+scout_compute_api_TruncateStrategyVisitor.__name__ = "TruncateStrategyVisitor"
+scout_compute_api_TruncateStrategyVisitor.__qualname__ = "TruncateStrategyVisitor"
+scout_compute_api_TruncateStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_UnaryArithmeticOperation(ConjureEnumType):
 
     COS = 'COS'

{nominal_api-0.944.1 → nominal_api-0.945.0}/nominal_api/scout_compute_api/__init__.py

@@ -109,6 +109,7 @@ from .._impl import (
     scout_compute_api_Enum1dArraySeries as Enum1dArraySeries,
     scout_compute_api_Enum1dArraySeriesVisitor as Enum1dArraySeriesVisitor,
     scout_compute_api_EnumAggregationFunction as EnumAggregationFunction,
+    scout_compute_api_EnumArrayPlot as EnumArrayPlot,
     scout_compute_api_EnumBucket as EnumBucket,
     scout_compute_api_EnumConstantResampleInterpolationConfiguration as EnumConstantResampleInterpolationConfiguration,
     scout_compute_api_EnumCountDuplicateSeries as EnumCountDuplicateSeries,
@@ -220,6 +221,7 @@ from .._impl import (
     scout_compute_api_Numeric1dArraySeriesVisitor as Numeric1dArraySeriesVisitor,
     scout_compute_api_NumericAggregationFunction as NumericAggregationFunction,
     scout_compute_api_NumericApproximateFilterSeries as NumericApproximateFilterSeries,
+    scout_compute_api_NumericArrayPlot as NumericArrayPlot,
     scout_compute_api_NumericBucket as NumericBucket,
     scout_compute_api_NumericConstantResampleInterpolationConfiguration as NumericConstantResampleInterpolationConfiguration,
     scout_compute_api_NumericFilterTransformationSeries as NumericFilterTransformationSeries,
@@ -254,9 +256,7 @@ from .._impl import (
     scout_compute_api_PageStrategyVisitor as PageStrategyVisitor,
     scout_compute_api_PageToken as PageToken,
     scout_compute_api_PageTokenVisitor as PageTokenVisitor,
-    scout_compute_api_PagedEnumArrayPlot as PagedEnumArrayPlot,
     scout_compute_api_PagedLogPlot as PagedLogPlot,
-    scout_compute_api_PagedNumericArrayPlot as PagedNumericArrayPlot,
     scout_compute_api_ParameterInput as ParameterInput,
     scout_compute_api_ParameterizedComputeNodeRequest as ParameterizedComputeNodeRequest,
     scout_compute_api_ParameterizedComputeNodeResponse as ParameterizedComputeNodeResponse,
@@ -354,6 +354,8 @@ from .._impl import (
     scout_compute_api_TimestampAndId as TimestampAndId,
     scout_compute_api_TimestampConstant as TimestampConstant,
     scout_compute_api_TimestampConstantVisitor as TimestampConstantVisitor,
+    scout_compute_api_TruncateStrategy as TruncateStrategy,
+    scout_compute_api_TruncateStrategyVisitor as TruncateStrategyVisitor,
     scout_compute_api_UnaryArithmeticOperation as UnaryArithmeticOperation,
     scout_compute_api_UnaryArithmeticSeries as UnaryArithmeticSeries,
     scout_compute_api_UnboundedBehavior as UnboundedBehavior,
@@ -486,6 +488,7 @@ __all__ = [
     'Enum1dArraySeries',
     'Enum1dArraySeriesVisitor',
     'EnumAggregationFunction',
+    'EnumArrayPlot',
     'EnumBucket',
     'EnumConstantResampleInterpolationConfiguration',
     'EnumCountDuplicateSeries',
@@ -597,6 +600,7 @@ __all__ = [
     'Numeric1dArraySeriesVisitor',
     'NumericAggregationFunction',
     'NumericApproximateFilterSeries',
+    'NumericArrayPlot',
     'NumericBucket',
     'NumericConstantResampleInterpolationConfiguration',
     'NumericFilterTransformationSeries',
@@ -631,9 +635,7 @@ __all__ = [
     'PageStrategyVisitor',
     'PageToken',
     'PageTokenVisitor',
-    'PagedEnumArrayPlot',
     'PagedLogPlot',
-    'PagedNumericArrayPlot',
     'ParameterInput',
     'ParameterizedComputeNodeRequest',
     'ParameterizedComputeNodeResponse',
@@ -731,6 +733,8 @@ __all__ = [
     'TimestampAndId',
     'TimestampConstant',
     'TimestampConstantVisitor',
+    'TruncateStrategy',
+    'TruncateStrategyVisitor',
     'UnaryArithmeticOperation',
     'UnaryArithmeticSeries',
     'UnboundedBehavior',

{nominal_api-0.944.1 → nominal_api-0.945.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.944.1 → nominal_api-0.945.0}/setup.py

@@ -6,7 +6,7 @@ from setuptools import (
 
 setup(
     name='nominal-api',
-    version='0.944.1',
+    version='0.945.0',
     python_requires='>=3.8',
     package_data={"": ["py.typed"]},
     packages=find_packages(),