nominal-api 0.621.0__py3-none-any.whl → 0.622.0__py3-none-any.whl

nominal_api/__init__.py

@@ -15,6 +15,7 @@ __all__ = [
     'datasource_pagination_api',
     'event',
     'ingest_api',
+    'ingest_workflow_api',
     'persistent_compute_api',
     'scout',
     'scout_api',
@@ -75,5 +76,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.621.0"
+__version__ = "0.622.0"
 

nominal_api/_impl.py

@@ -7029,8 +7029,8 @@ class ingest_api_ContainerizedOpts(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'sources': ConjureFieldDefinition('sources', Dict[ingest_api_ExtractorInputName, ingest_api_IngestSource]),
-            'extractor': ConjureFieldDefinition('extractor', str),
+            'sources': ConjureFieldDefinition('sources', Dict[ingest_api_EnvironmentVariable, ingest_api_IngestSource]),
+            'extractor': ConjureFieldDefinition('extractor', ingest_api_ContainerizedExtractorRid),
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', OptionalTypeWrapper[ingest_api_TimestampMetadata]),
             'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget)
         }
@@ -7078,17 +7078,19 @@ class ingest_api_CsvOpts(ConjureBeanType):
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
             'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
             'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
+            'tag_columns': ConjureFieldDefinition('tagColumns', OptionalTypeWrapper[Dict[api_TagName, api_ColumnName]]),
             'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]])
         }
 
-    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_additional_file_tags']
+    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_tag_columns', '_additional_file_tags']
 
-    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, tag_keys_from_columns: Optional[List[str]] = None) -> None:
+    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, tag_columns: Optional[Dict[str, str]] = 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._tag_columns = tag_columns
         self._additional_file_tags = additional_file_tags
 
     @builtins.property
@@ -7111,6 +7113,13 @@ class ingest_api_CsvOpts(ConjureBeanType):
     def tag_keys_from_columns(self) -> Optional[List[str]]:
         return self._tag_keys_from_columns
 
+    @builtins.property
+    def tag_columns(self) -> Optional[Dict[str, str]]:
+        """
+        A map of tag names to column names to derive the tag values from.
+        """
+        return self._tag_columns
+
     @builtins.property
     def additional_file_tags(self) -> Optional[Dict[str, str]]:
         return self._additional_file_tags
@@ -9943,18 +9952,20 @@ and archives such as .tar, .tar.gz, and .zip (must set the isArchive flag).
             'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
             'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
             'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
+            'tag_columns': ConjureFieldDefinition('tagColumns', OptionalTypeWrapper[Dict[api_TagName, api_ColumnName]]),
             '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']
+    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_tag_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:
+    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_columns: Optional[Dict[str, str]] = 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._tag_columns = tag_columns
         self._additional_file_tags = additional_file_tags
         self._is_archive = is_archive
 
@@ -9978,6 +9989,13 @@ and archives such as .tar, .tar.gz, and .zip (must set the isArchive flag).
     def tag_keys_from_columns(self) -> Optional[List[str]]:
         return self._tag_keys_from_columns
 
+    @builtins.property
+    def tag_columns(self) -> Optional[Dict[str, str]]:
+        """
+        A map of tag names to column names to derive the tag values from.
+        """
+        return self._tag_columns
+
     @builtins.property
     def additional_file_tags(self) -> Optional[Dict[str, str]]:
         return self._additional_file_tags
