nominal-api 0.565.1__tar.gz → 0.566.0__tar.gz

{nominal_api-0.565.1 → nominal_api-0.566.0}/PKG-INFO

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

{nominal_api-0.565.1 → nominal_api-0.566.0}/nominal_api/__init__.py

@@ -69,5 +69,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.565.1"
+__version__ = "0.566.0"
 

{nominal_api-0.565.1 → nominal_api-0.566.0}/nominal_api/_impl.py

@@ -7003,6 +7003,41 @@ ingest_api_ExistingDatasetIngestDestination.__qualname__ = "ExistingDatasetInges
 ingest_api_ExistingDatasetIngestDestination.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_ExistingVideoIngestDestination(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
+            'video_file_details': ConjureFieldDefinition('videoFileDetails', ingest_api_VideoFileIngestDetails)
+        }
+
+    __slots__: List[str] = ['_video_rid', '_video_file_details']
+
+    def __init__(self, video_file_details: "ingest_api_VideoFileIngestDetails", video_rid: str) -> None:
+        self._video_rid = video_rid
+        self._video_file_details = video_file_details
+
+    @builtins.property
+    def video_rid(self) -> str:
+        """
+        RID of the video to ingest the newly created video file to.
+        """
+        return self._video_rid
+
+    @builtins.property
+    def video_file_details(self) -> "ingest_api_VideoFileIngestDetails":
+        """
+        Metadata to associate with any created video file
+        """
+        return self._video_file_details
+
+
+ingest_api_ExistingVideoIngestDestination.__name__ = "ExistingVideoIngestDestination"
+ingest_api_ExistingVideoIngestDestination.__qualname__ = "ExistingVideoIngestDestination"
+ingest_api_ExistingVideoIngestDestination.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_GcsIngestSource(ConjureBeanType):
 
     @builtins.classmethod
@@ -7232,41 +7267,58 @@ ingest_api_IngestDestinationVisitor.__module__ = "nominal_api.ingest_api"
 
 class ingest_api_IngestDetails(ConjureUnionType):
     _dataset: Optional["ingest_api_IngestDatasetFileDetails"] = None
