nominal-api 0.597.0__tar.gz → 0.598.0__tar.gz

{nominal_api-0.597.0 → nominal_api-0.598.0}/PKG-INFO

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

{nominal_api-0.597.0 → nominal_api-0.598.0}/nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.597.0"
+__version__ = "0.598.0"
 

{nominal_api-0.597.0 → nominal_api-0.598.0}/nominal_api/_impl.py

@@ -8422,14 +8422,16 @@ class ingest_api_JournalJsonOpts(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'source': ConjureFieldDefinition('source', ingest_api_IngestSource),
-            'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget)
+            'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget),
+            'channel': ConjureFieldDefinition('channel', OptionalTypeWrapper[api_Channel])
         }
 
-    __slots__: List[str] = ['_source', '_target']
+    __slots__: List[str] = ['_source', '_target', '_channel']
 
-    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget") -> None:
+    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", channel: Optional[str] = None) -> None:
         self._source = source
         self._target = target
+        self._channel = channel
 
     @builtins.property
     def source(self) -> "ingest_api_IngestSource":
@@ -8439,6 +8441,14 @@ class ingest_api_JournalJsonOpts(ConjureBeanType):
     def target(self) -> "ingest_api_DatasetIngestTarget":
         return self._target
 
+    @builtins.property
+    def channel(self) -> Optional[str]:
+        """
+        If provided, ingests logs to the given channel.
+By default, log data will be ingested to a channel named 'logs'.
+        """
+        return self._channel
+
 
 ingest_api_JournalJsonOpts.__name__ = "JournalJsonOpts"
 ingest_api_JournalJsonOpts.__qualname__ = "JournalJsonOpts"
@@ -16079,12 +16089,13 @@ class scout_catalog_EnrichedDataset(ConjureBeanType):
             'timestamp_type': ConjureFieldDefinition('timestampType', scout_catalog_WeakTimestampType),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
-            'granularity': ConjureFieldDefinition('granularity', api_Granularity)
+            'granularity': ConjureFieldDefinition('granularity', api_Granularity),
+            'allow_streaming': ConjureFieldDefinition('allowStreaming', bool)
         }
 
-    __slots__: List[str] = ['_rid', '_uuid', '_name', '_description', '_display_name', '_metadata', '_handle', '_ingest_date', '_ingest_status', '_origin_metadata', '_last_ingest_status', '_retention_policy', '_source', '_bounds', '_timestamp_type', '_labels', '_properties', '_granularity']
+    __slots__: List[str] = ['_rid', '_uuid', '_name', '_description', '_display_name', '_metadata', '_handle', '_ingest_date', '_ingest_status', '_origin_metadata', '_last_ingest_status', '_retention_policy', '_source', '_bounds', '_timestamp_type', '_labels', '_properties', '_granularity', '_allow_streaming']
 
-    def __init__(self, display_name: str, granularity: "api_Granularity", ingest_date: str, labels: List[str], last_ingest_status: "api_IngestStatusV2", name: str, origin_metadata: "scout_catalog_DatasetOriginMetadata", properties: Dict[str, str], retention_policy: "scout_catalog_RetentionPolicy", rid: str, timestamp_type: "scout_catalog_WeakTimestampType", uuid: str, bounds: Optional["scout_catalog_Bounds"] = None, description: Optional[str] = None, handle: Optional["scout_catalog_Handle"] = None, ingest_status: Optional["scout_catalog_IngestStatus"] = None, metadata: Optional[Dict[str, str]] = None, source: Optional[str] = None) -> None:
+    def __init__(self, allow_streaming: bool, display_name: str, granularity: "api_Granularity", ingest_date: str, labels: List[str], last_ingest_status: "api_IngestStatusV2", name: str, origin_metadata: "scout_catalog_DatasetOriginMetadata", properties: Dict[str, str], retention_policy: "scout_catalog_RetentionPolicy", rid: str, timestamp_type: "scout_catalog_WeakTimestampType", uuid: str, bounds: Optional["scout_catalog_Bounds"] = None, description: Optional[str] = None, handle: Optional["scout_catalog_Handle"] = None, ingest_status: Optional["scout_catalog_IngestStatus"] = None, metadata: Optional[Dict[str, str]] = None, source: Optional[str] = None) -> None:
         self._rid = rid
         self._uuid = uuid
         self._name = name
@@ -16103,6 +16114,7 @@ class scout_catalog_EnrichedDataset(ConjureBeanType):
         self._labels = labels
         self._properties = properties
         self._granularity = granularity
+        self._allow_streaming = allow_streaming
 
     @builtins.property
     def rid(self) -> str:
