nominal-api 0.582.0__tar.gz → 0.584.0__tar.gz

{nominal_api-0.582.0 → nominal_api-0.584.0}/PKG-INFO

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

{nominal_api-0.582.0 → nominal_api-0.584.0}/nominal_api/__init__.py

@@ -73,5 +73,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.582.0"
+__version__ = "0.584.0"
 

{nominal_api-0.582.0 → nominal_api-0.584.0}/nominal_api/_impl.py

@@ -6846,12 +6846,12 @@ class ingest_api_ExistingVideoIngestDestination(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
-            'video_file_details': ConjureFieldDefinition('videoFileDetails', ingest_api_VideoFileIngestDetails)
+            'video_file_details': ConjureFieldDefinition('videoFileDetails', OptionalTypeWrapper[ingest_api_VideoFileIngestDetails])
         }
 
     __slots__: List[str] = ['_video_rid', '_video_file_details']
 
-    def __init__(self, video_file_details: "ingest_api_VideoFileIngestDetails", video_rid: str) -> None:
+    def __init__(self, video_rid: str, video_file_details: Optional["ingest_api_VideoFileIngestDetails"] = None) -> None:
         self._video_rid = video_rid
         self._video_file_details = video_file_details
 
@@ -6863,7 +6863,7 @@ class ingest_api_ExistingVideoIngestDestination(ConjureBeanType):
         return self._video_rid
 
     @builtins.property
-    def video_file_details(self) -> "ingest_api_VideoFileIngestDetails":
+    def video_file_details(self) -> Optional["ingest_api_VideoFileIngestDetails"]:
         """
         Metadata to associate with any created video file
         """
@@ -9615,13 +9615,13 @@ class ingest_api_VideoFileIngestDetails(ConjureBeanType):
     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])