+    _video: Optional["ingest_api_IngestVideoFileDetails"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'dataset': ConjureFieldDefinition('dataset', ingest_api_IngestDatasetFileDetails)
+            'dataset': ConjureFieldDefinition('dataset', ingest_api_IngestDatasetFileDetails),
+            'video': ConjureFieldDefinition('video', ingest_api_IngestVideoFileDetails)
         }
 
     def __init__(
             self,
             dataset: Optional["ingest_api_IngestDatasetFileDetails"] = None,
+            video: Optional["ingest_api_IngestVideoFileDetails"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (dataset is not None) != 1:
+            if (dataset is not None) + (video is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if dataset is not None:
                 self._dataset = dataset
                 self._type = 'dataset'
+            if video is not None:
+                self._video = video
+                self._type = 'video'
 
         elif type_of_union == 'dataset':
             if dataset is None:
                 raise ValueError('a union value must not be None')
             self._dataset = dataset
             self._type = 'dataset'
+        elif type_of_union == 'video':
+            if video is None:
+                raise ValueError('a union value must not be None')
+            self._video = video
+            self._type = 'video'
 
     @builtins.property
     def dataset(self) -> Optional["ingest_api_IngestDatasetFileDetails"]:
         return self._dataset
 
+    @builtins.property
+    def video(self) -> Optional["ingest_api_IngestVideoFileDetails"]:
+        return self._video
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, ingest_api_IngestDetailsVisitor):
             raise ValueError('{} is not an instance of ingest_api_IngestDetailsVisitor'.format(visitor.__class__.__name__))
         if self._type == 'dataset' and self.dataset is not None:
             return visitor._dataset(self.dataset)
+        if self._type == 'video' and self.video is not None:
+            return visitor._video(self.video)
 
 
 ingest_api_IngestDetails.__name__ = "IngestDetails"
@@ -7280,6 +7332,10 @@ class ingest_api_IngestDetailsVisitor:
     def _dataset(self, dataset: "ingest_api_IngestDatasetFileDetails") -> Any:
         pass
 
+    @abstractmethod
+    def _video(self, video: "ingest_api_IngestVideoFileDetails") -> Any:
+        pass
+
 
 ingest_api_IngestDetailsVisitor.__name__ = "IngestDetailsVisitor"
 ingest_api_IngestDetailsVisitor.__qualname__ = "IngestDetailsVisitor"
@@ -7362,18 +7418,24 @@ class ingest_api_IngestMcapResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'outputs': ConjureFieldDefinition('outputs', List[ingest_api_McapIngestionOutput])
+            'outputs': ConjureFieldDefinition('outputs', List[ingest_api_McapIngestionOutput]),
+            'async_handle': ConjureFieldDefinition('asyncHandle', OptionalTypeWrapper[ingest_api_AsyncHandle])
         }
 
-    __slots__: List[str] = ['_outputs']
+    __slots__: List[str] = ['_outputs', '_async_handle']
 
-    def __init__(self, outputs: List["ingest_api_McapIngestionOutput"]) -> None:
+    def __init__(self, outputs: List["ingest_api_McapIngestionOutput"], async_handle: Optional["ingest_api_AsyncHandle"] = None) -> None:
         self._outputs = outputs
+        self._async_handle = async_handle
 
     @builtins.property
     def outputs(self) -> List["ingest_api_McapIngestionOutput"]:
         return self._outputs
 
+    @builtins.property
+    def async_handle(self) -> Optional["ingest_api_AsyncHandle"]:
+        return self._async_handle
+
 
 ingest_api_IngestMcapResponse.__name__ = "IngestMcapResponse"
 ingest_api_IngestMcapResponse.__qualname__ = "IngestMcapResponse"
@@ -7385,6 +7447,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
+    _video: Optional["ingest_api_VideoOpts"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -7392,7 +7455,8 @@ class ingest_api_IngestOptions(ConjureUnionType):
             'dataflash': ConjureFieldDefinition('dataflash', ingest_api_DataflashOpts),
             'mcap_protobuf_timeseries': ConjureFieldDefinition('mcapProtobufTimeseries', ingest_api_McapProtobufTimeseriesOpts),
             'journal_json': ConjureFieldDefinition('journalJson', ingest_api_JournalJsonOpts),
-            'csv': ConjureFieldDefinition('csv', ingest_api_CsvOpts)
+            'csv': ConjureFieldDefinition('csv', ingest_api_CsvOpts),
+            'video': ConjureFieldDefinition('video', ingest_api_VideoOpts)
         }
 
     def __init__(
@@ -7401,10 +7465,11 @@ 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,
+            video: Optional["ingest_api_VideoOpts"] = 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) != 1:
+            if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (video is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if dataflash is not None:
@@ -7419,6 +7484,9 @@ class ingest_api_IngestOptions(ConjureUnionType):
             if csv is not None:
                 self._csv = csv
                 self._type = 'csv'
+            if video is not None:
+                self._video = video
+                self._type = 'video'
 
         elif type_of_union == 'dataflash':
             if dataflash is None:
@@ -7440,6 +7508,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 == 'video':
+            if video is None:
+                raise ValueError('a union value must not be None')
+            self._video = video
+            self._type = 'video'
 
     @builtins.property
     def dataflash(self) -> Optional["ingest_api_DataflashOpts"]:
@@ -7457,6 +7530,10 @@ class ingest_api_IngestOptions(ConjureUnionType):
     def csv(self) -> Optional["ingest_api_CsvOpts"]:
         return self._csv
 
+    @builtins.property
+    def video(self) -> Optional["ingest_api_VideoOpts"]:
+        return self._video
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, ingest_api_IngestOptionsVisitor):
             raise ValueError('{} is not an instance of ingest_api_IngestOptionsVisitor'.format(visitor.__class__.__name__))
@@ -7468,6 +7545,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 == 'video' and self.video is not None:
+            return visitor._video(self.video)
 
 
 ingest_api_IngestOptions.__name__ = "IngestOptions"
@@ -7493,6 +7572,10 @@ class ingest_api_IngestOptionsVisitor:
     def _csv(self, csv: "ingest_api_CsvOpts") -> Any:
         pass
 
+    @abstractmethod
+    def _video(self, video: "ingest_api_VideoOpts") -> Any:
+        pass
+
 
 ingest_api_IngestOptionsVisitor.__name__ = "IngestOptionsVisitor"
 ingest_api_IngestOptionsVisitor.__qualname__ = "IngestOptionsVisitor"
@@ -8084,60 +8167,33 @@ ingest_api_IngestStatus.__qualname__ = "IngestStatus"
 ingest_api_IngestStatus.__module__ = "nominal_api.ingest_api"
 
 
-class ingest_api_IngestVideoDestination(ConjureUnionType):
-    _new_video: Optional["ingest_api_NewVideoIngestDestination"] = None
+class ingest_api_IngestVideoFileDetails(ConjureBeanType):
 
     @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'new_video': ConjureFieldDefinition('newVideo', ingest_api_NewVideoIngestDestination)
+            'video_file_rid': ConjureFieldDefinition('videoFileRid', api_rids_VideoFileRid),
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid)
         }
 
