nominal-api 0.606.1__py3-none-any.whl → 0.608.0__py3-none-any.whl

nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.606.1"
+__version__ = "0.608.0"
 

nominal_api/_impl.py

@@ -6588,6 +6588,9 @@ ingest_api_CompleteMultipartUploadResponse.__module__ = "nominal_api.ingest_api"
 
 
 class ingest_api_CsvOpts(ConjureBeanType):
+    """
+    Options for ingesting csv files.  Supported file formats include .csv, .csv.gz
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -7538,6 +7541,7 @@ class ingest_api_IngestOptions(ConjureUnionType):
     _mcap_protobuf_timeseries: Optional["ingest_api_McapProtobufTimeseriesOpts"] = None
     _journal_json: Optional["ingest_api_JournalJsonOpts"] = None
     _csv: Optional["ingest_api_CsvOpts"] = None
+    _parquet: Optional["ingest_api_ParquetOpts"] = None
     _video: Optional["ingest_api_VideoOpts"] = None
     _custom: Optional["ingest_api_CustomOpts"] = None
 
@@ -7548,6 +7552,7 @@ class ingest_api_IngestOptions(ConjureUnionType):
             'mcap_protobuf_timeseries': ConjureFieldDefinition('mcapProtobufTimeseries', ingest_api_McapProtobufTimeseriesOpts),
             'journal_json': ConjureFieldDefinition('journalJson', ingest_api_JournalJsonOpts),
             'csv': ConjureFieldDefinition('csv', ingest_api_CsvOpts),
+            'parquet': ConjureFieldDefinition('parquet', ingest_api_ParquetOpts),
             'video': ConjureFieldDefinition('video', ingest_api_VideoOpts),
             'custom': ConjureFieldDefinition('custom', ingest_api_CustomOpts)
         }
@@ -7558,12 +7563,13 @@ class ingest_api_IngestOptions(ConjureUnionType):
             mcap_protobuf_timeseries: Optional["ingest_api_McapProtobufTimeseriesOpts"] = None,
             journal_json: Optional["ingest_api_JournalJsonOpts"] = None,
             csv: Optional["ingest_api_CsvOpts"] = None,
+            parquet: Optional["ingest_api_ParquetOpts"] = None,
             video: Optional["ingest_api_VideoOpts"] = None,
             custom: Optional["ingest_api_CustomOpts"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (video is not None) + (custom is not None) != 1:
+            if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (parquet is not None) + (video is not None) + (custom is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if dataflash is not None:
@@ -7578,6 +7584,9 @@ class ingest_api_IngestOptions(ConjureUnionType):
             if csv is not None:
                 self._csv = csv
                 self._type = 'csv'
+            if parquet is not None:
+                self._parquet = parquet
+                self._type = 'parquet'
             if video is not None:
                 self._video = video
                 self._type = 'video'
@@ -7605,6 +7614,11 @@ class ingest_api_IngestOptions(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._csv = csv
             self._type = 'csv'
+        elif type_of_union == 'parquet':
+            if parquet is None:
+                raise ValueError('a union value must not be None')
+            self._parquet = parquet
+            self._type = 'parquet'
         elif type_of_union == 'video':
             if video is None:
                 raise ValueError('a union value must not be None')
@@ -7632,6 +7646,10 @@ class ingest_api_IngestOptions(ConjureUnionType):
     def csv(self) -> Optional["ingest_api_CsvOpts"]:
         return self._csv
 
+    @builtins.property
+    def parquet(self) -> Optional["ingest_api_ParquetOpts"]:
+        return self._parquet
+
     @builtins.property
     def video(self) -> Optional["ingest_api_VideoOpts"]:
         return self._video
@@ -7651,6 +7669,8 @@ class ingest_api_IngestOptions(ConjureUnionType):
             return visitor._journal_json(self.journal_json)
         if self._type == 'csv' and self.csv is not None:
             return visitor._csv(self.csv)
+        if self._type == 'parquet' and self.parquet is not None:
+            return visitor._parquet(self.parquet)
         if self._type == 'video' and self.video is not None:
             return visitor._video(self.video)
         if self._type == 'custom' and self.custom is not None:
@@ -7680,6 +7700,10 @@ class ingest_api_IngestOptionsVisitor:
     def _csv(self, csv: "ingest_api_CsvOpts") -> Any:
         pass
 
+    @abstractmethod
+    def _parquet(self, parquet: "ingest_api_ParquetOpts") -> Any:
+        pass
+
     @abstractmethod
     def _video(self, video: "ingest_api_VideoOpts") -> Any:
         pass
@@ -9309,6 +9333,75 @@ ingest_api_NoTimestampManifest.__qualname__ = "NoTimestampManifest"
 ingest_api_NoTimestampManifest.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_ParquetOpts(ConjureBeanType):
+    """
+    Options for ingesting parquet files.
+Supported file formats include .parquet, .parquet.gz 
+and archives such as .tar, .tar.gz, and .zip (must set the isArchive flag).
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'source': ConjureFieldDefinition('source', ingest_api_IngestSource),
+            'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget),
+            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
+            'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
+            'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
+            'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]]),
+            'is_archive': ConjureFieldDefinition('isArchive', OptionalTypeWrapper[bool])
+        }
+
+    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_additional_file_tags', '_is_archive']
+
+    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", timestamp_metadata: "ingest_api_TimestampMetadata", additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None, is_archive: Optional[bool] = None, tag_keys_from_columns: Optional[List[str]] = None) -> None:
+        self._source = source
+        self._target = target
+        self._timestamp_metadata = timestamp_metadata
+        self._channel_prefix = channel_prefix
+        self._tag_keys_from_columns = tag_keys_from_columns
+        self._additional_file_tags = additional_file_tags
+        self._is_archive = is_archive
+
+    @builtins.property
+    def source(self) -> "ingest_api_IngestSource":
+        return self._source
+
+    @builtins.property
+    def target(self) -> "ingest_api_DatasetIngestTarget":
+        return self._target
+
+    @builtins.property
+    def timestamp_metadata(self) -> "ingest_api_TimestampMetadata":
+        return self._timestamp_metadata
+
+    @builtins.property
+    def channel_prefix(self) -> Optional[str]:
+        return self._channel_prefix
+
+    @builtins.property
+    def tag_keys_from_columns(self) -> Optional[List[str]]:
+        return self._tag_keys_from_columns
+
+    @builtins.property
+    def additional_file_tags(self) -> Optional[Dict[str, str]]:
+        return self._additional_file_tags
+
+    @builtins.property
+    def is_archive(self) -> Optional[bool]:
+        """
+        If true, the file is an archive. Supported archive formats include
+.tar, .tar.gz, and .zip. Only files ending in .parquet
+within the archive will be ingested. If field not provided, defaults to false.
+        """
+        return self._is_archive
+
+
+ingest_api_ParquetOpts.__name__ = "ParquetOpts"
+ingest_api_ParquetOpts.__qualname__ = "ParquetOpts"
+ingest_api_ParquetOpts.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_Part(ConjureBeanType):
 
     @builtins.classmethod
