nominal-api 0.764.0__tar.gz → 0.766.0__tar.gz

{nominal_api-0.764.0 → nominal_api-0.766.0}/PKG-INFO

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

{nominal_api-0.764.0 → nominal_api-0.766.0}/nominal_api/__init__.py

@@ -78,5 +78,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.764.0"
+__version__ = "0.766.0"
 

{nominal_api-0.764.0 → nominal_api-0.766.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"
@@ -46529,6 +46823,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 +46897,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 +49101,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 +49109,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 +49119,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 +49138,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 +49162,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 +49184,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 +49199,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 +49226,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"
@@ -53220,6 +53605,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 +58612,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 +58620,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 +58630,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 +58649,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 +58673,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 +58695,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 +58710,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 +58737,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-0.764.0 → nominal_api-0.766.0}/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,
@@ -220,7 +226,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 +347,10 @@ __all__ = [
     'ApproximateThresholdOperator',
     'ApproximateThresholdRanges',
     'ArithmeticSeries',
+    'ArraySeries',
+    'ArraySeriesVisitor',
+    'ArrowArrayPlot',
+    'ArrowArrayPlotVisitor',
     'ArrowBucketedEnumPlot',
     'ArrowBucketedNumericPlot',
     'ArrowEnumPlot',
@@ -364,9 +376,11 @@ __all__ = [
     'BitXorFunction',
     'BucketedCartesian3dPlot',
     'BucketedCartesianPlot',
+    'BucketedEnumArrayPlot',
     'BucketedEnumPlot',
     'BucketedGeoPlot',
     'BucketedGeoPlotVisitor',
+    'BucketedNumericArrayPlot',
     'BucketedNumericPlot',
     'Cartesian',
     'CartesianVisitor',
@@ -549,7 +563,9 @@ __all__ = [
     'PageStrategyVisitor',
     'PageToken',
     'PageTokenVisitor',
+    'PagedEnumArrayPlot',
     'PagedLogPlot',
+    'PagedNumericArrayPlot',
     'ParameterInput',
     'ParameterizedComputeNodeRequest',
     'ParameterizedComputeNodeResponse',

{nominal_api-0.764.0 → nominal_api-0.766.0}/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.764.0 → nominal_api-0.766.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.764.0 → nominal_api-0.766.0}/setup.py

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