-    def __init__(
-            self,
-            new_video: Optional["ingest_api_NewVideoIngestDestination"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (new_video is not None) != 1:
-                raise ValueError('a union must contain a single member')
+    __slots__: List[str] = ['_video_file_rid', '_video_rid']
 
-            if new_video is not None:
-                self._new_video = new_video
-                self._type = 'newVideo'
-
-        elif type_of_union == 'newVideo':
-            if new_video is None:
-                raise ValueError('a union value must not be None')
-            self._new_video = new_video
-            self._type = 'newVideo'
+    def __init__(self, video_file_rid: str, video_rid: str) -> None:
+        self._video_file_rid = video_file_rid
+        self._video_rid = video_rid
 
     @builtins.property
-    def new_video(self) -> Optional["ingest_api_NewVideoIngestDestination"]:
-        return self._new_video
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, ingest_api_IngestVideoDestinationVisitor):
-            raise ValueError('{} is not an instance of ingest_api_IngestVideoDestinationVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'newVideo' and self.new_video is not None:
-            return visitor._new_video(self.new_video)
-
+    def video_file_rid(self) -> str:
+        return self._video_file_rid
 
-ingest_api_IngestVideoDestination.__name__ = "IngestVideoDestination"
-ingest_api_IngestVideoDestination.__qualname__ = "IngestVideoDestination"
-ingest_api_IngestVideoDestination.__module__ = "nominal_api.ingest_api"
-
-
-class ingest_api_IngestVideoDestinationVisitor:
-
-    @abstractmethod
-    def _new_video(self, new_video: "ingest_api_NewVideoIngestDestination") -> Any:
-        pass
+    @builtins.property
+    def video_rid(self) -> str:
+        return self._video_rid
 
 
-ingest_api_IngestVideoDestinationVisitor.__name__ = "IngestVideoDestinationVisitor"
-ingest_api_IngestVideoDestinationVisitor.__qualname__ = "IngestVideoDestinationVisitor"
-ingest_api_IngestVideoDestinationVisitor.__module__ = "nominal_api.ingest_api"
+ingest_api_IngestVideoFileDetails.__name__ = "IngestVideoFileDetails"
+ingest_api_IngestVideoFileDetails.__qualname__ = "IngestVideoFileDetails"
+ingest_api_IngestVideoFileDetails.__module__ = "nominal_api.ingest_api"
 
 
 class ingest_api_IngestVideoRequest(ConjureBeanType):
@@ -8198,18 +8254,30 @@ class ingest_api_IngestVideoResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid)
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
+            'video_file_rid': ConjureFieldDefinition('videoFileRid', api_rids_VideoFileRid),
+            'async_handle': ConjureFieldDefinition('asyncHandle', OptionalTypeWrapper[ingest_api_AsyncHandle])
         }
 
-    __slots__: List[str] = ['_video_rid']
+    __slots__: List[str] = ['_video_rid', '_video_file_rid', '_async_handle']
 
-    def __init__(self, video_rid: str) -> None:
+    def __init__(self, video_file_rid: str, video_rid: str, async_handle: Optional["ingest_api_AsyncHandle"] = None) -> None:
         self._video_rid = video_rid
+        self._video_file_rid = video_file_rid
+        self._async_handle = async_handle
 
     @builtins.property
     def video_rid(self) -> str:
         return self._video_rid
 
+    @builtins.property
+    def video_file_rid(self) -> str:
+        return self._video_file_rid
+
+    @builtins.property
+    def async_handle(self) -> Optional["ingest_api_AsyncHandle"]:
+        return self._async_handle
+
 
 ingest_api_IngestVideoResponse.__name__ = "IngestVideoResponse"
 ingest_api_IngestVideoResponse.__qualname__ = "IngestVideoResponse"