@@ -22220,28 +22313,18 @@ class scout_checklistexecution_api_BatchChecklistLiveStatusRequest(ConjureBeanTy
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'requests': ConjureFieldDefinition('requests', List[scout_checklistexecution_api_ChecklistLiveStatusRequest]),
-            'computation_range': ConjureFieldDefinition('computationRange', OptionalTypeWrapper[scout_checklistexecution_api_ComputationRange])
+            'requests': ConjureFieldDefinition('requests', List[scout_checklistexecution_api_ChecklistLiveStatusRequest])
         }
 
-    __slots__: List[str] = ['_requests', '_computation_range']
+    __slots__: List[str] = ['_requests']
 
-    def __init__(self, requests: List["scout_checklistexecution_api_ChecklistLiveStatusRequest"], computation_range: Optional["scout_checklistexecution_api_ComputationRange"] = None) -> None:
+    def __init__(self, requests: List["scout_checklistexecution_api_ChecklistLiveStatusRequest"]) -> None:
         self._requests = requests
-        self._computation_range = computation_range
 
     @builtins.property
     def requests(self) -> List["scout_checklistexecution_api_ChecklistLiveStatusRequest"]:
         return self._requests
 
-    @builtins.property
-    def computation_range(self) -> Optional["scout_checklistexecution_api_ComputationRange"]:
-        """
-        The time range over which status and last failure were calculated. Failures outside of this time range
-will not be included in the results. If not specified, defaults to evaluating from now minus sixty minutes to now.
-        """
-        return self._computation_range
-
 
 scout_checklistexecution_api_BatchChecklistLiveStatusRequest.__name__ = "BatchChecklistLiveStatusRequest"
 scout_checklistexecution_api_BatchChecklistLiveStatusRequest.__qualname__ = "BatchChecklistLiveStatusRequest"
@@ -22253,27 +22336,17 @@ class scout_checklistexecution_api_BatchChecklistLiveStatusResponse(ConjureBeanT
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'computation_range': ConjureFieldDefinition('computationRange', scout_checklistexecution_api_ComputationRange),
-            'checklist_results': ConjureFieldDefinition('checklistResults', List[scout_checklistexecution_api_ChecklistLiveStatusResponse])
+            'checklist_live_status_responses': ConjureFieldDefinition('checklistLiveStatusResponses', List[scout_checklistexecution_api_ChecklistLiveStatusResponse])
         }
 
-    __slots__: List[str] = ['_computation_range', '_checklist_results']
-
-    def __init__(self, checklist_results: List["scout_checklistexecution_api_ChecklistLiveStatusResponse"], computation_range: "scout_checklistexecution_api_ComputationRange") -> None:
-        self._computation_range = computation_range
-        self._checklist_results = checklist_results
+    __slots__: List[str] = ['_checklist_live_status_responses']
 
-    @builtins.property
-    def computation_range(self) -> "scout_checklistexecution_api_ComputationRange":
-        """
-        The time range over which status and last failure were calculated. Failures outside of this time range
-will not be included in the results.
-        """
-        return self._computation_range
+    def __init__(self, checklist_live_status_responses: List["scout_checklistexecution_api_ChecklistLiveStatusResponse"]) -> None:
+        self._checklist_live_status_responses = checklist_live_status_responses
 
     @builtins.property
-    def checklist_results(self) -> List["scout_checklistexecution_api_ChecklistLiveStatusResponse"]:
-        return self._checklist_results
+    def checklist_live_status_responses(self) -> List["scout_checklistexecution_api_ChecklistLiveStatusResponse"]:
+        return self._checklist_live_status_responses
 
 
 scout_checklistexecution_api_BatchChecklistLiveStatusResponse.__name__ = "BatchChecklistLiveStatusResponse"
@@ -22281,6 +22354,52 @@ scout_checklistexecution_api_BatchChecklistLiveStatusResponse.__qualname__ = "Ba
 scout_checklistexecution_api_BatchChecklistLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_BatchGetStreamingChecklistRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'checklist_rids': ConjureFieldDefinition('checklistRids', List[scout_rids_api_ChecklistRid])
+        }
+
+    __slots__: List[str] = ['_checklist_rids']
+
+    def __init__(self, checklist_rids: List[str]) -> None:
+        self._checklist_rids = checklist_rids
+
+    @builtins.property
+    def checklist_rids(self) -> List[str]:
+        return self._checklist_rids
+
+
+scout_checklistexecution_api_BatchGetStreamingChecklistRequest.__name__ = "BatchGetStreamingChecklistRequest"
+scout_checklistexecution_api_BatchGetStreamingChecklistRequest.__qualname__ = "BatchGetStreamingChecklistRequest"
+scout_checklistexecution_api_BatchGetStreamingChecklistRequest.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
+class scout_checklistexecution_api_BatchGetStreamingChecklistResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'streaming_checklist_infos': ConjureFieldDefinition('streamingChecklistInfos', Dict[scout_rids_api_ChecklistRid, scout_checklistexecution_api_StreamingChecklistInfo])
+        }
+
+    __slots__: List[str] = ['_streaming_checklist_infos']
+
+    def __init__(self, streaming_checklist_infos: Dict[str, "scout_checklistexecution_api_StreamingChecklistInfo"]) -> None:
+        self._streaming_checklist_infos = streaming_checklist_infos
+
+    @builtins.property
+    def streaming_checklist_infos(self) -> Dict[str, "scout_checklistexecution_api_StreamingChecklistInfo"]:
+        return self._streaming_checklist_infos
+
+
+scout_checklistexecution_api_BatchGetStreamingChecklistResponse.__name__ = "BatchGetStreamingChecklistResponse"
+scout_checklistexecution_api_BatchGetStreamingChecklistResponse.__qualname__ = "BatchGetStreamingChecklistResponse"
+scout_checklistexecution_api_BatchGetStreamingChecklistResponse.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_BatchValidateChecklistResolutionRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -22379,33 +22498,33 @@ class scout_checklistexecution_api_CheckLiveStatusResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'result': ConjureFieldDefinition('result', scout_checklistexecution_api_CheckLiveStatusResult),
+            'status': ConjureFieldDefinition('status', scout_checklistexecution_api_CheckStatus),
             'check_rid': ConjureFieldDefinition('checkRid', scout_rids_api_CheckRid),
-            'check_implementation_index': ConjureFieldDefinition('checkImplementationIndex', OptionalTypeWrapper[int])
+            'check_parameter_index': ConjureFieldDefinition('checkParameterIndex', OptionalTypeWrapper[int])
         }
 
-    __slots__: List[str] = ['_result', '_check_rid', '_check_implementation_index']
+    __slots__: List[str] = ['_status', '_check_rid', '_check_parameter_index']
 
