nominal-api 0.685.0__py3-none-any.whl → 0.687.0__py3-none-any.whl

nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.685.0"
+__version__ = "0.687.0"
 

nominal_api/_impl.py

@@ -497,6 +497,10 @@ class api_SeriesDataType(ConjureEnumType):
     '''LOG'''
     INT = 'INT'
     '''INT'''
+    DOUBLE_ARRAY = 'DOUBLE_ARRAY'
+    '''DOUBLE_ARRAY'''
+    STRING_ARRAY = 'STRING_ARRAY'
+    '''STRING_ARRAY'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -19171,14 +19175,16 @@ class scout_catalog_AddFileToDataset(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'handle': ConjureFieldDefinition('handle', scout_catalog_Handle),
-            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[scout_catalog_TimestampMetadata])
+            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[scout_catalog_TimestampMetadata]),
+            'origin_file_handles': ConjureFieldDefinition('originFileHandles', OptionalTypeWrapper[List[scout_catalog_S3Handle]])
         }
 
-    __slots__: List[str] = ['_handle', '_timestamp_metadata']
+    __slots__: List[str] = ['_handle', '_timestamp_metadata', '_origin_file_handles']
 
-    def __init__(self, handle: "scout_catalog_Handle", timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
+    def __init__(self, handle: "scout_catalog_Handle", origin_file_handles: Optional[List["scout_catalog_S3Handle"]] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
         self._handle = handle
         self._timestamp_metadata = timestamp_metadata
+        self._origin_file_handles = origin_file_handles
 
     @builtins.property
     def handle(self) -> "scout_catalog_Handle":
@@ -19188,6 +19194,10 @@ class scout_catalog_AddFileToDataset(ConjureBeanType):
     def timestamp_metadata(self) -> Optional["scout_catalog_TimestampMetadata"]:
         return self._timestamp_metadata
 
+    @builtins.property
+    def origin_file_handles(self) -> Optional[List["scout_catalog_S3Handle"]]:
+        return self._origin_file_handles
+
 
 scout_catalog_AddFileToDataset.__name__ = "AddFileToDataset"
 scout_catalog_AddFileToDataset.__qualname__ = "AddFileToDataset"
@@ -20307,12 +20317,13 @@ class scout_catalog_DatasetFile(ConjureBeanType):
             'uploaded_at': ConjureFieldDefinition('uploadedAt', str),
             'ingested_at': ConjureFieldDefinition('ingestedAt', OptionalTypeWrapper[str]),
             'ingest_status': ConjureFieldDefinition('ingestStatus', api_IngestStatusV2),
-            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[scout_catalog_TimestampMetadata])
+            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[scout_catalog_TimestampMetadata]),
+            'origin_file_paths': ConjureFieldDefinition('originFilePaths', OptionalTypeWrapper[List[str]])
         }
 
-    __slots__: List[str] = ['_id', '_dataset_rid', '_name', '_handle', '_bounds', '_uploaded_at', '_ingested_at', '_ingest_status', '_timestamp_metadata']
+    __slots__: List[str] = ['_id', '_dataset_rid', '_name', '_handle', '_bounds', '_uploaded_at', '_ingested_at', '_ingest_status', '_timestamp_metadata', '_origin_file_paths']
 
-    def __init__(self, dataset_rid: str, handle: "scout_catalog_Handle", id: str, ingest_status: "api_IngestStatusV2", name: str, uploaded_at: str, bounds: Optional["scout_catalog_Bounds"] = None, ingested_at: Optional[str] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
+    def __init__(self, dataset_rid: str, handle: "scout_catalog_Handle", id: str, ingest_status: "api_IngestStatusV2", name: str, uploaded_at: str, bounds: Optional["scout_catalog_Bounds"] = None, ingested_at: Optional[str] = None, origin_file_paths: Optional[List[str]] = None, timestamp_metadata: Optional["scout_catalog_TimestampMetadata"] = None) -> None:
         self._id = id
         self._dataset_rid = dataset_rid
         self._name = name
@@ -20322,6 +20333,7 @@ class scout_catalog_DatasetFile(ConjureBeanType):
         self._ingested_at = ingested_at
         self._ingest_status = ingest_status
         self._timestamp_metadata = timestamp_metadata
+        self._origin_file_paths = origin_file_paths
 
     @builtins.property
     def id(self) -> str:
@@ -20366,6 +20378,10 @@ ingested for any reason or is still being processed, then this value will be emp
     def timestamp_metadata(self) -> Optional["scout_catalog_TimestampMetadata"]:
         return self._timestamp_metadata
 
+    @builtins.property
+    def origin_file_paths(self) -> Optional[List[str]]:
+        return self._origin_file_paths
+
 
 scout_catalog_DatasetFile.__name__ = "DatasetFile"
 scout_catalog_DatasetFile.__qualname__ = "DatasetFile"
@@ -34396,16 +34412,18 @@ class scout_compute_api_AssetChannel(ConjureBeanType):
             'asset_rid': ConjureFieldDefinition('assetRid', scout_compute_api_StringConstant),
             'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_compute_api_StringConstant),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
-            'additional_tags': ConjureFieldDefinition('additionalTags', Dict[str, scout_compute_api_StringConstant])
+            'additional_tags': ConjureFieldDefinition('additionalTags', Dict[str, scout_compute_api_StringConstant]),
+            'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[str])
         }
 
-    __slots__: List[str] = ['_asset_rid', '_data_scope_name', '_channel', '_additional_tags']
+    __slots__: List[str] = ['_asset_rid', '_data_scope_name', '_channel', '_additional_tags', '_tags_to_group_by']
 
-    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], asset_rid: "scout_compute_api_StringConstant", channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant") -> None:
+    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], asset_rid: "scout_compute_api_StringConstant", channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", tags_to_group_by: List[str]) -> None:
         self._asset_rid = asset_rid
         self._data_scope_name = data_scope_name
         self._channel = channel
         self._additional_tags = additional_tags
+        self._tags_to_group_by = tags_to_group_by
 
     @builtins.property
     def asset_rid(self) -> "scout_compute_api_StringConstant":
@@ -34431,6 +34449,14 @@ both sets of tag filters. For log series, include arg filters here in addition t
         """
         return self._additional_tags
 
+    @builtins.property
+    def tags_to_group_by(self) -> List[str]:
+        """
+        Tags that the channel should be grouped by. If this is non-empty a grouped result will be returned
+with an entry for each grouping.
+        """
+        return self._tags_to_group_by
+
 
 scout_compute_api_AssetChannel.__name__ = "AssetChannel"
 scout_compute_api_AssetChannel.__qualname__ = "AssetChannel"
@@ -36196,6 +36222,7 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     _numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None
     _enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None
     _curve_fit: Optional["scout_compute_api_CurveFitResult"] = None
+    _grouped: Optional["scout_compute_api_GroupedComputeNodeResponses"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -36218,7 +36245,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             'frequency_domain': ConjureFieldDefinition('frequencyDomain', scout_compute_api_FrequencyDomainPlot),
             'numeric_histogram': ConjureFieldDefinition('numericHistogram', scout_compute_api_NumericHistogramPlot),
             'enum_histogram': ConjureFieldDefinition('enumHistogram', scout_compute_api_EnumHistogramPlot),
-            'curve_fit': ConjureFieldDefinition('curveFit', scout_compute_api_CurveFitResult)
+            'curve_fit': ConjureFieldDefinition('curveFit', scout_compute_api_CurveFitResult),
+            'grouped': ConjureFieldDefinition('grouped', scout_compute_api_GroupedComputeNodeResponses)
         }
 
     def __init__(
@@ -36242,10 +36270,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             numeric_histogram: Optional["scout_compute_api_NumericHistogramPlot"] = None,
             enum_histogram: Optional["scout_compute_api_EnumHistogramPlot"] = None,
             curve_fit: Optional["scout_compute_api_CurveFitResult"] = None,
+            grouped: Optional["scout_compute_api_GroupedComputeNodeResponses"] = 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) + (enum is not None) + (enum_point is not None) + (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) != 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) + (enum is not None) + (enum_point is not None) + (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:
                 raise ValueError('a union must contain a single member')
 
             if range is not None:
@@ -36305,6 +36334,9 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             if curve_fit is not None:
                 self._curve_fit = curve_fit
                 self._type = 'curveFit'
+            if grouped is not None:
+                self._grouped = grouped
+                self._type = 'grouped'
 
         elif type_of_union == 'range':
             if range is None:
@@ -36401,6 +36433,11 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._curve_fit = curve_fit
             self._type = 'curveFit'
+        elif type_of_union == 'grouped':
+            if grouped is None:
+                raise ValueError('a union value must not be None')
+            self._grouped = grouped
+            self._type = 'grouped'
 
     @builtins.property
     def range(self) -> Optional[List["scout_compute_api_Range"]]:
@@ -36478,6 +36515,10 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
     def curve_fit(self) -> Optional["scout_compute_api_CurveFitResult"]:
         return self._curve_fit
 
+    @builtins.property
+    def grouped(self) -> Optional["scout_compute_api_GroupedComputeNodeResponses"]:
+        return self._grouped
+
     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__))
@@ -36519,6 +36560,8 @@ class scout_compute_api_ComputeNodeResponse(ConjureUnionType):
             return visitor._enum_histogram(self.enum_histogram)
         if self._type == 'curveFit' and self.curve_fit is not None:
             return visitor._curve_fit(self.curve_fit)
+        if self._type == 'grouped' and self.grouped is not None:
+            return visitor._grouped(self.grouped)
 
 
 scout_compute_api_ComputeNodeResponse.__name__ = "ComputeNodeResponse"
@@ -36604,6 +36647,10 @@ class scout_compute_api_ComputeNodeResponseVisitor:
     def _curve_fit(self, curve_fit: "scout_compute_api_CurveFitResult") -> Any:
         pass
 
+    @abstractmethod
+    def _grouped(self, grouped: "scout_compute_api_GroupedComputeNodeResponses") -> Any:
+        pass
+
 
 scout_compute_api_ComputeNodeResponseVisitor.__name__ = "ComputeNodeResponseVisitor"
 scout_compute_api_ComputeNodeResponseVisitor.__qualname__ = "ComputeNodeResponseVisitor"
@@ -37624,15 +37671,17 @@ class scout_compute_api_DataSourceChannel(ConjureBeanType):
         return {
             'data_source_rid': ConjureFieldDefinition('dataSourceRid', scout_compute_api_StringConstant),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
-            'tags': ConjureFieldDefinition('tags', Dict[str, scout_compute_api_StringConstant])
+            'tags': ConjureFieldDefinition('tags', Dict[str, scout_compute_api_StringConstant]),
+            'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[str])
         }
 
-    __slots__: List[str] = ['_data_source_rid', '_channel', '_tags']
+    __slots__: List[str] = ['_data_source_rid', '_channel', '_tags', '_tags_to_group_by']
 
-    def __init__(self, channel: "scout_compute_api_StringConstant", data_source_rid: "scout_compute_api_StringConstant", tags: Dict[str, "scout_compute_api_StringConstant"]) -> None:
+    def __init__(self, channel: "scout_compute_api_StringConstant", data_source_rid: "scout_compute_api_StringConstant", tags: Dict[str, "scout_compute_api_StringConstant"], tags_to_group_by: List[str]) -> None:
         self._data_source_rid = data_source_rid
         self._channel = channel
         self._tags = tags
+        self._tags_to_group_by = tags_to_group_by
 
     @builtins.property
     def data_source_rid(self) -> "scout_compute_api_StringConstant":
@@ -37650,6 +37699,14 @@ provided tag keys. For log series, include arg filters here in addition to tag f
         """
         return self._tags
 
+    @builtins.property
+    def tags_to_group_by(self) -> List[str]:
+        """
+        Tags that the channel should be grouped by. If this is non-empty a grouped result will be returned
+with an entry for each grouping.
+        """
+        return self._tags_to_group_by
+
 
 scout_compute_api_DataSourceChannel.__name__ = "DataSourceChannel"
 scout_compute_api_DataSourceChannel.__qualname__ = "DataSourceChannel"
@@ -39472,6 +39529,121 @@ scout_compute_api_GeoTimeBucket.__qualname__ = "GeoTimeBucket"
 scout_compute_api_GeoTimeBucket.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_GroupedComputeNodeResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'grouping': ConjureFieldDefinition('grouping', scout_compute_api_Grouping),
+            'response': ConjureFieldDefinition('response', scout_compute_api_ComputeNodeResponse)
+        }
+
+    __slots__: List[str] = ['_grouping', '_response']
+
+    def __init__(self, grouping: "scout_compute_api_Grouping", response: "scout_compute_api_ComputeNodeResponse") -> None:
+        self._grouping = grouping
+        self._response = response
+
+    @builtins.property
+    def grouping(self) -> "scout_compute_api_Grouping":
+        return self._grouping
+
+    @builtins.property
+    def response(self) -> "scout_compute_api_ComputeNodeResponse":
+        return self._response
+
+
+scout_compute_api_GroupedComputeNodeResponse.__name__ = "GroupedComputeNodeResponse"
+scout_compute_api_GroupedComputeNodeResponse.__qualname__ = "GroupedComputeNodeResponse"
+scout_compute_api_GroupedComputeNodeResponse.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_GroupedComputeNodeResponses(ConjureBeanType):
+    """
+    Contains a `ComputeNodeResponse` for each applicable grouping along with metadata describing the grouping.
+All the contained `ComputeNodeResponse`s are guaranteed to be of the same type.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[scout_compute_api_GroupedComputeNodeResponse])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["scout_compute_api_GroupedComputeNodeResponse"]) -> None:
+        self._responses = responses
+
+    @builtins.property
+    def responses(self) -> List["scout_compute_api_GroupedComputeNodeResponse"]:
+        return self._responses
+
+
+scout_compute_api_GroupedComputeNodeResponses.__name__ = "GroupedComputeNodeResponses"
+scout_compute_api_GroupedComputeNodeResponses.__qualname__ = "GroupedComputeNodeResponses"
+scout_compute_api_GroupedComputeNodeResponses.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_Grouping(ConjureUnionType):
+    _tags_with_values: Optional[Dict[str, str]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'tags_with_values': ConjureFieldDefinition('tagsWithValues', Dict[str, str])
+        }
+
+    def __init__(
+            self,
+            tags_with_values: Optional[Dict[str, str]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (tags_with_values is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if tags_with_values is not None:
+                self._tags_with_values = tags_with_values
+                self._type = 'tagsWithValues'
+
+        elif type_of_union == 'tagsWithValues':
+            if tags_with_values is None:
+                raise ValueError('a union value must not be None')
+            self._tags_with_values = tags_with_values
+            self._type = 'tagsWithValues'
+
+    @builtins.property
+    def tags_with_values(self) -> Optional[Dict[str, str]]:
+        """
+        A grouping identified by a specific instantiation of tag keys and values.
+        """
+        return self._tags_with_values
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_GroupingVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_GroupingVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'tagsWithValues' and self.tags_with_values is not None:
+            return visitor._tags_with_values(self.tags_with_values)
+
+
+scout_compute_api_Grouping.__name__ = "Grouping"
+scout_compute_api_Grouping.__qualname__ = "Grouping"
+scout_compute_api_Grouping.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_GroupingVisitor:
+
+    @abstractmethod
+    def _tags_with_values(self, tags_with_values: Dict[str, str]) -> Any:
+        pass
+
+
+scout_compute_api_GroupingVisitor.__name__ = "GroupingVisitor"
+scout_compute_api_GroupingVisitor.__qualname__ = "GroupingVisitor"
+scout_compute_api_GroupingVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_HighPassConfiguration(ConjureBeanType):
 
     @builtins.classmethod
@@ -44302,16 +44474,18 @@ class scout_compute_api_RunChannel(ConjureBeanType):
             'run_rid': ConjureFieldDefinition('runRid', scout_compute_api_StringConstant),
             'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_compute_api_StringConstant),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
-            'additional_tags': ConjureFieldDefinition('additionalTags', Dict[str, scout_compute_api_StringConstant])
+            'additional_tags': ConjureFieldDefinition('additionalTags', Dict[str, scout_compute_api_StringConstant]),
+            'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[str])
         }
 
-    __slots__: List[str] = ['_run_rid', '_data_scope_name', '_channel', '_additional_tags']
+    __slots__: List[str] = ['_run_rid', '_data_scope_name', '_channel', '_additional_tags', '_tags_to_group_by']
 
-    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", run_rid: "scout_compute_api_StringConstant") -> None:
+    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", run_rid: "scout_compute_api_StringConstant", tags_to_group_by: List[str]) -> None:
         self._run_rid = run_rid
         self._data_scope_name = data_scope_name
         self._channel = channel
         self._additional_tags = additional_tags
+        self._tags_to_group_by = tags_to_group_by
 
     @builtins.property
     def run_rid(self) -> "scout_compute_api_StringConstant":
@@ -44337,6 +44511,14 @@ both sets of tag filters. For log series, include arg filters here in addition t
         """
         return self._additional_tags
 
+    @builtins.property
+    def tags_to_group_by(self) -> List[str]:
+        """
+        Tags that the channel should be grouped by. If this is non-empty a grouped result will be returned
+with an entry for each grouping.
+        """
+        return self._tags_to_group_by
+
 
 scout_compute_api_RunChannel.__name__ = "RunChannel"
 scout_compute_api_RunChannel.__qualname__ = "RunChannel"
@@ -49510,14 +49692,16 @@ class scout_compute_resolved_api_ClickHouseSeriesResolutionDetails(ConjureBeanTy
         return {
             'channel': ConjureFieldDefinition('channel', api_Channel),
             'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[api_TagName]),
             'org_rid': ConjureFieldDefinition('orgRid', authentication_api_OrgRid)
         }
 
-    __slots__: List[str] = ['_channel', '_tags', '_org_rid']
+    __slots__: List[str] = ['_channel', '_tags', '_tags_to_group_by', '_org_rid']
 
-    def __init__(self, channel: str, org_rid: str, tags: Dict[str, str]) -> None:
+    def __init__(self, channel: str, org_rid: str, tags: Dict[str, str], tags_to_group_by: List[str]) -> None:
         self._channel = channel
         self._tags = tags
+        self._tags_to_group_by = tags_to_group_by
         self._org_rid = org_rid
 
     @builtins.property
@@ -49528,6 +49712,10 @@ class scout_compute_resolved_api_ClickHouseSeriesResolutionDetails(ConjureBeanTy
     def tags(self) -> Dict[str, str]:
         return self._tags
 
+    @builtins.property
+    def tags_to_group_by(self) -> List[str]:
+        return self._tags_to_group_by
+
     @builtins.property
     def org_rid(self) -> str:
         return self._org_rid
@@ -76063,6 +76251,10 @@ class storage_series_api_NominalDataType(ConjureEnumType):
     '''LOG'''
     INT64 = 'INT64'
     '''INT64'''
+    DOUBLE_ARRAY = 'DOUBLE_ARRAY'
+    '''DOUBLE_ARRAY'''
+    STRING_ARRAY = 'STRING_ARRAY'
+    '''STRING_ARRAY'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -76075,6 +76267,84 @@ storage_series_api_NominalDataType.__qualname__ = "NominalDataType"
 storage_series_api_NominalDataType.__module__ = "nominal_api.storage_series_api"
 
 
