nominal-api 0.553.0__py3-none-any.whl → 0.554.0__py3-none-any.whl

nominal_api/__init__.py

@@ -67,5 +67,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.553.0"
+__version__ = "0.554.0"
 

nominal_api/_impl.py

@@ -60922,6 +60922,406 @@ scout_versioning_api_Tag.__qualname__ = "Tag"
 scout_versioning_api_Tag.__module__ = "nominal_api.scout_versioning_api"
 
 
+class scout_video_VideoFileService(Service):
+    """
+    The video service manages individual video files and their metadata.
+    """
+
+    def create(self, auth_header: str, request: "scout_video_api_CreateVideoFileRequest") -> "scout_video_api_VideoFile":
+        """
+        Create and persist a video file entity with the given metadata
+        """
+
+        _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-files/v1/video-files'
+        _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_VideoFile, self._return_none_for_unknown_union_types)
+
+    def get(self, auth_header: str, video_file_rid: str) -> "scout_video_api_VideoFile":
+        """
+        Returns video file metadata associated with a video file RID.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/video-files/v1/video-files/{videoFileRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_video_api_VideoFile, self._return_none_for_unknown_union_types)
+
+    def batch_get(self, auth_header: str, request: "scout_video_api_BatchGetVideoFilesRequest") -> "scout_video_api_BatchGetVideoFilesResponse":
+        """
+        Returns video file metadata associated with the given video file RIDs.
+        """
+
+        _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-files/v1/video-files/batchGet'
+        _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_BatchGetVideoFilesResponse, self._return_none_for_unknown_union_types)
+
+    def search(self, auth_header: str, request: "scout_video_api_SearchVideoFilesRequest") -> "scout_video_api_SearchVideoFilesResponse":
+        """
+        Returns metadata about video files that match a given query.
+        """
+
+        _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-files/v1/video-files/search'
+        _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_SearchVideoFilesResponse, 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.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/video-files/v1/video-files/{videoFileRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_video_api_VideoFile, self._return_none_for_unknown_union_types)
+
+    def archive(self, auth_header: str, video_file_rid: str) -> None:
+        """
+        Archives a video file, which excludes it from search and hides it from being visible
+in the UI, but does not permanently delete it. Archived video files can be unarchived.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/video-files/v1/video-files/{videoFileRid}/archive'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def unarchive(self, auth_header: str, video_file_rid: str) -> None:
+        """
+        Unarchive a previously archived video file, exposing it to the UI and search.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/video-files/v1/video-files/{videoFileRid}/unarchive'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def get_ingest_status(self, auth_header: str, video_file_rid: str) -> "scout_video_api_IngestStatusResponse":
+        """
+        Get the latest ingest status for a given video file by RID.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/video-files/v1/video-files/{videoFileRid}/ingest-status'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_video_api_IngestStatusResponse, self._return_none_for_unknown_union_types)
+
+    def batch_get_ingest_status(self, auth_header: str, video_file_rids: List[str] = None) -> Dict[str, "scout_video_api_IngestStatusResponse"]:
+        """
+        Get the latest ingest status for a set of given video files by RID.
+        """
+        video_file_rids = video_file_rids if video_file_rids is not None else []
+
+        _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_file_rids)
+
+        _path = '/video-files/v1/videos/batch-get-ingest-status'
+        _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(), Dict[api_rids_VideoFileRid, scout_video_api_IngestStatusResponse], self._return_none_for_unknown_union_types)
+
+    def update_ingest_status(self, auth_header: str, request: "scout_video_api_UpdateIngestStatusRequest", video_file_rid: str) -> None:
+        """
+        Update the latest ingest status for a given video file by RID.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/video-files/v1/videos/{videoFileRid}/ingest-status'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def get_segment_summaries(self, auth_header: str, video_file_rid: str) -> List["scout_video_api_SegmentSummary"]:
+        """
+        Returns the min and max absolute and media timestamps for each segment in a video file. 
+To be used during frame-timestamp mapping when playing back videos.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/video-files/v1/video-files/{videoFileRid}/segment-summaries'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            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)
+
+    def get_playlist(self, auth_header: str, video_file_rid: str) -> Any:
+        """
+        Generate an HLS playlist for a video file with the given RID to enable playback.
+The HLS playlist will contain links to all of the video segments in the video in sequential order.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/octet-stream',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoFileRid': video_file_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/video-files/v1/video-files/{videoFileRid}/playlist'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            stream=True,
+            json=_json)
+
+        _raw = _response.raw
+        _raw.decode_content = True
+        return _raw
+
+
+scout_video_VideoFileService.__name__ = "VideoFileService"
+scout_video_VideoFileService.__qualname__ = "VideoFileService"
+scout_video_VideoFileService.__module__ = "nominal_api.scout_video"
+
+
 class scout_video_VideoSegmentService(Service):
     """
     Upon ingestion, every video is split into smaller segments. The Video Segment Service manages operations on videos