@@ -16176,6 +16188,10 @@ class scout_catalog_EnrichedDataset(ConjureBeanType):
     def granularity(self) -> "api_Granularity":
         return self._granularity
 
+    @builtins.property
+    def allow_streaming(self) -> bool:
+        return self._allow_streaming
+
 
 scout_catalog_EnrichedDataset.__name__ = "EnrichedDataset"
 scout_catalog_EnrichedDataset.__qualname__ = "EnrichedDataset"
@@ -17140,7 +17156,7 @@ class scout_catalog_SearchDatasetsRequest(ConjureBeanType):
     @builtins.property
     def page_size(self) -> Optional[int]:
         """
-        Defaults to 100. Will throw if larger than 1_000.
+        Defaults to 100. Will throw if larger than 1000.
         """
         return self._page_size
 
@@ -18607,6 +18623,27 @@ scout_chartdefinition_api_GeoAdditionalVariable.__qualname__ = "GeoAdditionalVar
 scout_chartdefinition_api_GeoAdditionalVariable.__module__ = "nominal_api.scout_chartdefinition_api"
 
 
+class scout_chartdefinition_api_GeoBaseTileset(ConjureEnumType):
+    """
+    The base map style. Default STREET if unspecified.
+    """
+
+    STREET = 'STREET'
+    '''STREET'''
+    SATELLITE = 'SATELLITE'
+    '''SATELLITE'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_chartdefinition_api_GeoBaseTileset.__name__ = "GeoBaseTileset"
+scout_chartdefinition_api_GeoBaseTileset.__qualname__ = "GeoBaseTileset"
+scout_chartdefinition_api_GeoBaseTileset.__module__ = "nominal_api.scout_chartdefinition_api"
+
+
 class scout_chartdefinition_api_GeoCustomFeature(ConjureUnionType):
     """Additional static objects on the map, such as a point representing a tower"""
     _point: Optional["scout_chartdefinition_api_GeoPoint"] = None
@@ -18980,15 +19017,17 @@ class scout_chartdefinition_api_GeoVizDefinitionV1(ConjureBeanType):
             'plots': ConjureFieldDefinition('plots', List[scout_chartdefinition_api_GeoPlotFromLatLong]),
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'custom_features': ConjureFieldDefinition('customFeatures', List[scout_chartdefinition_api_GeoCustomFeature]),
+            'base_tileset': ConjureFieldDefinition('baseTileset', OptionalTypeWrapper[scout_chartdefinition_api_GeoBaseTileset]),
             'additional_tileset': ConjureFieldDefinition('additionalTileset', OptionalTypeWrapper[scout_chartdefinition_api_GeoAdditionalTileset])
         }
 
-    __slots__: List[str] = ['_plots', '_title', '_custom_features', '_additional_tileset']
+    __slots__: List[str] = ['_plots', '_title', '_custom_features', '_base_tileset', '_additional_tileset']
 
-    def __init__(self, custom_features: List["scout_chartdefinition_api_GeoCustomFeature"], plots: List["scout_chartdefinition_api_GeoPlotFromLatLong"], additional_tileset: Optional["scout_chartdefinition_api_GeoAdditionalTileset"] = None, title: Optional[str] = None) -> None:
+    def __init__(self, custom_features: List["scout_chartdefinition_api_GeoCustomFeature"], plots: List["scout_chartdefinition_api_GeoPlotFromLatLong"], additional_tileset: Optional["scout_chartdefinition_api_GeoAdditionalTileset"] = None, base_tileset: Optional["scout_chartdefinition_api_GeoBaseTileset"] = None, title: Optional[str] = None) -> None:
         self._plots = plots
         self._title = title
         self._custom_features = custom_features
+        self._base_tileset = base_tileset
         self._additional_tileset = additional_tileset
 
     @builtins.property
@@ -19003,6 +19042,10 @@ class scout_chartdefinition_api_GeoVizDefinitionV1(ConjureBeanType):
     def custom_features(self) -> List["scout_chartdefinition_api_GeoCustomFeature"]:
         return self._custom_features
 
+    @builtins.property
+    def base_tileset(self) -> Optional["scout_chartdefinition_api_GeoBaseTileset"]:
+        return self._base_tileset
+
     @builtins.property
     def additional_tileset(self) -> Optional["scout_chartdefinition_api_GeoAdditionalTileset"]:
         return self._additional_tileset
@@ -64026,9 +64069,6 @@ class scout_video_VideoFileService(Service):
         return _decoder.decode(_response.json(), List[scout_video_api_VideoFile], self._return_none_for_unknown_union_types)
 
     def list_files_in_video(self, auth_header: str, video_rid: str) -> List["scout_video_api_VideoFile"]:
-        """
-        Returns all video files and their metadata associated with the given video RID.
-        """
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -64057,6 +64097,38 @@ class scout_video_VideoFileService(Service):
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), List[scout_video_api_VideoFile], self._return_none_for_unknown_union_types)
 
+    def list_files_in_video_paginated(self, auth_header: str, video_rid: "scout_video_api_ListFilesInVideoRequest") -> "scout_video_api_ListFilesInVideoResponse":
+        """
+        Returns a paginated list of all video files and their metadata associated with the given video RID.
+        """
+
+        _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(video_rid)
+
+        _path = '/video-files/v1/video-files/list-files-in-video-paginated'
+        _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_video_api_ListFilesInVideoResponse, self._return_none_for_unknown_union_types)
+
     def update(self, auth_header: str, request: "scout_video_api_UpdateVideoFileRequest", video_file_rid: str) -> "scout_video_api_VideoFile":
         """
         Updates the metadata for a video file associated with the given RID.
@@ -64683,6 +64755,35 @@ class scout_video_VideoService(Service):
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), Dict[api_rids_VideoRid, scout_video_api_DetailedIngestStatus], self._return_none_for_unknown_union_types)
 
+    def get_enriched_ingest_status(self, auth_header: str, request: "scout_video_api_GetEnrichedVideoIngestStatusRequest") -> Optional["scout_video_api_EnrichedVideoIngestStatus"]:
+
+        _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 = '/video/v1/videos/enriched-ingest-status'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return None if _response.status_code == 204 else _decoder.decode(_response.json(), OptionalTypeWrapper[scout_video_api_EnrichedVideoIngestStatus], self._return_none_for_unknown_union_types)
+
     def archive(self, auth_header: str, video_rid: str) -> None:
         """
         Archives a video, which excludes it from search and hides it from being publicly visible, but does not
@@ -64814,6 +64915,78 @@ frame-timestamp mapping.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), List[scout_video_api_SegmentSummary], self._return_none_for_unknown_union_types)
 
+    def get_playlist_in_bounds(self, auth_header: str, request: "scout_video_api_GetPlaylistInBoundsRequest", video_rid: str) -> Any:
+        """
+        Generates an HLS playlist for a video with the given video rid to enable playback within an optional set of
+bounds. The HLS playlist will contain links to all of the segments in the video that overlap with the given 
+bounds.
+playlist will be limited to the given bounds.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/octet-stream',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoRid': video_rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/video/v1/videos/{videoRid}/playlist-in-bounds'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            stream=True,
+            json=_json)
+
+        _raw = _response.raw
+        _raw.decode_content = True
+        return _raw
+
+    def get_segment_summaries_in_bounds(self, auth_header: str, request: "scout_video_api_GetSegmentSummariesInBoundsRequest", video_rid: str) -> List["scout_video_api_SegmentSummary"]:
+        """
+        Returns the min and max absolute and media timestamps for each segment in a video that overlap with an 
+optional set of bounds.
+        """
+
+        _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,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/video/v1/videos/{videoRid}/segment-summaries-in-bounds'
+        _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(), List[scout_video_api_SegmentSummary], self._return_none_for_unknown_union_types)
+
 
 scout_video_VideoService.__name__ = "VideoService"
 scout_video_VideoService.__qualname__ = "VideoService"
@@ -64998,13 +65171,13 @@ class scout_video_api_CreateVideoRequest(ConjureBeanType):
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'labels': ConjureFieldDefinition('labels', List[api_Label]),
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
-            'origin_metadata': ConjureFieldDefinition('originMetadata', scout_video_api_VideoOriginMetadata),
+            'origin_metadata': ConjureFieldDefinition('originMetadata', OptionalTypeWrapper[scout_video_api_VideoOriginMetadata]),
             'workspace': ConjureFieldDefinition('workspace', OptionalTypeWrapper[api_ids_WorkspaceId])
         }
 
     __slots__: List[str] = ['_title', '_description', '_labels', '_properties', '_origin_metadata', '_workspace']
 
-    def __init__(self, labels: List[str], origin_metadata: "scout_video_api_VideoOriginMetadata", properties: Dict[str, str], title: str, description: Optional[str] = None, workspace: Optional[str] = None) -> None:
+    def __init__(self, labels: List[str], properties: Dict[str, str], title: str, description: Optional[str] = None, origin_metadata: Optional["scout_video_api_VideoOriginMetadata"] = None, workspace: Optional[str] = None) -> None:
         self._title = title
         self._description = description
         self._labels = labels
@@ -65029,7 +65202,7 @@ class scout_video_api_CreateVideoRequest(ConjureBeanType):
         return self._properties
 
     @builtins.property
-    def origin_metadata(self) -> "scout_video_api_VideoOriginMetadata":
+    def origin_metadata(self) -> Optional["scout_video_api_VideoOriginMetadata"]:
         return self._origin_metadata
 
     @builtins.property
@@ -65148,6 +65321,41 @@ scout_video_api_DetailedIngestStatusVisitor.__qualname__ = "DetailedIngestStatus
 scout_video_api_DetailedIngestStatusVisitor.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_EnrichedVideoIngestStatus(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'status': ConjureFieldDefinition('status', scout_video_api_VideoIngestStatus),
+            'file_ingest_status': ConjureFieldDefinition('fileIngestStatus', Dict[api_rids_VideoFileRid, scout_video_api_VideoFileIngestStatus]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_status', '_file_ingest_status', '_next_page_token']
+
+    def __init__(self, file_ingest_status: Dict[str, "scout_video_api_VideoFileIngestStatus"], status: "scout_video_api_VideoIngestStatus", next_page_token: Optional[str] = None) -> None:
+        self._status = status
+        self._file_ingest_status = file_ingest_status
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def status(self) -> "scout_video_api_VideoIngestStatus":
+        return self._status
+
+    @builtins.property
+    def file_ingest_status(self) -> Dict[str, "scout_video_api_VideoFileIngestStatus"]:
+        return self._file_ingest_status
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+scout_video_api_EnrichedVideoIngestStatus.__name__ = "EnrichedVideoIngestStatus"
+scout_video_api_EnrichedVideoIngestStatus.__qualname__ = "EnrichedVideoIngestStatus"
+scout_video_api_EnrichedVideoIngestStatus.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_ErrorIngestStatus(ConjureBeanType):
 
     @builtins.classmethod
@@ -65171,6 +65379,35 @@ scout_video_api_ErrorIngestStatus.__qualname__ = "ErrorIngestStatus"
 scout_video_api_ErrorIngestStatus.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_GetEnrichedVideoIngestStatusRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_video_rid', '_token']
+
+    def __init__(self, video_rid: str, token: Optional[str] = None) -> None:
+        self._video_rid = video_rid
+        self._token = token
+
+    @builtins.property
+    def video_rid(self) -> str:
+        return self._video_rid
+
+    @builtins.property
+    def token(self) -> Optional[str]:
+        return self._token
+
+
+scout_video_api_GetEnrichedVideoIngestStatusRequest.__name__ = "GetEnrichedVideoIngestStatusRequest"
+scout_video_api_GetEnrichedVideoIngestStatusRequest.__qualname__ = "GetEnrichedVideoIngestStatusRequest"
+scout_video_api_GetEnrichedVideoIngestStatusRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_GetIngestStatusResponse(ConjureBeanType):
 
     @builtins.classmethod
@@ -65194,6 +65431,29 @@ scout_video_api_GetIngestStatusResponse.__qualname__ = "GetIngestStatusResponse"
 scout_video_api_GetIngestStatusResponse.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_GetPlaylistInBoundsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_video_api_Bounds])
+        }
+
+    __slots__: List[str] = ['_bounds']
+
+    def __init__(self, bounds: Optional["scout_video_api_Bounds"] = None) -> None:
+        self._bounds = bounds
+
+    @builtins.property
+    def bounds(self) -> Optional["scout_video_api_Bounds"]:
+        return self._bounds
+
+
+scout_video_api_GetPlaylistInBoundsRequest.__name__ = "GetPlaylistInBoundsRequest"
+scout_video_api_GetPlaylistInBoundsRequest.__qualname__ = "GetPlaylistInBoundsRequest"
+scout_video_api_GetPlaylistInBoundsRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_GetSegmentByTimestampRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -65230,6 +65490,29 @@ scout_video_api_GetSegmentByTimestampRequest.__qualname__ = "GetSegmentByTimesta
 scout_video_api_GetSegmentByTimestampRequest.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_GetSegmentSummariesInBoundsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'bounds': ConjureFieldDefinition('bounds', OptionalTypeWrapper[scout_video_api_Bounds])
+        }
+
+    __slots__: List[str] = ['_bounds']
+
+    def __init__(self, bounds: Optional["scout_video_api_Bounds"] = None) -> None:
+        self._bounds = bounds
+
+    @builtins.property
+    def bounds(self) -> Optional["scout_video_api_Bounds"]:
+        return self._bounds
+
+
+scout_video_api_GetSegmentSummariesInBoundsRequest.__name__ = "GetSegmentSummariesInBoundsRequest"
+scout_video_api_GetSegmentSummariesInBoundsRequest.__qualname__ = "GetSegmentSummariesInBoundsRequest"
+scout_video_api_GetSegmentSummariesInBoundsRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_GetVideosRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -65305,6 +65588,64 @@ scout_video_api_IngestError.__qualname__ = "IngestError"
 scout_video_api_IngestError.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_ListFilesInVideoRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_video_rid', '_token']
+
+    def __init__(self, video_rid: str, token: Optional[str] = None) -> None:
+        self._video_rid = video_rid
+        self._token = token
+
+    @builtins.property
+    def video_rid(self) -> str:
+        return self._video_rid
+
+    @builtins.property
+    def token(self) -> Optional[str]:
+        return self._token
+
+
+scout_video_api_ListFilesInVideoRequest.__name__ = "ListFilesInVideoRequest"
+scout_video_api_ListFilesInVideoRequest.__qualname__ = "ListFilesInVideoRequest"
+scout_video_api_ListFilesInVideoRequest.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_ListFilesInVideoResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'files': ConjureFieldDefinition('files', List[scout_video_api_VideoFile]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_files', '_next_page_token']
+
+    def __init__(self, files: List["scout_video_api_VideoFile"], next_page_token: Optional[str] = None) -> None:
+        self._files = files
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def files(self) -> List["scout_video_api_VideoFile"]:
+        return self._files
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+scout_video_api_ListFilesInVideoResponse.__name__ = "ListFilesInVideoResponse"
+scout_video_api_ListFilesInVideoResponse.__qualname__ = "ListFilesInVideoResponse"
+scout_video_api_ListFilesInVideoResponse.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_McapTimestampManifest(ConjureBeanType):
     """
     Timestamps are derived from the mcap file containing the video frames.
@@ -66100,14 +66441,20 @@ class scout_video_api_UpdateIngestStatusRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
+            'video': ConjureFieldDefinition('video', api_rids_VideoRid),
             'ingest_status': ConjureFieldDefinition('ingestStatus', scout_video_api_VideoFileIngestStatus)
         }
 
-    __slots__: List[str] = ['_ingest_status']
+    __slots__: List[str] = ['_video', '_ingest_status']
 
-    def __init__(self, ingest_status: "scout_video_api_VideoFileIngestStatus") -> None:
+    def __init__(self, ingest_status: "scout_video_api_VideoFileIngestStatus", video: str) -> None:
+        self._video = video
         self._ingest_status = ingest_status
 
+    @builtins.property
+    def video(self) -> str:
+        return self._video
+
     @builtins.property
     def ingest_status(self) -> "scout_video_api_VideoFileIngestStatus":
         return self._ingest_status
@@ -66126,26 +66473,20 @@ class scout_video_api_UpdateVideoFileRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'video_rid': ConjureFieldDefinition('videoRid', OptionalTypeWrapper[api_rids_VideoRid]),
             'title': ConjureFieldDefinition('title', OptionalTypeWrapper[str]),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'starting_timestamp': ConjureFieldDefinition('startingTimestamp', OptionalTypeWrapper[api_Timestamp]),
             'scale_parameter': ConjureFieldDefinition('scaleParameter', OptionalTypeWrapper[scout_video_api_ScaleParameter])
         }
 
-    __slots__: List[str] = ['_video_rid', '_title', '_description', '_starting_timestamp', '_scale_parameter']
+    __slots__: List[str] = ['_title', '_description', '_starting_timestamp', '_scale_parameter']
 
-    def __init__(self, description: Optional[str] = None, scale_parameter: Optional["scout_video_api_ScaleParameter"] = None, starting_timestamp: Optional["api_Timestamp"] = None, title: Optional[str] = None, video_rid: Optional[str] = None) -> None:
-        self._video_rid = video_rid
+    def __init__(self, description: Optional[str] = None, scale_parameter: Optional["scout_video_api_ScaleParameter"] = None, starting_timestamp: Optional["api_Timestamp"] = None, title: Optional[str] = None) -> None:
         self._title = title
         self._description = description
         self._starting_timestamp = starting_timestamp
         self._scale_parameter = scale_parameter
 
-    @builtins.property
-    def video_rid(self) -> Optional[str]:
-        return self._video_rid
-
     @builtins.property
     def title(self) -> Optional[str]:
         return self._title
@@ -66233,13 +66574,13 @@ class scout_video_api_Video(ConjureBeanType):
             'properties': ConjureFieldDefinition('properties', Dict[api_PropertyName, api_PropertyValue]),
             'created_by': ConjureFieldDefinition('createdBy', str),
             'created_at': ConjureFieldDefinition('createdAt', str),
-            'origin_metadata': ConjureFieldDefinition('originMetadata', scout_video_api_VideoOriginMetadata),
+            'origin_metadata': ConjureFieldDefinition('originMetadata', OptionalTypeWrapper[scout_video_api_VideoOriginMetadata]),
             'all_segments_metadata': ConjureFieldDefinition('allSegmentsMetadata', OptionalTypeWrapper[scout_video_api_VideoAllSegmentsMetadata])
         }
 
     __slots__: List[str] = ['_rid', '_title', '_description', '_labels', '_properties', '_created_by', '_created_at', '_origin_metadata', '_all_segments_metadata']
 
-    def __init__(self, created_at: str, created_by: str, labels: List[str], origin_metadata: "scout_video_api_VideoOriginMetadata", properties: Dict[str, str], rid: str, title: str, all_segments_metadata: Optional["scout_video_api_VideoAllSegmentsMetadata"] = None, description: Optional[str] = None) -> None:
+    def __init__(self, created_at: str, created_by: str, labels: List[str], properties: Dict[str, str], rid: str, title: str, all_segments_metadata: Optional["scout_video_api_VideoAllSegmentsMetadata"] = None, description: Optional[str] = None, origin_metadata: Optional["scout_video_api_VideoOriginMetadata"] = None) -> None:
         self._rid = rid
         self._title = title
         self._description = description
@@ -66279,7 +66620,7 @@ class scout_video_api_Video(ConjureBeanType):
         return self._created_at
 
     @builtins.property
-    def origin_metadata(self) -> "scout_video_api_VideoOriginMetadata":
+    def origin_metadata(self) -> Optional["scout_video_api_VideoOriginMetadata"]:
         return self._origin_metadata
 
     @builtins.property
@@ -66300,7 +66641,7 @@ class scout_video_api_VideoAllSegmentsMetadata(ConjureBeanType):
             'rid': ConjureFieldDefinition('rid', api_rids_VideoRid),
             'num_frames': ConjureFieldDefinition('numFrames', int),
             'num_segments': ConjureFieldDefinition('numSegments', int),
-            'scale_factor': ConjureFieldDefinition('scaleFactor', float),
+            'scale_factor': ConjureFieldDefinition('scaleFactor', OptionalTypeWrapper[float]),
             'min_absolute_timestamp': ConjureFieldDefinition('minAbsoluteTimestamp', api_Timestamp),
             'max_absolute_timestamp': ConjureFieldDefinition('maxAbsoluteTimestamp', api_Timestamp),
             'media_duration_seconds': ConjureFieldDefinition('mediaDurationSeconds', float),
@@ -66313,7 +66654,7 @@ class scout_video_api_VideoAllSegmentsMetadata(ConjureBeanType):
 
     __slots__: List[str] = ['_rid', '_num_frames', '_num_segments', '_scale_factor', '_min_absolute_timestamp', '_max_absolute_timestamp', '_media_duration_seconds', '_media_frame_rate', '_min_timestamp', '_max_timestamp', '_duration_seconds', '_frame_rate']
 
-    def __init__(self, max_absolute_timestamp: "api_Timestamp", media_duration_seconds: float, media_frame_rate: float, min_absolute_timestamp: "api_Timestamp", num_frames: int, num_segments: int, rid: str, scale_factor: float, duration_seconds: Optional[float] = None, frame_rate: Optional[float] = None, max_timestamp: Optional["api_Timestamp"] = None, min_timestamp: Optional["api_Timestamp"] = None) -> None:
+    def __init__(self, max_absolute_timestamp: "api_Timestamp", media_duration_seconds: float, media_frame_rate: float, min_absolute_timestamp: "api_Timestamp", num_frames: int, num_segments: int, rid: str, duration_seconds: Optional[float] = None, frame_rate: Optional[float] = None, max_timestamp: Optional["api_Timestamp"] = None, min_timestamp: Optional["api_Timestamp"] = None, scale_factor: Optional[float] = None) -> None:
         self._rid = rid
         self._num_frames = num_frames
         self._num_segments = num_segments
@@ -66340,7 +66681,10 @@ class scout_video_api_VideoAllSegmentsMetadata(ConjureBeanType):
         return self._num_segments
 
     @builtins.property
-    def scale_factor(self) -> float:
+    def scale_factor(self) -> Optional[float]:
+        """
+        deprecated, in favor of per-file VideoFileSegmentsMetadata scaleFactor. Will be removed after April 15th.
+        """
         return self._scale_factor
 
     @builtins.property
@@ -66368,28 +66712,28 @@ class scout_video_api_VideoAllSegmentsMetadata(ConjureBeanType):
     @builtins.property
     def min_timestamp(self) -> Optional["api_Timestamp"]:
         """
-        deprecated
+        deprecated. Will be removed after April 15th.
         """
         return self._min_timestamp
 
     @builtins.property
     def max_timestamp(self) -> Optional["api_Timestamp"]:
         """
-        deprecated
+        deprecated. Will be removed after April 15th.
         """
         return self._max_timestamp
 
     @builtins.property
     def duration_seconds(self) -> Optional[float]:
         """
-        deprecated
+        deprecated. Will be removed after April 15th.
         """
         return self._duration_seconds
 
     @builtins.property
     def frame_rate(self) -> Optional[float]:
         """
-        deprecated
+        deprecated. Will be removed after April 15th.
         """
         return self._frame_rate
 
@@ -66768,6 +67112,104 @@ scout_video_api_VideoFileTimestampManifestVisitor.__qualname__ = "VideoFileTimes
 scout_video_api_VideoFileTimestampManifestVisitor.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_VideoIngestStatus(ConjureUnionType):
+    _ready: Optional["api_Empty"] = None
+    _in_progress: Optional["api_Empty"] = None
+    _error: Optional["api_Empty"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'ready': ConjureFieldDefinition('ready', api_Empty),
+            'in_progress': ConjureFieldDefinition('inProgress', api_Empty),
+            'error': ConjureFieldDefinition('error', api_Empty)
+        }
+
+    def __init__(
+            self,
+            ready: Optional["api_Empty"] = None,
+            in_progress: Optional["api_Empty"] = None,
+            error: Optional["api_Empty"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (ready is not None) + (in_progress is not None) + (error is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if ready is not None:
+                self._ready = ready
+                self._type = 'ready'
+            if in_progress is not None:
+                self._in_progress = in_progress
+                self._type = 'inProgress'
+            if error is not None:
+                self._error = error
+                self._type = 'error'
+
+        elif type_of_union == 'ready':
+            if ready is None:
+                raise ValueError('a union value must not be None')
+            self._ready = ready
+            self._type = 'ready'
+        elif type_of_union == 'inProgress':
+            if in_progress is None:
+                raise ValueError('a union value must not be None')
+            self._in_progress = in_progress
+            self._type = 'inProgress'
+        elif type_of_union == 'error':
+            if error is None:
+                raise ValueError('a union value must not be None')
+            self._error = error
+            self._type = 'error'
+
+    @builtins.property
+    def ready(self) -> Optional["api_Empty"]:
+        return self._ready
+
+    @builtins.property
+    def in_progress(self) -> Optional["api_Empty"]:
+        return self._in_progress
+
+    @builtins.property
+    def error(self) -> Optional["api_Empty"]:
+        return self._error
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_video_api_VideoIngestStatusVisitor):
+            raise ValueError('{} is not an instance of scout_video_api_VideoIngestStatusVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'ready' and self.ready is not None:
+            return visitor._ready(self.ready)
+        if self._type == 'inProgress' and self.in_progress is not None:
+            return visitor._in_progress(self.in_progress)
+        if self._type == 'error' and self.error is not None:
+            return visitor._error(self.error)
+
+
+scout_video_api_VideoIngestStatus.__name__ = "VideoIngestStatus"
+scout_video_api_VideoIngestStatus.__qualname__ = "VideoIngestStatus"
+scout_video_api_VideoIngestStatus.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_VideoIngestStatusVisitor:
+
+    @abstractmethod
+    def _ready(self, ready: "api_Empty") -> Any:
+        pass
+
+    @abstractmethod
+    def _in_progress(self, in_progress: "api_Empty") -> Any:
+        pass
+
+    @abstractmethod
+    def _error(self, error: "api_Empty") -> Any:
+        pass
+
+
+scout_video_api_VideoIngestStatusVisitor.__name__ = "VideoIngestStatusVisitor"
+scout_video_api_VideoIngestStatusVisitor.__qualname__ = "VideoIngestStatusVisitor"
+scout_video_api_VideoIngestStatusVisitor.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_VideoOriginMetadata(ConjureBeanType):
 
     @builtins.classmethod
@@ -69201,18 +69643,28 @@ class storage_writer_api_WriteLogsRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'logs': ConjureFieldDefinition('logs', List[storage_writer_api_LogPoint])
+            'logs': ConjureFieldDefinition('logs', List[storage_writer_api_LogPoint]),
+            'channel': ConjureFieldDefinition('channel', OptionalTypeWrapper[api_Channel])
         }
 
-    __slots__: List[str] = ['_logs']
+    __slots__: List[str] = ['_logs', '_channel']
 
-    def __init__(self, logs: List["storage_writer_api_LogPoint"]) -> None:
+    def __init__(self, logs: List["storage_writer_api_LogPoint"], channel: Optional[str] = None) -> None:
         self._logs = logs
+        self._channel = channel
 
     @builtins.property
     def logs(self) -> List["storage_writer_api_LogPoint"]:
         return self._logs
 
+    @builtins.property
+    def channel(self) -> Optional[str]:
+        """
+        If provided, the channel to which to write logs.
+If not provided, defaults to "logs"
+        """
+        return self._channel
+
 
 storage_writer_api_WriteLogsRequest.__name__ = "WriteLogsRequest"
 storage_writer_api_WriteLogsRequest.__qualname__ = "WriteLogsRequest"

{nominal_api-0.597.0 → nominal_api-0.598.0}/nominal_api/scout_chartdefinition_api/__init__.py

@@ -31,6 +31,7 @@ from .._impl import (
     scout_chartdefinition_api_FrequencyPlot as FrequencyPlot,
     scout_chartdefinition_api_GeoAdditionalTileset as GeoAdditionalTileset,
     scout_chartdefinition_api_GeoAdditionalVariable as GeoAdditionalVariable,
+    scout_chartdefinition_api_GeoBaseTileset as GeoBaseTileset,
     scout_chartdefinition_api_GeoCustomFeature as GeoCustomFeature,
     scout_chartdefinition_api_GeoCustomFeatureVisitor as GeoCustomFeatureVisitor,
     scout_chartdefinition_api_GeoLineStyle as GeoLineStyle,

{nominal_api-0.597.0 → nominal_api-0.598.0}/nominal_api/scout_video_api/__init__.py

@@ -8,13 +8,19 @@ from .._impl import (
     scout_video_api_CreateVideoRequest as CreateVideoRequest,
     scout_video_api_DetailedIngestStatus as DetailedIngestStatus,
     scout_video_api_DetailedIngestStatusVisitor as DetailedIngestStatusVisitor,
+    scout_video_api_EnrichedVideoIngestStatus as EnrichedVideoIngestStatus,
     scout_video_api_ErrorIngestStatus as ErrorIngestStatus,
     scout_video_api_ErrorType as ErrorType,
+    scout_video_api_GetEnrichedVideoIngestStatusRequest as GetEnrichedVideoIngestStatusRequest,
     scout_video_api_GetIngestStatusResponse as GetIngestStatusResponse,
+    scout_video_api_GetPlaylistInBoundsRequest as GetPlaylistInBoundsRequest,
     scout_video_api_GetSegmentByTimestampRequest as GetSegmentByTimestampRequest,
+    scout_video_api_GetSegmentSummariesInBoundsRequest as GetSegmentSummariesInBoundsRequest,
     scout_video_api_GetVideosRequest as GetVideosRequest,
     scout_video_api_GetVideosResponse as GetVideosResponse,
     scout_video_api_IngestError as IngestError,
+    scout_video_api_ListFilesInVideoRequest as ListFilesInVideoRequest,
+    scout_video_api_ListFilesInVideoResponse as ListFilesInVideoResponse,
     scout_video_api_McapTimestampManifest as McapTimestampManifest,
     scout_video_api_NoTimestampManifest as NoTimestampManifest,
     scout_video_api_ScaleParameter as ScaleParameter,
@@ -45,6 +51,8 @@ from .._impl import (
     scout_video_api_VideoFileSegmentsMetadata as VideoFileSegmentsMetadata,
     scout_video_api_VideoFileTimestampManifest as VideoFileTimestampManifest,
     scout_video_api_VideoFileTimestampManifestVisitor as VideoFileTimestampManifestVisitor,
+    scout_video_api_VideoIngestStatus as VideoIngestStatus,
+    scout_video_api_VideoIngestStatusVisitor as VideoIngestStatusVisitor,
     scout_video_api_VideoOriginMetadata as VideoOriginMetadata,
     scout_video_api_VideoTimestampManifest as VideoTimestampManifest,
     scout_video_api_VideoTimestampManifestVisitor as VideoTimestampManifestVisitor,

{nominal_api-0.597.0 → nominal_api-0.598.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.597.0 → nominal_api-0.598.0}/setup.py

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