+class storage_writer_api_ArrayPoints(ConjureUnionType):
+    """Array points for the internal API for directly writing points which supports all points types."""
+    _double: Optional[List["storage_writer_api_DoubleArrayPoint"]] = None
+    _string: Optional[List["storage_writer_api_StringArrayPoint"]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'double': ConjureFieldDefinition('double', List[storage_writer_api_DoubleArrayPoint]),
+            'string': ConjureFieldDefinition('string', List[storage_writer_api_StringArrayPoint])
+        }
+
+    def __init__(
+            self,
+            double: Optional[List["storage_writer_api_DoubleArrayPoint"]] = None,
+            string: Optional[List["storage_writer_api_StringArrayPoint"]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (double is not None) + (string is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if double is not None:
+                self._double = double
+                self._type = 'double'
+            if string is not None:
+                self._string = string
+                self._type = 'string'
+
+        elif type_of_union == 'double':
+            if double is None:
+                raise ValueError('a union value must not be None')
+            self._double = double
+            self._type = 'double'
+        elif type_of_union == 'string':
+            if string is None:
+                raise ValueError('a union value must not be None')
+            self._string = string
+            self._type = 'string'
+
+    @builtins.property
+    def double(self) -> Optional[List["storage_writer_api_DoubleArrayPoint"]]:
+        return self._double
+
+    @builtins.property
+    def string(self) -> Optional[List["storage_writer_api_StringArrayPoint"]]:
+        return self._string
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, storage_writer_api_ArrayPointsVisitor):
+            raise ValueError('{} is not an instance of storage_writer_api_ArrayPointsVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'double' and self.double is not None:
+            return visitor._double(self.double)
+        if self._type == 'string' and self.string is not None:
+            return visitor._string(self.string)
+
+
+storage_writer_api_ArrayPoints.__name__ = "ArrayPoints"
+storage_writer_api_ArrayPoints.__qualname__ = "ArrayPoints"
+storage_writer_api_ArrayPoints.__module__ = "nominal_api.storage_writer_api"
+
+
+class storage_writer_api_ArrayPointsVisitor:
+
+    @abstractmethod
+    def _double(self, double: List["storage_writer_api_DoubleArrayPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _string(self, string: List["storage_writer_api_StringArrayPoint"]) -> Any:
+        pass
+
+
+storage_writer_api_ArrayPointsVisitor.__name__ = "ArrayPointsVisitor"
+storage_writer_api_ArrayPointsVisitor.__qualname__ = "ArrayPointsVisitor"
+storage_writer_api_ArrayPointsVisitor.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_DirectNominalChannelWriterService(Service):
     """
     Writes data points directly to Nominal's managed database offering.
@@ -76121,6 +76391,35 @@ storage_writer_api_DirectNominalChannelWriterService.__qualname__ = "DirectNomin
 storage_writer_api_DirectNominalChannelWriterService.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_DoubleArrayPoint(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'value': ConjureFieldDefinition('value', List[float])
+        }
+
+    __slots__: List[str] = ['_timestamp', '_value']
+
+    def __init__(self, timestamp: "api_Timestamp", value: List[float]) -> None:
+        self._timestamp = timestamp
+        self._value = value
+
+    @builtins.property
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
+
+    @builtins.property
+    def value(self) -> List[float]:
+        return self._value
+
+
+storage_writer_api_DoubleArrayPoint.__name__ = "DoubleArrayPoint"
+storage_writer_api_DoubleArrayPoint.__qualname__ = "DoubleArrayPoint"
+storage_writer_api_DoubleArrayPoint.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_DoublePoint(ConjureBeanType):
 
     @builtins.classmethod
@@ -76513,6 +76812,7 @@ Logs specifically are supported externally via a separate endpoint."""
     _double: Optional[List["storage_writer_api_DoublePoint"]] = None
     _log: Optional[List["storage_writer_api_LogPoint"]] = None
     _int_: Optional[List["storage_writer_api_IntPoint"]] = None
+    _array: Optional["storage_writer_api_ArrayPoints"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -76520,7 +76820,8 @@ Logs specifically are supported externally via a separate endpoint."""
             'string': ConjureFieldDefinition('string', List[storage_writer_api_StringPoint]),
             'double': ConjureFieldDefinition('double', List[storage_writer_api_DoublePoint]),
             'log': ConjureFieldDefinition('log', List[storage_writer_api_LogPoint]),
-            '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__(
@@ -76529,10 +76830,11 @@ Logs specifically are supported externally via a separate endpoint."""
             double: Optional[List["storage_writer_api_DoublePoint"]] = None,
             log: Optional[List["storage_writer_api_LogPoint"]] = 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) + (log is not None) + (int_ is not None) != 1:
+            if (string is not None) + (double is not None) + (log 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:
@@ -76547,6 +76849,9 @@ Logs specifically are supported externally via a separate endpoint."""
             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:
@@ -76568,6 +76873,11 @@ Logs specifically are supported externally via a separate endpoint."""
                 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"]]:
@@ -76585,6 +76895,10 @@ Logs specifically are supported externally via a separate endpoint."""
     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_PointsVisitor):
             raise ValueError('{} is not an instance of storage_writer_api_PointsVisitor'.format(visitor.__class__.__name__))
@@ -76596,6 +76910,8 @@ Logs specifically are supported externally via a separate endpoint."""
             return visitor._log(self.log)
         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_Points.__name__ = "Points"
@@ -76621,6 +76937,10 @@ class storage_writer_api_PointsVisitor:
     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_PointsVisitor.__name__ = "PointsVisitor"
 storage_writer_api_PointsVisitor.__qualname__ = "PointsVisitor"
@@ -76795,6 +77115,35 @@ storage_writer_api_RecordsBatchExternal.__qualname__ = "RecordsBatchExternal"
 storage_writer_api_RecordsBatchExternal.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_StringArrayPoint(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'value': ConjureFieldDefinition('value', List[str])
+        }
+
+    __slots__: List[str] = ['_timestamp', '_value']
+
+    def __init__(self, timestamp: "api_Timestamp", value: List[str]) -> None:
+        self._timestamp = timestamp
+        self._value = value
+
+    @builtins.property
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
+
+    @builtins.property
+    def value(self) -> List[str]:
+        return self._value
+
+
+storage_writer_api_StringArrayPoint.__name__ = "StringArrayPoint"
+storage_writer_api_StringArrayPoint.__qualname__ = "StringArrayPoint"
+storage_writer_api_StringArrayPoint.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_StringPoint(ConjureBeanType):
 
     @builtins.classmethod
@@ -80043,14 +80392,16 @@ class timeseries_logicalseries_api_NominalLocator(ConjureBeanType):
         return {
             'channel': ConjureFieldDefinition('channel', api_Channel),
             'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[api_TagName]),
             'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType)
         }
 
-    __slots__: List[str] = ['_channel', '_tags', '_type']
+    __slots__: List[str] = ['_channel', '_tags', '_tags_to_group_by', '_type']
 
-    def __init__(self, channel: str, tags: Dict[str, str], type: "storage_series_api_NominalDataType") -> None:
+    def __init__(self, channel: str, tags: Dict[str, str], tags_to_group_by: List[str], type: "storage_series_api_NominalDataType") -> None:
         self._channel = channel
         self._tags = tags
+        self._tags_to_group_by = tags_to_group_by
         self._type = type
 
     @builtins.property
@@ -80061,6 +80412,10 @@ class timeseries_logicalseries_api_NominalLocator(ConjureBeanType):
     def tags(self) -> Dict[str, str]:
         return self._tags
 
+    @builtins.property
+    def tags_to_group_by(self) -> List[str]:
+        return self._tags_to_group_by
+
     @builtins.property
     def type(self) -> "storage_series_api_NominalDataType":
         return self._type
@@ -80107,15 +80462,17 @@ class timeseries_logicalseries_api_ResolveSeriesRequest(ConjureBeanType):
         return {
             'name': ConjureFieldDefinition('name', api_Channel),
             'datasource': ConjureFieldDefinition('datasource', api_rids_DataSourceRid),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[api_TagName])
         }
 
-    __slots__: List[str] = ['_name', '_datasource', '_tags']
+    __slots__: List[str] = ['_name', '_datasource', '_tags', '_tags_to_group_by']
 
-    def __init__(self, datasource: str, name: str, tags: Dict[str, str]) -> None:
+    def __init__(self, datasource: str, name: str, tags: Dict[str, str], tags_to_group_by: List[str]) -> None:
         self._name = name
         self._datasource = datasource
         self._tags = tags
+        self._tags_to_group_by = tags_to_group_by
 
     @builtins.property
     def name(self) -> str:
@@ -80129,6 +80486,10 @@ class timeseries_logicalseries_api_ResolveSeriesRequest(ConjureBeanType):
     def tags(self) -> Dict[str, str]:
         return self._tags
 
+    @builtins.property
+    def tags_to_group_by(self) -> List[str]:
+        return self._tags_to_group_by
+
 
 timeseries_logicalseries_api_ResolveSeriesRequest.__name__ = "ResolveSeriesRequest"
 timeseries_logicalseries_api_ResolveSeriesRequest.__qualname__ = "ResolveSeriesRequest"

nominal_api/scout_compute_api/__init__.py

@@ -133,6 +133,10 @@ from .._impl import (
     scout_compute_api_GeoSummaryStrategyVisitor as GeoSummaryStrategyVisitor,
     scout_compute_api_GeoTemporalSummary as GeoTemporalSummary,
     scout_compute_api_GeoTimeBucket as GeoTimeBucket,
+    scout_compute_api_GroupedComputeNodeResponse as GroupedComputeNodeResponse,
+    scout_compute_api_GroupedComputeNodeResponses as GroupedComputeNodeResponses,
+    scout_compute_api_Grouping as Grouping,
+    scout_compute_api_GroupingVisitor as GroupingVisitor,
     scout_compute_api_HighPassConfiguration as HighPassConfiguration,
     scout_compute_api_Histogram as Histogram,
     scout_compute_api_HistogramChannelCount as HistogramChannelCount,

nominal_api/storage_writer_api/__init__.py

@@ -1,6 +1,9 @@
 # coding=utf-8
 from .._impl import (
+    storage_writer_api_ArrayPoints as ArrayPoints,
+    storage_writer_api_ArrayPointsVisitor as ArrayPointsVisitor,
     storage_writer_api_DirectNominalChannelWriterService as DirectNominalChannelWriterService,
+    storage_writer_api_DoubleArrayPoint as DoubleArrayPoint,
     storage_writer_api_DoublePoint as DoublePoint,
     storage_writer_api_Field as Field,
     storage_writer_api_IntPoint as IntPoint,
@@ -14,6 +17,7 @@ from .._impl import (
     storage_writer_api_PointsVisitor as PointsVisitor,
     storage_writer_api_RecordsBatch as RecordsBatch,
     storage_writer_api_RecordsBatchExternal as RecordsBatchExternal,
+    storage_writer_api_StringArrayPoint as StringArrayPoint,
     storage_writer_api_StringPoint as StringPoint,
     storage_writer_api_TelegrafMetric as TelegrafMetric,
     storage_writer_api_WriteBatchesRequest as WriteBatchesRequest,

{nominal_api-0.685.0.dist-info → nominal_api-0.687.0.dist-info}/METADATA

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

{nominal_api-0.685.0.dist-info → nominal_api-0.687.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=PpAYBL-xk3x2jETGlRY9uignX6t4p1pzAMTLzRpPmIo,1955
-nominal_api/_impl.py,sha256=5Jn2eGkYVFnnM-rtMs2fLw5qPEIU2B_LMYXY9yBN2Cs,3165392
+nominal_api/__init__.py,sha256=82q0gJ2eYLu1WuAhwlRnzOkbjVaUn0pEB8EDGC39W-s,1955
+nominal_api/_impl.py,sha256=CrFZwrm9oyvT7ylhCtsl5UPlijg7xyWAif3lLZSDOIs,3179901
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=1oJPOuAMfV2uClPUW8Ie1nj2Y6j81TDpedcc3yUFTe0,1294
 nominal_api/api_ids/__init__.py,sha256=CAtt44XgNZEEUDv-BbEbYtuxQ8y1wqSZU-STjBYdZv8,80
@@ -30,7 +30,7 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=1_nOnCSWn7bniSvTfskQ
 nominal_api/scout_checks_api/__init__.py,sha256=cNCQHBX38YqQv2qJMXwqUhjpCbayA3R9FqMmtKwzA3U,5160
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=8BL5jE9NDxqCj9DyvZWSPhq6zw2J7xp6aLsl3x9rpyw,4530
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=1LCXQe64tDqqeMQixW8PI-R_edSz7F5X0x2_ufEuC8M,480
-nominal_api/scout_compute_api/__init__.py,sha256=GsQzqbpslKY3zkMSPkuK760t39WqPnUnk_OeCdq6sfU,19604
+nominal_api/scout_compute_api/__init__.py,sha256=hqFzmHW1b58r3otIul1aUb_Qr0mL4QzO0Jq-GA9A9qU,19868
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=RggSfc6C1VR1-kNXPWybpfw3hZbkQ1gvxEisFZCHdnM,3732
 nominal_api/scout_compute_resolved_api/__init__.py,sha256=LJFZQR1u_EQbZLzLGWMQVS8sEsKsFSmsITrlYGI5JsA,10801
 nominal_api/scout_dataexport_api/__init__.py,sha256=pWRQdQJOObD0jITRYLw3AxeDJSrJQqAdFZACxULqA4o,1487
@@ -61,7 +61,7 @@ nominal_api/security_api_workspace/__init__.py,sha256=W-TKCfSPTZ5XvLP0xFhkjCLKUW
 nominal_api/storage_datasource_api/__init__.py,sha256=jh_OZE_b4nBNAvnyenBjw8aGZOnvIXR6qvUKd31fXOk,445
 nominal_api/storage_deletion_api/__init__.py,sha256=2bIuAU0tcnT_8lqae0fcII4R45A_RzfV0y_E-vTkpSQ,267
 nominal_api/storage_series_api/__init__.py,sha256=F2ctWx8yqb4-JtfHkLzCq74njNEpGwr69b9fWQp9UAQ,99
-nominal_api/storage_writer_api/__init__.py,sha256=1cupGTDJj_KcUCNEQFKIRuX0fWHzk4TuYGs9Q50nBaQ,1250
+nominal_api/storage_writer_api/__init__.py,sha256=gGXpDRA9WJYYZ6F6dujahrgmWIZ337gUl2X7TQryFgE,1488
 nominal_api/themes_api/__init__.py,sha256=w-G93T5f6_2zSSUi-ffyUHxH8QA_2oI9jM7YBSMFpwY,924
 nominal_api/timeseries_archetype/__init__.py,sha256=eKdgdZoOcZg_9pmec6J86NlgQdhxhi1282WUAFxghJ8,115
 nominal_api/timeseries_archetype_api/__init__.py,sha256=IREibRlChT9ugCAkeMKm7RiAChsKV4KJZ-DcKkVLC_U,1396
@@ -72,7 +72,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=Q9iZHurmyDsJIFbUg-Eb
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=U9EhlqdF9qzD1O9al0vcvcdgS_C5lq-lN3Kmr0K3g84,1191
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.685.0.dist-info/METADATA,sha256=Aqe_HwYnojzGQM2mmW_ahygY9TM10Spo8NiQg41Q0YU,199
-nominal_api-0.685.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-nominal_api-0.685.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.685.0.dist-info/RECORD,,
+nominal_api-0.687.0.dist-info/METADATA,sha256=9hsPDG8Y2cJL6Yg2Y2ydUg4zRgEG19jahCDDIpfY3uE,199
+nominal_api-0.687.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+nominal_api-0.687.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.687.0.dist-info/RECORD,,