nominal-api 0.983.0__tar.gz → 0.989.0__tar.gz

{nominal_api-0.983.0 → nominal_api-0.989.0}/PKG-INFO

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

{nominal_api-0.983.0 → nominal_api-0.989.0}/nominal_api/__init__.py

@@ -82,5 +82,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.983.0"
+__version__ = "0.989.0"
 

{nominal_api-0.983.0 → nominal_api-0.989.0}/nominal_api/_impl.py

@@ -18942,7 +18942,7 @@ a RunNotFound error will be thrown.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_notebook_api_Notebook, self._return_none_for_unknown_union_types)
 
-    def get(self, auth_header: str, rid: str) -> "scout_notebook_api_Notebook":
+    def get(self, auth_header: str, rid: str, snapshot: Optional[str] = None) -> "scout_notebook_api_Notebook":
         _conjure_encoder = ConjureEncoder()
 
         _headers: Dict[str, Any] = {
@@ -18951,6 +18951,7 @@ a RunNotFound error will be thrown.
         }
 
         _params: Dict[str, Any] = {
+            'snapshot': _conjure_encoder.default(snapshot),
         }
 
         _path_params: Dict[str, str] = {
@@ -31948,6 +31949,103 @@ scout_chartdefinition_api_StalenessVisualisationVisitor.__qualname__ = "Stalenes
 scout_chartdefinition_api_StalenessVisualisationVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_StructCellConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'visualisation': ConjureFieldDefinition('visualisation', OptionalTypeWrapper[scout_chartdefinition_api_StructVisualisation])
+        }
+
+    __slots__: List[str] = ['_visualisation']
+
+    def __init__(self, visualisation: Optional["scout_chartdefinition_api_StructVisualisation"] = None) -> None:
+        self._visualisation = visualisation
+
+    @builtins.property
+    def visualisation(self) -> Optional["scout_chartdefinition_api_StructVisualisation"]:
+        return self._visualisation
+
+
+scout_chartdefinition_api_StructCellConfig.__name__ = "StructCellConfig"
+scout_chartdefinition_api_StructCellConfig.__qualname__ = "StructCellConfig"
+scout_chartdefinition_api_StructCellConfig.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_StructRawVisualisation(ConjureBeanType):
+    """A raw struct visualisation (renders the JSON as-is)
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_chartdefinition_api_StructRawVisualisation.__name__ = "StructRawVisualisation"
+scout_chartdefinition_api_StructRawVisualisation.__qualname__ = "StructRawVisualisation"
+scout_chartdefinition_api_StructRawVisualisation.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_StructVisualisation(ConjureUnionType):
+    _raw: Optional["scout_chartdefinition_api_StructRawVisualisation"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'raw': ConjureFieldDefinition('raw', scout_chartdefinition_api_StructRawVisualisation)
+        }
+
+    def __init__(
+            self,
+            raw: Optional["scout_chartdefinition_api_StructRawVisualisation"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (raw is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if raw is not None:
+                self._raw = raw
+                self._type = 'raw'
+
+        elif type_of_union == 'raw':
+            if raw is None:
+                raise ValueError('a union value must not be None')
+            self._raw = raw
+            self._type = 'raw'
+
+    @builtins.property
+    def raw(self) -> Optional["scout_chartdefinition_api_StructRawVisualisation"]:
+        return self._raw
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_chartdefinition_api_StructVisualisationVisitor):
+            raise ValueError('{} is not an instance of scout_chartdefinition_api_StructVisualisationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'raw' and self.raw is not None:
+            return visitor._raw(self.raw)
+
+
+scout_chartdefinition_api_StructVisualisation.__name__ = "StructVisualisation"
+scout_chartdefinition_api_StructVisualisation.__qualname__ = "StructVisualisation"
+scout_chartdefinition_api_StructVisualisation.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
+class scout_chartdefinition_api_StructVisualisationVisitor:
+
+    @abstractmethod
+    def _raw(self, raw: "scout_chartdefinition_api_StructRawVisualisation") -> Any:
+        pass
+
+
+scout_chartdefinition_api_StructVisualisationVisitor.__name__ = "StructVisualisationVisitor"
+scout_chartdefinition_api_StructVisualisationVisitor.__qualname__ = "StructVisualisationVisitor"
+scout_chartdefinition_api_StructVisualisationVisitor.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_Threshold(ConjureBeanType):
 
     @builtins.classmethod
@@ -39344,6 +39442,7 @@ class scout_comparisonnotebook_api_AggregationType(ConjureUnionType):
     _mean: Optional["scout_comparisonnotebook_api_Mean"] = None
     _standard_deviation: Optional["scout_comparisonnotebook_api_StandardDeviation"] = None
     _count: Optional["scout_comparisonnotebook_api_Count"] = None
+    _root_mean_square: Optional["scout_comparisonnotebook_api_RootMeanSquare"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -39352,7 +39451,8 @@ class scout_comparisonnotebook_api_AggregationType(ConjureUnionType):
             'min': ConjureFieldDefinition('min', scout_comparisonnotebook_api_Min),
             'mean': ConjureFieldDefinition('mean', scout_comparisonnotebook_api_Mean),
             'standard_deviation': ConjureFieldDefinition('standardDeviation', scout_comparisonnotebook_api_StandardDeviation),
-            'count': ConjureFieldDefinition('count', scout_comparisonnotebook_api_Count)
+            'count': ConjureFieldDefinition('count', scout_comparisonnotebook_api_Count),
+            'root_mean_square': ConjureFieldDefinition('rootMeanSquare', scout_comparisonnotebook_api_RootMeanSquare)
         }
 
     def __init__(
@@ -39362,10 +39462,11 @@ class scout_comparisonnotebook_api_AggregationType(ConjureUnionType):
             mean: Optional["scout_comparisonnotebook_api_Mean"] = None,
             standard_deviation: Optional["scout_comparisonnotebook_api_StandardDeviation"] = None,
             count: Optional["scout_comparisonnotebook_api_Count"] = None,
+            root_mean_square: Optional["scout_comparisonnotebook_api_RootMeanSquare"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (max is not None) + (min is not None) + (mean is not None) + (standard_deviation is not None) + (count is not None) != 1:
+            if (max is not None) + (min is not None) + (mean is not None) + (standard_deviation is not None) + (count is not None) + (root_mean_square is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if max is not None:
@@ -39383,6 +39484,9 @@ class scout_comparisonnotebook_api_AggregationType(ConjureUnionType):
             if count is not None:
                 self._count = count
                 self._type = 'count'
+            if root_mean_square is not None:
+                self._root_mean_square = root_mean_square
+                self._type = 'rootMeanSquare'
 
         elif type_of_union == 'max':
             if max is None:
@@ -39409,6 +39513,11 @@ class scout_comparisonnotebook_api_AggregationType(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._count = count
             self._type = 'count'
+        elif type_of_union == 'rootMeanSquare':
+            if root_mean_square is None:
+                raise ValueError('a union value must not be None')
+            self._root_mean_square = root_mean_square
+            self._type = 'rootMeanSquare'
 
     @builtins.property
     def max(self) -> Optional["scout_comparisonnotebook_api_Max"]:
@@ -39430,6 +39539,10 @@ class scout_comparisonnotebook_api_AggregationType(ConjureUnionType):
     def count(self) -> Optional["scout_comparisonnotebook_api_Count"]:
         return self._count
 
+    @builtins.property
+    def root_mean_square(self) -> Optional["scout_comparisonnotebook_api_RootMeanSquare"]:
+        return self._root_mean_square
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_comparisonnotebook_api_AggregationTypeVisitor):
             raise ValueError('{} is not an instance of scout_comparisonnotebook_api_AggregationTypeVisitor'.format(visitor.__class__.__name__))
@@ -39443,6 +39556,8 @@ class scout_comparisonnotebook_api_AggregationType(ConjureUnionType):
             return visitor._standard_deviation(self.standard_deviation)
         if self._type == 'count' and self.count is not None:
             return visitor._count(self.count)
+        if self._type == 'rootMeanSquare' and self.root_mean_square is not None:
+            return visitor._root_mean_square(self.root_mean_square)
 
 
 scout_comparisonnotebook_api_AggregationType.__name__ = "AggregationType"
@@ -39472,6 +39587,10 @@ class scout_comparisonnotebook_api_AggregationTypeVisitor:
     def _count(self, count: "scout_comparisonnotebook_api_Count") -> Any:
         pass
 
+    @abstractmethod
+    def _root_mean_square(self, root_mean_square: "scout_comparisonnotebook_api_RootMeanSquare") -> Any:
+        pass
+
 
 scout_comparisonnotebook_api_AggregationTypeVisitor.__name__ = "AggregationTypeVisitor"
 scout_comparisonnotebook_api_AggregationTypeVisitor.__qualname__ = "AggregationTypeVisitor"
@@ -40533,6 +40652,22 @@ scout_comparisonnotebook_api_RangeAggregationDefinition.__qualname__ = "RangeAgg
 scout_comparisonnotebook_api_RangeAggregationDefinition.__module__ = "nominal_api.scout_comparisonnotebook_api"
 
 
+class scout_comparisonnotebook_api_RootMeanSquare(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_comparisonnotebook_api_RootMeanSquare.__name__ = "RootMeanSquare"
+scout_comparisonnotebook_api_RootMeanSquare.__qualname__ = "RootMeanSquare"
+scout_comparisonnotebook_api_RootMeanSquare.__module__ = "nominal_api.scout_comparisonnotebook_api"
+
+
 class scout_comparisonnotebook_api_ScatterPlotValueAxes(ConjureBeanType):
     """specifies the axes configurations for a given x and y axis.
     """
@@ -47820,6 +47955,38 @@ scout_compute_api_ExponentialResultDetails.__qualname__ = "ExponentialResultDeta
 scout_compute_api_ExponentialResultDetails.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ExtractStructFromStructSeries(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_StructSeries),
+            'field_path': ConjureFieldDefinition('fieldPath', scout_compute_api_StringConstant)
+        }
+
+    __slots__: List[str] = ['_input', '_field_path']
+
+    def __init__(self, field_path: "scout_compute_api_StringConstant", input: "scout_compute_api_StructSeries") -> None:
+        self._input = input
+        self._field_path = field_path
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_StructSeries":
+        return self._input
+
+    @builtins.property
+    def field_path(self) -> "scout_compute_api_StringConstant":
+        """Path to the field to extract as a struct. Nested fields are separated by periods and field names cannot contain periods.
+Returns an empty struct if the path is invalid or does not resolve to a valid JSON struct.
+        """
+        return self._field_path
+
+
+scout_compute_api_ExtractStructFromStructSeries.__name__ = "ExtractStructFromStructSeries"
+scout_compute_api_ExtractStructFromStructSeries.__qualname__ = "ExtractStructFromStructSeries"
+scout_compute_api_ExtractStructFromStructSeries.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_Fft(ConjureBeanType):
     """Returns the single sided amplitude spectrum of the input series.
     """
@@ -55637,13 +55804,15 @@ class scout_compute_api_StructSeries(ConjureUnionType):
     _channel: Optional["scout_compute_api_ChannelSeries"] = None
     _raw: Optional["scout_compute_api_Reference"] = None
     _derived: Optional["scout_compute_api_DerivedSeries"] = None
+    _extract_from_struct: Optional["scout_compute_api_ExtractStructFromStructSeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
             'raw': ConjureFieldDefinition('raw', scout_compute_api_Reference),
-            'derived': ConjureFieldDefinition('derived', scout_compute_api_DerivedSeries)
+            'derived': ConjureFieldDefinition('derived', scout_compute_api_DerivedSeries),
+            'extract_from_struct': ConjureFieldDefinition('extractFromStruct', scout_compute_api_ExtractStructFromStructSeries)
         }
 
     def __init__(
@@ -55651,10 +55820,11 @@ class scout_compute_api_StructSeries(ConjureUnionType):
             channel: Optional["scout_compute_api_ChannelSeries"] = None,
             raw: Optional["scout_compute_api_Reference"] = None,
             derived: Optional["scout_compute_api_DerivedSeries"] = None,
+            extract_from_struct: Optional["scout_compute_api_ExtractStructFromStructSeries"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (channel is not None) + (raw is not None) + (derived is not None) != 1:
+            if (channel is not None) + (raw is not None) + (derived is not None) + (extract_from_struct is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if channel is not None:
@@ -55666,6 +55836,9 @@ class scout_compute_api_StructSeries(ConjureUnionType):
             if derived is not None:
                 self._derived = derived
                 self._type = 'derived'
+            if extract_from_struct is not None:
+                self._extract_from_struct = extract_from_struct
+                self._type = 'extractFromStruct'
 
         elif type_of_union == 'channel':
             if channel is None:
@@ -55682,6 +55855,11 @@ class scout_compute_api_StructSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._derived = derived
             self._type = 'derived'
+        elif type_of_union == 'extractFromStruct':
+            if extract_from_struct is None:
+                raise ValueError('a union value must not be None')
+            self._extract_from_struct = extract_from_struct
+            self._type = 'extractFromStruct'
 
     @builtins.property
     def channel(self) -> Optional["scout_compute_api_ChannelSeries"]:
@@ -55695,6 +55873,10 @@ class scout_compute_api_StructSeries(ConjureUnionType):
     def derived(self) -> Optional["scout_compute_api_DerivedSeries"]:
         return self._derived
 
+    @builtins.property
+    def extract_from_struct(self) -> Optional["scout_compute_api_ExtractStructFromStructSeries"]:
+        return self._extract_from_struct
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_StructSeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_StructSeriesVisitor'.format(visitor.__class__.__name__))
@@ -55704,6 +55886,8 @@ class scout_compute_api_StructSeries(ConjureUnionType):
             return visitor._raw(self.raw)
         if self._type == 'derived' and self.derived is not None:
             return visitor._derived(self.derived)
+        if self._type == 'extractFromStruct' and self.extract_from_struct is not None:
+            return visitor._extract_from_struct(self.extract_from_struct)
 
 
 scout_compute_api_StructSeries.__name__ = "StructSeries"
@@ -55725,6 +55909,10 @@ class scout_compute_api_StructSeriesVisitor:
     def _derived(self, derived: "scout_compute_api_DerivedSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _extract_from_struct(self, extract_from_struct: "scout_compute_api_ExtractStructFromStructSeries") -> Any:
+        pass
+
 
 scout_compute_api_StructSeriesVisitor.__name__ = "StructSeriesVisitor"
 scout_compute_api_StructSeriesVisitor.__qualname__ = "StructSeriesVisitor"
@@ -61328,6 +61516,35 @@ scout_compute_resolved_api_ExponentialCurve.__qualname__ = "ExponentialCurve"
 scout_compute_resolved_api_ExponentialCurve.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_ExtractStructFromStructSeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_StructSeriesNode),
+            'field_path': ConjureFieldDefinition('fieldPath', str)
+        }
+
+    __slots__: List[str] = ['_input', '_field_path']
+
+    def __init__(self, field_path: str, input: "scout_compute_resolved_api_StructSeriesNode") -> None:
+        self._input = input
+        self._field_path = field_path
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_StructSeriesNode":
+        return self._input
+
+    @builtins.property
+    def field_path(self) -> str:
+        return self._field_path
+
+
+scout_compute_resolved_api_ExtractStructFromStructSeriesNode.__name__ = "ExtractStructFromStructSeriesNode"
+scout_compute_resolved_api_ExtractStructFromStructSeriesNode.__qualname__ = "ExtractStructFromStructSeriesNode"
+scout_compute_resolved_api_ExtractStructFromStructSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_ExtremaRangesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -65920,41 +66137,58 @@ scout_compute_resolved_api_StorageLocatorVisitor.__module__ = "nominal_api.scout
 
 class scout_compute_resolved_api_StructSeriesNode(ConjureUnionType):
     _raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None
+    _extract_from_struct: Optional["scout_compute_resolved_api_ExtractStructFromStructSeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_ResolvedSeries)
+            'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_ResolvedSeries),
+            'extract_from_struct': ConjureFieldDefinition('extractFromStruct', scout_compute_resolved_api_ExtractStructFromStructSeriesNode)
         }
 
     def __init__(
             self,
             raw: Optional["scout_compute_resolved_api_ResolvedSeries"] = None,
+            extract_from_struct: Optional["scout_compute_resolved_api_ExtractStructFromStructSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) != 1:
+            if (raw is not None) + (extract_from_struct is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
                 self._raw = raw
                 self._type = 'raw'
+            if extract_from_struct is not None:
+                self._extract_from_struct = extract_from_struct
+                self._type = 'extractFromStruct'
 
         elif type_of_union == 'raw':
             if raw is None:
                 raise ValueError('a union value must not be None')
             self._raw = raw
             self._type = 'raw'
+        elif type_of_union == 'extractFromStruct':
+            if extract_from_struct is None:
+                raise ValueError('a union value must not be None')
+            self._extract_from_struct = extract_from_struct
+            self._type = 'extractFromStruct'
 
     @builtins.property
     def raw(self) -> Optional["scout_compute_resolved_api_ResolvedSeries"]:
         return self._raw
 
+    @builtins.property
+    def extract_from_struct(self) -> Optional["scout_compute_resolved_api_ExtractStructFromStructSeriesNode"]:
+        return self._extract_from_struct
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_StructSeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_StructSeriesNodeVisitor'.format(visitor.__class__.__name__))
         if self._type == 'raw' and self.raw is not None:
             return visitor._raw(self.raw)
+        if self._type == 'extractFromStruct' and self.extract_from_struct is not None:
+            return visitor._extract_from_struct(self.extract_from_struct)
 
 
 scout_compute_resolved_api_StructSeriesNode.__name__ = "StructSeriesNode"
@@ -65968,6 +66202,10 @@ class scout_compute_resolved_api_StructSeriesNodeVisitor:
     def _raw(self, raw: "scout_compute_resolved_api_ResolvedSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _extract_from_struct(self, extract_from_struct: "scout_compute_resolved_api_ExtractStructFromStructSeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_StructSeriesNodeVisitor.__name__ = "StructSeriesNodeVisitor"
 scout_compute_resolved_api_StructSeriesNodeVisitor.__qualname__ = "StructSeriesNodeVisitor"
@@ -87008,6 +87246,40 @@ at the segment-level.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_video_api_CreateSegmentsResponse, self._return_none_for_unknown_union_types)
 
+    def create_video_stream_segments(self, auth_header: str, request: "scout_video_api_CreateSegmentsRequest", stream_uuid: str, video_rid: str) -> "scout_video_api_CreateSegmentsResponse":
+        """Creates segments for a video stream. Similar to createVideoFileSegments but for streaming video.
+        """
+        _conjure_encoder = ConjureEncoder()
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, str] = {
+            'videoRid': quote(str(_conjure_encoder.default(video_rid)), safe=''),
+            'streamUuid': quote(str(_conjure_encoder.default(stream_uuid)), safe=''),
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/video/v1/videos/{videoRid}/streams/{streamUuid}/create-segments'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_video_api_CreateSegmentsResponse, self._return_none_for_unknown_union_types)
+
     def get_segment_by_timestamp(self, auth_header: str, request: "scout_video_api_GetSegmentByTimestampRequest", video_rid: str) -> Optional["scout_video_api_Segment"]:
         """Returns metadata for the segment within a video containing the requested absolute timestamp.
         """

{nominal_api-0.983.0 → nominal_api-0.989.0}/nominal_api/scout_chartdefinition_api/__init__.py

@@ -148,6 +148,10 @@ from .._impl import (
     scout_chartdefinition_api_StalenessConfiguration as StalenessConfiguration,
     scout_chartdefinition_api_StalenessVisualisation as StalenessVisualisation,
     scout_chartdefinition_api_StalenessVisualisationVisitor as StalenessVisualisationVisitor,
+    scout_chartdefinition_api_StructCellConfig as StructCellConfig,
+    scout_chartdefinition_api_StructRawVisualisation as StructRawVisualisation,
+    scout_chartdefinition_api_StructVisualisation as StructVisualisation,
+    scout_chartdefinition_api_StructVisualisationVisitor as StructVisualisationVisitor,
     scout_chartdefinition_api_Threshold as Threshold,
     scout_chartdefinition_api_ThresholdDisconnectedValues as ThresholdDisconnectedValues,
     scout_chartdefinition_api_ThresholdLatch as ThresholdLatch,
@@ -346,6 +350,10 @@ __all__ = [
     'StalenessConfiguration',
     'StalenessVisualisation',
     'StalenessVisualisationVisitor',
+    'StructCellConfig',
+    'StructRawVisualisation',
+    'StructVisualisation',
+    'StructVisualisationVisitor',
     'Threshold',
     'ThresholdDisconnectedValues',
     'ThresholdLatch',

{nominal_api-0.983.0 → nominal_api-0.989.0}/nominal_api/scout_comparisonnotebook_api/__init__.py

@@ -38,6 +38,7 @@ from .._impl import (
     scout_comparisonnotebook_api_Min as Min,
     scout_comparisonnotebook_api_RangeAggregationContext as RangeAggregationContext,
     scout_comparisonnotebook_api_RangeAggregationDefinition as RangeAggregationDefinition,
+    scout_comparisonnotebook_api_RootMeanSquare as RootMeanSquare,
     scout_comparisonnotebook_api_ScatterPlotValueAxes as ScatterPlotValueAxes,
     scout_comparisonnotebook_api_StandardDeviation as StandardDeviation,
     scout_comparisonnotebook_api_SupplementalComparisonWorkbookContext as SupplementalComparisonWorkbookContext,
@@ -92,6 +93,7 @@ __all__ = [
     'Min',
     'RangeAggregationContext',
     'RangeAggregationDefinition',
+    'RootMeanSquare',
     'ScatterPlotValueAxes',
     'StandardDeviation',
     'SupplementalComparisonWorkbookContext',

{nominal_api-0.983.0 → nominal_api-0.989.0}/nominal_api/scout_compute_api/__init__.py

@@ -145,6 +145,7 @@ from .._impl import (
     scout_compute_api_ExcludeNegativeValues as ExcludeNegativeValues,
     scout_compute_api_ExponentialCurve as ExponentialCurve,
     scout_compute_api_ExponentialResultDetails as ExponentialResultDetails,
+    scout_compute_api_ExtractStructFromStructSeries as ExtractStructFromStructSeries,
     scout_compute_api_Fft as Fft,
     scout_compute_api_FftWindow as FftWindow,
     scout_compute_api_FilterByExpressionSeries as FilterByExpressionSeries,
@@ -529,6 +530,7 @@ __all__ = [
     'ExcludeNegativeValues',
     'ExponentialCurve',
     'ExponentialResultDetails',
+    'ExtractStructFromStructSeries',
     'Fft',
     'FftWindow',
     'FilterByExpressionSeries',

{nominal_api-0.983.0 → nominal_api-0.989.0}/nominal_api/scout_compute_resolved_api/__init__.py

@@ -44,6 +44,7 @@ from .._impl import (
     scout_compute_resolved_api_EnumUnionSeriesNode as EnumUnionSeriesNode,
     scout_compute_resolved_api_EventSearchNode as EventSearchNode,
     scout_compute_resolved_api_ExponentialCurve as ExponentialCurve,
+    scout_compute_resolved_api_ExtractStructFromStructSeriesNode as ExtractStructFromStructSeriesNode,
     scout_compute_resolved_api_ExtremaRangesNode as ExtremaRangesNode,
     scout_compute_resolved_api_FftNode as FftNode,
     scout_compute_resolved_api_FilterByExpressionSeriesNode as FilterByExpressionSeriesNode,
@@ -213,6 +214,7 @@ __all__ = [
     'EnumUnionSeriesNode',
     'EventSearchNode',
     'ExponentialCurve',
+    'ExtractStructFromStructSeriesNode',
     'ExtremaRangesNode',
     'FftNode',
     'FilterByExpressionSeriesNode',

{nominal_api-0.983.0 → nominal_api-0.989.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.983.0 → nominal_api-0.989.0}/setup.py

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