@@ -11235,6 +11253,547 @@ ingest_api_VideoTimestampManifestVisitor.__qualname__ = "VideoTimestampManifestV
 ingest_api_VideoTimestampManifestVisitor.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_workflow_api_Empty(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+ingest_workflow_api_Empty.__name__ = "Empty"
+ingest_workflow_api_Empty.__qualname__ = "Empty"
+ingest_workflow_api_Empty.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureExtractorJobCreatedRequest(ConjureBeanType):
+    """
+    Ensure that the extractor job exists in the control plane. Runs in the namespace given by workspaceRid.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
+            'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str),
+            'containerized_extractor': ConjureFieldDefinition('containerizedExtractor', ingest_api_ContainerizedExtractor),
+            'source_handles': ConjureFieldDefinition('sourceHandles', Dict[str, scout_catalog_S3Handle])
+        }
+
+    __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid', '_containerized_extractor', '_source_handles']
+
+    def __init__(self, containerized_extractor: "ingest_api_ContainerizedExtractor", ingest_job_uuid: str, source_handles: Dict[str, "scout_catalog_S3Handle"], workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+        self._ingest_job_uuid = ingest_job_uuid
+        self._containerized_extractor = containerized_extractor
+        self._source_handles = source_handles
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+    @builtins.property
+    def ingest_job_uuid(self) -> str:
+        return self._ingest_job_uuid
+
+    @builtins.property
+    def containerized_extractor(self) -> "ingest_api_ContainerizedExtractor":
+        return self._containerized_extractor
+
+    @builtins.property
+    def source_handles(self) -> Dict[str, "scout_catalog_S3Handle"]:
+        return self._source_handles
+
+
+ingest_workflow_api_EnsureExtractorJobCreatedRequest.__name__ = "EnsureExtractorJobCreatedRequest"
+ingest_workflow_api_EnsureExtractorJobCreatedRequest.__qualname__ = "EnsureExtractorJobCreatedRequest"
+ingest_workflow_api_EnsureExtractorJobCreatedRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureExtractorJobCreatedResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+ingest_workflow_api_EnsureExtractorJobCreatedResponse.__name__ = "EnsureExtractorJobCreatedResponse"
+ingest_workflow_api_EnsureExtractorJobCreatedResponse.__qualname__ = "EnsureExtractorJobCreatedResponse"
+ingest_workflow_api_EnsureExtractorJobCreatedResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest(ConjureBeanType):
+    """
+    For a given workspace rid, ensures that there is a corresponding K8s namespace created.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid)
+        }
+
+    __slots__: List[str] = ['_workspace_rid']
+
+    def __init__(self, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+
+ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest.__name__ = "EnsureWorkspaceNamespaceCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest.__qualname__ = "EnsureWorkspaceNamespaceCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest(ConjureBeanType):
+    """
+    For a given workspace rid, ensures that there is a service account in the proper K8s Namespace.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid)
+        }
+
+    __slots__: List[str] = ['_workspace_rid']
+
+    def __init__(self, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+
+ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest.__name__ = "EnsureWorkspaceServiceAccountCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest.__qualname__ = "EnsureWorkspaceServiceAccountCreatedRequest"
+ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_ExtractorJobState(ConjureEnumType):
+
+    PENDING = 'PENDING'
+    '''PENDING'''
+    RUNNING = 'RUNNING'
+    '''RUNNING'''
+    FAILED = 'FAILED'
+    '''FAILED'''
+    SUCCEEDED = 'SUCCEEDED'
+    '''SUCCEEDED'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+ingest_workflow_api_ExtractorJobState.__name__ = "ExtractorJobState"
+ingest_workflow_api_ExtractorJobState.__qualname__ = "ExtractorJobState"
+ingest_workflow_api_ExtractorJobState.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_GetExtractorJobStateRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid),
+            'ingest_job_uuid': ConjureFieldDefinition('ingestJobUuid', str)
+        }
+
+    __slots__: List[str] = ['_workspace_rid', '_ingest_job_uuid']
+
+    def __init__(self, ingest_job_uuid: str, workspace_rid: str) -> None:
+        self._workspace_rid = workspace_rid
+        self._ingest_job_uuid = ingest_job_uuid
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+    @builtins.property
+    def ingest_job_uuid(self) -> str:
+        return self._ingest_job_uuid
+
+
+ingest_workflow_api_GetExtractorJobStateRequest.__name__ = "GetExtractorJobStateRequest"
+ingest_workflow_api_GetExtractorJobStateRequest.__qualname__ = "GetExtractorJobStateRequest"
+ingest_workflow_api_GetExtractorJobStateRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_GetExtractorJobStateResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'state': ConjureFieldDefinition('state', ingest_workflow_api_ExtractorJobState)
+        }
+
+    __slots__: List[str] = ['_state']
+
+    def __init__(self, state: "ingest_workflow_api_ExtractorJobState") -> None:
+        self._state = state
+
+    @builtins.property
+    def state(self) -> "ingest_workflow_api_ExtractorJobState":
+        return self._state
+
+
+ingest_workflow_api_GetExtractorJobStateResponse.__name__ = "GetExtractorJobStateResponse"
+ingest_workflow_api_GetExtractorJobStateResponse.__qualname__ = "GetExtractorJobStateResponse"
+ingest_workflow_api_GetExtractorJobStateResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestDataflashRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator)
+        }
+
+    __slots__: List[str] = ['_locator']
+
+    def __init__(self, locator: "ingest_workflow_api_ObjectLocator") -> None:
+        self._locator = locator
+
+    @builtins.property
+    def locator(self) -> "ingest_workflow_api_ObjectLocator":
+        return self._locator
+
+
+ingest_workflow_api_IngestDataflashRequest.__name__ = "IngestDataflashRequest"
+ingest_workflow_api_IngestDataflashRequest.__qualname__ = "IngestDataflashRequest"
+ingest_workflow_api_IngestDataflashRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestDataflashResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'units': ConjureFieldDefinition('units', Dict[str, str]),
+            'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator]),
+            'timestamp_series_name': ConjureFieldDefinition('timestampSeriesName', str),
+            'time_unit': ConjureFieldDefinition('timeUnit', ingest_workflow_api_TimeUnitSeconds)
+        }
+
+    __slots__: List[str] = ['_units', '_parquet_object_locators', '_timestamp_series_name', '_time_unit']
+
+    def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], time_unit: "ingest_workflow_api_TimeUnitSeconds", timestamp_series_name: str, units: Dict[str, str]) -> None:
+        self._units = units
+        self._parquet_object_locators = parquet_object_locators
+        self._timestamp_series_name = timestamp_series_name
+        self._time_unit = time_unit
+
+    @builtins.property
+    def units(self) -> Dict[str, str]:
+        return self._units
+
+    @builtins.property
+    def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
+        """
+        Azure or S3-style blob locators of parquet files. Currently
+only a single file is supported, the list type is used for future compatibility.
+        """
+        return self._parquet_object_locators
+
+    @builtins.property
+    def timestamp_series_name(self) -> str:
+        """
+        The name of the column in the generated parquet file that contains the timestamp.
+        """
+        return self._timestamp_series_name
+
+    @builtins.property
+    def time_unit(self) -> "ingest_workflow_api_TimeUnitSeconds":
+        """
+        The unit of time for the timestamp column. Can only be seconds.
+        """
+        return self._time_unit
+
+
+ingest_workflow_api_IngestDataflashResponse.__name__ = "IngestDataflashResponse"
+ingest_workflow_api_IngestDataflashResponse.__qualname__ = "IngestDataflashResponse"
+ingest_workflow_api_IngestDataflashResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestMcapProtobufRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'locator': ConjureFieldDefinition('locator', ingest_workflow_api_ObjectLocator),
+            'channels': ConjureFieldDefinition('channels', ingest_workflow_api_McapProtoChannels)
+        }
+
+    __slots__: List[str] = ['_locator', '_channels']
+
+    def __init__(self, channels: "ingest_workflow_api_McapProtoChannels", locator: "ingest_workflow_api_ObjectLocator") -> None:
+        self._locator = locator
+        self._channels = channels
+
+    @builtins.property
+    def locator(self) -> "ingest_workflow_api_ObjectLocator":
+        return self._locator
+
+    @builtins.property
+    def channels(self) -> "ingest_workflow_api_McapProtoChannels":
+        return self._channels
+
+
+ingest_workflow_api_IngestMcapProtobufRequest.__name__ = "IngestMcapProtobufRequest"
+ingest_workflow_api_IngestMcapProtobufRequest.__qualname__ = "IngestMcapProtobufRequest"
+ingest_workflow_api_IngestMcapProtobufRequest.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_IngestMcapProtobufResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'timestamp_column_name': ConjureFieldDefinition('timestampColumnName', str),
+            'parquet_object_locators': ConjureFieldDefinition('parquetObjectLocators', List[ingest_workflow_api_ObjectLocator])
+        }
+
+    __slots__: List[str] = ['_timestamp_column_name', '_parquet_object_locators']
+
+    def __init__(self, parquet_object_locators: List["ingest_workflow_api_ObjectLocator"], timestamp_column_name: str) -> None:
+        self._timestamp_column_name = timestamp_column_name
+        self._parquet_object_locators = parquet_object_locators
+
+    @builtins.property
+    def timestamp_column_name(self) -> str:
+        return self._timestamp_column_name
+
+    @builtins.property
+    def parquet_object_locators(self) -> List["ingest_workflow_api_ObjectLocator"]:
+        """
+        Azure or S3-style blob locators of parquet files. Currently
+only a single file is supported, the list type is used for future compatibility.
+        """
+        return self._parquet_object_locators
+
+
+ingest_workflow_api_IngestMcapProtobufResponse.__name__ = "IngestMcapProtobufResponse"
+ingest_workflow_api_IngestMcapProtobufResponse.__qualname__ = "IngestMcapProtobufResponse"
+ingest_workflow_api_IngestMcapProtobufResponse.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_McapProtoChannels(ConjureUnionType):
+    _all: Optional["ingest_workflow_api_Empty"] = None
+    _include_topics: Optional[List[str]] = None
+    _exclude_topics: Optional[List[str]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'all': ConjureFieldDefinition('all', ingest_workflow_api_Empty),
+            'include_topics': ConjureFieldDefinition('includeTopics', List[ingest_workflow_api_McapTopicName]),
+            'exclude_topics': ConjureFieldDefinition('excludeTopics', List[ingest_workflow_api_McapTopicName])
+        }
+
+    def __init__(
+            self,
+            all: Optional["ingest_workflow_api_Empty"] = None,
+            include_topics: Optional[List[str]] = None,
+            exclude_topics: Optional[List[str]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (all is not None) + (include_topics is not None) + (exclude_topics is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if all is not None:
+                self._all = all
+                self._type = 'all'
+            if include_topics is not None:
+                self._include_topics = include_topics
+                self._type = 'includeTopics'
+            if exclude_topics is not None:
+                self._exclude_topics = exclude_topics
+                self._type = 'excludeTopics'
+
+        elif type_of_union == 'all':
+            if all is None:
+                raise ValueError('a union value must not be None')
+            self._all = all
+            self._type = 'all'
+        elif type_of_union == 'includeTopics':
+            if include_topics is None:
+                raise ValueError('a union value must not be None')
+            self._include_topics = include_topics
+            self._type = 'includeTopics'
+        elif type_of_union == 'excludeTopics':
+            if exclude_topics is None:
+                raise ValueError('a union value must not be None')
+            self._exclude_topics = exclude_topics
+            self._type = 'excludeTopics'
+
+    @builtins.property
+    def all(self) -> Optional["ingest_workflow_api_Empty"]:
+        return self._all
+
+    @builtins.property
+    def include_topics(self) -> Optional[List[str]]:
+        return self._include_topics
+
+    @builtins.property
+    def exclude_topics(self) -> Optional[List[str]]:
+        return self._exclude_topics
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, ingest_workflow_api_McapProtoChannelsVisitor):
+            raise ValueError('{} is not an instance of ingest_workflow_api_McapProtoChannelsVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'all' and self.all is not None:
+            return visitor._all(self.all)
+        if self._type == 'includeTopics' and self.include_topics is not None:
+            return visitor._include_topics(self.include_topics)
+        if self._type == 'excludeTopics' and self.exclude_topics is not None:
+            return visitor._exclude_topics(self.exclude_topics)
+
+
+ingest_workflow_api_McapProtoChannels.__name__ = "McapProtoChannels"
+ingest_workflow_api_McapProtoChannels.__qualname__ = "McapProtoChannels"
+ingest_workflow_api_McapProtoChannels.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_McapProtoChannelsVisitor:
+
+    @abstractmethod
+    def _all(self, all: "ingest_workflow_api_Empty") -> Any:
+        pass
+
+    @abstractmethod
+    def _include_topics(self, include_topics: List[str]) -> Any:
+        pass
+
+    @abstractmethod
+    def _exclude_topics(self, exclude_topics: List[str]) -> Any:
+        pass
+
+
+ingest_workflow_api_McapProtoChannelsVisitor.__name__ = "McapProtoChannelsVisitor"
+ingest_workflow_api_McapProtoChannelsVisitor.__qualname__ = "McapProtoChannelsVisitor"
+ingest_workflow_api_McapProtoChannelsVisitor.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_ObjectLocator(ConjureBeanType):
+    """
+    Locator for files in an object store. 
+Clients are expected to have auth and origin/region configured independently.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'bucket': ConjureFieldDefinition('bucket', str),
+            'object_name': ConjureFieldDefinition('objectName', str)
+        }
+
+    __slots__: List[str] = ['_bucket', '_object_name']
+
+    def __init__(self, bucket: str, object_name: str) -> None:
+        self._bucket = bucket
+        self._object_name = object_name
+
+    @builtins.property
+    def bucket(self) -> str:
+        return self._bucket
+
+    @builtins.property
+    def object_name(self) -> str:
+        return self._object_name
+
+
+ingest_workflow_api_ObjectLocator.__name__ = "ObjectLocator"
+ingest_workflow_api_ObjectLocator.__qualname__ = "ObjectLocator"
+ingest_workflow_api_ObjectLocator.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class ingest_workflow_api_TimeUnitSeconds(ConjureEnumType):
+
+    SECONDS = 'SECONDS'
+    '''SECONDS'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+ingest_workflow_api_TimeUnitSeconds.__name__ = "TimeUnitSeconds"
+ingest_workflow_api_TimeUnitSeconds.__qualname__ = "TimeUnitSeconds"
+ingest_workflow_api_TimeUnitSeconds.__module__ = "nominal_api.ingest_workflow_api"
+
+
+class persistent_compute_api_AppendResult(ConjureBeanType):
+    """
+    An append result won't cover the full `StreamingComputeNodeRequest#windowWidth` but rather just a smaller 
+window. The end of the window that the append covers is guaranteed to be later than previously sent results.
+The start, however, can and most likely will overlap with previous results. That allows us to support 
+out-of-order points. The client will have to merge this new `AppendResult` with previous results.
+Example of time windows that might be covered by results for a subscription: 
+We send a full result for window [0s, 120s] followed by an append result for [116s, 121s] and another 
+append result for [117s, 122s].
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'subscription_id': ConjureFieldDefinition('subscriptionId', persistent_compute_api_SubscriptionId),
+            'start': ConjureFieldDefinition('start', api_Timestamp),
+            'end': ConjureFieldDefinition('end', api_Timestamp),
+            'result': ConjureFieldDefinition('result', persistent_compute_api_ComputeNodeAppendResponse)
+        }
+
+    __slots__: List[str] = ['_subscription_id', '_start', '_end', '_result']
+
+    def __init__(self, end: "api_Timestamp", result: "persistent_compute_api_ComputeNodeAppendResponse", start: "api_Timestamp", subscription_id: str) -> None:
+        self._subscription_id = subscription_id
+        self._start = start
+        self._end = end
+        self._result = result
+
+    @builtins.property
+    def subscription_id(self) -> str:
+        return self._subscription_id
+
+    @builtins.property
+    def start(self) -> "api_Timestamp":
+        """
+        The start of the time range that the append result covers
+        """
+        return self._start
+
+    @builtins.property
+    def end(self) -> "api_Timestamp":
+        """
+        The end of the time range that the append result covers
+        """
+        return self._end
+
+    @builtins.property
+    def result(self) -> "persistent_compute_api_ComputeNodeAppendResponse":
+        return self._result
+
+
+persistent_compute_api_AppendResult.__name__ = "AppendResult"
+persistent_compute_api_AppendResult.__qualname__ = "AppendResult"
+persistent_compute_api_AppendResult.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_ClientMessage(ConjureUnionType):
     _subscribe: Optional[Dict[str, "persistent_compute_api_StreamingComputeNodeSubscription"]] = None
     _unsubscribe: Optional[List[str]] = None
@@ -11361,6 +11920,217 @@ persistent_compute_api_ClientMessageVisitor.__qualname__ = "ClientMessageVisitor
 persistent_compute_api_ClientMessageVisitor.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_ComputeNodeAppendResponse(ConjureUnionType):
+    """These cover the subset of the union type in `ComputeWithUnitsResponse` for which we support append result.
+Append results will have the same subtype as the previous full result for the same `SubscriptionId`. 
+If the subtype were to change (e.g., we start doing bucketing because data frequency increased) we will send 
+a new full result with that new type. The results will also have the same units as the previous `FullResult`.
+Notably, we currently don't support appends for bucketed results as merging buckets is not trivial, especially 
+when accounting for out-of-order points."""
+    _range: Optional[List["scout_compute_api_Range"]] = None
+    _enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None
+    _numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None
+    _log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None
+    _range_value: Optional[Optional["scout_compute_api_Range"]] = None
+    _numeric: Optional["scout_compute_api_NumericPlot"] = None
+    _enum: Optional["scout_compute_api_EnumPlot"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'range': ConjureFieldDefinition('range', List[scout_compute_api_Range]),
+            'enum_point': ConjureFieldDefinition('enumPoint', OptionalTypeWrapper[scout_compute_api_EnumPoint]),
+            'numeric_point': ConjureFieldDefinition('numericPoint', OptionalTypeWrapper[scout_compute_api_NumericPoint]),
+            'log_point': ConjureFieldDefinition('logPoint', OptionalTypeWrapper[scout_compute_api_LogPoint]),
+            'range_value': ConjureFieldDefinition('rangeValue', OptionalTypeWrapper[scout_compute_api_Range]),
+            'numeric': ConjureFieldDefinition('numeric', scout_compute_api_NumericPlot),
+            'enum': ConjureFieldDefinition('enum', scout_compute_api_EnumPlot)
+        }
+
+    def __init__(
+            self,
+            range: Optional[List["scout_compute_api_Range"]] = None,
+            enum_point: Optional[Optional["scout_compute_api_EnumPoint"]] = None,
+            numeric_point: Optional[Optional["scout_compute_api_NumericPoint"]] = None,
+            log_point: Optional[Optional["scout_compute_api_LogPoint"]] = None,
+            range_value: Optional[Optional["scout_compute_api_Range"]] = None,
+            numeric: Optional["scout_compute_api_NumericPlot"] = None,
+            enum: Optional["scout_compute_api_EnumPlot"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (range is not None) + (enum_point is not None) + (numeric_point is not None) + (log_point is not None) + (range_value is not None) + (numeric is not None) + (enum is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if range is not None:
+                self._range = range
+                self._type = 'range'
+            if enum_point is not None:
+                self._enum_point = enum_point
+                self._type = 'enumPoint'
+            if numeric_point is not None:
+                self._numeric_point = numeric_point
+                self._type = 'numericPoint'
+            if log_point is not None:
+                self._log_point = log_point
+                self._type = 'logPoint'
+            if range_value is not None:
+                self._range_value = range_value
+                self._type = 'rangeValue'
+            if numeric is not None:
+                self._numeric = numeric
+                self._type = 'numeric'
+            if enum is not None:
+                self._enum = enum
+                self._type = 'enum'
+
+        elif type_of_union == 'range':
+            if range is None:
+                raise ValueError('a union value must not be None')
+            self._range = range
+            self._type = 'range'
+        elif type_of_union == 'enumPoint':
+            if enum_point is None:
+                raise ValueError('a union value must not be None')
+            self._enum_point = enum_point
+            self._type = 'enumPoint'
+        elif type_of_union == 'numericPoint':
+            if numeric_point is None:
+                raise ValueError('a union value must not be None')
+            self._numeric_point = numeric_point
+            self._type = 'numericPoint'
+        elif type_of_union == 'logPoint':
+            if log_point is None:
+                raise ValueError('a union value must not be None')
+            self._log_point = log_point
+            self._type = 'logPoint'
+        elif type_of_union == 'rangeValue':
+            if range_value is None:
+                raise ValueError('a union value must not be None')
+            self._range_value = range_value
+            self._type = 'rangeValue'
+        elif type_of_union == 'numeric':
+            if numeric is None:
+                raise ValueError('a union value must not be None')
+            self._numeric = numeric
+            self._type = 'numeric'
+        elif type_of_union == 'enum':
+            if enum is None:
+                raise ValueError('a union value must not be None')
+            self._enum = enum
+            self._type = 'enum'
+
+    @builtins.property
+    def range(self) -> Optional[List["scout_compute_api_Range"]]:
+        """
+        Merging can be done via dropping any old ranges (possibly truncating the last one) and adding these new 
+ranges, possibly merging them if they overlap or are adjacent.
+        """
+        return self._range
+
+    @builtins.property
+    def enum_point(self) -> Optional[Optional["scout_compute_api_EnumPoint"]]:
+        """
+        Merging can be done by keeping track of the applicable point present within the current window
+        """
+        return self._enum_point
+
+    @builtins.property
+    def numeric_point(self) -> Optional[Optional["scout_compute_api_NumericPoint"]]:
+        """
+        Merging can be done by keeping track of the applicable point present within the current window
+        """
+        return self._numeric_point
+
+    @builtins.property
+    def log_point(self) -> Optional[Optional["scout_compute_api_LogPoint"]]:
+        """
+        Merging can be done by keeping track of the applicable point present within the current window
+        """
+        return self._log_point
+
+    @builtins.property
+    def range_value(self) -> Optional[Optional["scout_compute_api_Range"]]:
+        """
+        Merging can be done by keeping track of the applicable range present within the current window, possibly
+merging ranges if they are overlap or are adjacent
+        """
+        return self._range_value
+
+    @builtins.property
+    def numeric(self) -> Optional["scout_compute_api_NumericPlot"]:
+        """
+        Merging be be done by dropping any old points and adding the new ones, accounting for overlaps
+        """
+        return self._numeric
+
+    @builtins.property
+    def enum(self) -> Optional["scout_compute_api_EnumPlot"]:
+        """
+        Merging be be done by dropping any old points and adding the new ones, accounting for overlaps
+        """
+        return self._enum
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, persistent_compute_api_ComputeNodeAppendResponseVisitor):
+            raise ValueError('{} is not an instance of persistent_compute_api_ComputeNodeAppendResponseVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'range' and self.range is not None:
+            return visitor._range(self.range)
+        if self._type == 'enumPoint' and self.enum_point is not None:
+            return visitor._enum_point(self.enum_point)
+        if self._type == 'numericPoint' and self.numeric_point is not None:
+            return visitor._numeric_point(self.numeric_point)
+        if self._type == 'logPoint' and self.log_point is not None:
+            return visitor._log_point(self.log_point)
+        if self._type == 'rangeValue' and self.range_value is not None:
+            return visitor._range_value(self.range_value)
+        if self._type == 'numeric' and self.numeric is not None:
+            return visitor._numeric(self.numeric)
+        if self._type == 'enum' and self.enum is not None:
+            return visitor._enum(self.enum)
+
+
+persistent_compute_api_ComputeNodeAppendResponse.__name__ = "ComputeNodeAppendResponse"
+persistent_compute_api_ComputeNodeAppendResponse.__qualname__ = "ComputeNodeAppendResponse"
+persistent_compute_api_ComputeNodeAppendResponse.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_ComputeNodeAppendResponseVisitor:
+
+    @abstractmethod
+    def _range(self, range: List["scout_compute_api_Range"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _enum_point(self, enum_point: Optional["scout_compute_api_EnumPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _numeric_point(self, numeric_point: Optional["scout_compute_api_NumericPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _log_point(self, log_point: Optional["scout_compute_api_LogPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _range_value(self, range_value: Optional["scout_compute_api_Range"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _numeric(self, numeric: "scout_compute_api_NumericPlot") -> Any:
+        pass
+
+    @abstractmethod
+    def _enum(self, enum: "scout_compute_api_EnumPlot") -> Any:
+        pass
+
+
+persistent_compute_api_ComputeNodeAppendResponseVisitor.__name__ = "ComputeNodeAppendResponseVisitor"
+persistent_compute_api_ComputeNodeAppendResponseVisitor.__qualname__ = "ComputeNodeAppendResponseVisitor"
+persistent_compute_api_ComputeNodeAppendResponseVisitor.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_FullResult(ConjureBeanType):
 
     @builtins.classmethod
@@ -11677,13 +12447,15 @@ class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'min_delay': ConjureFieldDefinition('minDelay', persistent_compute_api_Milliseconds)
+            'min_delay': ConjureFieldDefinition('minDelay', persistent_compute_api_Milliseconds),
+            'allow_appends': ConjureFieldDefinition('allowAppends', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_min_delay']
+    __slots__: List[str] = ['_min_delay', '_allow_appends']
 
-    def __init__(self, min_delay: int) -> None:
+    def __init__(self, min_delay: int, allow_appends: Optional[bool] = None) -> None:
         self._min_delay = min_delay
+        self._allow_appends = allow_appends
 
     @builtins.property
     def min_delay(self) -> int:
@@ -11692,6 +12464,19 @@ class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
         """
         return self._min_delay
 
+    @builtins.property
+    def allow_appends(self) -> Optional[bool]:
+        """
+        Can be set to `false` by the client to indicate that it doesn't support appends for this subscription
+and always wants to receive full results. Defaults to `false` if not set.
+The expectation is that clients should implement support for appends for any of the results covered in
+`ComputeNodeAppendResponse` and set this to `true` as quickly as possible. However, in order to support 
+adding new sub-types to `ComputeNodeAppendResponse` without breaking clients that haven't upgraded yet 
+and haven't yet added support for them, we default this to `false` and make clients opt-in as soon as they
+implement support.
+        """
+        return self._allow_appends
+
 
 persistent_compute_api_SubscriptionOptions.__name__ = "SubscriptionOptions"
 persistent_compute_api_SubscriptionOptions.__qualname__ = "SubscriptionOptions"
@@ -11700,41 +12485,58 @@ persistent_compute_api_SubscriptionOptions.__module__ = "nominal_api.persistent_
 
 class persistent_compute_api_SubscriptionUpdate(ConjureUnionType):
     _full: Optional["persistent_compute_api_FullResult"] = None
+    _append: Optional["persistent_compute_api_AppendResult"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'full': ConjureFieldDefinition('full', persistent_compute_api_FullResult)
+            'full': ConjureFieldDefinition('full', persistent_compute_api_FullResult),
+            'append': ConjureFieldDefinition('append', persistent_compute_api_AppendResult)
         }
 
     def __init__(
             self,
             full: Optional["persistent_compute_api_FullResult"] = None,
+            append: Optional["persistent_compute_api_AppendResult"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (full is not None) != 1:
+            if (full is not None) + (append is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if full is not None:
                 self._full = full
                 self._type = 'full'
+            if append is not None:
+                self._append = append
+                self._type = 'append'
 
         elif type_of_union == 'full':
             if full is None:
                 raise ValueError('a union value must not be None')
             self._full = full
             self._type = 'full'
+        elif type_of_union == 'append':
+            if append is None:
+                raise ValueError('a union value must not be None')
+            self._append = append
+            self._type = 'append'
 
     @builtins.property
     def full(self) -> Optional["persistent_compute_api_FullResult"]:
         return self._full
 
+    @builtins.property
+    def append(self) -> Optional["persistent_compute_api_AppendResult"]:
+        return self._append
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, persistent_compute_api_SubscriptionUpdateVisitor):
             raise ValueError('{} is not an instance of persistent_compute_api_SubscriptionUpdateVisitor'.format(visitor.__class__.__name__))
         if self._type == 'full' and self.full is not None:
             return visitor._full(self.full)
+        if self._type == 'append' and self.append is not None:
+            return visitor._append(self.append)
 
 
 persistent_compute_api_SubscriptionUpdate.__name__ = "SubscriptionUpdate"
@@ -11748,6 +12550,10 @@ class persistent_compute_api_SubscriptionUpdateVisitor:
     def _full(self, full: "persistent_compute_api_FullResult") -> Any:
         pass
 
+    @abstractmethod
+    def _append(self, append: "persistent_compute_api_AppendResult") -> Any:
+        pass
+
 
 persistent_compute_api_SubscriptionUpdateVisitor.__name__ = "SubscriptionUpdateVisitor"
 persistent_compute_api_SubscriptionUpdateVisitor.__qualname__ = "SubscriptionUpdateVisitor"
@@ -76237,6 +77043,8 @@ upload_api_UploadService.__qualname__ = "UploadService"
 upload_api_UploadService.__module__ = "nominal_api.upload_api"
 
 
+api_ColumnName = str
+
 api_Label = str
 
 timeseries_archetype_api_SeriesArchetypeName = str
@@ -76267,6 +77075,8 @@ api_rids_VideoFileRid = str
 
 api_Unit = str
 
+ingest_workflow_api_McapTopicName = str
+
 scout_versioning_api_BranchRid = str
 
 datasource_DatasetFileId = str
@@ -76433,8 +77243,6 @@ scout_datareview_api_AutomaticCheckEvaluationRid = str
 
 scout_compute_api_ErrorType = str
 
-ingest_api_ExtractorInputName = str
-
 comments_api_ResourceRid = str
 
 scout_rids_api_FunctionLineageRid = str

nominal_api/api/__init__.py

@@ -2,6 +2,7 @@
 from .._impl import (
     api_ArchivedStatus as ArchivedStatus,
     api_Channel as Channel,
+    api_ColumnName as ColumnName,
     api_Empty as Empty,
     api_ErrorResult as ErrorResult,
     api_ErrorType as ErrorType,

nominal_api/ingest_api/__init__.py

@@ -29,7 +29,6 @@ from .._impl import (
     ingest_api_EpochTimestamp as EpochTimestamp,
     ingest_api_ExistingDatasetIngestDestination as ExistingDatasetIngestDestination,
     ingest_api_ExistingVideoIngestDestination as ExistingVideoIngestDestination,
-    ingest_api_ExtractorInputName as ExtractorInputName,
     ingest_api_FileExtractionInput as FileExtractionInput,
     ingest_api_GcsIngestSource as GcsIngestSource,
     ingest_api_GetContainerizedExtractorsRequest as GetContainerizedExtractorsRequest,

nominal_api/ingest_workflow_api/__init__.py

@@ -0,0 +1,21 @@
+# coding=utf-8
+from .._impl import (
+    ingest_workflow_api_Empty as Empty,
+    ingest_workflow_api_EnsureExtractorJobCreatedRequest as EnsureExtractorJobCreatedRequest,
+    ingest_workflow_api_EnsureExtractorJobCreatedResponse as EnsureExtractorJobCreatedResponse,
+    ingest_workflow_api_EnsureWorkspaceNamespaceCreatedRequest as EnsureWorkspaceNamespaceCreatedRequest,
+    ingest_workflow_api_EnsureWorkspaceServiceAccountCreatedRequest as EnsureWorkspaceServiceAccountCreatedRequest,
+    ingest_workflow_api_ExtractorJobState as ExtractorJobState,
+    ingest_workflow_api_GetExtractorJobStateRequest as GetExtractorJobStateRequest,
+    ingest_workflow_api_GetExtractorJobStateResponse as GetExtractorJobStateResponse,
+    ingest_workflow_api_IngestDataflashRequest as IngestDataflashRequest,
+    ingest_workflow_api_IngestDataflashResponse as IngestDataflashResponse,
+    ingest_workflow_api_IngestMcapProtobufRequest as IngestMcapProtobufRequest,
+    ingest_workflow_api_IngestMcapProtobufResponse as IngestMcapProtobufResponse,
+    ingest_workflow_api_McapProtoChannels as McapProtoChannels,
+    ingest_workflow_api_McapProtoChannelsVisitor as McapProtoChannelsVisitor,
+    ingest_workflow_api_McapTopicName as McapTopicName,
+    ingest_workflow_api_ObjectLocator as ObjectLocator,
+    ingest_workflow_api_TimeUnitSeconds as TimeUnitSeconds,
+)
+

nominal_api/persistent_compute_api/__init__.py

@@ -1,7 +1,10 @@
 # coding=utf-8
 from .._impl import (
+    persistent_compute_api_AppendResult as AppendResult,
     persistent_compute_api_ClientMessage as ClientMessage,
     persistent_compute_api_ClientMessageVisitor as ClientMessageVisitor,
+    persistent_compute_api_ComputeNodeAppendResponse as ComputeNodeAppendResponse,
+    persistent_compute_api_ComputeNodeAppendResponseVisitor as ComputeNodeAppendResponseVisitor,
     persistent_compute_api_FullResult as FullResult,
     persistent_compute_api_Milliseconds as Milliseconds,
     persistent_compute_api_Ping as Ping,

{nominal_api-0.621.0.dist-info → nominal_api-0.622.0.dist-info}/METADATA

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

{nominal_api-0.621.0.dist-info → nominal_api-0.622.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-nominal_api/__init__.py,sha256=bNSfoZZt3sMHaZ8x218pvZhUM01KSi1oOOgpS2xXfgE,1968
-nominal_api/_impl.py,sha256=rowkQT01DPB4jQTKsythRZsRWhV9FFWrF5OC0VCiJs8,2959590
+nominal_api/__init__.py,sha256=btAy6zqyIIHpHeaorCYcaJgTDMvINRMVcUZculTl8Pk,1995
+nominal_api/_impl.py,sha256=9FkFuSqGbDLVdd22akS3dFrbi6cubdwoNLO_ogpZeDo,2992871
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
-nominal_api/api/__init__.py,sha256=kJBEE_HLVpKYdLH12KyO-cSAVzwxYpBwaaDutCtT-LM,1236
+nominal_api/api/__init__.py,sha256=f6fvZACzXUPSIN-H855AjAYLwmisy_VrHy4Ie2HXiNE,1270
 nominal_api/api_ids/__init__.py,sha256=CAtt44XgNZEEUDv-BbEbYtuxQ8y1wqSZU-STjBYdZv8,80
 nominal_api/api_rids/__init__.py,sha256=qerno2fgGWLfokoSdCarKSXg2jDjTJpz45Wv8PnqI6Q,500
 nominal_api/attachments_api/__init__.py,sha256=eQBE8xVTFDaTItCZv-WJSZqSStpgdai192n23pmVeeQ,634
@@ -15,8 +15,9 @@ 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=UhryPXVmWzGACR4WrPQaEqAbOdM6XCn0zvyiGNZ6z0w,7010
-nominal_api/persistent_compute_api/__init__.py,sha256=5qZTTfN4X9u_qunFnWbLrPpG_FO5h7YBX68-_F6gYyQ,1031
+nominal_api/ingest_api/__init__.py,sha256=jpxmJO0dzcCEIv5iM7xvziQEs1x92XLTm-LmbHxtii4,6953
+nominal_api/ingest_workflow_api/__init__.py,sha256=1oJO78YCmXFkfN5LY7x0gOJwtijrOcXD8Sl0GJCOyrk,1352
+nominal_api/persistent_compute_api/__init__.py,sha256=ovp4TsiVPGgCFjHVo4L9s0xSr0t7lV6GRSn6-8m3wBE,1268
 nominal_api/scout/__init__.py,sha256=ip3XK_9jJKAoFiCifUVMTpDMiUE4mWIdGzMDu7LASus,324
 nominal_api/scout_api/__init__.py,sha256=biO4DEygbGcLwM6Dg2VuvMra3A5EW6NBjukbIemXoG8,178
 nominal_api/scout_asset_api/__init__.py,sha256=Ph-KlW-ki0JRejYQZDvbZ2jRzNAttVBux27lcEj7--Q,1910
@@ -72,7 +73,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.621.0.dist-info/METADATA,sha256=MSO5MT5ZLdf6xzcYaibi4VQC79w_2MI7vzlit-tThsw,199
-nominal_api-0.621.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nominal_api-0.621.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.621.0.dist-info/RECORD,,
+nominal_api-0.622.0.dist-info/METADATA,sha256=K6Is4RUEqV8CitFExGLpoKX2MBAQDpjobJpEYwAOoa4,199
+nominal_api-0.622.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nominal_api-0.622.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.622.0.dist-info/RECORD,,