nominal-api 0.765.0__py3-none-any.whl → 0.767.0__py3-none-any.whl

nominal_api/__init__.py

@@ -78,5 +78,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.765.0"
+__version__ = "0.767.0"
 

nominal_api/_impl.py

@@ -37875,6 +37875,202 @@ scout_compute_api_ArithmeticSeries.__qualname__ = "ArithmeticSeries"
 scout_compute_api_ArithmeticSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ArraySeries(ConjureUnionType):
+    _numeric1d: Optional["scout_compute_api_Numeric1dArraySeries"] = None
+    _enum1d: Optional["scout_compute_api_Enum1dArraySeries"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'numeric1d': ConjureFieldDefinition('numeric1d', scout_compute_api_Numeric1dArraySeries),
+            'enum1d': ConjureFieldDefinition('enum1d', scout_compute_api_Enum1dArraySeries)
+        }
+
+    def __init__(
+            self,
+            numeric1d: Optional["scout_compute_api_Numeric1dArraySeries"] = None,
+            enum1d: Optional["scout_compute_api_Enum1dArraySeries"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (numeric1d is not None) + (enum1d is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if numeric1d is not None:
+                self._numeric1d = numeric1d
+                self._type = 'numeric1d'
+            if enum1d is not None:
+                self._enum1d = enum1d
+                self._type = 'enum1d'
+
+        elif type_of_union == 'numeric1d':
+            if numeric1d is None:
+                raise ValueError('a union value must not be None')
+            self._numeric1d = numeric1d
+            self._type = 'numeric1d'
+        elif type_of_union == 'enum1d':
+            if enum1d is None:
+                raise ValueError('a union value must not be None')
+            self._enum1d = enum1d
+            self._type = 'enum1d'
+
+    @builtins.property
+    def numeric1d(self) -> Optional["scout_compute_api_Numeric1dArraySeries"]:
+        return self._numeric1d
+
+    @builtins.property
+    def enum1d(self) -> Optional["scout_compute_api_Enum1dArraySeries"]:
+        return self._enum1d
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_ArraySeriesVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_ArraySeriesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'numeric1d' and self.numeric1d is not None:
+            return visitor._numeric1d(self.numeric1d)
+        if self._type == 'enum1d' and self.enum1d is not None:
+            return visitor._enum1d(self.enum1d)
+
+
+scout_compute_api_ArraySeries.__name__ = "ArraySeries"
+scout_compute_api_ArraySeries.__qualname__ = "ArraySeries"
+scout_compute_api_ArraySeries.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_ArraySeriesVisitor:
+
+    @abstractmethod
+    def _numeric1d(self, numeric1d: "scout_compute_api_Numeric1dArraySeries") -> Any:
+        pass
+
+    @abstractmethod
+    def _enum1d(self, enum1d: "scout_compute_api_Enum1dArraySeries") -> Any:
+        pass
+
+
+scout_compute_api_ArraySeriesVisitor.__name__ = "ArraySeriesVisitor"
+scout_compute_api_ArraySeriesVisitor.__qualname__ = "ArraySeriesVisitor"
+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
+    _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),
+            '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,
+            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:
+                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 bucketed_numeric is not None:
+                self._bucketed_numeric = bucketed_numeric
+                self._type = 'bucketedNumeric'
+            if bucketed_enum is not None:
+                self._bucketed_enum = bucketed_enum
+                self._type = 'bucketedEnum'
+
+        elif type_of_union == 'pagedNumeric':
+            if paged_numeric 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:
+                raise ValueError('a union value must not be None')
+            self._paged_enum = paged_enum
+            self._type = 'pagedEnum'
+        elif type_of_union == 'bucketedNumeric':
+            if bucketed_numeric is None:
+                raise ValueError('a union value must not be None')
+            self._bucketed_numeric = bucketed_numeric
+            self._type = 'bucketedNumeric'
+        elif type_of_union == 'bucketedEnum':
+            if bucketed_enum is None:
+                raise ValueError('a union value must not be None')
+            self._bucketed_enum = bucketed_enum
+            self._type = 'bucketedEnum'
+
+    @builtins.property
+    def paged_numeric(self) -> Optional["scout_compute_api_PagedNumericArrayPlot"]:
+        return self._paged_numeric
+
+    @builtins.property
+    def paged_enum(self) -> Optional["scout_compute_api_PagedEnumArrayPlot"]:
+        return self._paged_enum
+
+    @builtins.property
+    def bucketed_numeric(self) -> Optional["scout_compute_api_BucketedNumericArrayPlot"]:
+        return self._bucketed_numeric
+
+    @builtins.property
+    def bucketed_enum(self) -> Optional["scout_compute_api_BucketedEnumArrayPlot"]:
+        return self._bucketed_enum
+
+    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 == '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:
+            return visitor._bucketed_enum(self.bucketed_enum)
+
+
+scout_compute_api_ArrowArrayPlot.__name__ = "ArrowArrayPlot"
+scout_compute_api_ArrowArrayPlot.__qualname__ = "ArrowArrayPlot"
+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:
+        pass
+
+    @abstractmethod
+    def _paged_enum(self, paged_enum: "scout_compute_api_PagedEnumArrayPlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _bucketed_numeric(self, bucketed_numeric: "scout_compute_api_BucketedNumericArrayPlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _bucketed_enum(self, bucketed_enum: "scout_compute_api_BucketedEnumArrayPlot") -> Any:
+        pass
+
+
+scout_compute_api_ArrowArrayPlotVisitor.__name__ = "ArrowArrayPlotVisitor"
+scout_compute_api_ArrowArrayPlotVisitor.__qualname__ = "ArrowArrayPlotVisitor"
+scout_compute_api_ArrowArrayPlotVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ArrowBucketedEnumPlot(ConjureBeanType):
 
     @builtins.classmethod
@@ -38654,6 +38850,34 @@ scout_compute_api_BucketedCartesianPlot.__qualname__ = "BucketedCartesianPlot"
 scout_compute_api_BucketedCartesianPlot.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_BucketedEnumArrayPlot(ConjureBeanType):
+    """The array is flattened out into a an arrow stream of bucketed primitive results, with an extra column to
+indicate the index of the array that the bucket corresponds to.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'arrow_binary': ConjureFieldDefinition('arrowBinary', BinaryType)
+        }
+
+    __slots__: List[str] = ['_arrow_binary']
+
+    def __init__(self, arrow_binary: Any) -> None:
+        self._arrow_binary = arrow_binary
+
+    @builtins.property
+    def arrow_binary(self) -> Any:
+        """The raw binary containing Arrow IPC stream for a bucketed N-dimensional enum array plot.
+        """
+        return self._arrow_binary
+
+
+scout_compute_api_BucketedEnumArrayPlot.__name__ = "BucketedEnumArrayPlot"
+scout_compute_api_BucketedEnumArrayPlot.__qualname__ = "BucketedEnumArrayPlot"
+scout_compute_api_BucketedEnumArrayPlot.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_BucketedEnumPlot(ConjureBeanType):
 
     @builtins.classmethod
@@ -38747,6 +38971,34 @@ scout_compute_api_BucketedGeoPlotVisitor.__qualname__ = "BucketedGeoPlotVisitor"
 scout_compute_api_BucketedGeoPlotVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_BucketedNumericArrayPlot(ConjureBeanType):
+    """The array is flattened out into a an arrow stream of bucketed primitive results, with an extra column to
+indicate the index of the array that the bucket corresponds to.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'arrow_binary': ConjureFieldDefinition('arrowBinary', BinaryType)
+        }
+
+    __slots__: List[str] = ['_arrow_binary']
+
+    def __init__(self, arrow_binary: Any) -> None:
+        self._arrow_binary = arrow_binary
+
+    @builtins.property
+    def arrow_binary(self) -> Any:
+        """The raw binary containing Arrow IPC stream for a bucketed N-dimensional numeric array plot.
+        """
+        return self._arrow_binary
+
+
+scout_compute_api_BucketedNumericArrayPlot.__name__ = "BucketedNumericArrayPlot"
+scout_compute_api_BucketedNumericArrayPlot.__qualname__ = "BucketedNumericArrayPlot"
+scout_compute_api_BucketedNumericArrayPlot.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_BucketedNumericPlot(ConjureBeanType):
 
     @builtins.classmethod
@@ -39627,6 +39879,7 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
     _numeric: Optional["scout_compute_api_NumericSeries"] = None
     _log: Optional["scout_compute_api_LogSeries"] = None
     _ranges: Optional["scout_compute_api_RangeSeries"] = None
+    _array: Optional["scout_compute_api_ArraySeries"] = None
     _curve_fit: Optional["scout_compute_api_CurveFit"] = None
     _raw: Optional["scout_compute_api_Reference"] = None
 
@@ -39637,6 +39890,7 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericSeries),
             'log': ConjureFieldDefinition('log', scout_compute_api_LogSeries),
             'ranges': ConjureFieldDefinition('ranges', scout_compute_api_RangeSeries),
+            'array': ConjureFieldDefinition('array', scout_compute_api_ArraySeries),
             'curve_fit': ConjureFieldDefinition('curveFit', scout_compute_api_CurveFit),
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference)
         }