@@ -8630,14 +8698,16 @@ class ingest_api_McapIngestionOutput(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'source': ConjureFieldDefinition('source', ingest_api_McapSource),
-            'target': ConjureFieldDefinition('target', ingest_api_McapDestination)
+            'target': ConjureFieldDefinition('target', ingest_api_McapDestination),
+            'video_file_rid': ConjureFieldDefinition('videoFileRid', OptionalTypeWrapper[api_rids_VideoFileRid])
         }
 
-    __slots__: List[str] = ['_source', '_target']
+    __slots__: List[str] = ['_source', '_target', '_video_file_rid']
 
-    def __init__(self, source: "ingest_api_McapSource", target: "ingest_api_McapDestination") -> None:
+    def __init__(self, source: "ingest_api_McapSource", target: "ingest_api_McapDestination", video_file_rid: Optional[str] = None) -> None:
         self._source = source
         self._target = target
+        self._video_file_rid = video_file_rid
 
     @builtins.property
     def source(self) -> "ingest_api_McapSource":
@@ -8647,6 +8717,14 @@ class ingest_api_McapIngestionOutput(ConjureBeanType):
     def target(self) -> "ingest_api_McapDestination":
         return self._target
 
+    @builtins.property
+    def video_file_rid(self) -> Optional[str]:
+        """
+        If the destination points to a video, this will be populated with the video file
+populated during ingestion.
+        """
+        return self._video_file_rid
+
 
 ingest_api_McapIngestionOutput.__name__ = "McapIngestionOutput"
 ingest_api_McapIngestionOutput.__qualname__ = "McapIngestionOutput"
@@ -8961,35 +9039,57 @@ class ingest_api_NewVideoIngestDestination(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
+            'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
-            'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
-            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str])
+            'video_file_details': ConjureFieldDefinition('videoFileDetails', OptionalTypeWrapper[ingest_api_VideoFileIngestDetails])
         }
 
-    __slots__: List[str] = ['_properties', '_labels', '_title', '_description']
+    __slots__: List[str] = ['_title', '_description', '_properties', '_labels', '_video_file_details']
 
-    def __init__(self, labels: List[str], properties: Dict[str, str], description: Optional[str] = None, title: Optional[str] = None) -> None:
-        self._properties = properties
-        self._labels = labels
+    def __init__(self, labels: List[str], properties: Dict[str, str], description: Optional[str] = None, title: Optional[str] = None, video_file_details: Optional["ingest_api_VideoFileIngestDetails"] = None) -> None:
         self._title = title
         self._description = description
+        self._properties = properties
+        self._labels = labels
+        self._video_file_details = video_file_details
+
+    @builtins.property
+    def title(self) -> Optional[str]:
+        """
+        Title of the Video that will get created.
+If not provided, a name is deduced from the ingested file.
+        """
+        return self._title
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        """
+        Description that is applied to the newly created video
+        """
+        return self._description
 
     @builtins.property
     def properties(self) -> Dict[str, str]:
+        """
+        Key-Value properties that are applied to the newly created video
+        """
         return self._properties
 
     @builtins.property
     def labels(self) -> List[str]:
+        """
+        Labels that are applied to the newly created video
+        """
         return self._labels
 
     @builtins.property
-    def title(self) -> Optional[str]:
-        return self._title
-
-    @builtins.property
-    def description(self) -> Optional[str]:
-        return self._description
+    def video_file_details(self) -> Optional["ingest_api_VideoFileIngestDetails"]:
+        """
+        Metadata to associate with any created video file
+        """
+        return self._video_file_details
 
 
 ingest_api_NewVideoIngestDestination.__name__ = "NewVideoIngestDestination"