@@ -61104,7 +61504,7 @@ class scout_video_VideoService(Service):
 
     def search(self, auth_header: str, request: "scout_video_api_SearchVideosRequest") -> "scout_video_api_SearchVideosResponse":
         """
-        Returns metadata about videos that match a given a query.
+        Returns metadata about videos that match a given query.
         """
 
         _headers: Dict[str, Any] = {
@@ -61454,6 +61854,58 @@ scout_video_VideoService.__qualname__ = "VideoService"
 scout_video_VideoService.__module__ = "nominal_api.scout_video"
 
 
+class scout_video_api_BatchGetVideoFilesRequest(ConjureBeanType):
+    """
+    Request to get a batch of video files by RIDs
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'video_file_rids': ConjureFieldDefinition('videoFileRids', List[api_rids_VideoFileRid])
+        }
+
+    __slots__: List[str] = ['_video_file_rids']
+
+    def __init__(self, video_file_rids: List[str]) -> None:
+        self._video_file_rids = video_file_rids
+
+    @builtins.property
+    def video_file_rids(self) -> List[str]:
+        return self._video_file_rids
+
+
+scout_video_api_BatchGetVideoFilesRequest.__name__ = "BatchGetVideoFilesRequest"
+scout_video_api_BatchGetVideoFilesRequest.__qualname__ = "BatchGetVideoFilesRequest"
+scout_video_api_BatchGetVideoFilesRequest.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_BatchGetVideoFilesResponse(ConjureBeanType):
+    """
+    Paginated response containing requested video file metadata.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'video_files': ConjureFieldDefinition('videoFiles', List[scout_video_api_VideoFile])
+        }
+
+    __slots__: List[str] = ['_video_files']
+
+    def __init__(self, video_files: List["scout_video_api_VideoFile"]) -> None:
+        self._video_files = video_files
+
+    @builtins.property
+    def video_files(self) -> List["scout_video_api_VideoFile"]:
+        return self._video_files
+
+
+scout_video_api_BatchGetVideoFilesResponse.__name__ = "BatchGetVideoFilesResponse"
+scout_video_api_BatchGetVideoFilesResponse.__qualname__ = "BatchGetVideoFilesResponse"
+scout_video_api_BatchGetVideoFilesResponse.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_CreateSegment(ConjureBeanType):
 
     @builtins.classmethod
@@ -61550,6 +62002,62 @@ scout_video_api_CreateSegmentsResponse.__qualname__ = "CreateSegmentsResponse"
 scout_video_api_CreateSegmentsResponse.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_CreateVideoFileRequest(ConjureBeanType):