-    def __init__(self, check_rid: str, result: "scout_checklistexecution_api_CheckLiveStatusResult", check_implementation_index: Optional[int] = None) -> None:
-        self._result = result
+    def __init__(self, check_rid: str, status: "scout_checklistexecution_api_CheckStatus", check_parameter_index: Optional[int] = None) -> None:
+        self._status = status
         self._check_rid = check_rid
-        self._check_implementation_index = check_implementation_index
+        self._check_parameter_index = check_parameter_index
 
     @builtins.property
-    def result(self) -> "scout_checklistexecution_api_CheckLiveStatusResult":
-        return self._result
+    def status(self) -> "scout_checklistexecution_api_CheckStatus":
+        return self._status
 
     @builtins.property
     def check_rid(self) -> str:
         return self._check_rid
 
     @builtins.property
-    def check_implementation_index(self) -> Optional[int]:
+    def check_parameter_index(self) -> Optional[int]:
         """
         Checks can define a single range computation which can evaluate over multiple implementations of a context.
 The check implementation index will correspond to the implementation index of the check condition.
         """
-        return self._check_implementation_index
+        return self._check_parameter_index
 
 
 scout_checklistexecution_api_CheckLiveStatusResponse.__name__ = "CheckLiveStatusResponse"
@@ -22413,130 +22532,31 @@ scout_checklistexecution_api_CheckLiveStatusResponse.__qualname__ = "CheckLiveSt
 scout_checklistexecution_api_CheckLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_CheckLiveStatusResult(ConjureUnionType):