@@ -9672,6 +9772,163 @@ ingest_api_UtcTimestamp.__qualname__ = "UtcTimestamp"
 ingest_api_UtcTimestamp.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_VideoFileIngestDetails(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'file_description': ConjureFieldDefinition('fileDescription', OptionalTypeWrapper[str]),
+            'file_properties': ConjureFieldDefinition('fileProperties', Dict[api_PropertyName, api_PropertyValue]),
+            'file_labels': ConjureFieldDefinition('fileLabels', List[api_Label])
+        }
+
+    __slots__: List[str] = ['_file_description', '_file_properties', '_file_labels']
+
+    def __init__(self, file_labels: List[str], file_properties: Dict[str, str], file_description: Optional[str] = None) -> None:
+        self._file_description = file_description
+        self._file_properties = file_properties
+        self._file_labels = file_labels
+
+    @builtins.property
+    def file_description(self) -> Optional[str]:
+        """
+        Description that is applied to the newly created video file.
+If not provided, defaults to the description used to create the video.
+        """
+        return self._file_description
+
+    @builtins.property
+    def file_properties(self) -> Dict[str, str]:
+        """
+        Key-Value properties that are applied to the newly created video file.
+        """
+        return self._file_properties
+
+    @builtins.property
+    def file_labels(self) -> List[str]:
+        """
+        Labels that are applied to the newly created video file.
+        """
+        return self._file_labels
+
+
+ingest_api_VideoFileIngestDetails.__name__ = "VideoFileIngestDetails"
+ingest_api_VideoFileIngestDetails.__qualname__ = "VideoFileIngestDetails"
+ingest_api_VideoFileIngestDetails.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_VideoIngestTarget(ConjureUnionType):
+    _new: Optional["ingest_api_NewVideoIngestDestination"] = None
+    _existing: Optional["ingest_api_ExistingVideoIngestDestination"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'new': ConjureFieldDefinition('new', ingest_api_NewVideoIngestDestination),
+            'existing': ConjureFieldDefinition('existing', ingest_api_ExistingVideoIngestDestination)
+        }
+
+    def __init__(
+            self,
+            new: Optional["ingest_api_NewVideoIngestDestination"] = None,
+            existing: Optional["ingest_api_ExistingVideoIngestDestination"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (new is not None) + (existing is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if new is not None:
+                self._new = new
+                self._type = 'new'
+            if existing is not None:
+                self._existing = existing
+                self._type = 'existing'
+
+        elif type_of_union == 'new':
+            if new is None:
+                raise ValueError('a union value must not be None')
+            self._new = new
+            self._type = 'new'
+        elif type_of_union == 'existing':
+            if existing is None:
+                raise ValueError('a union value must not be None')
+            self._existing = existing
+            self._type = 'existing'
+
+    @builtins.property
+    def new(self) -> Optional["ingest_api_NewVideoIngestDestination"]:
+        return self._new
+
+    @builtins.property
+    def existing(self) -> Optional["ingest_api_ExistingVideoIngestDestination"]:
+        return self._existing
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, ingest_api_VideoIngestTargetVisitor):
+            raise ValueError('{} is not an instance of ingest_api_VideoIngestTargetVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'new' and self.new is not None:
+            return visitor._new(self.new)
+        if self._type == 'existing' and self.existing is not None:
+            return visitor._existing(self.existing)
+
+
+ingest_api_VideoIngestTarget.__name__ = "VideoIngestTarget"
+ingest_api_VideoIngestTarget.__qualname__ = "VideoIngestTarget"
+ingest_api_VideoIngestTarget.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_VideoIngestTargetVisitor:
+
+    @abstractmethod
+    def _new(self, new: "ingest_api_NewVideoIngestDestination") -> Any:
+        pass
+
+    @abstractmethod
+    def _existing(self, existing: "ingest_api_ExistingVideoIngestDestination") -> Any:
+        pass
+
+
+ingest_api_VideoIngestTargetVisitor.__name__ = "VideoIngestTargetVisitor"
+ingest_api_VideoIngestTargetVisitor.__qualname__ = "VideoIngestTargetVisitor"
+ingest_api_VideoIngestTargetVisitor.__module__ = "nominal_api.ingest_api"
+
+
+class ingest_api_VideoOpts(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'source': ConjureFieldDefinition('source', ingest_api_IngestSource),
+            'target': ConjureFieldDefinition('target', ingest_api_VideoIngestTarget),
+            'timestamp_manifest': ConjureFieldDefinition('timestampManifest', scout_video_api_VideoFileTimestampManifest)
+        }
+
+    __slots__: List[str] = ['_source', '_target', '_timestamp_manifest']
+
+    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_VideoIngestTarget", timestamp_manifest: "scout_video_api_VideoFileTimestampManifest") -> None:
+        self._source = source
+        self._target = target
+        self._timestamp_manifest = timestamp_manifest
+
+    @builtins.property
+    def source(self) -> "ingest_api_IngestSource":
+        return self._source
+
+    @builtins.property
+    def target(self) -> "ingest_api_VideoIngestTarget":
+        return self._target
+
+    @builtins.property
+    def timestamp_manifest(self) -> "scout_video_api_VideoFileTimestampManifest":
+        return self._timestamp_manifest
+
+
+ingest_api_VideoOpts.__name__ = "VideoOpts"
+ingest_api_VideoOpts.__qualname__ = "VideoOpts"
+ingest_api_VideoOpts.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_VideoTimestampManifest(ConjureUnionType):
     _no_manifest: Optional["ingest_api_NoTimestampManifest"] = None
     _timestamp_manifests: Optional["ingest_api_TimestampManifest"] = None
@@ -61811,7 +62068,7 @@ class scout_video_VideoSegmentService(Service):
 at the segment-level.
     """
 
-    def create_segments(self, auth_header: str, request: "scout_video_api_CreateSegmentsRequest", video_rid: str) -> "scout_video_api_CreateSegmentsResponse":
+    def create_segments(self, auth_header: str, request: "scout_video_api_CreateSegmentsRequest", video_rid: str) -> None:
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -61831,6 +62088,36 @@ at the segment-level.
         _path = '/video/v1/videos/{videoRid}/create-segments'
         _path = _path.format(**_path_params)
 
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def create_video_file_segments(self, auth_header: str, request: "scout_video_api_CreateSegmentsRequest", video_file_rid: str, video_rid: str) -> "scout_video_api_CreateSegmentsResponse":
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoRid': video_rid,
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/video/v1/videos/{videoRid}/{videoFileRid}/create-segments'
+        _path = _path.format(**_path_params)
+
         _response: Response = self._request(
             'POST',
             self._uri + _path,

{nominal_api-0.565.1 → nominal_api-0.566.0}/nominal_api/ingest_api/__init__.py

@@ -20,6 +20,7 @@ from .._impl import (
     ingest_api_DeprecatedTriggerIngest as DeprecatedTriggerIngest,
     ingest_api_EpochTimestamp as EpochTimestamp,
     ingest_api_ExistingDatasetIngestDestination as ExistingDatasetIngestDestination,
+    ingest_api_ExistingVideoIngestDestination as ExistingVideoIngestDestination,
     ingest_api_GcsIngestSource as GcsIngestSource,
     ingest_api_IngestDataSource as IngestDataSource,
     ingest_api_IngestDataSourceVisitor as IngestDataSourceVisitor,
@@ -43,8 +44,7 @@ from .._impl import (
     ingest_api_IngestSourceMetadata as IngestSourceMetadata,
     ingest_api_IngestSourceVisitor as IngestSourceVisitor,
     ingest_api_IngestStatus as IngestStatus,
-    ingest_api_IngestVideoDestination as IngestVideoDestination,
-    ingest_api_IngestVideoDestinationVisitor as IngestVideoDestinationVisitor,
+    ingest_api_IngestVideoFileDetails as IngestVideoFileDetails,
     ingest_api_IngestVideoRequest as IngestVideoRequest,
     ingest_api_IngestVideoResponse as IngestVideoResponse,
     ingest_api_InitiateMultipartUploadRequest as InitiateMultipartUploadRequest,
@@ -90,6 +90,10 @@ from .._impl import (
     ingest_api_TriggerIngest as TriggerIngest,
     ingest_api_TriggeredIngest as TriggeredIngest,
     ingest_api_UtcTimestamp as UtcTimestamp,
+    ingest_api_VideoFileIngestDetails as VideoFileIngestDetails,
+    ingest_api_VideoIngestTarget as VideoIngestTarget,
+    ingest_api_VideoIngestTargetVisitor as VideoIngestTargetVisitor,
+    ingest_api_VideoOpts as VideoOpts,
     ingest_api_VideoTimestampManifest as VideoTimestampManifest,
     ingest_api_VideoTimestampManifestVisitor as VideoTimestampManifestVisitor,
 )

{nominal_api-0.565.1 → nominal_api-0.566.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.565.1 → nominal_api-0.566.0}/setup.py

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