+    """
+    Request to create and persist a video file
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'title': ConjureFieldDefinition('title', str),
+            '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),
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid)
+        }
+
+    __slots__: List[str] = ['_title', '_description', '_labels', '_properties', '_origin_metadata', '_video_rid']
+
+    def __init__(self, labels: List[str], origin_metadata: "scout_video_api_VideoOriginMetadata", properties: Dict[str, str], title: str, video_rid: str, description: Optional[str] = None) -> None:
+        self._title = title
+        self._description = description
+        self._labels = labels
+        self._properties = properties
+        self._origin_metadata = origin_metadata
+        self._video_rid = video_rid
+
+    @builtins.property
+    def title(self) -> str:
+        return self._title
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def labels(self) -> List[str]:
+        return self._labels
+
+    @builtins.property
+    def properties(self) -> Dict[str, str]:
+        return self._properties
+
+    @builtins.property
+    def origin_metadata(self) -> "scout_video_api_VideoOriginMetadata":
+        return self._origin_metadata
+
+    @builtins.property
+    def video_rid(self) -> str:
+        return self._video_rid
+
+
+scout_video_api_CreateVideoFileRequest.__name__ = "CreateVideoFileRequest"
+scout_video_api_CreateVideoFileRequest.__qualname__ = "CreateVideoFileRequest"
+scout_video_api_CreateVideoFileRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_CreateVideoRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -61819,6 +62327,32 @@ scout_video_api_IngestError.__qualname__ = "IngestError"
 scout_video_api_IngestError.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_IngestStatusResponse(ConjureBeanType):
+    """
+    Response containing the ingest status for a given video file.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'ingest_status': ConjureFieldDefinition('ingestStatus', scout_video_api_DetailedIngestStatus)
+        }
+
+    __slots__: List[str] = ['_ingest_status']
+
+    def __init__(self, ingest_status: "scout_video_api_DetailedIngestStatus") -> None:
+        self._ingest_status = ingest_status
+
+    @builtins.property
+    def ingest_status(self) -> "scout_video_api_DetailedIngestStatus":
+        return self._ingest_status
+
+
+scout_video_api_IngestStatusResponse.__name__ = "IngestStatusResponse"
+scout_video_api_IngestStatusResponse.__qualname__ = "IngestStatusResponse"
+scout_video_api_IngestStatusResponse.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_McapTimestampManifest(ConjureBeanType):
     """
     Timestamps are derived from the mcap file containing the video frames.
@@ -61935,54 +62469,142 @@ class scout_video_api_ScaleParameter(ConjureUnionType):
             self._type = 'scaleFactor'
 
     @builtins.property
-    def true_frame_rate(self) -> Optional[float]:
-        return self._true_frame_rate
+    def true_frame_rate(self) -> Optional[float]:
+        return self._true_frame_rate
+
+    @builtins.property
+    def ending_timestamp(self) -> Optional["api_Timestamp"]:
+        return self._ending_timestamp
+
+    @builtins.property
+    def scale_factor(self) -> Optional[float]:
+        """
+        the scale factor can be used to calculate whether media duration differs from a video's | real duration, and if so, the true frame rate of the camera. The video time will thus be scaled | by the ratio of the real duration to media duration, or media frame rate to true frame rate.
+        """
+        return self._scale_factor
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_video_api_ScaleParameterVisitor):
+            raise ValueError('{} is not an instance of scout_video_api_ScaleParameterVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'trueFrameRate' and self.true_frame_rate is not None:
+            return visitor._true_frame_rate(self.true_frame_rate)
+        if self._type == 'endingTimestamp' and self.ending_timestamp is not None:
+            return visitor._ending_timestamp(self.ending_timestamp)
+        if self._type == 'scaleFactor' and self.scale_factor is not None:
+            return visitor._scale_factor(self.scale_factor)
+
+
+scout_video_api_ScaleParameter.__name__ = "ScaleParameter"
+scout_video_api_ScaleParameter.__qualname__ = "ScaleParameter"
+scout_video_api_ScaleParameter.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_ScaleParameterVisitor:
+
+    @abstractmethod
+    def _true_frame_rate(self, true_frame_rate: float) -> Any:
+        pass
+
+    @abstractmethod
+    def _ending_timestamp(self, ending_timestamp: "api_Timestamp") -> Any:
+        pass
+
+    @abstractmethod
+    def _scale_factor(self, scale_factor: float) -> Any:
+        pass
+
+
+scout_video_api_ScaleParameterVisitor.__name__ = "ScaleParameterVisitor"
+scout_video_api_ScaleParameterVisitor.__qualname__ = "ScaleParameterVisitor"
+scout_video_api_ScaleParameterVisitor.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_SearchVideoFilesRequest(ConjureBeanType):
+    """
+    Request to get video files based on a user-provided query
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'query': ConjureFieldDefinition('query', scout_video_api_SearchVideosQuery),
+            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
+            'token': ConjureFieldDefinition('token', OptionalTypeWrapper[api_Token]),
+            'sort_options': ConjureFieldDefinition('sortOptions', scout_video_api_SortOptions),
+            'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
+        }
+
+    __slots__: List[str] = ['_query', '_page_size', '_token', '_sort_options', '_archived_statuses']
+
+    def __init__(self, query: "scout_video_api_SearchVideosQuery", sort_options: "scout_video_api_SortOptions", archived_statuses: Optional[List["api_ArchivedStatus"]] = None, page_size: Optional[int] = None, token: Optional[str] = None) -> None:
+        self._query = query
+        self._page_size = page_size
+        self._token = token
+        self._sort_options = sort_options
+        self._archived_statuses = archived_statuses
+
+    @builtins.property
+    def query(self) -> "scout_video_api_SearchVideosQuery":
+        return self._query
+
+    @builtins.property
+    def page_size(self) -> Optional[int]:
+        """
+        Defaults to 100. Will throw if larger than 1_000.
+        """
+        return self._page_size
 
     @builtins.property
