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

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

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

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

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

{nominal_api-0.981.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"
@@ -81642,6 +81880,7 @@ class scout_run_api_SearchQuery(ConjureUnionType):
     _end_time_inclusive: Optional["scout_run_api_UtcTimestamp"] = None
     _end_time: Optional["scout_run_api_TimeframeFilter"] = None
     _time_range: Optional["scout_run_api_TimeRangeFilter"] = None
+    _created_at: Optional["scout_run_api_TimeframeFilter"] = None
     _exact_match: Optional[str] = None
     _search_text: Optional[str] = None
     _asset: Optional[str] = None
@@ -81671,6 +81910,7 @@ class scout_run_api_SearchQuery(ConjureUnionType):
             'end_time_inclusive': ConjureFieldDefinition('endTimeInclusive', scout_run_api_UtcTimestamp),
             'end_time': ConjureFieldDefinition('endTime', scout_run_api_TimeframeFilter),
             'time_range': ConjureFieldDefinition('timeRange', scout_run_api_TimeRangeFilter),
+            'created_at': ConjureFieldDefinition('createdAt', scout_run_api_TimeframeFilter),
             'exact_match': ConjureFieldDefinition('exactMatch', str),
             'search_text': ConjureFieldDefinition('searchText', str),
             'asset': ConjureFieldDefinition('asset', scout_rids_api_AssetRid),
@@ -81700,6 +81940,7 @@ class scout_run_api_SearchQuery(ConjureUnionType):
             end_time_inclusive: Optional["scout_run_api_UtcTimestamp"] = None,
             end_time: Optional["scout_run_api_TimeframeFilter"] = None,
             time_range: Optional["scout_run_api_TimeRangeFilter"] = None,
+            created_at: Optional["scout_run_api_TimeframeFilter"] = None,
             exact_match: Optional[str] = None,
             search_text: Optional[str] = None,
             asset: Optional[str] = None,
@@ -81723,7 +81964,7 @@ class scout_run_api_SearchQuery(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (start_time_inclusive is not None) + (start_time is not None) + (end_time_inclusive is not None) + (end_time is not None) + (time_range is not None) + (exact_match is not None) + (search_text is not None) + (asset is not None) + (assets is not None) + (is_single_asset is not None) + (label is not None) + (labels is not None) + (property is not None) + (properties is not None) + (data_source_series_tag is not None) + (data_source_ref_name is not None) + (data_source is not None) + (run_number is not None) + (run_prefix is not None) + (check_alert_states_filter is not None) + (archived is not None) + (and_ is not None) + (or_ is not None) + (not_ is not None) + (workspace is not None) != 1:
+            if (start_time_inclusive is not None) + (start_time is not None) + (end_time_inclusive is not None) + (end_time is not None) + (time_range is not None) + (created_at is not None) + (exact_match is not None) + (search_text is not None) + (asset is not None) + (assets is not None) + (is_single_asset is not None) + (label is not None) + (labels is not None) + (property is not None) + (properties is not None) + (data_source_series_tag is not None) + (data_source_ref_name is not None) + (data_source is not None) + (run_number is not None) + (run_prefix is not None) + (check_alert_states_filter is not None) + (archived is not None) + (and_ is not None) + (or_ is not None) + (not_ is not None) + (workspace is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if start_time_inclusive is not None:
@@ -81741,6 +81982,9 @@ class scout_run_api_SearchQuery(ConjureUnionType):
             if time_range is not None:
                 self._time_range = time_range
                 self._type = 'timeRange'
+            if created_at is not None:
+                self._created_at = created_at
+                self._type = 'createdAt'
             if exact_match is not None:
                 self._exact_match = exact_match
                 self._type = 'exactMatch'
@@ -81827,6 +82071,11 @@ class scout_run_api_SearchQuery(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._time_range = time_range
             self._type = 'timeRange'
+        elif type_of_union == 'createdAt':
+            if created_at is None:
+                raise ValueError('a union value must not be None')
+            self._created_at = created_at
+            self._type = 'createdAt'
         elif type_of_union == 'exactMatch':
             if exact_match is None:
                 raise ValueError('a union value must not be None')
@@ -81948,6 +82197,10 @@ class scout_run_api_SearchQuery(ConjureUnionType):
     def time_range(self) -> Optional["scout_run_api_TimeRangeFilter"]:
         return self._time_range
 
+    @builtins.property
+    def created_at(self) -> Optional["scout_run_api_TimeframeFilter"]:
+        return self._created_at
+
     @builtins.property
     def exact_match(self) -> Optional[str]:
         """Performs case insensitive exact substring match search on the title.
@@ -82047,6 +82300,8 @@ class scout_run_api_SearchQuery(ConjureUnionType):
             return visitor._end_time(self.end_time)
         if self._type == 'timeRange' and self.time_range is not None:
             return visitor._time_range(self.time_range)
+        if self._type == 'createdAt' and self.created_at is not None:
+            return visitor._created_at(self.created_at)
         if self._type == 'exactMatch' and self.exact_match is not None:
             return visitor._exact_match(self.exact_match)
         if self._type == 'searchText' and self.search_text is not None:
@@ -82116,6 +82371,10 @@ class scout_run_api_SearchQueryVisitor:
     def _time_range(self, time_range: "scout_run_api_TimeRangeFilter") -> Any:
         pass
 
+    @abstractmethod
+    def _created_at(self, created_at: "scout_run_api_TimeframeFilter") -> Any:
+        pass
+
     @abstractmethod
     def _exact_match(self, exact_match: str) -> Any:
         pass
@@ -86987,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.
         """
@@ -87617,7 +87910,7 @@ Enforces read permission on the video.
         _decoder = ConjureDecoder()
         return None if _response.status_code == 204 else _decoder.decode(_response.json(), OptionalTypeWrapper[scout_video_api_GenerateWhepStreamResponse], self._return_none_for_unknown_union_types)
 
-    def upload_segment_from_media_mtx(self, auth_header: str, body: Any, content_length: int, duration: str, path: str) -> None:
+    def upload_segment_from_media_mtx(self, auth_header: str, body: Any, content_length: int, duration: str, file_path: str, stream_path: str) -> None:
         """MediaMTX segment upload endpoint. Receives video segments from MediaMTX hooks.
 Validates JWT and logs session. Future: create video segments from uploaded files.
         """
@@ -87631,7 +87924,8 @@ Validates JWT and logs session. Future: create video segments from uploaded file
         }
 
         _params: Dict[str, Any] = {
-            'path': _conjure_encoder.default(path),
+            'streamPath': _conjure_encoder.default(stream_path),
+            'filePath': _conjure_encoder.default(file_path),
             'duration': _conjure_encoder.default(duration),
         }
 
@@ -93496,7 +93790,7 @@ message WriteRequestNominal {
 message Series {
   Channel channel = 1;            
   map<string, string> tags = 2;   // Key-value pairs for series tags
-  Points points = 3;              // Contains either double or string points
+  Points points = 3;              // Contains double, string, integer, or array points
 }
 
 message Channel {
@@ -93508,6 +93802,7 @@ message Points {
     DoublePoints double_points = 1;
     StringPoints string_points = 2;
     IntegerPoints integer_points = 3;
+    ArrayPoints array_points = 4;
   }
 }
 
@@ -93523,6 +93818,21 @@ message IntegerPoints {
   repeated IntegerPoint points = 1;
 }
 
+message ArrayPoints {
+  oneof array_type {
+    DoubleArrayPoints double_array_points = 1;
+    StringArrayPoints string_array_points = 2;
+  }
+}
+
+message DoubleArrayPoints {
+  repeated DoubleArrayPoint points = 1;
+}
+
+message StringArrayPoints {
+  repeated StringArrayPoint points = 1;
+}
+
 message DoublePoint {
   google.protobuf.Timestamp timestamp = 1;
   double value = 2;
@@ -93537,13 +93847,24 @@ message IntegerPoint {
   google.protobuf.Timestamp timestamp = 1;
   int64 value = 2;
 }
+
+message DoubleArrayPoint {
+  google.protobuf.Timestamp timestamp = 1;
+  repeated double value = 2;
+}
+
+message StringArrayPoint {
+  google.protobuf.Timestamp timestamp = 1;
+  repeated string value = 2;
+}
 ```
 
 Each request can contain multiple series, where each series consists of:
 - A channel name
 - A map of tags (key-value pairs)
-- A collection of points, which can be either double or string values
+- A collection of points, which can be double, string, integer, or array (double/string) values
 - Each point includes a timestamp (using google.protobuf.Timestamp) and its value
+- Array points contain repeated values (array<double> or array<string>)
 
 The endpoint requires the Content-Type header to be set to "application/x-protobuf".
 If the payload is compressed, the appropriate Content-Encoding header must be included.
@@ -93783,13 +94104,15 @@ class storage_writer_api_PointsExternal(ConjureUnionType):
     _string: Optional[List["storage_writer_api_StringPoint"]] = None
     _double: Optional[List["storage_writer_api_DoublePoint"]] = None
     _int_: Optional[List["storage_writer_api_IntPoint"]] = None
+    _array: Optional["storage_writer_api_ArrayPoints"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'string': ConjureFieldDefinition('string', List[storage_writer_api_StringPoint]),
             'double': ConjureFieldDefinition('double', List[storage_writer_api_DoublePoint]),
-            'int_': ConjureFieldDefinition('int', List[storage_writer_api_IntPoint])
+            'int_': ConjureFieldDefinition('int', List[storage_writer_api_IntPoint]),
+            'array': ConjureFieldDefinition('array', storage_writer_api_ArrayPoints)
         }
 
     def __init__(
@@ -93797,10 +94120,11 @@ class storage_writer_api_PointsExternal(ConjureUnionType):
             string: Optional[List["storage_writer_api_StringPoint"]] = None,
             double: Optional[List["storage_writer_api_DoublePoint"]] = None,
             int_: Optional[List["storage_writer_api_IntPoint"]] = None,
+            array: Optional["storage_writer_api_ArrayPoints"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (string is not None) + (double is not None) + (int_ is not None) != 1:
+            if (string is not None) + (double is not None) + (int_ is not None) + (array is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if string is not None:
@@ -93812,6 +94136,9 @@ class storage_writer_api_PointsExternal(ConjureUnionType):
             if int_ is not None:
                 self._int_ = int_
                 self._type = 'int'
+            if array is not None:
+                self._array = array
+                self._type = 'array'
 
         elif type_of_union == 'string':
             if string is None:
@@ -93828,6 +94155,11 @@ class storage_writer_api_PointsExternal(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._int_ = int_
             self._type = 'int'
+        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 string(self) -> Optional[List["storage_writer_api_StringPoint"]]:
@@ -93841,6 +94173,10 @@ class storage_writer_api_PointsExternal(ConjureUnionType):
     def int_(self) -> Optional[List["storage_writer_api_IntPoint"]]:
         return self._int_
 
+    @builtins.property
+    def array(self) -> Optional["storage_writer_api_ArrayPoints"]:
+        return self._array
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, storage_writer_api_PointsExternalVisitor):
             raise ValueError('{} is not an instance of storage_writer_api_PointsExternalVisitor'.format(visitor.__class__.__name__))
@@ -93850,6 +94186,8 @@ class storage_writer_api_PointsExternal(ConjureUnionType):
             return visitor._double(self.double)
         if self._type == 'int' and self.int_ is not None:
             return visitor._int(self.int_)
+        if self._type == 'array' and self.array is not None:
+            return visitor._array(self.array)
 
 
 storage_writer_api_PointsExternal.__name__ = "PointsExternal"
@@ -93871,6 +94209,10 @@ class storage_writer_api_PointsExternalVisitor:
     def _int(self, int_: List["storage_writer_api_IntPoint"]) -> Any:
         pass
 
+    @abstractmethod
+    def _array(self, array: "storage_writer_api_ArrayPoints") -> Any:
+        pass
+
 
 storage_writer_api_PointsExternalVisitor.__name__ = "PointsExternalVisitor"
 storage_writer_api_PointsExternalVisitor.__qualname__ = "PointsExternalVisitor"

{nominal_api-0.981.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.981.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.981.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.981.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.981.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.981.0
+Version: 0.989.0
 Requires-Python: >=3.8
 Requires-Dist: requests
 Requires-Dist: conjure-python-client<4,>=2.8.0

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

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