-    _computed: Optional["scout_checklistexecution_api_ComputedResult"] = None
-    _not_computable: Optional["scout_checklistexecution_api_NotComputable"] = None
-    _failed_to_resolve: Optional["scout_checklistexecution_api_FailedToResolve"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'computed': ConjureFieldDefinition('computed', scout_checklistexecution_api_ComputedResult),
-            'not_computable': ConjureFieldDefinition('notComputable', scout_checklistexecution_api_NotComputable),
-            'failed_to_resolve': ConjureFieldDefinition('failedToResolve', scout_checklistexecution_api_FailedToResolve)
-        }
-
-    def __init__(
-            self,
-            computed: Optional["scout_checklistexecution_api_ComputedResult"] = None,
-            not_computable: Optional["scout_checklistexecution_api_NotComputable"] = None,
-            failed_to_resolve: Optional["scout_checklistexecution_api_FailedToResolve"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (computed is not None) + (not_computable is not None) + (failed_to_resolve is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if computed is not None:
-                self._computed = computed
-                self._type = 'computed'
-            if not_computable is not None:
-                self._not_computable = not_computable
-                self._type = 'notComputable'
-            if failed_to_resolve is not None:
-                self._failed_to_resolve = failed_to_resolve
-                self._type = 'failedToResolve'
-
-        elif type_of_union == 'computed':
-            if computed is None:
-                raise ValueError('a union value must not be None')
-            self._computed = computed
-            self._type = 'computed'
-        elif type_of_union == 'notComputable':
-            if not_computable is None:
-                raise ValueError('a union value must not be None')
-            self._not_computable = not_computable
-            self._type = 'notComputable'
-        elif type_of_union == 'failedToResolve':
-            if failed_to_resolve is None:
-                raise ValueError('a union value must not be None')
-            self._failed_to_resolve = failed_to_resolve
-            self._type = 'failedToResolve'
-
-    @builtins.property
-    def computed(self) -> Optional["scout_checklistexecution_api_ComputedResult"]:
-        return self._computed
-
-    @builtins.property
-    def not_computable(self) -> Optional["scout_checklistexecution_api_NotComputable"]:
-        """
-        The check cannot be computed in a streaming context. This would be returned if an overly expensive
-computation was attempted, such as checking the rolling median over the last year of data.
-        """
-        return self._not_computable
-
-    @builtins.property
-    def failed_to_resolve(self) -> Optional["scout_checklistexecution_api_FailedToResolve"]:
-        """
-        The checklist cannot be applied to the data sources.
-        """
-        return self._failed_to_resolve
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_checklistexecution_api_CheckLiveStatusResultVisitor):
-            raise ValueError('{} is not an instance of scout_checklistexecution_api_CheckLiveStatusResultVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'computed' and self.computed is not None:
-            return visitor._computed(self.computed)
-        if self._type == 'notComputable' and self.not_computable is not None:
-            return visitor._not_computable(self.not_computable)
-        if self._type == 'failedToResolve' and self.failed_to_resolve is not None:
-            return visitor._failed_to_resolve(self.failed_to_resolve)
-
-
-scout_checklistexecution_api_CheckLiveStatusResult.__name__ = "CheckLiveStatusResult"
-scout_checklistexecution_api_CheckLiveStatusResult.__qualname__ = "CheckLiveStatusResult"
-scout_checklistexecution_api_CheckLiveStatusResult.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
-class scout_checklistexecution_api_CheckLiveStatusResultVisitor:
-
-    @abstractmethod
-    def _computed(self, computed: "scout_checklistexecution_api_ComputedResult") -> Any:
-        pass
-
-    @abstractmethod
-    def _not_computable(self, not_computable: "scout_checklistexecution_api_NotComputable") -> Any:
-        pass
-
-    @abstractmethod
-    def _failed_to_resolve(self, failed_to_resolve: "scout_checklistexecution_api_FailedToResolve") -> Any:
-        pass
-
-
-scout_checklistexecution_api_CheckLiveStatusResultVisitor.__name__ = "CheckLiveStatusResultVisitor"
-scout_checklistexecution_api_CheckLiveStatusResultVisitor.__qualname__ = "CheckLiveStatusResultVisitor"
-scout_checklistexecution_api_CheckLiveStatusResultVisitor.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
 class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
     _pass_: Optional["scout_checklistexecution_api_Pass"] = None
     _fail: Optional["scout_checklistexecution_api_Fail"] = None
+    _invalid: Optional["scout_checklistexecution_api_Invalid"] = None
+    _skipped: Optional["scout_checklistexecution_api_Skipped"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'pass_': ConjureFieldDefinition('pass', scout_checklistexecution_api_Pass),
-            'fail': ConjureFieldDefinition('fail', scout_checklistexecution_api_Fail)
+            'fail': ConjureFieldDefinition('fail', scout_checklistexecution_api_Fail),
+            'invalid': ConjureFieldDefinition('invalid', scout_checklistexecution_api_Invalid),
+            'skipped': ConjureFieldDefinition('skipped', scout_checklistexecution_api_Skipped)
         }
 
     def __init__(
             self,
             pass_: Optional["scout_checklistexecution_api_Pass"] = None,
             fail: Optional["scout_checklistexecution_api_Fail"] = None,
+            invalid: Optional["scout_checklistexecution_api_Invalid"] = None,
+            skipped: Optional["scout_checklistexecution_api_Skipped"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (pass_ is not None) + (fail is not None) != 1:
+            if (pass_ is not None) + (fail is not None) + (invalid is not None) + (skipped is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if pass_ is not None:
@@ -22545,6 +22565,12 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
             if fail is not None:
                 self._fail = fail
                 self._type = 'fail'
+            if invalid is not None:
+                self._invalid = invalid
+                self._type = 'invalid'
+            if skipped is not None:
+                self._skipped = skipped
+                self._type = 'skipped'
 
         elif type_of_union == 'pass':
             if pass_ is None:
@@ -22556,6 +22582,16 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._fail = fail
             self._type = 'fail'
+        elif type_of_union == 'invalid':
+            if invalid is None:
+                raise ValueError('a union value must not be None')
+            self._invalid = invalid
+            self._type = 'invalid'
+        elif type_of_union == 'skipped':
+            if skipped is None:
+                raise ValueError('a union value must not be None')
+            self._skipped = skipped
+            self._type = 'skipped'
 
     @builtins.property
     def pass_(self) -> Optional["scout_checklistexecution_api_Pass"]:
@@ -22571,6 +22607,24 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
         """
         return self._fail
 
+    @builtins.property
+    def invalid(self) -> Optional["scout_checklistexecution_api_Invalid"]:
+        """
+        The check was evaluated and is currently in state INVALID.
+This signifies that the check could not be evaluated due to an internal error or
+if an overly expensive computation was attempted.
+        """
+        return self._invalid
+
+    @builtins.property
+    def skipped(self) -> Optional["scout_checklistexecution_api_Skipped"]:
+        """
+        The check was skipped and was not evaluated.
+This typically occurs when the check performs operations that are not supported in the streaming context,
+or if the required channels could not be resolved.
+        """
+        return self._skipped
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_checklistexecution_api_CheckStatusVisitor):
             raise ValueError('{} is not an instance of scout_checklistexecution_api_CheckStatusVisitor'.format(visitor.__class__.__name__))
@@ -22578,6 +22632,10 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
             return visitor._pass(self.pass_)
         if self._type == 'fail' and self.fail is not None:
             return visitor._fail(self.fail)
+        if self._type == 'invalid' and self.invalid is not None:
+            return visitor._invalid(self.invalid)
+        if self._type == 'skipped' and self.skipped is not None:
+            return visitor._skipped(self.skipped)
 
 
 scout_checklistexecution_api_CheckStatus.__name__ = "CheckStatus"
@@ -22595,6 +22653,14 @@ class scout_checklistexecution_api_CheckStatusVisitor:
     def _fail(self, fail: "scout_checklistexecution_api_Fail") -> Any:
         pass
 
+    @abstractmethod
+    def _invalid(self, invalid: "scout_checklistexecution_api_Invalid") -> Any:
+        pass
+
+    @abstractmethod
+    def _skipped(self, skipped: "scout_checklistexecution_api_Skipped") -> Any:
+        pass
+
 
 scout_checklistexecution_api_CheckStatusVisitor.__name__ = "CheckStatusVisitor"
 scout_checklistexecution_api_CheckStatusVisitor.__qualname__ = "CheckStatusVisitor"
@@ -22608,8 +22674,7 @@ class scout_checklistexecution_api_ChecklistExecutionService(Service):
 
     def checklist_live_status(self, auth_header: str, request: "scout_checklistexecution_api_BatchChecklistLiveStatusRequest") -> "scout_checklistexecution_api_BatchChecklistLiveStatusResponse":
         """
-        For each request, get the current status and last failing time (if possible) for
-every automatic check against the given run.
+        For each request, get the latest status for each check in a streaming checklist against the given asset.
         """
 
         _headers: Dict[str, Any] = {
@@ -22641,8 +22706,8 @@ every automatic check against the given run.
 
     def execute_streaming_checklist(self, auth_header: str, request: "scout_checklistexecution_api_ExecuteChecklistForAssetsRequest") -> None:
         """
-        Triggers a checklist to run continuously against assets. Returns a ChecklistAlreadyRunning error if the
-checklist is already running for the given asset.
+        Triggers a checklist to run continuously against assets.
+If the checklist is already running for the given asset, replace the existing configuration with the one specified by the request.
         """
 
         _headers: Dict[str, Any] = {
@@ -22737,7 +22802,7 @@ checklist is already running for the given asset.
 
     def get_streaming_checklist(self, auth_header: str, checklist_rid: str) -> "scout_checklistexecution_api_StreamingChecklistInfo":
         """
-        Retrieves information about a streaming checklist using the provided checklistRid.
+        Retrieves the set of assets and their execution configurations for a streaming checklist specified by the checklistRid.
         """
 
         _headers: Dict[str, Any] = {
@@ -22767,6 +22832,39 @@ checklist is already running for the given asset.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_checklistexecution_api_StreamingChecklistInfo, self._return_none_for_unknown_union_types)
 
+    def batch_get_streaming_checklist(self, auth_header: str, request: "scout_checklistexecution_api_BatchGetStreamingChecklistRequest") -> "scout_checklistexecution_api_BatchGetStreamingChecklistResponse":
+        """
+        Retrieves the set of assets and their execution configurations for all streaming checklists specified by the request.
+If a streaming checklist is not found, it will not be included in the response.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/scout/v2/checklist-execution/get-streaming-checklists'
+        _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_checklistexecution_api_BatchGetStreamingChecklistResponse, self._return_none_for_unknown_union_types)
+
     def stop_streaming_checklist(self, auth_header: str, checklist_rid: str) -> None:
         """
         Stops the execution of a streaming checklist on all assets.
@@ -22898,147 +22996,175 @@ scout_checklistexecution_api_ChecklistExecutionService.__qualname__ = "Checklist
 scout_checklistexecution_api_ChecklistExecutionService.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_ChecklistLiveStatusRequest(ConjureBeanType):
-    """
-    If commit is not provided, the latest commit on main will be used. At least one of runRid or assetRid must be provided, but not both.
-    """
+class scout_checklistexecution_api_ChecklistLiveStatus(ConjureUnionType):
+    _running: Optional["scout_checklistexecution_api_StreamingChecklistRunning"] = None
+    _initializing: Optional["scout_checklistexecution_api_StreamingChecklistInitializing"] = None
+    _failed: Optional["scout_checklistexecution_api_StreamingChecklistFailed"] = None
 
     @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
-            'commit': ConjureFieldDefinition('commit', OptionalTypeWrapper[scout_versioning_api_CommitId]),
-            'run_rid': ConjureFieldDefinition('runRid', OptionalTypeWrapper[scout_run_api_RunRid]),
-            'asset_rid': ConjureFieldDefinition('assetRid', OptionalTypeWrapper[scout_rids_api_AssetRid])
+            'running': ConjureFieldDefinition('running', scout_checklistexecution_api_StreamingChecklistRunning),
+            'initializing': ConjureFieldDefinition('initializing', scout_checklistexecution_api_StreamingChecklistInitializing),
+            'failed': ConjureFieldDefinition('failed', scout_checklistexecution_api_StreamingChecklistFailed)
         }
 
-    __slots__: List[str] = ['_checklist_rid', '_commit', '_run_rid', '_asset_rid']
+    def __init__(
+            self,
+            running: Optional["scout_checklistexecution_api_StreamingChecklistRunning"] = None,
+            initializing: Optional["scout_checklistexecution_api_StreamingChecklistInitializing"] = None,
+            failed: Optional["scout_checklistexecution_api_StreamingChecklistFailed"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (running is not None) + (initializing is not None) + (failed is not None) != 1:
+                raise ValueError('a union must contain a single member')
 
-    def __init__(self, checklist_rid: str, asset_rid: Optional[str] = None, commit: Optional[str] = None, run_rid: Optional[str] = None) -> None:
-        self._checklist_rid = checklist_rid
-        self._commit = commit
-        self._run_rid = run_rid
-        self._asset_rid = asset_rid
+            if running is not None:
+                self._running = running
+                self._type = 'running'
+            if initializing is not None:
+                self._initializing = initializing
+                self._type = 'initializing'
+            if failed is not None:
+                self._failed = failed
+                self._type = 'failed'
 
-    @builtins.property
-    def checklist_rid(self) -> str:
-        return self._checklist_rid
+        elif type_of_union == 'running':
+            if running is None:
+                raise ValueError('a union value must not be None')
+            self._running = running
+            self._type = 'running'
+        elif type_of_union == 'initializing':
+            if initializing is None:
+                raise ValueError('a union value must not be None')
+            self._initializing = initializing
+            self._type = 'initializing'
+        elif type_of_union == 'failed':
+            if failed is None:
+                raise ValueError('a union value must not be None')
+            self._failed = failed
+            self._type = 'failed'
 
     @builtins.property
-    def commit(self) -> Optional[str]:
-        return self._commit
+    def running(self) -> Optional["scout_checklistexecution_api_StreamingChecklistRunning"]:
+        """
+        The streaming checklist is currently executing against the asset.
+        """
+        return self._running
 
     @builtins.property
-    def run_rid(self) -> Optional[str]:
-        return self._run_rid
+    def initializing(self) -> Optional["scout_checklistexecution_api_StreamingChecklistInitializing"]:
+        """
+        The streaming checklist is currently initializing against the asset.
+        """
+        return self._initializing
 
     @builtins.property
-    def asset_rid(self) -> Optional[str]:
-        return self._asset_rid
-
+    def failed(self) -> Optional["scout_checklistexecution_api_StreamingChecklistFailed"]:
+        """
+        The streaming checklist failed unexpectedly. Please contact support.
+        """
+        return self._failed
 
-scout_checklistexecution_api_ChecklistLiveStatusRequest.__name__ = "ChecklistLiveStatusRequest"
-scout_checklistexecution_api_ChecklistLiveStatusRequest.__qualname__ = "ChecklistLiveStatusRequest"
-scout_checklistexecution_api_ChecklistLiveStatusRequest.__module__ = "nominal_api.scout_checklistexecution_api"
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_checklistexecution_api_ChecklistLiveStatusVisitor):
+            raise ValueError('{} is not an instance of scout_checklistexecution_api_ChecklistLiveStatusVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'running' and self.running is not None:
+            return visitor._running(self.running)
+        if self._type == 'initializing' and self.initializing is not None:
+            return visitor._initializing(self.initializing)
+        if self._type == 'failed' and self.failed is not None:
+            return visitor._failed(self.failed)
 
 
-class scout_checklistexecution_api_ChecklistLiveStatusResponse(ConjureBeanType):
+scout_checklistexecution_api_ChecklistLiveStatus.__name__ = "ChecklistLiveStatus"
+scout_checklistexecution_api_ChecklistLiveStatus.__qualname__ = "ChecklistLiveStatus"
+scout_checklistexecution_api_ChecklistLiveStatus.__module__ = "nominal_api.scout_checklistexecution_api"
 
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
-            'check_results': ConjureFieldDefinition('checkResults', List[scout_checklistexecution_api_CheckLiveStatusResponse])
-        }
 
-    __slots__: List[str] = ['_checklist_rid', '_check_results']
+class scout_checklistexecution_api_ChecklistLiveStatusVisitor:
 
-    def __init__(self, check_results: List["scout_checklistexecution_api_CheckLiveStatusResponse"], checklist_rid: str) -> None:
-        self._checklist_rid = checklist_rid
-        self._check_results = check_results
+    @abstractmethod
+    def _running(self, running: "scout_checklistexecution_api_StreamingChecklistRunning") -> Any:
+        pass
 
-    @builtins.property
-    def checklist_rid(self) -> str:
-        return self._checklist_rid
+    @abstractmethod
+    def _initializing(self, initializing: "scout_checklistexecution_api_StreamingChecklistInitializing") -> Any:
+        pass
 
-    @builtins.property
-    def check_results(self) -> List["scout_checklistexecution_api_CheckLiveStatusResponse"]:
-        return self._check_results
+    @abstractmethod
+    def _failed(self, failed: "scout_checklistexecution_api_StreamingChecklistFailed") -> Any:
+        pass
 
 
-scout_checklistexecution_api_ChecklistLiveStatusResponse.__name__ = "ChecklistLiveStatusResponse"
-scout_checklistexecution_api_ChecklistLiveStatusResponse.__qualname__ = "ChecklistLiveStatusResponse"
-scout_checklistexecution_api_ChecklistLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
+scout_checklistexecution_api_ChecklistLiveStatusVisitor.__name__ = "ChecklistLiveStatusVisitor"
+scout_checklistexecution_api_ChecklistLiveStatusVisitor.__qualname__ = "ChecklistLiveStatusVisitor"
+scout_checklistexecution_api_ChecklistLiveStatusVisitor.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_ComputationRange(ConjureBeanType):
-    """
-    The time range over which status and last failure were calculated. Failures outside of this time range
-will not be included in the results.
-    """
+class scout_checklistexecution_api_ChecklistLiveStatusRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'start': ConjureFieldDefinition('start', api_Timestamp),
-            'end': ConjureFieldDefinition('end', api_Timestamp)
+            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid)
         }
 
-    __slots__: List[str] = ['_start', '_end']
+    __slots__: List[str] = ['_checklist_rid', '_asset_rid']
 
-    def __init__(self, end: "api_Timestamp", start: "api_Timestamp") -> None:
-        self._start = start
-        self._end = end
+    def __init__(self, asset_rid: str, checklist_rid: str) -> None:
+        self._checklist_rid = checklist_rid
+        self._asset_rid = asset_rid
 
     @builtins.property
-    def start(self) -> "api_Timestamp":
-        return self._start
+    def checklist_rid(self) -> str:
+        return self._checklist_rid
 
     @builtins.property
-    def end(self) -> "api_Timestamp":
-        return self._end
+    def asset_rid(self) -> str:
+        return self._asset_rid
 
 
-scout_checklistexecution_api_ComputationRange.__name__ = "ComputationRange"
-scout_checklistexecution_api_ComputationRange.__qualname__ = "ComputationRange"
-scout_checklistexecution_api_ComputationRange.__module__ = "nominal_api.scout_checklistexecution_api"
+scout_checklistexecution_api_ChecklistLiveStatusRequest.__name__ = "ChecklistLiveStatusRequest"
+scout_checklistexecution_api_ChecklistLiveStatusRequest.__qualname__ = "ChecklistLiveStatusRequest"
+scout_checklistexecution_api_ChecklistLiveStatusRequest.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_ComputedResult(ConjureBeanType):
+class scout_checklistexecution_api_ChecklistLiveStatusResponse(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'status': ConjureFieldDefinition('status', scout_checklistexecution_api_CheckStatus),
-            'last_failure': ConjureFieldDefinition('lastFailure', scout_checklistexecution_api_LastFailure)
+            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
+            'status': ConjureFieldDefinition('status', scout_checklistexecution_api_ChecklistLiveStatus)
         }
 
-    __slots__: List[str] = ['_status', '_last_failure']
+    __slots__: List[str] = ['_checklist_rid', '_asset_rid', '_status']
 
-    def __init__(self, last_failure: "scout_checklistexecution_api_LastFailure", status: "scout_checklistexecution_api_CheckStatus") -> None:
+    def __init__(self, asset_rid: str, checklist_rid: str, status: "scout_checklistexecution_api_ChecklistLiveStatus") -> None:
+        self._checklist_rid = checklist_rid
+        self._asset_rid = asset_rid
         self._status = status
-        self._last_failure = last_failure
 
     @builtins.property
-    def status(self) -> "scout_checklistexecution_api_CheckStatus":
-        """
-        The current status of a check at the time it was evaluated.
-        """
-        return self._status
+    def checklist_rid(self) -> str:
+        return self._checklist_rid
 
     @builtins.property
-    def last_failure(self) -> "scout_checklistexecution_api_LastFailure":
-        """
-        If computed, represents the last time the check failed.
-Can also represent that the last failure hasn't been computed, or is currently being computed.
-If the check is currently failing, the current failure is returned.
-        """
-        return self._last_failure
+    def asset_rid(self) -> str:
+        return self._asset_rid
 
+    @builtins.property
+    def status(self) -> "scout_checklistexecution_api_ChecklistLiveStatus":
+        return self._status
 
-scout_checklistexecution_api_ComputedResult.__name__ = "ComputedResult"
-scout_checklistexecution_api_ComputedResult.__qualname__ = "ComputedResult"
-scout_checklistexecution_api_ComputedResult.__module__ = "nominal_api.scout_checklistexecution_api"
+
+scout_checklistexecution_api_ChecklistLiveStatusResponse.__name__ = "ChecklistLiveStatusResponse"
+scout_checklistexecution_api_ChecklistLiveStatusResponse.__qualname__ = "ChecklistLiveStatusResponse"
+scout_checklistexecution_api_ChecklistLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
 class scout_checklistexecution_api_Computing(ConjureBeanType):
@@ -23133,35 +23259,6 @@ scout_checklistexecution_api_Fail.__qualname__ = "Fail"
 scout_checklistexecution_api_Fail.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_FailedToResolve(ConjureBeanType):
-    """
-    The checklist cannot be applied to the data sources.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'variable_name': ConjureFieldDefinition('variableName', str)
-        }
-
-    __slots__: List[str] = ['_variable_name']
-
-    def __init__(self, variable_name: str) -> None:
-        self._variable_name = variable_name
-
-    @builtins.property
-    def variable_name(self) -> str:
-        """
-        The variable name that couldn't be resolved to a series.
-        """
-        return self._variable_name
-
-
-scout_checklistexecution_api_FailedToResolve.__name__ = "FailedToResolve"
-scout_checklistexecution_api_FailedToResolve.__qualname__ = "FailedToResolve"
-scout_checklistexecution_api_FailedToResolve.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
 class scout_checklistexecution_api_Failure(ConjureBeanType):
     """
     The time range where a check was failing.
@@ -23194,6 +23291,22 @@ scout_checklistexecution_api_Failure.__qualname__ = "Failure"
 scout_checklistexecution_api_Failure.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_Invalid(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_Invalid.__name__ = "Invalid"
+scout_checklistexecution_api_Invalid.__qualname__ = "Invalid"
+scout_checklistexecution_api_Invalid.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_InvalidStreamingComputeNode(ConjureEnumType):
 
     POINT_PERSISTENCE = 'POINT_PERSISTENCE'
@@ -23501,35 +23614,6 @@ scout_checklistexecution_api_NoPreviousFailure.__qualname__ = "NoPreviousFailure
 scout_checklistexecution_api_NoPreviousFailure.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_NotComputable(ConjureBeanType):
-    """
-    The result cannot be computed in a streaming context.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'message': ConjureFieldDefinition('message', str)
-        }
-
-    __slots__: List[str] = ['_message']
-
-    def __init__(self, message: str) -> None:
-        self._message = message
-
-    @builtins.property
-    def message(self) -> str:
-        """
-        Why the result couldn't be computed
-        """
-        return self._message
-
-
-scout_checklistexecution_api_NotComputable.__name__ = "NotComputable"
-scout_checklistexecution_api_NotComputable.__qualname__ = "NotComputable"
-scout_checklistexecution_api_NotComputable.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
 class scout_checklistexecution_api_NotComputed(ConjureBeanType):
     """
     The result has not been computed, and is not currently being computed.
@@ -23569,7 +23653,6 @@ class scout_checklistexecution_api_ResolvedCheckStatus(ConjureBeanType):
     """
     Provides the resolution status for the required channels for a check and the set of invalid streaming compute nodes present within the check's compute graph.
 Uniqueness between checkRid and checkParameterIndex pairs is guaranteed.
-checkParameterIndex is optional and will be null if the check is not parameterized otherwise it will be the index of the parameter.
     """
 
     @builtins.classmethod
@@ -23595,6 +23678,10 @@ checkParameterIndex is optional and will be null if the check is not parameteriz
 
     @builtins.property
     def check_parameter_index(self) -> Optional[int]:
+        """
+        Checks can define a single range computation which can evaluate over multiple implementations of a context.
+The check implementation index will correspond to the implementation index of the check condition.
+        """
         return self._check_parameter_index
 
     @builtins.property
@@ -23611,6 +23698,22 @@ scout_checklistexecution_api_ResolvedCheckStatus.__qualname__ = "ResolvedCheckSt
 scout_checklistexecution_api_ResolvedCheckStatus.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_Skipped(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_Skipped.__name__ = "Skipped"
+scout_checklistexecution_api_Skipped.__qualname__ = "Skipped"
+scout_checklistexecution_api_Skipped.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_StopStreamingChecklistForAssetsRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -23640,6 +23743,22 @@ scout_checklistexecution_api_StopStreamingChecklistForAssetsRequest.__qualname__
 scout_checklistexecution_api_StopStreamingChecklistForAssetsRequest.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_StreamingChecklistFailed(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_StreamingChecklistFailed.__name__ = "StreamingChecklistFailed"
+scout_checklistexecution_api_StreamingChecklistFailed.__qualname__ = "StreamingChecklistFailed"
+scout_checklistexecution_api_StreamingChecklistFailed.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_StreamingChecklistInfo(ConjureBeanType):
 
     @builtins.classmethod
@@ -23669,6 +23788,54 @@ scout_checklistexecution_api_StreamingChecklistInfo.__qualname__ = "StreamingChe
 scout_checklistexecution_api_StreamingChecklistInfo.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_StreamingChecklistInitializing(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_StreamingChecklistInitializing.__name__ = "StreamingChecklistInitializing"
+scout_checklistexecution_api_StreamingChecklistInitializing.__qualname__ = "StreamingChecklistInitializing"
+scout_checklistexecution_api_StreamingChecklistInitializing.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
+class scout_checklistexecution_api_StreamingChecklistRunning(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'commit_id': ConjureFieldDefinition('commitId', scout_versioning_api_CommitId),
+            'check_results': ConjureFieldDefinition('checkResults', List[scout_checklistexecution_api_CheckLiveStatusResponse])
+        }
+
+    __slots__: List[str] = ['_commit_id', '_check_results']
+
+    def __init__(self, check_results: List["scout_checklistexecution_api_CheckLiveStatusResponse"], commit_id: str) -> None:
+        self._commit_id = commit_id
+        self._check_results = check_results
+
+    @builtins.property
+    def commit_id(self) -> str:
+        """
+        The commitId of the checklist that is currently executing.
+        """
+        return self._commit_id
+
+    @builtins.property
+    def check_results(self) -> List["scout_checklistexecution_api_CheckLiveStatusResponse"]:
+        return self._check_results
+
+
+scout_checklistexecution_api_StreamingChecklistRunning.__name__ = "StreamingChecklistRunning"
+scout_checklistexecution_api_StreamingChecklistRunning.__qualname__ = "StreamingChecklistRunning"
+scout_checklistexecution_api_StreamingChecklistRunning.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_ValidateChecklistResolutionRequest(ConjureBeanType):
     """
     Validates that the channels referenced by the checklist can be resolved against the data sources.
@@ -72916,15 +73083,19 @@ class timeseries_logicalseries_api_CsvLocator(ConjureBeanType):
         return {
             's3_path': ConjureFieldDefinition('s3Path', api_S3Path),
             'index': ConjureFieldDefinition('index', int),
-            'uses_legacy_format': ConjureFieldDefinition('usesLegacyFormat', OptionalTypeWrapper[bool])
+            'uses_legacy_format': ConjureFieldDefinition('usesLegacyFormat', OptionalTypeWrapper[bool]),
+            'x_series_handle': ConjureFieldDefinition('xSeriesHandle', OptionalTypeWrapper[str]),
+            'y_series_handle': ConjureFieldDefinition('ySeriesHandle', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = ['_s3_path', '_index', '_uses_legacy_format']
+    __slots__: List[str] = ['_s3_path', '_index', '_uses_legacy_format', '_x_series_handle', '_y_series_handle']
 
-    def __init__(self, index: int, s3_path: str, uses_legacy_format: Optional[bool] = None) -> None:
+    def __init__(self, index: int, s3_path: str, uses_legacy_format: Optional[bool] = None, x_series_handle: Optional[str] = None, y_series_handle: Optional[str] = None) -> None:
         self._s3_path = s3_path
         self._index = index
         self._uses_legacy_format = uses_legacy_format
+        self._x_series_handle = x_series_handle
+        self._y_series_handle = y_series_handle
 
     @builtins.property
     def s3_path(self) -> str:
@@ -72942,6 +73113,20 @@ and values are split into two separate arrow files.
         """
         return self._uses_legacy_format
 
+    @builtins.property
+    def x_series_handle(self) -> Optional[str]:
+        """
+        The handle of the x series to use for this logical series.
+        """
+        return self._x_series_handle
+
+    @builtins.property
+    def y_series_handle(self) -> Optional[str]:
+        """
+        The handle of the y series to use for this logical series.
+        """
+        return self._y_series_handle
+
 
 timeseries_logicalseries_api_CsvLocator.__name__ = "CsvLocator"
 timeseries_logicalseries_api_CsvLocator.__qualname__ = "CsvLocator"

nominal_api/ingest_api/__init__.py

@@ -73,6 +73,7 @@ from .._impl import (
     ingest_api_NewDatasetIngestDestination as NewDatasetIngestDestination,
     ingest_api_NewVideoIngestDestination as NewVideoIngestDestination,
     ingest_api_NoTimestampManifest as NoTimestampManifest,
+    ingest_api_ParquetOpts as ParquetOpts,
     ingest_api_Part as Part,
     ingest_api_PartWithSize as PartWithSize,
     ingest_api_RelativeTimestamp as RelativeTimestamp,

nominal_api/scout_checklistexecution_api/__init__.py

@@ -3,25 +3,25 @@ from .._impl import (
     scout_checklistexecution_api_AssetStreamConfiguration as AssetStreamConfiguration,
     scout_checklistexecution_api_BatchChecklistLiveStatusRequest as BatchChecklistLiveStatusRequest,
     scout_checklistexecution_api_BatchChecklistLiveStatusResponse as BatchChecklistLiveStatusResponse,
+    scout_checklistexecution_api_BatchGetStreamingChecklistRequest as BatchGetStreamingChecklistRequest,
+    scout_checklistexecution_api_BatchGetStreamingChecklistResponse as BatchGetStreamingChecklistResponse,
     scout_checklistexecution_api_BatchValidateChecklistResolutionRequest as BatchValidateChecklistResolutionRequest,
     scout_checklistexecution_api_BatchValidateChecklistResolutionResponse as BatchValidateChecklistResolutionResponse,
     scout_checklistexecution_api_ChannelLocatorWithStatus as ChannelLocatorWithStatus,
     scout_checklistexecution_api_ChannelResolutionStatus as ChannelResolutionStatus,
     scout_checklistexecution_api_CheckLiveStatusResponse as CheckLiveStatusResponse,
-    scout_checklistexecution_api_CheckLiveStatusResult as CheckLiveStatusResult,
-    scout_checklistexecution_api_CheckLiveStatusResultVisitor as CheckLiveStatusResultVisitor,
     scout_checklistexecution_api_CheckStatus as CheckStatus,
     scout_checklistexecution_api_CheckStatusVisitor as CheckStatusVisitor,
     scout_checklistexecution_api_ChecklistExecutionService as ChecklistExecutionService,
+    scout_checklistexecution_api_ChecklistLiveStatus as ChecklistLiveStatus,
     scout_checklistexecution_api_ChecklistLiveStatusRequest as ChecklistLiveStatusRequest,
     scout_checklistexecution_api_ChecklistLiveStatusResponse as ChecklistLiveStatusResponse,
-    scout_checklistexecution_api_ComputationRange as ComputationRange,
-    scout_checklistexecution_api_ComputedResult as ComputedResult,
+    scout_checklistexecution_api_ChecklistLiveStatusVisitor as ChecklistLiveStatusVisitor,
     scout_checklistexecution_api_Computing as Computing,
     scout_checklistexecution_api_ExecuteChecklistForAssetsRequest as ExecuteChecklistForAssetsRequest,
     scout_checklistexecution_api_Fail as Fail,
-    scout_checklistexecution_api_FailedToResolve as FailedToResolve,
     scout_checklistexecution_api_Failure as Failure,
+    scout_checklistexecution_api_Invalid as Invalid,
     scout_checklistexecution_api_InvalidStreamingComputeNode as InvalidStreamingComputeNode,
     scout_checklistexecution_api_LastFailure as LastFailure,
     scout_checklistexecution_api_LastFailureVisitor as LastFailureVisitor,
@@ -30,12 +30,15 @@ from .._impl import (
     scout_checklistexecution_api_ListStreamingChecklistRequest as ListStreamingChecklistRequest,
     scout_checklistexecution_api_ListStreamingChecklistResponse as ListStreamingChecklistResponse,
     scout_checklistexecution_api_NoPreviousFailure as NoPreviousFailure,
-    scout_checklistexecution_api_NotComputable as NotComputable,
     scout_checklistexecution_api_NotComputed as NotComputed,
     scout_checklistexecution_api_Pass as Pass,
     scout_checklistexecution_api_ResolvedCheckStatus as ResolvedCheckStatus,
+    scout_checklistexecution_api_Skipped as Skipped,
     scout_checklistexecution_api_StopStreamingChecklistForAssetsRequest as StopStreamingChecklistForAssetsRequest,
+    scout_checklistexecution_api_StreamingChecklistFailed as StreamingChecklistFailed,
     scout_checklistexecution_api_StreamingChecklistInfo as StreamingChecklistInfo,
+    scout_checklistexecution_api_StreamingChecklistInitializing as StreamingChecklistInitializing,
+    scout_checklistexecution_api_StreamingChecklistRunning as StreamingChecklistRunning,
     scout_checklistexecution_api_ValidateChecklistResolutionRequest as ValidateChecklistResolutionRequest,
     scout_checklistexecution_api_ValidateChecklistResolutionResponse as ValidateChecklistResolutionResponse,
 )

{nominal_api-0.606.1.dist-info → nominal_api-0.608.0.dist-info}/METADATA

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

{nominal_api-0.606.1.dist-info → nominal_api-0.608.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=LM9gaKPHeYKZe5sW0V92DDVgJc_0yZwcU7KlFLc58Qs,1968
-nominal_api/_impl.py,sha256=0pJTOCYGjBz8Zcf5HJuwRGYZSfLY0XhBdTQ05ny5jCs,2905768
+nominal_api/__init__.py,sha256=KHJDIyibxuSy5qn5THJqs1ukbFKshe7Fr2nCQICCFR4,1968
+nominal_api/_impl.py,sha256=Wp_eJzHp5nSlc-pwBdiwcwumVefiBA-2BZkRpT081m8,2913421
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=kJBEE_HLVpKYdLH12KyO-cSAVzwxYpBwaaDutCtT-LM,1236
 nominal_api/api_ids/__init__.py,sha256=CAtt44XgNZEEUDv-BbEbYtuxQ8y1wqSZU-STjBYdZv8,80
@@ -15,7 +15,7 @@ nominal_api/datasource_logset/__init__.py,sha256=H3fNxqyYC490MwvdWbt5BwhgWQUev7u
 nominal_api/datasource_logset_api/__init__.py,sha256=JyjO1tQmG-HZ7kYMi8lSfeaaYddBZdCMIyqc0IUJfWo,1006
 nominal_api/datasource_pagination_api/__init__.py,sha256=3GO8TAUavOe6dUEitOhje74aSZHjTKVI5N1MNuct1lI,212
 nominal_api/event/__init__.py,sha256=YUhvDFXtyAn08WNd7Xwnybz3PtflvtTcIOaunRS5-1I,836
-nominal_api/ingest_api/__init__.py,sha256=Dls3tZXO9kHjZJQCbqOAi5IJa5-MZsDJ4c_NDlf7xkg,5630
+nominal_api/ingest_api/__init__.py,sha256=R0c6aMKwtqya4icx6Ffd31jgfQCwrr-yntkg9vOde_0,5673
 nominal_api/persistent_compute_api/__init__.py,sha256=5qZTTfN4X9u_qunFnWbLrPpG_FO5h7YBX68-_F6gYyQ,1031
 nominal_api/scout/__init__.py,sha256=ip3XK_9jJKAoFiCifUVMTpDMiUE4mWIdGzMDu7LASus,324
 nominal_api/scout_api/__init__.py,sha256=biO4DEygbGcLwM6Dg2VuvMra3A5EW6NBjukbIemXoG8,178
@@ -25,7 +25,7 @@ nominal_api/scout_catalog/__init__.py,sha256=ZGm4w1YKd4B-3CNxijTpB-1B653nctA_R0u
 nominal_api/scout_channelvariables_api/__init__.py,sha256=4OQV1O-M2MQE36yCGlyYftnqaXSddYTYTyGce_WC4JQ,466
 nominal_api/scout_chart_api/__init__.py,sha256=sw7WSYs6SarSW7x-3IBkSIrVea1cVFnQnpYiNKbCWnQ,184
 nominal_api/scout_chartdefinition_api/__init__.py,sha256=pXGFjL1eYAJXOxYXzRF6FvI6-uwRcscbF52uR1UqG_A,9486
-nominal_api/scout_checklistexecution_api/__init__.py,sha256=lpBtfyRP-ReEwNzFTcynDgiMe8ahtEJb75pg7cKl-Q0,3266
+nominal_api/scout_checklistexecution_api/__init__.py,sha256=1_nOnCSWn7bniSvTfskQ9LSJq5U2SRAKICZY9qipOJc,3579
 nominal_api/scout_checks_api/__init__.py,sha256=RJH7HsXjUhItC11V9C-hfv6lkIfiSXyxnB8slUpaT2g,5203
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=8BL5jE9NDxqCj9DyvZWSPhq6zw2J7xp6aLsl3x9rpyw,4530
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=1LCXQe64tDqqeMQixW8PI-R_edSz7F5X0x2_ufEuC8M,480
@@ -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.606.1.dist-info/METADATA,sha256=FTVzWTStfxlEoB87d4hYOPPd_O7PS7qJ07IDqv7Ovbo,199
-nominal_api-0.606.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nominal_api-0.606.1.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.606.1.dist-info/RECORD,,
+nominal_api-0.608.0.dist-info/METADATA,sha256=oN7fE7_RlXLBED9IjmlHUq1c5S_ey-OJpzWqb65Q4CA,199
+nominal_api-0.608.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nominal_api-0.608.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.608.0.dist-info/RECORD,,