@@ -39647,12 +39901,13 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             numeric: Optional["scout_compute_api_NumericSeries"] = None,
             log: Optional["scout_compute_api_LogSeries"] = None,
             ranges: Optional["scout_compute_api_RangeSeries"] = None,
+            array: Optional["scout_compute_api_ArraySeries"] = None,
             curve_fit: Optional["scout_compute_api_CurveFit"] = None,
             raw: Optional["scout_compute_api_Reference"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (enum is not None) + (numeric is not None) + (log is not None) + (ranges is not None) + (curve_fit is not None) + (raw is not None) != 1:
+            if (enum is not None) + (numeric is not None) + (log is not None) + (ranges is not None) + (array is not None) + (curve_fit is not None) + (raw is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if enum is not None:
@@ -39667,6 +39922,9 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             if ranges is not None:
                 self._ranges = ranges
                 self._type = 'ranges'
+            if array is not None:
+                self._array = array
+                self._type = 'array'
             if curve_fit is not None:
                 self._curve_fit = curve_fit
                 self._type = 'curveFit'
@@ -39694,6 +39952,11 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._ranges = ranges
             self._type = 'ranges'
+        elif type_of_union == 'array':
+            if array is None:
+                raise ValueError('a union value must not be None')
+            self._array = array
+            self._type = 'array'
         elif type_of_union == 'curveFit':
             if curve_fit is None:
                 raise ValueError('a union value must not be None')
@@ -39721,6 +39984,10 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
     def ranges(self) -> Optional["scout_compute_api_RangeSeries"]:
         return self._ranges
 
+    @builtins.property
+    def array(self) -> Optional["scout_compute_api_ArraySeries"]:
+        return self._array
+
     @builtins.property
     def curve_fit(self) -> Optional["scout_compute_api_CurveFit"]:
         return self._curve_fit
@@ -39740,6 +40007,8 @@ class scout_compute_api_ComputeNode(ConjureUnionType):
             return visitor._log(self.log)
         if self._type == 'ranges' and self.ranges is not None:
             return visitor._ranges(self.ranges)
+        if self._type == 'array' and self.array is not None:
+            return visitor._array(self.array)
         if self._type == 'curveFit' and self.curve_fit is not None:
             return visitor._curve_fit(self.curve_fit)
         if self._type == 'raw' and self.raw is not None:
@@ -39769,6 +40038,10 @@ class scout_compute_api_ComputeNodeVisitor:
     def _ranges(self, ranges: "scout_compute_api_RangeSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _array(self, array: "scout_compute_api_ArraySeries") -> Any:
+        pass
+
     @abstractmethod
     def _curve_fit(self, curve_fit: "scout_compute_api_CurveFit") -> Any:
         pass
@@ -39890,6 +40163,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None
     _curve_fit: Optional["scout_compute_api_CurveFitResult"] = None
     _grouped: Optional["scout_compute_api_GroupedComputeNodeResponses"] = None
+    _array: Optional["scout_compute_api_ArrowArrayPlot"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -39917,7 +40191,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             'numeric_histogram': ConjureFieldDefinition('numericHistogram', scout_compute_api_NumericHistogramPlot),
             'enum_histogram': ConjureFieldDefinition('enumHistogram', scout_compute_api_EnumHistogramPlot),
             'curve_fit': ConjureFieldDefinition('curveFit', scout_compute_api_CurveFitResult),
-            'grouped': ConjureFieldDefinition('grouped', scout_compute_api_GroupedComputeNodeResponses)
+            'grouped': ConjureFieldDefinition('grouped', scout_compute_api_GroupedComputeNodeResponses),
+            'array': ConjureFieldDefinition('array', scout_compute_api_ArrowArrayPlot)
         }
 
     def __init__(
@@ -39946,10 +40221,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None,
             curve_fit: Optional["scout_compute_api_CurveFitResult"] = None,
             grouped: Optional["scout_compute_api_GroupedComputeNodeResponses"] = None,
+            array: Optional["scout_compute_api_ArrowArrayPlot"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (range is not None) + (ranges_summary is not None) + (range_value is not None) + (numeric is not None) + (bucketed_numeric is not None) + (numeric_point is not None) + (arrow_numeric is not None) + (arrow_bucketed_numeric is not None) + (enum is not None) + (enum_point is not None) + (bucketed_enum is not None) + (arrow_enum is not None) + (arrow_bucketed_enum is not None) + (paged_log is not None) + (log_point is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (bucketed_geo is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit is not None) + (grouped is not None) != 1:
+            if (range is not None) + (ranges_summary is not None) + (range_value is not None) + (numeric is not None) + (bucketed_numeric is not None) + (numeric_point is not None) + (arrow_numeric is not None) + (arrow_bucketed_numeric is not None) + (enum is not None) + (enum_point is not None) + (bucketed_enum is not None) + (arrow_enum is not None) + (arrow_bucketed_enum is not None) + (paged_log is not None) + (log_point is not None) + (cartesian is not None) + (bucketed_cartesian is not None) + (bucketed_cartesian3d is not None) + (bucketed_geo is not None) + (frequency_domain is not None) + (numeric_histogram is not None) + (enum_histogram is not None) + (curve_fit is not None) + (grouped is not None) + (array is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if range is not None:
@@ -40024,6 +40300,9 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if grouped is not None:
                 self._grouped = grouped
                 self._type = 'grouped'
+            if array is not None:
+                self._array = array
+                self._type = 'array'
 
         elif type_of_union == 'range':
             if range is None:
@@ -40145,6 +40424,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._grouped = grouped
             self._type = 'grouped'
+        elif type_of_union == 'array':
+            if array is None:
+                raise ValueError('a union value must not be None')
+            self._array = array
+            self._type = 'array'
 
     @builtins.property
     def range(self) -> Optional[List["scout_compute_api_Range"]]:
@@ -40242,6 +40526,10 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def grouped(self) -> Optional["scout_compute_api_GroupedComputeNodeResponses"]:
         return self._grouped
 
+    @builtins.property
+    def array(self) -> Optional["scout_compute_api_ArrowArrayPlot"]:
+        return self._array
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_ComputeNodeResponseVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_ComputeNodeResponseVisitor'.format(visitor.__class__.__name__))
@@ -40293,6 +40581,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._curve_fit(self.curve_fit)
         if self._type == 'grouped' and self.grouped is not None:
             return visitor._grouped(self.grouped)
+        if self._type == 'array' and self.array is not None:
+            return visitor._array(self.array)
 
 
 scout_compute_api_ComputeNodeResponse.__name__ = "ComputeNodeResponse"
@@ -40398,6 +40688,10 @@ class scout_compute_api_ComputeNodeResponseVisitor:
     def _grouped(self, grouped: "scout_compute_api_GroupedComputeNodeResponses") -> Any:
         pass
 
+    @abstractmethod
+    def _array(self, array: "scout_compute_api_ArrowArrayPlot") -> Any:
+        pass
+
 
 scout_compute_api_ComputeNodeResponseVisitor.__name__ = "ComputeNodeResponseVisitor"
 scout_compute_api_ComputeNodeResponseVisitor.__qualname__ = "ComputeNodeResponseVisitor"
@@ -41658,6 +41952,65 @@ scout_compute_api_DerivativeSeries.__qualname__ = "DerivativeSeries"
 scout_compute_api_DerivativeSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_DerivedSeries(ConjureUnionType):
+    """Represents a derived series within a compute graph.
+This is a series that is derived from a function within a module.
+    """
+    _module_application: Optional["scout_compute_api_ModuleApplicationDerivedSeries"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'module_application': ConjureFieldDefinition('moduleApplication', scout_compute_api_ModuleApplicationDerivedSeries)
+        }
+
+    def __init__(
+            self,
+            module_application: Optional["scout_compute_api_ModuleApplicationDerivedSeries"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (module_application is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if module_application is not None:
+                self._module_application = module_application
+                self._type = 'moduleApplication'
+
+        elif type_of_union == 'moduleApplication':
+            if module_application is None:
+                raise ValueError('a union value must not be None')
+            self._module_application = module_application
+            self._type = 'moduleApplication'
+
+    @builtins.property
+    def module_application(self) -> Optional["scout_compute_api_ModuleApplicationDerivedSeries"]:
+        return self._module_application
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_DerivedSeriesVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_DerivedSeriesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'moduleApplication' and self.module_application is not None:
+            return visitor._module_application(self.module_application)
+
+
+scout_compute_api_DerivedSeries.__name__ = "DerivedSeries"
+scout_compute_api_DerivedSeries.__qualname__ = "DerivedSeries"
+scout_compute_api_DerivedSeries.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_DerivedSeriesVisitor:
+
+    @abstractmethod
+    def _module_application(self, module_application: "scout_compute_api_ModuleApplicationDerivedSeries") -> Any:
+        pass
+
+
+scout_compute_api_DerivedSeriesVisitor.__name__ = "DerivedSeriesVisitor"
+scout_compute_api_DerivedSeriesVisitor.__qualname__ = "DerivedSeriesVisitor"
+scout_compute_api_DerivedSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_DoubleConstant(ConjureUnionType):
     _literal: Optional[float] = None
     _variable: Optional[str] = None
@@ -44673,6 +45026,49 @@ scout_compute_api_Minimum.__qualname__ = "Minimum"
 scout_compute_api_Minimum.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ModuleApplicationDerivedSeries(ConjureBeanType):
+    """A reference to a derived series resulting from applying a module to an asset.
+The referenced module must be applied to the referenced asset.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'module_application_rid': ConjureFieldDefinition('moduleApplicationRid', scout_compute_api_StringConstant),
+            'function_name': ConjureFieldDefinition('functionName', scout_compute_api_StringConstant),
+            'function_args': ConjureFieldDefinition('functionArgs', Dict[scout_compute_api_VariableName, scout_compute_api_VariableValue])
+        }
+
+    __slots__: List[str] = ['_module_application_rid', '_function_name', '_function_args']
+
+    def __init__(self, function_args: Dict[str, "scout_compute_api_VariableValue"], function_name: "scout_compute_api_StringConstant", module_application_rid: "scout_compute_api_StringConstant") -> None:
+        self._module_application_rid = module_application_rid
+        self._function_name = function_name
+        self._function_args = function_args
+
+    @builtins.property
+    def module_application_rid(self) -> "scout_compute_api_StringConstant":
+        """A reference to the module application that produced this derived series.
+        """
+        return self._module_application_rid
+
+    @builtins.property
+    def function_name(self) -> "scout_compute_api_StringConstant":
+        return self._function_name
+
+    @builtins.property
+    def function_args(self) -> Dict[str, "scout_compute_api_VariableValue"]:
+        """Map of function input names to their values. The function inputs must match the function's parameter
+names and types. Because all function parameters have default values when the module is applied to the asset, this can be empty.
+        """
+        return self._function_args
+
+
+scout_compute_api_ModuleApplicationDerivedSeries.__name__ = "ModuleApplicationDerivedSeries"
+scout_compute_api_ModuleApplicationDerivedSeries.__qualname__ = "ModuleApplicationDerivedSeries"
+scout_compute_api_ModuleApplicationDerivedSeries.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_NegativeValueConfiguration(ConjureUnionType):
     _allow_negative_values: Optional["scout_compute_api_AllowNegativeValues"] = None
     _set_negative_values_to_zero: Optional["scout_compute_api_SetNegativeValuesToZero"] = None
@@ -46529,6 +46925,41 @@ 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),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_compute_api_PageToken])
+        }
+
+    __slots__: List[str] = ['_arrow_binary', '_next_page_token']
+
+    def __init__(self, arrow_binary: Any, next_page_token: Optional["scout_compute_api_PageToken"] = None) -> None:
+        self._arrow_binary = arrow_binary
+        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 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
@@ -46568,6 +46999,41 @@ 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),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_compute_api_PageToken])
+        }
+
+    __slots__: List[str] = ['_arrow_binary', '_next_page_token']
+
+    def __init__(self, arrow_binary: Any, next_page_token: Optional["scout_compute_api_PageToken"] = None) -> None:
+        self._arrow_binary = arrow_binary
+        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 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
@@ -48737,6 +49203,7 @@ class scout_compute_api_Series(ConjureUnionType):
     _enum: Optional["scout_compute_api_EnumSeries"] = None
     _numeric: Optional["scout_compute_api_NumericSeries"] = None
     _log: Optional["scout_compute_api_LogSeries"] = None
+    _array: Optional["scout_compute_api_ArraySeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -48744,7 +49211,8 @@ class scout_compute_api_Series(ConjureUnionType):
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
             'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumSeries),
             'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericSeries),
-            'log': ConjureFieldDefinition('log', scout_compute_api_LogSeries)
+            'log': ConjureFieldDefinition('log', scout_compute_api_LogSeries),
+            'array': ConjureFieldDefinition('array', scout_compute_api_ArraySeries)
         }
 
     def __init__(
@@ -48753,10 +49221,11 @@ class scout_compute_api_Series(ConjureUnionType):
             enum: Optional["scout_compute_api_EnumSeries"] = None,
             numeric: Optional["scout_compute_api_NumericSeries"] = None,
             log: Optional["scout_compute_api_LogSeries"] = None,
+            array: Optional["scout_compute_api_ArraySeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) != 1:
+            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) + (array is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -48771,6 +49240,9 @@ class scout_compute_api_Series(ConjureUnionType):
             if log is not None:
                 self._log = log
                 self._type = 'log'
+            if array is not None:
+                self._array = array
+                self._type = 'array'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -48792,6 +49264,11 @@ class scout_compute_api_Series(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._log = log
             self._type = 'log'
+        elif type_of_union == 'array':
+            if array is None:
+                raise ValueError('a union value must not be None')
+            self._array = array
+            self._type = 'array'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_api_Reference"]:
@@ -48809,6 +49286,10 @@ class scout_compute_api_Series(ConjureUnionType):
     def log(self) -> Optional["scout_compute_api_LogSeries"]:
         return self._log
 
+    @builtins.property
+    def array(self) -> Optional["scout_compute_api_ArraySeries"]:
+        return self._array
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_SeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_SeriesVisitor'.format(visitor.__class__.__name__))
@@ -48820,6 +49301,8 @@ class scout_compute_api_Series(ConjureUnionType):
             return visitor._numeric(self.numeric)
         if self._type == 'log' and self.log is not None:
             return visitor._log(self.log)
+        if self._type == 'array' and self.array is not None:
+            return visitor._array(self.array)
 
 
 scout_compute_api_Series.__name__ = "Series"
@@ -48845,6 +49328,10 @@ class scout_compute_api_SeriesVisitor:
     def _log(self, log: "scout_compute_api_LogSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _array(self, array: "scout_compute_api_ArraySeries") -> Any:
+        pass
+
 
 scout_compute_api_SeriesVisitor.__name__ = "SeriesVisitor"
 scout_compute_api_SeriesVisitor.__qualname__ = "SeriesVisitor"
@@ -50787,6 +51274,7 @@ class scout_compute_api_VariableValue(ConjureUnionType):
     _duration: Optional["scout_run_api_Duration"] = None
     _integer: Optional[int] = None
     _channel: Optional["scout_compute_api_ChannelSeries"] = None
+    _derived: Optional["scout_compute_api_DerivedSeries"] = None
     _series: Optional["scout_compute_api_SeriesSpec"] = None
     _string: Optional[str] = None
     _string_set: Optional[List[str]] = None
@@ -50800,6 +51288,7 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             'duration': ConjureFieldDefinition('duration', scout_run_api_Duration),
             'integer': ConjureFieldDefinition('integer', int),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
+            'derived': ConjureFieldDefinition('derived', scout_compute_api_DerivedSeries),
             'series': ConjureFieldDefinition('series', scout_compute_api_SeriesSpec),
             'string': ConjureFieldDefinition('string', str),
             'string_set': ConjureFieldDefinition('stringSet', List[str]),
@@ -50813,6 +51302,7 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             duration: Optional["scout_run_api_Duration"] = None,
             integer: Optional[int] = None,
             channel: Optional["scout_compute_api_ChannelSeries"] = None,
+            derived: Optional["scout_compute_api_DerivedSeries"] = None,
             series: Optional["scout_compute_api_SeriesSpec"] = None,
             string: Optional[str] = None,
             string_set: Optional[List[str]] = None,
@@ -50820,7 +51310,7 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (double is not None) + (compute_node is not None) + (duration is not None) + (integer is not None) + (channel is not None) + (series is not None) + (string is not None) + (string_set is not None) + (timestamp is not None) != 1:
+            if (double is not None) + (compute_node is not None) + (duration is not None) + (integer is not None) + (channel is not None) + (derived is not None) + (series is not None) + (string is not None) + (string_set is not None) + (timestamp is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if double is not None:
@@ -50838,6 +51328,9 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             if channel is not None:
                 self._channel = channel
                 self._type = 'channel'
+            if derived is not None:
+                self._derived = derived
+                self._type = 'derived'
             if series is not None:
                 self._series = series
                 self._type = 'series'
@@ -50876,6 +51369,11 @@ class scout_compute_api_VariableValue(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._channel = channel
             self._type = 'channel'
+        elif type_of_union == 'derived':
+            if derived is None:
+                raise ValueError('a union value must not be None')
+            self._derived = derived
+            self._type = 'derived'
         elif type_of_union == 'series':
             if series is None:
                 raise ValueError('a union value must not be None')
@@ -50917,6 +51415,10 @@ class scout_compute_api_VariableValue(ConjureUnionType):
     def channel(self) -> Optional["scout_compute_api_ChannelSeries"]:
         return self._channel
 
+    @builtins.property
+    def derived(self) -> Optional["scout_compute_api_DerivedSeries"]:
+        return self._derived
+
     @builtins.property
     def series(self) -> Optional["scout_compute_api_SeriesSpec"]:
         return self._series
@@ -50946,6 +51448,8 @@ class scout_compute_api_VariableValue(ConjureUnionType):
             return visitor._integer(self.integer)
         if self._type == 'channel' and self.channel is not None:
             return visitor._channel(self.channel)
+        if self._type == 'derived' and self.derived is not None:
+            return visitor._derived(self.derived)
         if self._type == 'series' and self.series is not None:
             return visitor._series(self.series)
         if self._type == 'string' and self.string is not None:
@@ -50983,6 +51487,10 @@ class scout_compute_api_VariableValueVisitor:
     def _channel(self, channel: "scout_compute_api_ChannelSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _derived(self, derived: "scout_compute_api_DerivedSeries") -> Any:
+        pass
+
     @abstractmethod
     def _series(self, series: "scout_compute_api_SeriesSpec") -> Any:
         pass
@@ -53220,6 +53728,83 @@ scout_compute_resolved_api_ArithmeticSeriesNode.__qualname__ = "ArithmeticSeries
 scout_compute_resolved_api_ArithmeticSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_ArraySeriesNode(ConjureUnionType):
+    _numeric1d: Optional["scout_compute_resolved_api_NumericArraySeriesNode"] = None
+    _enum1d: Optional["scout_compute_resolved_api_EnumArraySeriesNode"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'numeric1d': ConjureFieldDefinition('numeric1d', scout_compute_resolved_api_NumericArraySeriesNode),
+            'enum1d': ConjureFieldDefinition('enum1d', scout_compute_resolved_api_EnumArraySeriesNode)
+        }
+
+    def __init__(
+            self,
+            numeric1d: Optional["scout_compute_resolved_api_NumericArraySeriesNode"] = None,
+            enum1d: Optional["scout_compute_resolved_api_EnumArraySeriesNode"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (numeric1d is not None) + (enum1d is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if numeric1d is not None:
+                self._numeric1d = numeric1d
+                self._type = 'numeric1d'
+            if enum1d is not None:
+                self._enum1d = enum1d
+                self._type = 'enum1d'
+
+        elif type_of_union == 'numeric1d':
+            if numeric1d is None:
+                raise ValueError('a union value must not be None')
+            self._numeric1d = numeric1d
+            self._type = 'numeric1d'
+        elif type_of_union == 'enum1d':
+            if enum1d is None:
+                raise ValueError('a union value must not be None')
+            self._enum1d = enum1d
+            self._type = 'enum1d'
+
+    @builtins.property
+    def numeric1d(self) -> Optional["scout_compute_resolved_api_NumericArraySeriesNode"]:
+        return self._numeric1d
+
+    @builtins.property
+    def enum1d(self) -> Optional["scout_compute_resolved_api_EnumArraySeriesNode"]:
+        return self._enum1d
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_ArraySeriesNodeVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_ArraySeriesNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'numeric1d' and self.numeric1d is not None:
+            return visitor._numeric1d(self.numeric1d)
+        if self._type == 'enum1d' and self.enum1d is not None:
+            return visitor._enum1d(self.enum1d)
+
+
+scout_compute_resolved_api_ArraySeriesNode.__name__ = "ArraySeriesNode"
+scout_compute_resolved_api_ArraySeriesNode.__qualname__ = "ArraySeriesNode"
+scout_compute_resolved_api_ArraySeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_ArraySeriesNodeVisitor:
+
+    @abstractmethod
+    def _numeric1d(self, numeric1d: "scout_compute_resolved_api_NumericArraySeriesNode") -> Any:
+        pass
+
+    @abstractmethod
+    def _enum1d(self, enum1d: "scout_compute_resolved_api_EnumArraySeriesNode") -> Any:
+        pass
+
+
+scout_compute_resolved_api_ArraySeriesNodeVisitor.__name__ = "ArraySeriesNodeVisitor"
+scout_compute_resolved_api_ArraySeriesNodeVisitor.__qualname__ = "ArraySeriesNodeVisitor"
+scout_compute_resolved_api_ArraySeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_BandPassConfiguration(ConjureBeanType):
 
     @builtins.classmethod
@@ -58150,6 +58735,7 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
     _enum: Optional["scout_compute_resolved_api_EnumSeriesNode"] = None
     _numeric: Optional["scout_compute_resolved_api_NumericSeriesNode"] = None
     _log: Optional["scout_compute_resolved_api_LogSeriesNode"] = None
+    _array: Optional["scout_compute_resolved_api_ArraySeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -58157,7 +58743,8 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_RawUntypedSeriesNode),
             'enum': ConjureFieldDefinition('enum', scout_compute_resolved_api_EnumSeriesNode),
             'numeric': ConjureFieldDefinition('numeric', scout_compute_resolved_api_NumericSeriesNode),
-            'log': ConjureFieldDefinition('log', scout_compute_resolved_api_LogSeriesNode)
+            'log': ConjureFieldDefinition('log', scout_compute_resolved_api_LogSeriesNode),
+            'array': ConjureFieldDefinition('array', scout_compute_resolved_api_ArraySeriesNode)
         }
 
     def __init__(
@@ -58166,10 +58753,11 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             enum: Optional["scout_compute_resolved_api_EnumSeriesNode"] = None,
             numeric: Optional["scout_compute_resolved_api_NumericSeriesNode"] = None,
             log: Optional["scout_compute_resolved_api_LogSeriesNode"] = None,
+            array: Optional["scout_compute_resolved_api_ArraySeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) != 1:
+            if (raw is not None) + (enum is not None) + (numeric is not None) + (log is not None) + (array is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -58184,6 +58772,9 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             if log is not None:
                 self._log = log
                 self._type = 'log'
+            if array is not None:
+                self._array = array
+                self._type = 'array'
 
         elif type_of_union == 'raw':
             if raw is None:
@@ -58205,6 +58796,11 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._log = log
             self._type = 'log'
+        elif type_of_union == 'array':
+            if array is None:
+                raise ValueError('a union value must not be None')
+            self._array = array
+            self._type = 'array'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_resolved_api_RawUntypedSeriesNode"]:
@@ -58222,6 +58818,10 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
     def log(self) -> Optional["scout_compute_resolved_api_LogSeriesNode"]:
         return self._log
 
+    @builtins.property
+    def array(self) -> Optional["scout_compute_resolved_api_ArraySeriesNode"]:
+        return self._array
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_SeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_SeriesNodeVisitor'.format(visitor.__class__.__name__))
@@ -58233,6 +58833,8 @@ class scout_compute_resolved_api_SeriesNode(ConjureUnionType):
             return visitor._numeric(self.numeric)
         if self._type == 'log' and self.log is not None:
             return visitor._log(self.log)
+        if self._type == 'array' and self.array is not None:
+            return visitor._array(self.array)
 
 
 scout_compute_resolved_api_SeriesNode.__name__ = "SeriesNode"
@@ -58258,6 +58860,10 @@ class scout_compute_resolved_api_SeriesNodeVisitor:
     def _log(self, log: "scout_compute_resolved_api_LogSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _array(self, array: "scout_compute_resolved_api_ArraySeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_SeriesNodeVisitor.__name__ = "SeriesNodeVisitor"
 scout_compute_resolved_api_SeriesNodeVisitor.__qualname__ = "SeriesNodeVisitor"

nominal_api/scout_compute_api/__init__.py

@@ -9,6 +9,10 @@ from .._impl import (
     scout_compute_api_ApproximateThresholdOperator as ApproximateThresholdOperator,
     scout_compute_api_ApproximateThresholdRanges as ApproximateThresholdRanges,
     scout_compute_api_ArithmeticSeries as ArithmeticSeries,
+    scout_compute_api_ArraySeries as ArraySeries,
+    scout_compute_api_ArraySeriesVisitor as ArraySeriesVisitor,
+    scout_compute_api_ArrowArrayPlot as ArrowArrayPlot,
+    scout_compute_api_ArrowArrayPlotVisitor as ArrowArrayPlotVisitor,
     scout_compute_api_ArrowBucketedEnumPlot as ArrowBucketedEnumPlot,
     scout_compute_api_ArrowBucketedNumericPlot as ArrowBucketedNumericPlot,
     scout_compute_api_ArrowEnumPlot as ArrowEnumPlot,
@@ -34,9 +38,11 @@ from .._impl import (
     scout_compute_api_BitXorFunction as BitXorFunction,
     scout_compute_api_BucketedCartesian3dPlot as BucketedCartesian3dPlot,
     scout_compute_api_BucketedCartesianPlot as BucketedCartesianPlot,
+    scout_compute_api_BucketedEnumArrayPlot as BucketedEnumArrayPlot,
     scout_compute_api_BucketedEnumPlot as BucketedEnumPlot,
     scout_compute_api_BucketedGeoPlot as BucketedGeoPlot,
     scout_compute_api_BucketedGeoPlotVisitor as BucketedGeoPlotVisitor,
+    scout_compute_api_BucketedNumericArrayPlot as BucketedNumericArrayPlot,
     scout_compute_api_BucketedNumericPlot as BucketedNumericPlot,
     scout_compute_api_Cartesian as Cartesian,
     scout_compute_api_Cartesian3d as Cartesian3d,
@@ -89,6 +95,8 @@ from .._impl import (
     scout_compute_api_DecimateWithBuckets as DecimateWithBuckets,
     scout_compute_api_DecimateWithResolution as DecimateWithResolution,
     scout_compute_api_DerivativeSeries as DerivativeSeries,
+    scout_compute_api_DerivedSeries as DerivedSeries,
+    scout_compute_api_DerivedSeriesVisitor as DerivedSeriesVisitor,
     scout_compute_api_DoubleConstant as DoubleConstant,
     scout_compute_api_DoubleConstantVisitor as DoubleConstantVisitor,
     scout_compute_api_DriverSeries3d as DriverSeries3d,
@@ -185,6 +193,7 @@ from .._impl import (
     scout_compute_api_MinMaxThresholdRanges as MinMaxThresholdRanges,
     scout_compute_api_MinSeries as MinSeries,
     scout_compute_api_Minimum as Minimum,
+    scout_compute_api_ModuleApplicationDerivedSeries as ModuleApplicationDerivedSeries,
     scout_compute_api_NegativeValueConfiguration as NegativeValueConfiguration,
     scout_compute_api_NegativeValueConfigurationVisitor as NegativeValueConfigurationVisitor,
     scout_compute_api_NotRanges as NotRanges,
@@ -220,7 +229,9 @@ 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,
@@ -339,6 +350,10 @@ __all__ = [
     'ApproximateThresholdOperator',
     'ApproximateThresholdRanges',
     'ArithmeticSeries',
+    'ArraySeries',
+    'ArraySeriesVisitor',
+    'ArrowArrayPlot',
+    'ArrowArrayPlotVisitor',
     'ArrowBucketedEnumPlot',
     'ArrowBucketedNumericPlot',
     'ArrowEnumPlot',
@@ -364,9 +379,11 @@ __all__ = [
     'BitXorFunction',
     'BucketedCartesian3dPlot',
     'BucketedCartesianPlot',
+    'BucketedEnumArrayPlot',
     'BucketedEnumPlot',
     'BucketedGeoPlot',
     'BucketedGeoPlotVisitor',
+    'BucketedNumericArrayPlot',
     'BucketedNumericPlot',
     'Cartesian',
     'CartesianVisitor',
@@ -418,6 +435,8 @@ __all__ = [
     'DecimateWithBuckets',
     'DecimateWithResolution',
     'DerivativeSeries',
+    'DerivedSeries',
+    'DerivedSeriesVisitor',
     'DoubleConstant',
     'DoubleConstantVisitor',
     'DriverSeries3d',
@@ -514,6 +533,7 @@ __all__ = [
     'MinMaxThresholdRanges',
     'MinSeries',
     'Minimum',
+    'ModuleApplicationDerivedSeries',
     'NegativeValueConfiguration',
     'NegativeValueConfigurationVisitor',
     'NotRanges',
@@ -549,7 +569,9 @@ __all__ = [
     'PageStrategyVisitor',
     'PageToken',
     'PageTokenVisitor',
+    'PagedEnumArrayPlot',
     'PagedLogPlot',
+    'PagedNumericArrayPlot',
     'ParameterInput',
     'ParameterizedComputeNodeRequest',
     'ParameterizedComputeNodeResponse',

nominal_api/scout_compute_resolved_api/__init__.py

@@ -5,6 +5,8 @@ from .._impl import (
     scout_compute_resolved_api_AggregateEnumSeriesNode as AggregateEnumSeriesNode,
     scout_compute_resolved_api_AggregateNumericSeriesNode as AggregateNumericSeriesNode,
     scout_compute_resolved_api_ArithmeticSeriesNode as ArithmeticSeriesNode,
+    scout_compute_resolved_api_ArraySeriesNode as ArraySeriesNode,
+    scout_compute_resolved_api_ArraySeriesNodeVisitor as ArraySeriesNodeVisitor,
     scout_compute_resolved_api_BandPassConfiguration as BandPassConfiguration,
     scout_compute_resolved_api_BandStopConfiguration as BandStopConfiguration,
     scout_compute_resolved_api_BinaryArithmeticSeriesNode as BinaryArithmeticSeriesNode,
@@ -160,6 +162,8 @@ __all__ = [
     'AggregateEnumSeriesNode',
     'AggregateNumericSeriesNode',
     'ArithmeticSeriesNode',
+    'ArraySeriesNode',
+    'ArraySeriesNodeVisitor',
     'BandPassConfiguration',
     'BandStopConfiguration',
     'BinaryArithmeticSeriesNode',

{nominal_api-0.765.0.dist-info → nominal_api-0.767.0.dist-info}/METADATA

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

{nominal_api-0.765.0.dist-info → nominal_api-0.767.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=JTurJdbQFFxDeJ_uuYwHVGLfm0bkuzQwEo-C5Hj0S44,2012
-nominal_api/_impl.py,sha256=BF9wm9x5t8aXYeiX6rUt7IRadOlbHjklA2vG7O096SY,3412059
+nominal_api/__init__.py,sha256=C8TOUpzPxlnt-PZIg80zWTZbdwJcAGBlT664bcOlQmQ,2012
+nominal_api/_impl.py,sha256=GJaQ4bSGFheLnUcULCHu4eU3YdMgXRpw2dujSVkH0lU,3438202
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=PMREKP7UhxJ1_gHkrlJET46qlDHksKMm6-woR1p6WnU,1970
 nominal_api/api_ids/__init__.py,sha256=sxqN5dMk6bOx0SKOd0ANG3_kmx1VtdSVotzEGn_q6sE,114
@@ -33,9 +33,9 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=iVeUjPTlbpQ3vlQkQjHr
 nominal_api/scout_checks_api/__init__.py,sha256=uCmiNrVwLDlkg8YnpP-uZr9nFFFN52sM644Qo6YNy3k,6972
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=RpTvc8WqNxOuDSXWs-xV3MSSFIoIy8Fj3eaIDCVygvU,6215
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=y5SlDoXvskyTKjg2O8o3cBhGSN-KA7iVlVjyy3vb3Co,652
-nominal_api/scout_compute_api/__init__.py,sha256=YuZBcMy3WbAVThmYpZWZTr534ptbYa8o4iI-qmI1DTI,29605
+nominal_api/scout_compute_api/__init__.py,sha256=u3dRvCib5I0Eu8fwfoaNFHH9cAQpr9ulBDjHY7FyiXc,30634
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=JrZKbt1ulYECTdUSkXn6On22Alu_cPUBjCRWTN3ctxk,5041
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=Q1cKCbGdqm_adVh-NitZa8FCjJRC7NDvYMXveLUs4cY,16231
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=jzIpuPL2C39v88tKQHcv0MROTe6tMQGXLSMpT5VtIpQ,16432
 nominal_api/scout_dataexport_api/__init__.py,sha256=CF2vuo8kUXLJ4B7w95STrU0UMoBGuziacH5Eo3uxYf4,2068
 nominal_api/scout_datareview_api/__init__.py,sha256=kTDvcuav5bBm3IPhvmDrBTYyVD26iQVkyzdZnu75omE,11695
 nominal_api/scout_datasource/__init__.py,sha256=Z1Msu1Daf8GlLuM3w5imyB-6DhTNZojxI6xpH1sSvhM,141
@@ -75,7 +75,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=BwdqHLq_98LOsRV14JA3
 nominal_api/timeseries_seriescache/__init__.py,sha256=hL5hN8jKLEGE_fDiZzdASmWIrRjU6tncpmDeuc_47P4,150
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=USBxFmNnVFdnhTPLvWi3UgsvBZ4Iz4ycNgBTi10F-zI,1603
 nominal_api/upload_api/__init__.py,sha256=7-XXuZUqKPV4AMWvxNpZPZ5vBun4x-AomXj3Vol_BN4,123
-nominal_api-0.765.0.dist-info/METADATA,sha256=37IVqi6icsM0vt4ZyDZWN-WEJ0T979NBV0u1dCY5nDE,199
-nominal_api-0.765.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nominal_api-0.765.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.765.0.dist-info/RECORD,,
+nominal_api-0.767.0.dist-info/METADATA,sha256=wljXeOzBtCdGWM3PmulcTKQ6hHMisUgT5bb8YCvZuL4,199
+nominal_api-0.767.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nominal_api-0.767.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.767.0.dist-info/RECORD,,