+            'file_properties': ConjureFieldDefinition('fileProperties', OptionalTypeWrapper[Dict[api_PropertyName, api_PropertyValue]]),
+            'file_labels': ConjureFieldDefinition('fileLabels', OptionalTypeWrapper[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:
+    def __init__(self, file_description: Optional[str] = None, file_labels: Optional[List[str]] = None, file_properties: Optional[Dict[str, str]] = None) -> None:
         self._file_description = file_description
         self._file_properties = file_properties
         self._file_labels = file_labels
@@ -9635,14 +9635,14 @@ 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]:
+    def file_properties(self) -> Optional[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]:
+    def file_labels(self) -> Optional[List[str]]:
         """
         Labels that are applied to the newly created video file.
         """
@@ -12086,6 +12086,83 @@ scout_api_ChannelLocator.__qualname__ = "ChannelLocator"
 scout_api_ChannelLocator.__module__ = "nominal_api.scout_api"
 
 
+class scout_api_DataScope(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
+            'offset': ConjureFieldDefinition('offset', scout_run_api_Duration),
+            'ref_name': ConjureFieldDefinition('refName', scout_api_DataSourceRefName),
+            'timestamp_type': ConjureFieldDefinition('timestampType', scout_api_WeakTimestampType),
+            'series_tags': ConjureFieldDefinition('seriesTags', Dict[api_TagName, api_TagValue])
+        }
+
+    __slots__: List[str] = ['_data_source', '_offset', '_ref_name', '_timestamp_type', '_series_tags']
+
+    def __init__(self, data_source: "scout_run_api_DataSource", offset: "scout_run_api_Duration", ref_name: str, series_tags: Dict[str, str], timestamp_type: "scout_api_WeakTimestampType") -> None:
+        self._data_source = data_source
+        self._offset = offset
+        self._ref_name = ref_name
+        self._timestamp_type = timestamp_type
+        self._series_tags = series_tags
+
+    @builtins.property
+    def data_source(self) -> "scout_run_api_DataSource":
+        return self._data_source
+
+    @builtins.property
+    def offset(self) -> "scout_run_api_Duration":
+        """
+        This offset is used for small time-sync corrections. Notably, it is
+not the offset to move a relative data source to the start of the run.
+        """
+        return self._offset
+
+    @builtins.property
+    def ref_name(self) -> str:
+        return self._ref_name
+
+    @builtins.property
+    def timestamp_type(self) -> "scout_api_WeakTimestampType":
+        return self._timestamp_type
+
+    @builtins.property
+    def series_tags(self) -> Dict[str, str]:
+        """
+        Used to resolve logical series for this data source.
+        """
+        return self._series_tags
+
+
+scout_api_DataScope.__name__ = "DataScope"
+scout_api_DataScope.__qualname__ = "DataScope"
+scout_api_DataScope.__module__ = "nominal_api.scout_api"
+
+
+class scout_api_WeakTimestampType(ConjureEnumType):
+    """
+    If a CSV data source is still being split, the timestamp type is not known.
+    """
+
+    ABSOLUTE = 'ABSOLUTE'
+    '''ABSOLUTE'''
+    RELATIVE = 'RELATIVE'
+    '''RELATIVE'''
+    PENDING = 'PENDING'
+    '''PENDING'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_api_WeakTimestampType.__name__ = "WeakTimestampType"
+scout_api_WeakTimestampType.__qualname__ = "WeakTimestampType"
+scout_api_WeakTimestampType.__module__ = "nominal_api.scout_api"
+
+
 class scout_asset_api_AddDataScopesToAssetRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -12225,6 +12302,10 @@ scout_asset_api_Asset.__module__ = "nominal_api.scout_asset_api"
 
 
 class scout_asset_api_AssetDataScope(ConjureBeanType):
+    """
+    This type is equivalent to the DataScope type, except it uses a dataScopeName instead of refName. It will
+eventually be deprecated in favor of DataScope.
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -12232,13 +12313,13 @@ class scout_asset_api_AssetDataScope(ConjureBeanType):
             'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_asset_api_DataScopeName),
             'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
             'offset': ConjureFieldDefinition('offset', OptionalTypeWrapper[scout_run_api_Duration]),
-            'timestamp_type': ConjureFieldDefinition('timestampType', scout_run_api_WeakTimestampType),
+            'timestamp_type': ConjureFieldDefinition('timestampType', scout_api_WeakTimestampType),
             'series_tags': ConjureFieldDefinition('seriesTags', Dict[scout_asset_api_SeriesTagName, scout_asset_api_SeriesTagValue])
         }
 
     __slots__: List[str] = ['_data_scope_name', '_data_source', '_offset', '_timestamp_type', '_series_tags']
 
-    def __init__(self, data_scope_name: str, data_source: "scout_run_api_DataSource", series_tags: Dict[str, str], timestamp_type: "scout_run_api_WeakTimestampType", offset: Optional["scout_run_api_Duration"] = None) -> None:
+    def __init__(self, data_scope_name: str, data_source: "scout_run_api_DataSource", series_tags: Dict[str, str], timestamp_type: "scout_api_WeakTimestampType", offset: Optional["scout_run_api_Duration"] = None) -> None:
         self._data_scope_name = data_scope_name
         self._data_source = data_source
         self._offset = offset
@@ -12261,7 +12342,7 @@ class scout_asset_api_AssetDataScope(ConjureBeanType):
         return self._offset
 
     @builtins.property
-    def timestamp_type(self) -> "scout_run_api_WeakTimestampType":
+    def timestamp_type(self) -> "scout_api_WeakTimestampType":
         return self._timestamp_type
 
     @builtins.property
@@ -60277,16 +60358,17 @@ class scout_run_api_Run(ConjureBeanType):
             'links': ConjureFieldDefinition('links', List[scout_run_api_Link]),
             'created_at': ConjureFieldDefinition('createdAt', str),
             'updated_at': ConjureFieldDefinition('updatedAt', str),
-            'asset_data_scopes': ConjureFieldDefinition('assetDataScopes', List[scout_asset_api_AssetDataScope]),
-            'data_sources': ConjureFieldDefinition('dataSources', Dict[scout_api_DataSourceRefName, scout_run_api_RunDataSource]),
+            'asset_data_scopes': ConjureFieldDefinition('assetDataScopes', List[scout_api_DataScope]),
+            'additional_data_scopes': ConjureFieldDefinition('additionalDataScopes', List[scout_api_DataScope]),
+            'data_sources': ConjureFieldDefinition('dataSources', Dict[scout_api_DataSourceRefName, scout_api_DataScope]),
             'attachments': ConjureFieldDefinition('attachments', List[api_rids_AttachmentRid]),
             'asset': ConjureFieldDefinition('asset', OptionalTypeWrapper[scout_rids_api_AssetRid]),
             'assets': ConjureFieldDefinition('assets', List[scout_rids_api_AssetRid])
         }
 
-    __slots__: List[str] = ['_rid', '_run_number', '_run_prefix', '_title', '_description', '_author_rid', '_start_time', '_end_time', '_properties', '_labels', '_links', '_created_at', '_updated_at', '_asset_data_scopes', '_data_sources', '_attachments', '_asset', '_assets']
+    __slots__: List[str] = ['_rid', '_run_number', '_run_prefix', '_title', '_description', '_author_rid', '_start_time', '_end_time', '_properties', '_labels', '_links', '_created_at', '_updated_at', '_asset_data_scopes', '_additional_data_scopes', '_data_sources', '_attachments', '_asset', '_assets']
 
-    def __init__(self, asset_data_scopes: List["scout_asset_api_AssetDataScope"], assets: List[str], attachments: List[str], created_at: str, data_sources: Dict[str, "scout_run_api_RunDataSource"], description: str, labels: List[str], links: List["scout_run_api_Link"], properties: Dict[str, str], rid: str, run_number: int, start_time: "scout_run_api_UtcTimestamp", title: str, updated_at: str, asset: Optional[str] = None, author_rid: Optional[str] = None, end_time: Optional["scout_run_api_UtcTimestamp"] = None, run_prefix: Optional[str] = None) -> None:
+    def __init__(self, additional_data_scopes: List["scout_api_DataScope"], asset_data_scopes: List["scout_api_DataScope"], assets: List[str], attachments: List[str], created_at: str, data_sources: Dict[str, "scout_api_DataScope"], description: str, labels: List[str], links: List["scout_run_api_Link"], properties: Dict[str, str], rid: str, run_number: int, start_time: "scout_run_api_UtcTimestamp", title: str, updated_at: str, asset: Optional[str] = None, author_rid: Optional[str] = None, end_time: Optional["scout_run_api_UtcTimestamp"] = None, run_prefix: Optional[str] = None) -> None:
         self._rid = rid
         self._run_number = run_number
         self._run_prefix = run_prefix
@@ -60301,6 +60383,7 @@ class scout_run_api_Run(ConjureBeanType):
         self._created_at = created_at
         self._updated_at = updated_at
         self._asset_data_scopes = asset_data_scopes
+        self._additional_data_scopes = additional_data_scopes
         self._data_sources = data_sources
         self._attachments = attachments
         self._asset = asset
@@ -60359,14 +60442,24 @@ class scout_run_api_Run(ConjureBeanType):
         return self._updated_at
 
     @builtins.property
-    def asset_data_scopes(self) -> List["scout_asset_api_AssetDataScope"]:
+    def asset_data_scopes(self) -> List["scout_api_DataScope"]:
         """
         returns the data scopes for the assets associated with the run.
         """
         return self._asset_data_scopes
 
     @builtins.property
-    def data_sources(self) -> Dict[str, "scout_run_api_RunDataSource"]:
+    def additional_data_scopes(self) -> List["scout_api_DataScope"]:
+        """
+        returns any data scopes added directly to the run.
+        """
+        return self._additional_data_scopes
+
+    @builtins.property
+    def data_sources(self) -> Dict[str, "scout_api_DataScope"]:
+        """
+        returns all of the data scopes under the run. This includes data scopes of any associated assets. If there are data scopes attached directly to the run that have the same ref name as data scopes from the asset, they will override them.
+        """
         return self._data_sources
 
     @builtins.property
@@ -60464,66 +60557,6 @@ scout_run_api_RunDataReviewSummary.__qualname__ = "RunDataReviewSummary"
 scout_run_api_RunDataReviewSummary.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_RunDataSource(ConjureBeanType):
-    """
-    For read requests, we want to require all fields
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'data_source': ConjureFieldDefinition('dataSource', scout_run_api_DataSource),
-            'offset': ConjureFieldDefinition('offset', scout_run_api_Duration),
-            'ref_name': ConjureFieldDefinition('refName', scout_api_DataSourceRefName),
-            'timestamp_type': ConjureFieldDefinition('timestampType', scout_run_api_WeakTimestampType),
-            'series_tags': ConjureFieldDefinition('seriesTags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_data_source', '_offset', '_ref_name', '_timestamp_type', '_series_tags']
-
-    def __init__(self, data_source: "scout_run_api_DataSource", offset: "scout_run_api_Duration", ref_name: str, series_tags: Dict[str, str], timestamp_type: "scout_run_api_WeakTimestampType") -> None:
-        self._data_source = data_source
-        self._offset = offset
-        self._ref_name = ref_name
-        self._timestamp_type = timestamp_type
-        self._series_tags = series_tags
-
-    @builtins.property
-    def data_source(self) -> "scout_run_api_DataSource":
-        return self._data_source
-
-    @builtins.property
-    def offset(self) -> "scout_run_api_Duration":
-        """
-        This offset is used for small time-sync corrections. Notably, it is
-not the offset to move a relative data source to the start of the run.
-        """
-        return self._offset
-
-    @builtins.property
-    def ref_name(self) -> str:
-        """
-        Included for convenience, duplicated from the key of the map
-        """
-        return self._ref_name
-
-    @builtins.property
-    def timestamp_type(self) -> "scout_run_api_WeakTimestampType":
-        return self._timestamp_type
-
-    @builtins.property
-    def series_tags(self) -> Dict[str, str]:
-        """
-        Used to resolve logical series for this data source.
-        """
-        return self._series_tags
-
-
-scout_run_api_RunDataSource.__name__ = "RunDataSource"
-scout_run_api_RunDataSource.__qualname__ = "RunDataSource"
-scout_run_api_RunDataSource.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_RunWithDataReviewMetrics(ConjureBeanType):
 
     @builtins.classmethod
@@ -61378,29 +61411,6 @@ scout_run_api_UtcTimestamp.__qualname__ = "UtcTimestamp"
 scout_run_api_UtcTimestamp.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_WeakTimestampType(ConjureEnumType):
-    """
-    If a CSV data source is still being split, the timestamp type is not known.
-    """
-
-    ABSOLUTE = 'ABSOLUTE'
-    '''ABSOLUTE'''
-    RELATIVE = 'RELATIVE'
-    '''RELATIVE'''
-    PENDING = 'PENDING'
-    '''PENDING'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-scout_run_api_WeakTimestampType.__name__ = "WeakTimestampType"
-scout_run_api_WeakTimestampType.__qualname__ = "WeakTimestampType"
-scout_run_api_WeakTimestampType.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_template_api_CommitTemplateRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -62960,7 +62970,7 @@ class scout_video_VideoFileService(Service):
 
     def batch_get(self, auth_header: str, video_file_rids: List[str] = None) -> List["scout_video_api_VideoFile"]:
         """
-        Returns video file metadata associated with the given video file RIDs.
+        Returns all video files and their metadata associated with the given RIDs
         """
         video_file_rids = video_file_rids if video_file_rids is not None else []
 
@@ -62991,9 +63001,9 @@ 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 search(self, auth_header: str, request: "scout_video_api_SearchVideoFilesRequest") -> "scout_video_api_SearchVideoFilesResponse":
+    def list_files_in_video(self, auth_header: str, video_rid: str) -> List["scout_video_api_VideoFile"]:
         """
-        Returns metadata about video files that match a given query.
+        Returns all video files and their metadata associated with the given video RID.
         """
 
         _headers: Dict[str, Any] = {
@@ -63008,9 +63018,9 @@ class scout_video_VideoFileService(Service):
         _path_params: Dict[str, Any] = {
         }
 
-        _json: Any = ConjureEncoder().default(request)
+        _json: Any = ConjureEncoder().default(video_rid)
 
-        _path = '/video-files/v1/video-files/search'
+        _path = '/video-files/v1/video-files/list-files-in-video'
         _path = _path.format(**_path_params)
 
         _response: Response = self._request(
@@ -63021,7 +63031,7 @@ class scout_video_VideoFileService(Service):
             json=_json)
 
         _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_video_api_SearchVideoFilesResponse, self._return_none_for_unknown_union_types)
+        return _decoder.decode(_response.json(), List[scout_video_api_VideoFile], 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":
         """
@@ -63921,19 +63931,15 @@ class scout_video_api_CreateVideoFileRequest(ConjureBeanType):
         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_VideoFileOriginMetadata),
             'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid)
         }
 
-    __slots__: List[str] = ['_title', '_description', '_labels', '_properties', '_origin_metadata', '_video_rid']
+    __slots__: List[str] = ['_title', '_description', '_origin_metadata', '_video_rid']
 
-    def __init__(self, labels: List[str], origin_metadata: "scout_video_api_VideoFileOriginMetadata", properties: Dict[str, str], title: str, video_rid: str, description: Optional[str] = None) -> None:
+    def __init__(self, origin_metadata: "scout_video_api_VideoFileOriginMetadata", 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
 
@@ -63945,14 +63951,6 @@ class scout_video_api_CreateVideoFileRequest(ConjureBeanType):
     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_VideoFileOriginMetadata":
         return self._origin_metadata
@@ -64438,94 +64436,6 @@ 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 token(self) -> Optional[str]:
-        return self._token
-
-    @builtins.property
-    def sort_options(self) -> "scout_video_api_SortOptions":
-        return self._sort_options
-
-    @builtins.property
-    def archived_statuses(self) -> Optional[List["api_ArchivedStatus"]]:
-        """
-        Default search status is NOT_ARCHIVED if none are provided.
-        """
-        return self._archived_statuses
-
-
-scout_video_api_SearchVideoFilesRequest.__name__ = "SearchVideoFilesRequest"
-scout_video_api_SearchVideoFilesRequest.__qualname__ = "SearchVideoFilesRequest"
-scout_video_api_SearchVideoFilesRequest.__module__ = "nominal_api.scout_video_api"
-
-
-class scout_video_api_SearchVideoFilesResponse(ConjureBeanType):
-    """
-    Paginated response containing requested video file metadata.
-    """
-
-    @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])
-        }
-
-    __slots__: List[str] = ['_results', '_next_page_token']
-
-    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
-
-    @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_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):
     _search_text: Optional[str] = None
     _label: Optional[str] = None
@@ -65163,20 +65073,16 @@ class scout_video_api_UpdateVideoFileRequest(ConjureBeanType):
             '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']
+    __slots__: List[str] = ['_video_rid', '_title', '_description', '_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:
+    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
         self._title = title
         self._description = description
-        self._labels = labels
-        self._properties = properties
         self._starting_timestamp = starting_timestamp
         self._scale_parameter = scale_parameter
 
@@ -65192,14 +65098,6 @@ class scout_video_api_UpdateVideoFileRequest(ConjureBeanType):
     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
@@ -65457,23 +65355,19 @@ class scout_video_api_VideoFile(ConjureBeanType):
             '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_VideoFileOriginMetadata),
             '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']
+    __slots__: List[str] = ['_rid', '_video_rid', '_title', '_description', '_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_VideoFileOriginMetadata", properties: Dict[str, str], rid: str, title: str, video_rid: str, description: Optional[str] = None, segment_metadata: Optional["scout_video_api_VideoFileSegmentsMetadata"] = None) -> None:
+    def __init__(self, created_at: str, created_by: str, origin_metadata: "scout_video_api_VideoFileOriginMetadata", 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
@@ -65495,14 +65389,6 @@ class scout_video_api_VideoFile(ConjureBeanType):
     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

{nominal_api-0.582.0 → nominal_api-0.584.0}/nominal_api/scout_api/__init__.py

@@ -1,7 +1,9 @@
 # coding=utf-8
 from .._impl import (
     scout_api_ChannelLocator as ChannelLocator,
+    scout_api_DataScope as DataScope,
     scout_api_DataSourceRefName as DataSourceRefName,
     scout_api_HexColor as HexColor,
+    scout_api_WeakTimestampType as WeakTimestampType,
 )
 

{nominal_api-0.582.0 → nominal_api-0.584.0}/nominal_api/scout_run_api/__init__.py

@@ -24,7 +24,6 @@ from .._impl import (
     scout_run_api_Run as Run,
     scout_run_api_RunDataReviewEvaluationStatus as RunDataReviewEvaluationStatus,
     scout_run_api_RunDataReviewSummary as RunDataReviewSummary,
-    scout_run_api_RunDataSource as RunDataSource,
     scout_run_api_RunRid as RunRid,
     scout_run_api_RunWithDataReviewMetrics as RunWithDataReviewMetrics,
     scout_run_api_RunWithDataReviewSummary as RunWithDataReviewSummary,
@@ -42,6 +41,5 @@ from .._impl import (
     scout_run_api_UpdateAttachmentsRequest as UpdateAttachmentsRequest,
     scout_run_api_UpdateRunRequest as UpdateRunRequest,
     scout_run_api_UtcTimestamp as UtcTimestamp,
-    scout_run_api_WeakTimestampType as WeakTimestampType,
 )
 

{nominal_api-0.582.0 → nominal_api-0.584.0}/nominal_api/scout_video_api/__init__.py

@@ -19,8 +19,6 @@ from .._impl import (
     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,

{nominal_api-0.582.0 → nominal_api-0.584.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.582.0 → nominal_api-0.584.0}/setup.py

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