nominal-api 0.717.1__tar.gz → 0.718.0__tar.gz

{nominal_api-0.717.1 → nominal_api-0.718.0}/PKG-INFO

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

{nominal_api-0.717.1 → nominal_api-0.718.0}/nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.717.1"
+__version__ = "0.718.0"
 

{nominal_api-0.717.1 → nominal_api-0.718.0}/nominal_api/_impl.py

@@ -38847,6 +38847,83 @@ scout_compute_api_DurationFilterRanges.__qualname__ = "DurationFilterRanges"
 scout_compute_api_DurationFilterRanges.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_Enum1dArraySeries(ConjureUnionType):
+    _channel: Optional["scout_compute_api_ChannelSeries"] = None
+    _raw: Optional["scout_compute_api_Reference"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
+            'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference)
+        }
+
+    def __init__(
+            self,
+            channel: Optional["scout_compute_api_ChannelSeries"] = None,
+            raw: Optional["scout_compute_api_Reference"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (channel is not None) + (raw is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if channel is not None:
+                self._channel = channel
+                self._type = 'channel'
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+
+        elif type_of_union == 'channel':
+            if channel is None:
+                raise ValueError('a union value must not be None')
+            self._channel = channel
+            self._type = 'channel'
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+
+    @builtins.property
+    def channel(self) -> Optional["scout_compute_api_ChannelSeries"]:
+        return self._channel
+
+    @builtins.property
+    def raw(self) -> Optional["scout_compute_api_Reference"]:
+        return self._raw
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_Enum1dArraySeriesVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_Enum1dArraySeriesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'channel' and self.channel is not None:
+            return visitor._channel(self.channel)
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+
+
+scout_compute_api_Enum1dArraySeries.__name__ = "Enum1dArraySeries"
+scout_compute_api_Enum1dArraySeries.__qualname__ = "Enum1dArraySeries"
+scout_compute_api_Enum1dArraySeries.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_Enum1dArraySeriesVisitor:
+
+    @abstractmethod
+    def _channel(self, channel: "scout_compute_api_ChannelSeries") -> Any:
+        pass
+
+    @abstractmethod
+    def _raw(self, raw: "scout_compute_api_Reference") -> Any:
+        pass
+
+
+scout_compute_api_Enum1dArraySeriesVisitor.__name__ = "Enum1dArraySeriesVisitor"
+scout_compute_api_Enum1dArraySeriesVisitor.__qualname__ = "Enum1dArraySeriesVisitor"
+scout_compute_api_Enum1dArraySeriesVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_EnumAggregationFunction(ConjureEnumType):
 
     MIN = 'MIN'
@@ -39211,6 +39288,7 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
     _union: Optional["scout_compute_api_EnumUnionSeries"] = None
     _filter_transformation: Optional["scout_compute_api_EnumFilterTransformationSeries"] = None
     _value_map: Optional["scout_compute_api_ValueMapSeries"] = None
+    _select1d_array_index: Optional["scout_compute_api_SelectIndexFrom1dEnumArraySeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -39224,7 +39302,8 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             'time_shift': ConjureFieldDefinition('timeShift', scout_compute_api_EnumTimeShiftSeries),
             'union': ConjureFieldDefinition('union', scout_compute_api_EnumUnionSeries),
             'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_api_EnumFilterTransformationSeries),
-            'value_map': ConjureFieldDefinition('valueMap', scout_compute_api_ValueMapSeries)
+            'value_map': ConjureFieldDefinition('valueMap', scout_compute_api_ValueMapSeries),
+            'select1d_array_index': ConjureFieldDefinition('select1dArrayIndex', scout_compute_api_SelectIndexFrom1dEnumArraySeries)
         }
 
     def __init__(
@@ -39239,10 +39318,11 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             union: Optional["scout_compute_api_EnumUnionSeries"] = None,
             filter_transformation: Optional["scout_compute_api_EnumFilterTransformationSeries"] = None,
             value_map: Optional["scout_compute_api_ValueMapSeries"] = None,
+            select1d_array_index: Optional["scout_compute_api_SelectIndexFrom1dEnumArraySeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (aggregate is not None) + (function is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (filter_transformation is not None) + (value_map is not None) != 1:
+            if (aggregate is not None) + (function is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (filter_transformation is not None) + (value_map is not None) + (select1d_array_index is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
@@ -39275,6 +39355,9 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             if value_map is not None:
                 self._value_map = value_map
                 self._type = 'valueMap'
+            if select1d_array_index is not None:
+                self._select1d_array_index = select1d_array_index
+                self._type = 'select1dArrayIndex'
 
         elif type_of_union == 'aggregate':
             if aggregate is None:
@@ -39326,6 +39409,11 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._value_map = value_map
             self._type = 'valueMap'
+        elif type_of_union == 'select1dArrayIndex':
+            if select1d_array_index is None:
+                raise ValueError('a union value must not be None')
+            self._select1d_array_index = select1d_array_index
+            self._type = 'select1dArrayIndex'
 
     @builtins.property
     def aggregate(self) -> Optional["scout_compute_api_AggregateEnumSeries"]:
@@ -39367,6 +39455,10 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
     def value_map(self) -> Optional["scout_compute_api_ValueMapSeries"]:
         return self._value_map
 
+    @builtins.property
+    def select1d_array_index(self) -> Optional["scout_compute_api_SelectIndexFrom1dEnumArraySeries"]:
+        return self._select1d_array_index
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_EnumSeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_EnumSeriesVisitor'.format(visitor.__class__.__name__))
@@ -39390,6 +39482,8 @@ class scout_compute_api_EnumSeries(ConjureUnionType):
             return visitor._filter_transformation(self.filter_transformation)
         if self._type == 'valueMap' and self.value_map is not None:
             return visitor._value_map(self.value_map)
+        if self._type == 'select1dArrayIndex' and self.select1d_array_index is not None:
+            return visitor._select1d_array_index(self.select1d_array_index)
 
 
 scout_compute_api_EnumSeries.__name__ = "EnumSeries"
@@ -39439,6 +39533,10 @@ class scout_compute_api_EnumSeriesVisitor:
     def _value_map(self, value_map: "scout_compute_api_ValueMapSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _select1d_array_index(self, select1d_array_index: "scout_compute_api_SelectIndexFrom1dEnumArraySeries") -> Any:
+        pass
+
 
 scout_compute_api_EnumSeriesVisitor.__name__ = "EnumSeriesVisitor"
 scout_compute_api_EnumSeriesVisitor.__qualname__ = "EnumSeriesVisitor"
@@ -41768,6 +41866,83 @@ scout_compute_api_NotRanges.__qualname__ = "NotRanges"
 scout_compute_api_NotRanges.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_Numeric1dArraySeries(ConjureUnionType):
+    _channel: Optional["scout_compute_api_ChannelSeries"] = None
+    _raw: Optional["scout_compute_api_Reference"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
+            'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference)
+        }
+
+    def __init__(
+            self,
+            channel: Optional["scout_compute_api_ChannelSeries"] = None,
+            raw: Optional["scout_compute_api_Reference"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (channel is not None) + (raw is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if channel is not None:
+                self._channel = channel
+                self._type = 'channel'
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+
+        elif type_of_union == 'channel':
+            if channel is None:
+                raise ValueError('a union value must not be None')
+            self._channel = channel
+            self._type = 'channel'
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+
+    @builtins.property
+    def channel(self) -> Optional["scout_compute_api_ChannelSeries"]:
+        return self._channel
+
+    @builtins.property
+    def raw(self) -> Optional["scout_compute_api_Reference"]:
+        return self._raw
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_Numeric1dArraySeriesVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_Numeric1dArraySeriesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'channel' and self.channel is not None:
+            return visitor._channel(self.channel)
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+
+
+scout_compute_api_Numeric1dArraySeries.__name__ = "Numeric1dArraySeries"
+scout_compute_api_Numeric1dArraySeries.__qualname__ = "Numeric1dArraySeries"
+scout_compute_api_Numeric1dArraySeries.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_Numeric1dArraySeriesVisitor:
+
+    @abstractmethod
+    def _channel(self, channel: "scout_compute_api_ChannelSeries") -> Any:
+        pass
+
+    @abstractmethod
+    def _raw(self, raw: "scout_compute_api_Reference") -> Any:
+        pass
+
+
+scout_compute_api_Numeric1dArraySeriesVisitor.__name__ = "Numeric1dArraySeriesVisitor"
+scout_compute_api_Numeric1dArraySeriesVisitor.__qualname__ = "Numeric1dArraySeriesVisitor"
+scout_compute_api_Numeric1dArraySeriesVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_NumericAggregationFunction(ConjureEnumType):
 
     SUM = 'SUM'
@@ -42270,6 +42445,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     _filter_transformation: Optional["scout_compute_api_NumericFilterTransformationSeries"] = None
     _threshold_filter: Optional["scout_compute_api_NumericThresholdFilterSeries"] = None
     _approximate_filter: Optional["scout_compute_api_NumericApproximateFilterSeries"] = None
+    _select1d_array_index: Optional["scout_compute_api_SelectIndexFrom1dNumericArraySeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -42304,7 +42480,8 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             'value_difference': ConjureFieldDefinition('valueDifference', scout_compute_api_ValueDifferenceSeries),
             'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_api_NumericFilterTransformationSeries),
             'threshold_filter': ConjureFieldDefinition('thresholdFilter', scout_compute_api_NumericThresholdFilterSeries),
-            'approximate_filter': ConjureFieldDefinition('approximateFilter', scout_compute_api_NumericApproximateFilterSeries)
+            'approximate_filter': ConjureFieldDefinition('approximateFilter', scout_compute_api_NumericApproximateFilterSeries),
+            'select1d_array_index': ConjureFieldDefinition('select1dArrayIndex', scout_compute_api_SelectIndexFrom1dNumericArraySeries)
         }
 
     def __init__(
@@ -42340,10 +42517,11 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             filter_transformation: Optional["scout_compute_api_NumericFilterTransformationSeries"] = None,
             threshold_filter: Optional["scout_compute_api_NumericThresholdFilterSeries"] = None,
             approximate_filter: Optional["scout_compute_api_NumericApproximateFilterSeries"] = None,
+            select1d_array_index: Optional["scout_compute_api_SelectIndexFrom1dNumericArraySeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (count_duplicate is not None) + (cumulative_sum is not None) + (derivative is not None) + (function is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) + (approximate_filter is not None) != 1:
+            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (count_duplicate is not None) + (cumulative_sum is not None) + (derivative is not None) + (function is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) + (approximate_filter is not None) + (select1d_array_index is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
@@ -42439,6 +42617,9 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             if approximate_filter is not None:
                 self._approximate_filter = approximate_filter
                 self._type = 'approximateFilter'
+            if select1d_array_index is not None:
+                self._select1d_array_index = select1d_array_index
+                self._type = 'select1dArrayIndex'
 
         elif type_of_union == 'aggregate':
             if aggregate is None:
@@ -42595,6 +42776,11 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._approximate_filter = approximate_filter
             self._type = 'approximateFilter'
+        elif type_of_union == 'select1dArrayIndex':
+            if select1d_array_index is None:
+                raise ValueError('a union value must not be None')
+            self._select1d_array_index = select1d_array_index
+            self._type = 'select1dArrayIndex'
 
     @builtins.property
     def aggregate(self) -> Optional["scout_compute_api_AggregateNumericSeries"]:
@@ -42720,6 +42906,10 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     def approximate_filter(self) -> Optional["scout_compute_api_NumericApproximateFilterSeries"]:
         return self._approximate_filter
 
+    @builtins.property
+    def select1d_array_index(self) -> Optional["scout_compute_api_SelectIndexFrom1dNumericArraySeries"]:
+        return self._select1d_array_index
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_NumericSeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_NumericSeriesVisitor'.format(visitor.__class__.__name__))
@@ -42785,6 +42975,8 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             return visitor._threshold_filter(self.threshold_filter)
         if self._type == 'approximateFilter' and self.approximate_filter is not None:
             return visitor._approximate_filter(self.approximate_filter)
+        if self._type == 'select1dArrayIndex' and self.select1d_array_index is not None:
+            return visitor._select1d_array_index(self.select1d_array_index)
 
 
 scout_compute_api_NumericSeries.__name__ = "NumericSeries"
@@ -42918,6 +43110,10 @@ class scout_compute_api_NumericSeriesVisitor:
     def _approximate_filter(self, approximate_filter: "scout_compute_api_NumericApproximateFilterSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _select1d_array_index(self, select1d_array_index: "scout_compute_api_SelectIndexFrom1dNumericArraySeries") -> Any:
+        pass
+
 
 scout_compute_api_NumericSeriesVisitor.__name__ = "NumericSeriesVisitor"
 scout_compute_api_NumericSeriesVisitor.__qualname__ = "NumericSeriesVisitor"
@@ -45465,6 +45661,70 @@ scout_compute_api_ScatterSummarizationStrategyVisitor.__qualname__ = "ScatterSum
 scout_compute_api_ScatterSummarizationStrategyVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_SelectIndexFrom1dEnumArraySeries(ConjureBeanType):
+    """For each timestamp, selects a single enum value from the 1D enum array at the specified index. If the index
+is out of bounds for an array at a given timestamp, it is omitted.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_Enum1dArraySeries),
+            'index': ConjureFieldDefinition('index', scout_compute_api_IntegerConstant)
+        }
+
+    __slots__: List[str] = ['_input', '_index']
+
+    def __init__(self, index: "scout_compute_api_IntegerConstant", input: "scout_compute_api_Enum1dArraySeries") -> None:
+        self._input = input
+        self._index = index
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_Enum1dArraySeries":
+        return self._input
+
+    @builtins.property
+    def index(self) -> "scout_compute_api_IntegerConstant":
+        return self._index
+
+
+scout_compute_api_SelectIndexFrom1dEnumArraySeries.__name__ = "SelectIndexFrom1dEnumArraySeries"
+scout_compute_api_SelectIndexFrom1dEnumArraySeries.__qualname__ = "SelectIndexFrom1dEnumArraySeries"
+scout_compute_api_SelectIndexFrom1dEnumArraySeries.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_SelectIndexFrom1dNumericArraySeries(ConjureBeanType):
+    """For each timestamp, selects a single numeric value from the 1D numeric array at the specified index. If the 
+index is out of bounds for an array at a given timestamp, it is omitted.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_Numeric1dArraySeries),
+            'index': ConjureFieldDefinition('index', scout_compute_api_IntegerConstant)
+        }
+
+    __slots__: List[str] = ['_input', '_index']
+
+    def __init__(self, index: "scout_compute_api_IntegerConstant", input: "scout_compute_api_Numeric1dArraySeries") -> None:
+        self._input = input
+        self._index = index
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_Numeric1dArraySeries":
+        return self._input
+
+    @builtins.property
+    def index(self) -> "scout_compute_api_IntegerConstant":
+        return self._index
+
+
+scout_compute_api_SelectIndexFrom1dNumericArraySeries.__name__ = "SelectIndexFrom1dNumericArraySeries"
+scout_compute_api_SelectIndexFrom1dNumericArraySeries.__qualname__ = "SelectIndexFrom1dNumericArraySeries"
+scout_compute_api_SelectIndexFrom1dNumericArraySeries.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_SelectValue(ConjureUnionType):
     _first_point: Optional["scout_compute_api_Series"] = None
     _first_range: Optional["scout_compute_api_RangeSeries"] = None
@@ -50718,6 +50978,62 @@ scout_compute_resolved_api_DurationFilterRangesNode.__qualname__ = "DurationFilt
 scout_compute_resolved_api_DurationFilterRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_EnumArraySeriesNode(ConjureUnionType):
+    _raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_ResolvedSeries)
+        }
+
+    def __init__(
+            self,
+            raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (raw is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+
+    @builtins.property
+    def raw(self) -> Optional["scout_compute_resolved_api_ResolvedSeries"]:
+        return self._raw
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_EnumArraySeriesNodeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_EnumArraySeriesNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+
+
+scout_compute_resolved_api_EnumArraySeriesNode.__name__ = "EnumArraySeriesNode"
+scout_compute_resolved_api_EnumArraySeriesNode.__qualname__ = "EnumArraySeriesNode"
+scout_compute_resolved_api_EnumArraySeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_EnumArraySeriesNodeVisitor:
+
+    @abstractmethod
+    def _raw(self, raw: "scout_compute_resolved_api_ResolvedSeries") -> Any:
+        pass
+
+
+scout_compute_resolved_api_EnumArraySeriesNodeVisitor.__name__ = "EnumArraySeriesNodeVisitor"
+scout_compute_resolved_api_EnumArraySeriesNodeVisitor.__qualname__ = "EnumArraySeriesNodeVisitor"
+scout_compute_resolved_api_EnumArraySeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_EnumCountDuplicateSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -50915,6 +51231,7 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
     _aggregate: Optional["scout_compute_resolved_api_AggregateEnumSeriesNode"] = None
     _filter_transformation: Optional["scout_compute_resolved_api_EnumFilterTransformationSeriesNode"] = None
     _value_map: Optional["scout_compute_resolved_api_ValueMapSeriesNode"] = None
+    _array_select: Optional["scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -50926,7 +51243,8 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             'union': ConjureFieldDefinition('union', scout_compute_resolved_api_EnumUnionSeriesNode),
             'aggregate': ConjureFieldDefinition('aggregate', scout_compute_resolved_api_AggregateEnumSeriesNode),
             'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_EnumFilterTransformationSeriesNode),
-            'value_map': ConjureFieldDefinition('valueMap', scout_compute_resolved_api_ValueMapSeriesNode)
+            'value_map': ConjureFieldDefinition('valueMap', scout_compute_resolved_api_ValueMapSeriesNode),
+            'array_select': ConjureFieldDefinition('arraySelect', scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode)
         }
 
     def __init__(
@@ -50939,10 +51257,11 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             aggregate: Optional["scout_compute_resolved_api_AggregateEnumSeriesNode"] = None,
             filter_transformation: Optional["scout_compute_resolved_api_EnumFilterTransformationSeriesNode"] = None,
             value_map: Optional["scout_compute_resolved_api_ValueMapSeriesNode"] = None,
+            array_select: Optional["scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (aggregate is not None) + (filter_transformation is not None) + (value_map is not None) != 1:
+            if (raw is not None) + (resample is not None) + (time_range_filter is not None) + (time_shift is not None) + (union is not None) + (aggregate is not None) + (filter_transformation is not None) + (value_map is not None) + (array_select is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -50969,6 +51288,9 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             if value_map is not None:
                 self._value_map = value_map
                 self._type = 'valueMap'
+            if array_select is not None:
+                self._array_select = array_select
+                self._type = 'arraySelect'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -51010,6 +51332,11 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._value_map = value_map
             self._type = 'valueMap'
+        elif type_of_union == 'arraySelect':
+            if array_select is None:
+                raise ValueError('a union value must not be None')
+            self._array_select = array_select
+            self._type = 'arraySelect'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_resolved_api_RawEnumSeriesNode"]:
@@ -51043,6 +51370,10 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
     def value_map(self) -> Optional["scout_compute_resolved_api_ValueMapSeriesNode"]:
         return self._value_map
 
+    @builtins.property
+    def array_select(self) -> Optional["scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode"]:
+        return self._array_select
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_EnumSeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_EnumSeriesNodeVisitor'.format(visitor.__class__.__name__))
@@ -51062,6 +51393,8 @@ class scout_compute_resolved_api_EnumSeriesNode(ConjureUnionType):
             return visitor._filter_transformation(self.filter_transformation)
         if self._type == 'valueMap' and self.value_map is not None:
             return visitor._value_map(self.value_map)
+        if self._type == 'arraySelect' and self.array_select is not None:
+            return visitor._array_select(self.array_select)
 
 
 scout_compute_resolved_api_EnumSeriesNode.__name__ = "EnumSeriesNode"
@@ -51103,6 +51436,10 @@ class scout_compute_resolved_api_EnumSeriesNodeVisitor:
     def _value_map(self, value_map: "scout_compute_resolved_api_ValueMapSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _array_select(self, array_select: "scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_EnumSeriesNodeVisitor.__name__ = "EnumSeriesNodeVisitor"
 scout_compute_resolved_api_EnumSeriesNodeVisitor.__qualname__ = "EnumSeriesNodeVisitor"
@@ -52285,6 +52622,62 @@ scout_compute_resolved_api_NotRangesNode.__qualname__ = "NotRangesNode"
 scout_compute_resolved_api_NotRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_NumericArraySeriesNode(ConjureUnionType):
+    _raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_ResolvedSeries)
+        }
+
+    def __init__(
+            self,
+            raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (raw is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+
+    @builtins.property
+    def raw(self) -> Optional["scout_compute_resolved_api_ResolvedSeries"]:
+        return self._raw
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_NumericArraySeriesNodeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_NumericArraySeriesNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+
+
+scout_compute_resolved_api_NumericArraySeriesNode.__name__ = "NumericArraySeriesNode"
+scout_compute_resolved_api_NumericArraySeriesNode.__qualname__ = "NumericArraySeriesNode"
+scout_compute_resolved_api_NumericArraySeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_NumericArraySeriesNodeVisitor:
+
+    @abstractmethod
+    def _raw(self, raw: "scout_compute_resolved_api_ResolvedSeries") -> Any:
+        pass
+
+
+scout_compute_resolved_api_NumericArraySeriesNodeVisitor.__name__ = "NumericArraySeriesNodeVisitor"
+scout_compute_resolved_api_NumericArraySeriesNodeVisitor.__qualname__ = "NumericArraySeriesNodeVisitor"
+scout_compute_resolved_api_NumericArraySeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_NumericFilterTransformationSeriesNode(ConjureBeanType):
     """Outputs the values of the numeric plot value within the ranges specified by a ranges node
     """
@@ -52508,6 +52901,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     _unit_conversion: Optional["scout_compute_resolved_api_UnitConversionSeriesNode"] = None
     _value_difference: Optional["scout_compute_resolved_api_ValueDifferenceSeriesNode"] = None
     _filter_transformation: Optional["scout_compute_resolved_api_NumericFilterTransformationSeriesNode"] = None
+    _array_select: Optional["scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -52538,7 +52932,8 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             'union': ConjureFieldDefinition('union', scout_compute_resolved_api_NumericUnionSeriesNode),
             'unit_conversion': ConjureFieldDefinition('unitConversion', scout_compute_resolved_api_UnitConversionSeriesNode),
             'value_difference': ConjureFieldDefinition('valueDifference', scout_compute_resolved_api_ValueDifferenceSeriesNode),
-            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_NumericFilterTransformationSeriesNode)
+            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_NumericFilterTransformationSeriesNode),
+            'array_select': ConjureFieldDefinition('arraySelect', scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode)
         }
 
     def __init__(
@@ -52570,10 +52965,11 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             unit_conversion: Optional["scout_compute_resolved_api_UnitConversionSeriesNode"] = None,
             value_difference: Optional["scout_compute_resolved_api_ValueDifferenceSeriesNode"] = None,
             filter_transformation: Optional["scout_compute_resolved_api_NumericFilterTransformationSeriesNode"] = None,
+            array_select: Optional["scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (arithmetic is not None) + (bit_operation is not None) + (count_duplicate is not None) + (cumulative_sum is not None) + (derivative is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (resample is not None) + (rolling_operation is not None) + (aggregate is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) != 1:
+            if (arithmetic is not None) + (bit_operation is not None) + (count_duplicate is not None) + (cumulative_sum is not None) + (derivative is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (resample is not None) + (rolling_operation is not None) + (aggregate is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (array_select is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if arithmetic is not None:
@@ -52657,6 +53053,9 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             if filter_transformation is not None:
                 self._filter_transformation = filter_transformation
                 self._type = 'filterTransformation'
+            if array_select is not None:
+                self._array_select = array_select
+                self._type = 'arraySelect'
 
         elif type_of_union == 'arithmetic':
             if arithmetic is None:
@@ -52793,6 +53192,11 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._filter_transformation = filter_transformation
             self._type = 'filterTransformation'
+        elif type_of_union == 'arraySelect':
+            if array_select is None:
+                raise ValueError('a union value must not be None')
+            self._array_select = array_select
+            self._type = 'arraySelect'
 
     @builtins.property
     def arithmetic(self) -> Optional["scout_compute_resolved_api_ArithmeticSeriesNode"]:
@@ -52902,6 +53306,10 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     def filter_transformation(self) -> Optional["scout_compute_resolved_api_NumericFilterTransformationSeriesNode"]:
         return self._filter_transformation
 
+    @builtins.property
+    def array_select(self) -> Optional["scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode"]:
+        return self._array_select
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_NumericSeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_NumericSeriesNodeVisitor'.format(visitor.__class__.__name__))
@@ -52959,6 +53367,8 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             return visitor._value_difference(self.value_difference)
         if self._type == 'filterTransformation' and self.filter_transformation is not None:
             return visitor._filter_transformation(self.filter_transformation)
+        if self._type == 'arraySelect' and self.array_select is not None:
+            return visitor._array_select(self.array_select)
 
 
 scout_compute_resolved_api_NumericSeriesNode.__name__ = "NumericSeriesNode"
@@ -53076,6 +53486,10 @@ class scout_compute_resolved_api_NumericSeriesNodeVisitor:
     def _filter_transformation(self, filter_transformation: "scout_compute_resolved_api_NumericFilterTransformationSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _array_select(self, array_select: "scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_NumericSeriesNodeVisitor.__name__ = "NumericSeriesNodeVisitor"
 scout_compute_resolved_api_NumericSeriesNodeVisitor.__qualname__ = "NumericSeriesNodeVisitor"
@@ -54431,6 +54845,64 @@ scout_compute_resolved_api_ScatterNode.__qualname__ = "ScatterNode"
 scout_compute_resolved_api_ScatterNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_EnumArraySeriesNode),
+            'index': ConjureFieldDefinition('index', int)
+        }
+
+    __slots__: List[str] = ['_input', '_index']
+
+    def __init__(self, index: int, input: "scout_compute_resolved_api_EnumArraySeriesNode") -> None:
+        self._input = input
+        self._index = index
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_EnumArraySeriesNode":
+        return self._input
+
+    @builtins.property
+    def index(self) -> int:
+        return self._index
+
+
+scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode.__name__ = "SelectIndexFromEnumArraySeriesNode"
+scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode.__qualname__ = "SelectIndexFromEnumArraySeriesNode"
+scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_NumericArraySeriesNode),
+            'index': ConjureFieldDefinition('index', int)
+        }
+
+    __slots__: List[str] = ['_input', '_index']
+
+    def __init__(self, index: int, input: "scout_compute_resolved_api_NumericArraySeriesNode") -> None:
+        self._input = input
+        self._index = index
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_NumericArraySeriesNode":
+        return self._input
+
+    @builtins.property
+    def index(self) -> int:
+        return self._index
+
+
+scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode.__name__ = "SelectIndexFromNumericArraySeriesNode"
+scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode.__qualname__ = "SelectIndexFromNumericArraySeriesNode"
+scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_SelectValueNode(ConjureUnionType):
     _first_point: Optional["scout_compute_resolved_api_SeriesNode"] = None
     _first_range: Optional["scout_compute_resolved_api_RangesNode"] = None

{nominal_api-0.717.1 → nominal_api-0.718.0}/nominal_api/scout_compute_api/__init__.py

@@ -87,6 +87,8 @@ from .._impl import (
     scout_compute_api_DurationConstant as DurationConstant,
     scout_compute_api_DurationConstantVisitor as DurationConstantVisitor,
     scout_compute_api_DurationFilterRanges as DurationFilterRanges,
+    scout_compute_api_Enum1dArraySeries as Enum1dArraySeries,
+    scout_compute_api_Enum1dArraySeriesVisitor as Enum1dArraySeriesVisitor,
     scout_compute_api_EnumAggregationFunction as EnumAggregationFunction,
     scout_compute_api_EnumBucket as EnumBucket,
     scout_compute_api_EnumCountDuplicateSeries as EnumCountDuplicateSeries,
@@ -180,6 +182,8 @@ from .._impl import (
     scout_compute_api_NegativeValueConfiguration as NegativeValueConfiguration,
     scout_compute_api_NegativeValueConfigurationVisitor as NegativeValueConfigurationVisitor,
     scout_compute_api_NotRanges as NotRanges,
+    scout_compute_api_Numeric1dArraySeries as Numeric1dArraySeries,
+    scout_compute_api_Numeric1dArraySeriesVisitor as Numeric1dArraySeriesVisitor,
     scout_compute_api_NumericAggregationFunction as NumericAggregationFunction,
     scout_compute_api_NumericApproximateFilterSeries as NumericApproximateFilterSeries,
     scout_compute_api_NumericBucket as NumericBucket,
@@ -253,6 +257,8 @@ from .._impl import (
     scout_compute_api_ScatterFitOptions as ScatterFitOptions,
     scout_compute_api_ScatterSummarizationStrategy as ScatterSummarizationStrategy,
     scout_compute_api_ScatterSummarizationStrategyVisitor as ScatterSummarizationStrategyVisitor,
+    scout_compute_api_SelectIndexFrom1dEnumArraySeries as SelectIndexFrom1dEnumArraySeries,
+    scout_compute_api_SelectIndexFrom1dNumericArraySeries as SelectIndexFrom1dNumericArraySeries,
     scout_compute_api_SelectValue as SelectValue,
     scout_compute_api_SelectValueVisitor as SelectValueVisitor,
     scout_compute_api_Series as Series,
@@ -400,6 +406,8 @@ __all__ = [
     'DurationConstant',
     'DurationConstantVisitor',
     'DurationFilterRanges',
+    'Enum1dArraySeries',
+    'Enum1dArraySeriesVisitor',
     'EnumAggregationFunction',
     'EnumBucket',
     'EnumCountDuplicateSeries',
@@ -493,6 +501,8 @@ __all__ = [
     'NegativeValueConfiguration',
     'NegativeValueConfigurationVisitor',
     'NotRanges',
+    'Numeric1dArraySeries',
+    'Numeric1dArraySeriesVisitor',
     'NumericAggregationFunction',
     'NumericApproximateFilterSeries',
     'NumericBucket',
@@ -566,6 +576,8 @@ __all__ = [
     'ScatterFitOptions',
     'ScatterSummarizationStrategy',
     'ScatterSummarizationStrategyVisitor',
+    'SelectIndexFrom1dEnumArraySeries',
+    'SelectIndexFrom1dNumericArraySeries',
     'SelectValue',
     'SelectValueVisitor',
     'Series',

{nominal_api-0.717.1 → nominal_api-0.718.0}/nominal_api/scout_compute_resolved_api/__init__.py

@@ -25,6 +25,8 @@ from .._impl import (
     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_EnumArraySeriesNode as EnumArraySeriesNode,
+    scout_compute_resolved_api_EnumArraySeriesNodeVisitor as EnumArraySeriesNodeVisitor,
     scout_compute_resolved_api_EnumCountDuplicateSeriesNode as EnumCountDuplicateSeriesNode,
     scout_compute_resolved_api_EnumEqualityRangesNode as EnumEqualityRangesNode,
     scout_compute_resolved_api_EnumFilterRangesNode as EnumFilterRangesNode,
@@ -72,6 +74,8 @@ from .._impl import (
     scout_compute_resolved_api_MinSeriesNode as MinSeriesNode,
     scout_compute_resolved_api_NominalStorageLocator as NominalStorageLocator,
     scout_compute_resolved_api_NotRangesNode as NotRangesNode,
+    scout_compute_resolved_api_NumericArraySeriesNode as NumericArraySeriesNode,
+    scout_compute_resolved_api_NumericArraySeriesNodeVisitor as NumericArraySeriesNodeVisitor,
     scout_compute_resolved_api_NumericFilterTransformationSeriesNode as NumericFilterTransformationSeriesNode,
     scout_compute_resolved_api_NumericHistogramBucketStrategy as NumericHistogramBucketStrategy,
     scout_compute_resolved_api_NumericHistogramBucketStrategyVisitor as NumericHistogramBucketStrategyVisitor,
@@ -110,6 +114,8 @@ from .._impl import (
     scout_compute_resolved_api_ScatterCurveFitNode as ScatterCurveFitNode,
     scout_compute_resolved_api_ScatterFitOptions as ScatterFitOptions,
     scout_compute_resolved_api_ScatterNode as ScatterNode,
+    scout_compute_resolved_api_SelectIndexFromEnumArraySeriesNode as SelectIndexFromEnumArraySeriesNode,
+    scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode as SelectIndexFromNumericArraySeriesNode,
     scout_compute_resolved_api_SelectValueNode as SelectValueNode,
     scout_compute_resolved_api_SelectValueNodeVisitor as SelectValueNodeVisitor,
     scout_compute_resolved_api_SeriesCrossoverRangesNode as SeriesCrossoverRangesNode,
@@ -168,6 +174,8 @@ __all__ = [
     'CurveFitPlotTypeNodeVisitor',
     'DerivativeSeriesNode',
     'DurationFilterRangesNode',
+    'EnumArraySeriesNode',
+    'EnumArraySeriesNodeVisitor',
     'EnumCountDuplicateSeriesNode',
     'EnumEqualityRangesNode',
     'EnumFilterRangesNode',
@@ -215,6 +223,8 @@ __all__ = [
     'MinSeriesNode',
     'NominalStorageLocator',
     'NotRangesNode',
+    'NumericArraySeriesNode',
+    'NumericArraySeriesNodeVisitor',
     'NumericFilterTransformationSeriesNode',
     'NumericHistogramBucketStrategy',
     'NumericHistogramBucketStrategyVisitor',
@@ -253,6 +263,8 @@ __all__ = [
     'ScatterCurveFitNode',
     'ScatterFitOptions',
     'ScatterNode',
+    'SelectIndexFromEnumArraySeriesNode',
+    'SelectIndexFromNumericArraySeriesNode',
     'SelectValueNode',
     'SelectValueNodeVisitor',
     'SeriesCrossoverRangesNode',

{nominal_api-0.717.1 → nominal_api-0.718.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.717.1 → nominal_api-0.718.0}/setup.py

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