-    def ending_timestamp(self) -> Optional["api_Timestamp"]:
-        return self._ending_timestamp
+    def token(self) -> Optional[str]:
+        return self._token
 
     @builtins.property
-    def scale_factor(self) -> Optional[float]:
+    def sort_options(self) -> "scout_video_api_SortOptions":
+        return self._sort_options
+
+    @builtins.property
+    def archived_statuses(self) -> Optional[List["api_ArchivedStatus"]]:
         """
-        the scale factor can be used to calculate whether media duration differs from a video's | real duration, and if so, the true frame rate of the camera. The video time will thus be scaled | by the ratio of the real duration to media duration, or media frame rate to true frame rate.
+        Default search status is NOT_ARCHIVED if none are provided.
         """
-        return self._scale_factor
+        return self._archived_statuses
 
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_video_api_ScaleParameterVisitor):
-            raise ValueError('{} is not an instance of scout_video_api_ScaleParameterVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'trueFrameRate' and self.true_frame_rate is not None:
-            return visitor._true_frame_rate(self.true_frame_rate)
-        if self._type == 'endingTimestamp' and self.ending_timestamp is not None:
-            return visitor._ending_timestamp(self.ending_timestamp)
-        if self._type == 'scaleFactor' and self.scale_factor is not None:
-            return visitor._scale_factor(self.scale_factor)
 
+scout_video_api_SearchVideoFilesRequest.__name__ = "SearchVideoFilesRequest"
+scout_video_api_SearchVideoFilesRequest.__qualname__ = "SearchVideoFilesRequest"
+scout_video_api_SearchVideoFilesRequest.__module__ = "nominal_api.scout_video_api"
 
-scout_video_api_ScaleParameter.__name__ = "ScaleParameter"
-scout_video_api_ScaleParameter.__qualname__ = "ScaleParameter"
-scout_video_api_ScaleParameter.__module__ = "nominal_api.scout_video_api"
 
+class scout_video_api_SearchVideoFilesResponse(ConjureBeanType):
+    """
+    Paginated response containing requested video file metadata.
+    """
 
-class scout_video_api_ScaleParameterVisitor:
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'results': ConjureFieldDefinition('results', List[scout_video_api_VideoFile]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
 
-    @abstractmethod
-    def _true_frame_rate(self, true_frame_rate: float) -> Any:
-        pass
+    __slots__: List[str] = ['_results', '_next_page_token']
 
-    @abstractmethod
-    def _ending_timestamp(self, ending_timestamp: "api_Timestamp") -> Any:
-        pass
+    def __init__(self, results: List["scout_video_api_VideoFile"], next_page_token: Optional[str] = None) -> None:
+        self._results = results
+        self._next_page_token = next_page_token
 
-    @abstractmethod
-    def _scale_factor(self, scale_factor: float) -> Any:
-        pass
+    @builtins.property
+    def results(self) -> List["scout_video_api_VideoFile"]:
+        return self._results
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
 
 
-scout_video_api_ScaleParameterVisitor.__name__ = "ScaleParameterVisitor"
-scout_video_api_ScaleParameterVisitor.__qualname__ = "ScaleParameterVisitor"
-scout_video_api_ScaleParameterVisitor.__module__ = "nominal_api.scout_video_api"
+scout_video_api_SearchVideoFilesResponse.__name__ = "SearchVideoFilesResponse"
+scout_video_api_SearchVideoFilesResponse.__qualname__ = "SearchVideoFilesResponse"
+scout_video_api_SearchVideoFilesResponse.__module__ = "nominal_api.scout_video_api"
 
 
 class scout_video_api_SearchVideosQuery(ConjureUnionType):
@@ -62609,6 +63231,32 @@ scout_video_api_UpdateIngestStatusVisitor.__qualname__ = "UpdateIngestStatusVisi
 scout_video_api_UpdateIngestStatusVisitor.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_UpdateIngestStatusRequest(ConjureBeanType):
+    """
+    Request to update the ingest status for a video file.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'updated_status': ConjureFieldDefinition('updatedStatus', scout_video_api_UpdateIngestStatus)
+        }
+
+    __slots__: List[str] = ['_updated_status']
+
+    def __init__(self, updated_status: "scout_video_api_UpdateIngestStatus") -> None:
+        self._updated_status = updated_status
+
+    @builtins.property
+    def updated_status(self) -> "scout_video_api_UpdateIngestStatus":
+        return self._updated_status
+
+
+scout_video_api_UpdateIngestStatusRequest.__name__ = "UpdateIngestStatusRequest"
+scout_video_api_UpdateIngestStatusRequest.__qualname__ = "UpdateIngestStatusRequest"
+scout_video_api_UpdateIngestStatusRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_UpdateTargetDurationRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -62663,6 +63311,68 @@ scout_video_api_UpdateTargetDurationResponse.__qualname__ = "UpdateTargetDuratio
 scout_video_api_UpdateTargetDurationResponse.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_UpdateVideoFileRequest(ConjureBeanType):
+    """
+    Request to update metadata for a given video file.
+    """
+
+    @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]),
+            'labels': ConjureFieldDefinition('labels', OptionalTypeWrapper[List[api_Label]]),
+            'properties': ConjureFieldDefinition('properties', OptionalTypeWrapper[Dict[api_PropertyName, api_PropertyValue]]),
+            'starting_timestamp': ConjureFieldDefinition('startingTimestamp', OptionalTypeWrapper[api_Timestamp]),
+            'scale_parameter': ConjureFieldDefinition('scaleParameter', OptionalTypeWrapper[scout_video_api_ScaleParameter])
+        }
+
+    __slots__: List[str] = ['_video_rid', '_title', '_description', '_labels', '_properties', '_starting_timestamp', '_scale_parameter']
+
+    def __init__(self, description: Optional[str] = None, labels: Optional[List[str]] = None, properties: Optional[Dict[str, 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
+        self._title = title
+        self._description = description
+        self._labels = labels
+        self._properties = properties
+        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
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def labels(self) -> Optional[List[str]]:
+        return self._labels
+
+    @builtins.property
+    def properties(self) -> Optional[Dict[str, str]]:
+        return self._properties
+
+    @builtins.property
+    def starting_timestamp(self) -> Optional["api_Timestamp"]:
+        return self._starting_timestamp
+
+    @builtins.property
+    def scale_parameter(self) -> Optional["scout_video_api_ScaleParameter"]:
+        return self._scale_parameter
+
+
+scout_video_api_UpdateVideoFileRequest.__name__ = "UpdateVideoFileRequest"
+scout_video_api_UpdateVideoFileRequest.__qualname__ = "UpdateVideoFileRequest"
+scout_video_api_UpdateVideoFileRequest.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_UpdateVideoMetadataRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -62894,6 +63604,151 @@ scout_video_api_VideoAllSegmentsMetadata.__qualname__ = "VideoAllSegmentsMetadat
 scout_video_api_VideoAllSegmentsMetadata.__module__ = "nominal_api.scout_video_api"
 
 
+class scout_video_api_VideoFile(ConjureBeanType):
+    """
+    Representation of a single user-provided video file.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rid': ConjureFieldDefinition('rid', api_rids_VideoFileRid),
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
+            'title': ConjureFieldDefinition('title', str),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'labels': ConjureFieldDefinition('labels', List[api_Label]),
+            '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),
+            'segment_metadata': ConjureFieldDefinition('segmentMetadata', OptionalTypeWrapper[scout_video_api_VideoFileSegmentsMetadata])
+        }
+
+    __slots__: List[str] = ['_rid', '_video_rid', '_title', '_description', '_labels', '_properties', '_created_by', '_created_at', '_origin_metadata', '_segment_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, video_rid: str, description: Optional[str] = None, segment_metadata: Optional["scout_video_api_VideoFileSegmentsMetadata"] = None) -> None:
+        self._rid = rid
+        self._video_rid = video_rid
+        self._title = title
+        self._description = description
+        self._labels = labels
+        self._properties = properties
+        self._created_by = created_by
+        self._created_at = created_at
+        self._origin_metadata = origin_metadata
+        self._segment_metadata = segment_metadata
+
+    @builtins.property
+    def rid(self) -> str:
+        return self._rid
+
+    @builtins.property
+    def video_rid(self) -> str:
+        return self._video_rid
+
+    @builtins.property
+    def title(self) -> str:
+        return self._title
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def labels(self) -> List[str]:
+        return self._labels
+
+    @builtins.property
+    def properties(self) -> Dict[str, str]:
+        return self._properties
+
+    @builtins.property
+    def created_by(self) -> str:
+        return self._created_by
+
+    @builtins.property
+    def created_at(self) -> str:
+        return self._created_at
+
+    @builtins.property
+    def origin_metadata(self) -> "scout_video_api_VideoOriginMetadata":
+        return self._origin_metadata
+
+    @builtins.property
+    def segment_metadata(self) -> Optional["scout_video_api_VideoFileSegmentsMetadata"]:
+        return self._segment_metadata
+
+
+scout_video_api_VideoFile.__name__ = "VideoFile"
+scout_video_api_VideoFile.__qualname__ = "VideoFile"
+scout_video_api_VideoFile.__module__ = "nominal_api.scout_video_api"
+
+
+class scout_video_api_VideoFileSegmentsMetadata(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rid': ConjureFieldDefinition('rid', api_rids_VideoFileRid),
+            'num_frames': ConjureFieldDefinition('numFrames', int),
+            'num_segments': ConjureFieldDefinition('numSegments', int),
+            'scale_factor': ConjureFieldDefinition('scaleFactor', float),
+            'min_absolute_timestamp': ConjureFieldDefinition('minAbsoluteTimestamp', api_Timestamp),
+            'max_absolute_timestamp': ConjureFieldDefinition('maxAbsoluteTimestamp', api_Timestamp),
+            'media_duration_seconds': ConjureFieldDefinition('mediaDurationSeconds', float),
+            'media_frame_rate': ConjureFieldDefinition('mediaFrameRate', float)
+        }
+
+    __slots__: List[str] = ['_rid', '_num_frames', '_num_segments', '_scale_factor', '_min_absolute_timestamp', '_max_absolute_timestamp', '_media_duration_seconds', '_media_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) -> None:
+        self._rid = rid
+        self._num_frames = num_frames
+        self._num_segments = num_segments
+        self._scale_factor = scale_factor
+        self._min_absolute_timestamp = min_absolute_timestamp
+        self._max_absolute_timestamp = max_absolute_timestamp
+        self._media_duration_seconds = media_duration_seconds
+        self._media_frame_rate = media_frame_rate
+
+    @builtins.property
+    def rid(self) -> str:
+        return self._rid
+
+    @builtins.property
+    def num_frames(self) -> int:
+        return self._num_frames
+
+    @builtins.property
+    def num_segments(self) -> int:
+        return self._num_segments
+
+    @builtins.property
+    def scale_factor(self) -> float:
+        return self._scale_factor
+
+    @builtins.property
+    def min_absolute_timestamp(self) -> "api_Timestamp":
+        return self._min_absolute_timestamp
+
+    @builtins.property
+    def max_absolute_timestamp(self) -> "api_Timestamp":
+        return self._max_absolute_timestamp
+
+    @builtins.property
+    def media_duration_seconds(self) -> float:
+        return self._media_duration_seconds
+
+    @builtins.property
+    def media_frame_rate(self) -> float:
+        return self._media_frame_rate
+
+
+scout_video_api_VideoFileSegmentsMetadata.__name__ = "VideoFileSegmentsMetadata"
+scout_video_api_VideoFileSegmentsMetadata.__qualname__ = "VideoFileSegmentsMetadata"
+scout_video_api_VideoFileSegmentsMetadata.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_VideoOriginMetadata(ConjureBeanType):
 
     @builtins.classmethod
@@ -69625,6 +70480,8 @@ scout_integrations_api_IntegrationRid = str
 
 scout_api_DataSourceRefName = str
 
+api_rids_VideoFileRid = str
+
 api_Unit = str
 
 scout_versioning_api_BranchRid = str

nominal_api/api_rids/__init__.py

@@ -6,6 +6,7 @@ from .._impl import (
     api_rids_DatasetRid as DatasetRid,
     api_rids_NominalDataSourceRid as NominalDataSourceRid,
     api_rids_SegmentRid as SegmentRid,
+    api_rids_VideoFileRid as VideoFileRid,
     api_rids_VideoRid as VideoRid,
 )
 

nominal_api/scout_video/__init__.py

@@ -1,5 +1,6 @@
 # coding=utf-8
 from .._impl import (
+    scout_video_VideoFileService as VideoFileService,
     scout_video_VideoSegmentService as VideoSegmentService,
     scout_video_VideoService as VideoService,
 )

nominal_api/scout_video_api/__init__.py

@@ -1,8 +1,11 @@
 # coding=utf-8
 from .._impl import (
+    scout_video_api_BatchGetVideoFilesRequest as BatchGetVideoFilesRequest,
+    scout_video_api_BatchGetVideoFilesResponse as BatchGetVideoFilesResponse,
     scout_video_api_CreateSegment as CreateSegment,
     scout_video_api_CreateSegmentsRequest as CreateSegmentsRequest,
     scout_video_api_CreateSegmentsResponse as CreateSegmentsResponse,
+    scout_video_api_CreateVideoFileRequest as CreateVideoFileRequest,
     scout_video_api_CreateVideoRequest as CreateVideoRequest,
     scout_video_api_DetailedIngestStatus as DetailedIngestStatus,
     scout_video_api_DetailedIngestStatusVisitor as DetailedIngestStatusVisitor,
@@ -12,10 +15,13 @@ from .._impl import (
     scout_video_api_GetVideosRequest as GetVideosRequest,
     scout_video_api_GetVideosResponse as GetVideosResponse,
     scout_video_api_IngestError as IngestError,
+    scout_video_api_IngestStatusResponse as IngestStatusResponse,
     scout_video_api_McapTimestampManifest as McapTimestampManifest,
     scout_video_api_NoTimestampManifest as NoTimestampManifest,
     scout_video_api_ScaleParameter as ScaleParameter,
     scout_video_api_ScaleParameterVisitor as ScaleParameterVisitor,
+    scout_video_api_SearchVideoFilesRequest as SearchVideoFilesRequest,
+    scout_video_api_SearchVideoFilesResponse as SearchVideoFilesResponse,
     scout_video_api_SearchVideosQuery as SearchVideosQuery,
     scout_video_api_SearchVideosQueryVisitor as SearchVideosQueryVisitor,
     scout_video_api_SearchVideosRequest as SearchVideosRequest,
@@ -29,12 +35,16 @@ from .._impl import (
     scout_video_api_SuccessIngestStatus as SuccessIngestStatus,
     scout_video_api_TimestampMappings as TimestampMappings,
     scout_video_api_UpdateIngestStatus as UpdateIngestStatus,
+    scout_video_api_UpdateIngestStatusRequest as UpdateIngestStatusRequest,
     scout_video_api_UpdateIngestStatusVisitor as UpdateIngestStatusVisitor,
     scout_video_api_UpdateTargetDurationRequest as UpdateTargetDurationRequest,
     scout_video_api_UpdateTargetDurationResponse as UpdateTargetDurationResponse,
+    scout_video_api_UpdateVideoFileRequest as UpdateVideoFileRequest,
     scout_video_api_UpdateVideoMetadataRequest as UpdateVideoMetadataRequest,
     scout_video_api_Video as Video,
     scout_video_api_VideoAllSegmentsMetadata as VideoAllSegmentsMetadata,
+    scout_video_api_VideoFile as VideoFile,
+    scout_video_api_VideoFileSegmentsMetadata as VideoFileSegmentsMetadata,
     scout_video_api_VideoOriginMetadata as VideoOriginMetadata,
     scout_video_api_VideoTimestampManifest as VideoTimestampManifest,
     scout_video_api_VideoTimestampManifestVisitor as VideoTimestampManifestVisitor,

{nominal_api-0.553.0.dist-info → nominal_api-0.554.0.dist-info}/METADATA

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

{nominal_api-0.553.0.dist-info → nominal_api-0.554.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-nominal_api/__init__.py,sha256=RpuYv4dgrOLQB8bXYvi1y11WvA-amzHj0k8PcHJc5g4,1741
-nominal_api/_impl.py,sha256=MZ0zXHzizun27r8KkCtXcaf3MMh6yQqAU3dDpDVPT-8,2697965
+nominal_api/__init__.py,sha256=yjQQ-1E2ytN2bNTY9wnpBPKPLD4mncd4fEU7huzLHvw,1741
+nominal_api/_impl.py,sha256=XEzp3OP6H1EUSpMNlRTz4SZa2goL7gYoYGHzO_s0dus,2727887
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=kJBEE_HLVpKYdLH12KyO-cSAVzwxYpBwaaDutCtT-LM,1236
-nominal_api/api_rids/__init__.py,sha256=vLyAVUPTfk7u9D_K_7MHE-2Pf8leC5JxC-o8NrrnOPk,337
+nominal_api/api_rids/__init__.py,sha256=MwCU7tf4EQBdNPY12rgPdr4y11iowEXxYqtNCvw7sdo,380
 nominal_api/attachments_api/__init__.py,sha256=eQBE8xVTFDaTItCZv-WJSZqSStpgdai192n23pmVeeQ,634
 nominal_api/authentication/__init__.py,sha256=Vvna9rXXV-WMeJCk2ekq01jHzgsHHsdJl2ROtd4aRgI,272
 nominal_api/authentication_api/__init__.py,sha256=HBQrldagoqcvYES_kjB1Eh8oZTZ8SJdX85UZySJB9z0,986
@@ -49,8 +49,8 @@ nominal_api/scout_run_api/__init__.py,sha256=lTAFwaHSqRs7dx316MzdQcgdBy7Y_fe_Bbf
 nominal_api/scout_template_api/__init__.py,sha256=bsu8qPiZ4gf67G5iFvwsfkqEKJRZ7L5Wyg6qcFyogO0,1037
 nominal_api/scout_units_api/__init__.py,sha256=KxRDScfumX__0ncWJftGvgApn_LBTfnIBAvnaBrcA5A,368
 nominal_api/scout_versioning_api/__init__.py,sha256=Sf4T4t0rZXNRIZgkqLBN3yh0sAnrxiuzaTfDQVVkyO4,1323
-nominal_api/scout_video/__init__.py,sha256=yTmMEO1HF-vJq-Q_uuQd34CqvC_EZPVkTKARVQjKNI0,146
-nominal_api/scout_video_api/__init__.py,sha256=pyqUVdN3RtVKxnbeW0z0ffVc4CUYRe7l9_aNMldjP8U,2458
+nominal_api/scout_video/__init__.py,sha256=zB7mM23yGAgC529rF4gjDmqcLRbsp0kJA3xef8meZko,200
+nominal_api/scout_video_api/__init__.py,sha256=gafiE-WxxQLyTq4RvIZory2Z8pQccYTA9OCeNonsDwk,3160
 nominal_api/scout_workbookcommon_api/__init__.py,sha256=6Ai0cYNOOw2A6JOlKzraTbpZwolspM-WTqVGLMN2HdI,413
 nominal_api/secrets_api/__init__.py,sha256=V5BpnbNzjdMP8kgvR2N6SEVcVyXi6Vyl_lh_5fKjJzw,736
 nominal_api/storage_datasource_api/__init__.py,sha256=jh_OZE_b4nBNAvnyenBjw8aGZOnvIXR6qvUKd31fXOk,445
@@ -64,7 +64,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=KuHLafDLeHzOTl0B6j7T
 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.553.0.dist-info/METADATA,sha256=7BmpRimBEb9RhkLm7a9aB_ywsIk4s0D82DidHaPVsNI,199
-nominal_api-0.553.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nominal_api-0.553.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.553.0.dist-info/RECORD,,
+nominal_api-0.554.0.dist-info/METADATA,sha256=dDjyKHdFCnPz5QH4nOnf30orx-LXRgqeIl14ybpNa-g,199
+nominal_api-0.554.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nominal_api-0.554.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.554.0.dist-info/RECORD,,