nominal-api 0.1235.0__tar.gz → 0.1237.0__tar.gz

{nominal_api-0.1235.0 → nominal_api-0.1237.0}/PKG-INFO

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

{nominal_api-0.1235.0 → nominal_api-0.1237.0}/nominal_api/__init__.py

@@ -36,6 +36,7 @@ __all__ = [
     'scout_compute_api_deprecated',
     'scout_compute_resolved_api',
     'scout_dataexport_api',
+    'scout_dataframe_api',
     'scout_datareview_api',
     'scout_datasource',
     'scout_datasource_connection',
@@ -85,5 +86,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.1235.0"
+__version__ = "0.1237.0"
 

{nominal_api-0.1235.0 → nominal_api-0.1237.0}/nominal_api/_impl.py

@@ -62803,14 +62803,16 @@ class scout_compute_api_LiteralRange(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'start_timestamp': ConjureFieldDefinition('startTimestamp', OptionalTypeWrapper[scout_compute_api_TimestampConstant]),
-            'end_timestamp': ConjureFieldDefinition('endTimestamp', OptionalTypeWrapper[scout_compute_api_TimestampConstant])
+            'end_timestamp': ConjureFieldDefinition('endTimestamp', OptionalTypeWrapper[scout_compute_api_TimestampConstant]),
+            'tags': ConjureFieldDefinition('tags', OptionalTypeWrapper[Dict[str, str]])
         }
 
-    __slots__: List[str] = ['_start_timestamp', '_end_timestamp']
+    __slots__: List[str] = ['_start_timestamp', '_end_timestamp', '_tags']
 
-    def __init__(self, end_timestamp: Optional["scout_compute_api_TimestampConstant"] = None, start_timestamp: Optional["scout_compute_api_TimestampConstant"] = None) -> None:
+    def __init__(self, end_timestamp: Optional["scout_compute_api_TimestampConstant"] = None, start_timestamp: Optional["scout_compute_api_TimestampConstant"] = None, tags: Optional[Dict[str, str]] = None) -> None:
         self._start_timestamp = start_timestamp
         self._end_timestamp = end_timestamp
+        self._tags = tags
 
     @builtins.property
     def start_timestamp(self) -> Optional["scout_compute_api_TimestampConstant"]:
@@ -62820,6 +62822,10 @@ class scout_compute_api_LiteralRange(ConjureBeanType):
     def end_timestamp(self) -> Optional["scout_compute_api_TimestampConstant"]:
         return self._end_timestamp
 
+    @builtins.property
+    def tags(self) -> Optional[Dict[str, str]]:
+        return self._tags
+
 
 scout_compute_api_LiteralRange.__name__ = "LiteralRange"
 scout_compute_api_LiteralRange.__qualname__ = "LiteralRange"
@@ -80268,14 +80274,16 @@ class scout_compute_resolved_api_LiteralRange(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'start_timestamp': ConjureFieldDefinition('startTimestamp', OptionalTypeWrapper[api_Timestamp]),
-            'end_timestamp': ConjureFieldDefinition('endTimestamp', OptionalTypeWrapper[api_Timestamp])
+            'end_timestamp': ConjureFieldDefinition('endTimestamp', OptionalTypeWrapper[api_Timestamp]),
+            'tags': ConjureFieldDefinition('tags', OptionalTypeWrapper[Dict[str, str]])
         }
 
-    __slots__: List[str] = ['_start_timestamp', '_end_timestamp']
+    __slots__: List[str] = ['_start_timestamp', '_end_timestamp', '_tags']
 
-    def __init__(self, end_timestamp: Optional["api_Timestamp"] = None, start_timestamp: Optional["api_Timestamp"] = None) -> None:
+    def __init__(self, end_timestamp: Optional["api_Timestamp"] = None, start_timestamp: Optional["api_Timestamp"] = None, tags: Optional[Dict[str, str]] = None) -> None:
         self._start_timestamp = start_timestamp
         self._end_timestamp = end_timestamp
+        self._tags = tags
 
     @builtins.property
     def start_timestamp(self) -> Optional["api_Timestamp"]:
@@ -80285,6 +80293,10 @@ class scout_compute_resolved_api_LiteralRange(ConjureBeanType):
     def end_timestamp(self) -> Optional["api_Timestamp"]:
         return self._end_timestamp
 
+    @builtins.property
+    def tags(self) -> Optional[Dict[str, str]]:
+        return self._tags
+
 
 scout_compute_resolved_api_LiteralRange.__name__ = "LiteralRange"
 scout_compute_resolved_api_LiteralRange.__qualname__ = "LiteralRange"
@@ -87123,6 +87135,362 @@ scout_dataexport_api_UndecimatedResolution.__qualname__ = "UndecimatedResolution
 scout_dataexport_api_UndecimatedResolution.__module__ = "nominal_api.scout_dataexport_api"
 
 
+class scout_dataframe_api_BatchDataFrameMetadata(ConjureBeanType):
+    """Metadata about a data frame.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'streaming_support': ConjureFieldDefinition('streamingSupport', scout_dataframe_api_BatchStreamingSupport)
+        }
+
+    __slots__: List[str] = ['_streaming_support']
+
+    def __init__(self, streaming_support: "scout_dataframe_api_BatchStreamingSupport") -> None:
+        self._streaming_support = streaming_support
+
+    @builtins.property
+    def streaming_support(self) -> "scout_dataframe_api_BatchStreamingSupport":
+        return self._streaming_support
+
+
+scout_dataframe_api_BatchDataFrameMetadata.__name__ = "BatchDataFrameMetadata"
+scout_dataframe_api_BatchDataFrameMetadata.__qualname__ = "BatchDataFrameMetadata"
+scout_dataframe_api_BatchDataFrameMetadata.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_BatchDataSourceStreamingSupport(ConjureBeanType):
+    """Diagnostic details for a data source within a batched metadata request
+that does not support streaming.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
+            'unsupported_reason': ConjureFieldDefinition('unsupportedReason', scout_dataframe_api_StreamingNotSupportedReason),
+            'request_ids': ConjureFieldDefinition('requestIds', List[str])
+        }
+
+    __slots__: List[str] = ['_data_source', '_unsupported_reason', '_request_ids']
+
+    def __init__(self, data_source: "scout_run_api_DataSource", request_ids: List[str], unsupported_reason: "scout_dataframe_api_StreamingNotSupportedReason") -> None:
+        self._data_source = data_source
+        self._unsupported_reason = unsupported_reason
+        self._request_ids = request_ids
+
+    @builtins.property
+    def data_source(self) -> "scout_run_api_DataSource":
+        return self._data_source
+
+    @builtins.property
+    def unsupported_reason(self) -> "scout_dataframe_api_StreamingNotSupportedReason":
+        """Why this data source does not support live streaming.
+        """
+        return self._unsupported_reason
+
+    @builtins.property
+    def request_ids(self) -> List[str]:
+        """Request ids of the data frames that included this data source.
+        """
+        return self._request_ids
+
+
+scout_dataframe_api_BatchDataSourceStreamingSupport.__name__ = "BatchDataSourceStreamingSupport"
+scout_dataframe_api_BatchDataSourceStreamingSupport.__qualname__ = "BatchDataSourceStreamingSupport"
+scout_dataframe_api_BatchDataSourceStreamingSupport.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_BatchGetDataFrameMetadataRequest(ConjureBeanType):
+    """Batched form of `getDataFrameMetadata`. The map key of `requests` can be an
+arbitrary string identifier and is returned in diagnostic `requestIds`.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', Dict[str, scout_dataframe_api_GetDataFrameMetadataRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: Dict[str, "scout_dataframe_api_GetDataFrameMetadataRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> Dict[str, "scout_dataframe_api_GetDataFrameMetadataRequest"]:
+        return self._requests
+
+
+scout_dataframe_api_BatchGetDataFrameMetadataRequest.__name__ = "BatchGetDataFrameMetadataRequest"
+scout_dataframe_api_BatchGetDataFrameMetadataRequest.__qualname__ = "BatchGetDataFrameMetadataRequest"
+scout_dataframe_api_BatchGetDataFrameMetadataRequest.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_BatchStreamingSupport(ConjureBeanType):
+    """Whether the data frame supports live streaming, plus unsupported data
+source diagnostics.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'supports_streaming': ConjureFieldDefinition('supportsStreaming', bool),
+            'unsupported_data_sources': ConjureFieldDefinition('unsupportedDataSources', List[scout_dataframe_api_BatchDataSourceStreamingSupport])
+        }
+
+    __slots__: List[str] = ['_supports_streaming', '_unsupported_data_sources']
+
+    def __init__(self, supports_streaming: bool, unsupported_data_sources: List["scout_dataframe_api_BatchDataSourceStreamingSupport"]) -> None:
+        self._supports_streaming = supports_streaming
+        self._unsupported_data_sources = unsupported_data_sources
+
+    @builtins.property
+    def supports_streaming(self) -> bool:
+        """True iff `unsupportedDataSources` is empty.
+        """
+        return self._supports_streaming
+
+    @builtins.property
+    def unsupported_data_sources(self) -> List["scout_dataframe_api_BatchDataSourceStreamingSupport"]:
+        """Diagnostic entries for data sources reachable from the data frame that do
+not support live streaming. A data source may appear multiple times if
+multiple checks fail.
+        """
+        return self._unsupported_data_sources
+
+
+scout_dataframe_api_BatchStreamingSupport.__name__ = "BatchStreamingSupport"
+scout_dataframe_api_BatchStreamingSupport.__qualname__ = "BatchStreamingSupport"
+scout_dataframe_api_BatchStreamingSupport.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_DataFrameMetadata(ConjureBeanType):
+    """Metadata about a data frame.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'streaming_support': ConjureFieldDefinition('streamingSupport', scout_dataframe_api_StreamingSupport)
+        }
+
+    __slots__: List[str] = ['_streaming_support']
+
+    def __init__(self, streaming_support: "scout_dataframe_api_StreamingSupport") -> None:
+        self._streaming_support = streaming_support
+
+    @builtins.property
+    def streaming_support(self) -> "scout_dataframe_api_StreamingSupport":
+        return self._streaming_support
+
+
+scout_dataframe_api_DataFrameMetadata.__name__ = "DataFrameMetadata"
+scout_dataframe_api_DataFrameMetadata.__qualname__ = "DataFrameMetadata"
+scout_dataframe_api_DataFrameMetadata.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_DataFrameMetadataService(Service):
+    """Data frame metadata lookup. This includes metadata about the data sources 
+reachable from the data frame.
+    """
+
+    def get_data_frame_metadata(self, auth_header: str, request: "scout_dataframe_api_GetDataFrameMetadataRequest") -> "scout_dataframe_api_DataFrameMetadata":
+        """Resolves metadata for the data frame.
+        """
+        _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] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/dataframe/metadata/v1/metadata'
+        _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_dataframe_api_DataFrameMetadata, self._return_none_for_unknown_union_types)
+
+    def batch_get_data_frame_metadata(self, auth_header: str, request: "scout_dataframe_api_BatchGetDataFrameMetadataRequest") -> "scout_dataframe_api_BatchDataFrameMetadata":
+        """Batched form of `getDataFrameMetadata`.
+        """
+        _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] = {
+        }
+
+        _json: Any = _conjure_encoder.default(request)
+
+        _path = '/dataframe/metadata/v1/metadata/batch'
+        _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_dataframe_api_BatchDataFrameMetadata, self._return_none_for_unknown_union_types)
+
+
+scout_dataframe_api_DataFrameMetadataService.__name__ = "DataFrameMetadataService"
+scout_dataframe_api_DataFrameMetadataService.__qualname__ = "DataFrameMetadataService"
+scout_dataframe_api_DataFrameMetadataService.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_DataSourceStreamingSupport(ConjureBeanType):
+    """Diagnostic details for a data source within the data frame that does
+not support streaming.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
+            'unsupported_reason': ConjureFieldDefinition('unsupportedReason', scout_dataframe_api_StreamingNotSupportedReason)
+        }
+
+    __slots__: List[str] = ['_data_source', '_unsupported_reason']
+
+    def __init__(self, data_source: "scout_run_api_DataSource", unsupported_reason: "scout_dataframe_api_StreamingNotSupportedReason") -> None:
+        self._data_source = data_source
+        self._unsupported_reason = unsupported_reason
+
+    @builtins.property
+    def data_source(self) -> "scout_run_api_DataSource":
+        return self._data_source
+
+    @builtins.property
+    def unsupported_reason(self) -> "scout_dataframe_api_StreamingNotSupportedReason":
+        """Why this data source does not support live streaming.
+        """
+        return self._unsupported_reason
+
+
+scout_dataframe_api_DataSourceStreamingSupport.__name__ = "DataSourceStreamingSupport"
+scout_dataframe_api_DataSourceStreamingSupport.__qualname__ = "DataSourceStreamingSupport"
+scout_dataframe_api_DataSourceStreamingSupport.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_GetDataFrameMetadataRequest(ConjureBeanType):
+    """Data frame metadata request.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_frame': ConjureFieldDefinition('dataFrame', scout_channel_api_ChannelSearchDataFrame),
+            'context': ConjureFieldDefinition('context', scout_compute_api_Context)
+        }
+
+    __slots__: List[str] = ['_data_frame', '_context']
+
+    def __init__(self, context: "scout_compute_api_Context", data_frame: "scout_channel_api_ChannelSearchDataFrame") -> None:
+        self._data_frame = data_frame
+        self._context = context
+
+    @builtins.property
+    def data_frame(self) -> "scout_channel_api_ChannelSearchDataFrame":
+        return self._data_frame
+
+    @builtins.property
+    def context(self) -> "scout_compute_api_Context":
+        return self._context
+
+
+scout_dataframe_api_GetDataFrameMetadataRequest.__name__ = "GetDataFrameMetadataRequest"
+scout_dataframe_api_GetDataFrameMetadataRequest.__qualname__ = "GetDataFrameMetadataRequest"
+scout_dataframe_api_GetDataFrameMetadataRequest.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_StreamingNotSupportedReason(ConjureEnumType):
+    """Why a particular data source within the dataframedoes not support streaming.
+    """
+
+    DATASET_DOES_NOT_ALLOW_STREAMING = 'DATASET_DOES_NOT_ALLOW_STREAMING'
+    '''DATASET_DOES_NOT_ALLOW_STREAMING'''
+    CONNECTION_TYPE_NOT_NOMINAL = 'CONNECTION_TYPE_NOT_NOMINAL'
+    '''CONNECTION_TYPE_NOT_NOMINAL'''
+    CONNECTION_TIMESTAMP_TYPE_NOT_ABSOLUTE = 'CONNECTION_TIMESTAMP_TYPE_NOT_ABSOLUTE'
+    '''CONNECTION_TIMESTAMP_TYPE_NOT_ABSOLUTE'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_dataframe_api_StreamingNotSupportedReason.__name__ = "StreamingNotSupportedReason"
+scout_dataframe_api_StreamingNotSupportedReason.__qualname__ = "StreamingNotSupportedReason"
+scout_dataframe_api_StreamingNotSupportedReason.__module__ = "nominal_api.scout_dataframe_api"
+
+
+class scout_dataframe_api_StreamingSupport(ConjureBeanType):
+    """Whether the data frame supports live streaming, plus unsupported data
+source diagnostics.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'supports_streaming': ConjureFieldDefinition('supportsStreaming', bool),
+            'unsupported_data_sources': ConjureFieldDefinition('unsupportedDataSources', List[scout_dataframe_api_DataSourceStreamingSupport])
+        }
+
+    __slots__: List[str] = ['_supports_streaming', '_unsupported_data_sources']
+
+    def __init__(self, supports_streaming: bool, unsupported_data_sources: List["scout_dataframe_api_DataSourceStreamingSupport"]) -> None:
+        self._supports_streaming = supports_streaming
+        self._unsupported_data_sources = unsupported_data_sources
+
+    @builtins.property
+    def supports_streaming(self) -> bool:
+        """True iff `unsupportedDataSources` is empty.
+        """
+        return self._supports_streaming
+
+    @builtins.property
+    def unsupported_data_sources(self) -> List["scout_dataframe_api_DataSourceStreamingSupport"]:
+        """Diagnostic entries for data sources reachable from the data frame that do
+not support live streaming. A data source may appear multiple times if
+multiple checks fail.
+        """
+        return self._unsupported_data_sources
+
+
+scout_dataframe_api_StreamingSupport.__name__ = "StreamingSupport"
+scout_dataframe_api_StreamingSupport.__qualname__ = "StreamingSupport"
+scout_dataframe_api_StreamingSupport.__module__ = "nominal_api.scout_dataframe_api"
+
+
 class scout_datareview_api_ArchiveDataReview(ConjureBeanType):
     """Archive the data review which created this check alert. Only performable via the archive data review endpoint;
 not supported by Perform Check Alert Action.