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

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

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

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

@@ -62,6 +62,8 @@ __all__ = [
     'themes_api',
     'timeseries_archetype',
     'timeseries_archetype_api',
+    'timeseries_channelmetadata',
+    'timeseries_channelmetadata_api',
     'timeseries_logicalseries',
     'timeseries_logicalseries_api',
     'timeseries_seriescache',
@@ -71,5 +73,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.580.0"
+__version__ = "0.582.0"
 

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

@@ -63358,8 +63358,7 @@ at the segment-level.
 
     def get_segment_by_timestamp(self, auth_header: str, request: "scout_video_api_GetSegmentByTimestampRequest", video_rid: str) -> Optional["scout_video_api_Segment"]:
         """
-        Returns metadata for the segment containing the requested absolute timestamp. This endpoint should only be 
-used for videos that were ingested with frame-level timestamps.
+        Returns metadata for the segment within a video containing the requested absolute timestamp.
         """
 
         _headers: Dict[str, Any] = {
@@ -63787,6 +63786,35 @@ scout_video_VideoService.__qualname__ = "VideoService"
 scout_video_VideoService.__module__ = "nominal_api.scout_video"
 
 
+class scout_video_api_Bounds(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'start': ConjureFieldDefinition('start', api_Timestamp),
+            'end': ConjureFieldDefinition('end', api_Timestamp)
+        }
+
+    __slots__: List[str] = ['_start', '_end']
+
+    def __init__(self, end: "api_Timestamp", start: "api_Timestamp") -> None:
+        self._start = start
+        self._end = end
+
+    @builtins.property
+    def start(self) -> "api_Timestamp":
+        return self._start
+
+    @builtins.property
+    def end(self) -> "api_Timestamp":
+        return self._end
+
+
+scout_video_api_Bounds.__name__ = "Bounds"
+scout_video_api_Bounds.__qualname__ = "Bounds"
+scout_video_api_Bounds.__module__ = "nominal_api.scout_video_api"
+
+
 class scout_video_api_CreateSegment(ConjureBeanType):
 
     @builtins.classmethod
@@ -64138,18 +64166,31 @@ class scout_video_api_GetSegmentByTimestampRequest(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp)
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp),
+            'view_range_start': ConjureFieldDefinition('viewRangeStart', OptionalTypeWrapper[api_Timestamp])
         }
 
-    __slots__: List[str] = ['_timestamp']
+    __slots__: List[str] = ['_timestamp', '_view_range_start']
 
-    def __init__(self, timestamp: "api_Timestamp") -> None:
+    def __init__(self, timestamp: "api_Timestamp", view_range_start: Optional["api_Timestamp"] = None) -> None:
         self._timestamp = timestamp
+        self._view_range_start = view_range_start
 
     @builtins.property
     def timestamp(self) -> "api_Timestamp":
         return self._timestamp
 
+    @builtins.property
+    def view_range_start(self) -> Optional["api_Timestamp"]:
+        """
+        The start of the view range used to dynamically calculate media timestamps. The first segment with an 
+overlap with the time bounds will have its minimum media timestamp set to 0, with every subsequent
+segment building media time cumulatively from that offset. This will determine the starting media
+timestamp of the returned segment. The view range should be the same as the one requested to get the
+playlist and segment summaries.
+        """
+        return self._view_range_start
+
 
 scout_video_api_GetSegmentByTimestampRequest.__name__ = "GetSegmentByTimestampRequest"
 scout_video_api_GetSegmentByTimestampRequest.__qualname__ = "GetSegmentByTimestampRequest"
@@ -70160,6 +70201,367 @@ timeseries_archetype_api_VisualCrossingLocatorTemplate.__qualname__ = "VisualCro
 timeseries_archetype_api_VisualCrossingLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
 
 
+class timeseries_channelmetadata_ChannelMetadataService(Service):
+    """
+    Endpoints for retrieving and updating channel metadata.
+    """
+
+    def get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_GetChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
+        """
+        Get the metadata for a channel.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/get'
+        _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(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
+
+    def batch_get_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchGetChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchGetChannelMetadataResponse":
+        """
+        Batch get the metadata for multiple channels. If some channels cannot be found or authorized, 
+they will be omitted from the response.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/batch-get'
+        _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(), timeseries_channelmetadata_api_BatchGetChannelMetadataResponse, self._return_none_for_unknown_union_types)
+
+    def update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_UpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_ChannelMetadata":
+        """
+        Update the metadata for a channel.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/update'
+        _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(), timeseries_channelmetadata_api_ChannelMetadata, self._return_none_for_unknown_union_types)
+
+    def batch_update_channel_metadata(self, auth_header: str, request: "timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest") -> "timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse":
+        """
+        Batch update the metadata for multiple channels. If some channels cannot be found or authorized,
+no metadata will be updated for any of the channels in the request.
+        """
+
+        _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 = '/timeseries/channel-metadata/v1/channel-metadata/batch-update'
+        _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(), timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse, self._return_none_for_unknown_union_types)
+
+
+timeseries_channelmetadata_ChannelMetadataService.__name__ = "ChannelMetadataService"
+timeseries_channelmetadata_ChannelMetadataService.__qualname__ = "ChannelMetadataService"
+timeseries_channelmetadata_ChannelMetadataService.__module__ = "nominal_api.timeseries_channelmetadata"
+
+
+class timeseries_channelmetadata_api_BatchGetChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_GetChannelMetadataRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> List["timeseries_channelmetadata_api_GetChannelMetadataRequest"]:
+        return self._requests
+
+
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__name__ = "BatchGetChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__qualname__ = "BatchGetChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchGetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_BatchGetChannelMetadataResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
+        self._responses = responses
+
+    @builtins.property
+    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
+        return self._responses
+
+
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__name__ = "BatchGetChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__qualname__ = "BatchGetChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchGetChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', List[timeseries_channelmetadata_api_UpdateChannelMetadataRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> List["timeseries_channelmetadata_api_UpdateChannelMetadataRequest"]:
+        return self._requests
+
+
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__name__ = "BatchUpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__qualname__ = "BatchUpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'responses': ConjureFieldDefinition('responses', List[timeseries_channelmetadata_api_ChannelMetadata])
+        }
+
+    __slots__: List[str] = ['_responses']
+
+    def __init__(self, responses: List["timeseries_channelmetadata_api_ChannelMetadata"]) -> None:
+        self._responses = responses
+
+    @builtins.property
+    def responses(self) -> List["timeseries_channelmetadata_api_ChannelMetadata"]:
+        return self._responses
+
+
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__name__ = "BatchUpdateChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__qualname__ = "BatchUpdateChannelMetadataResponse"
+timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_ChannelIdentifier(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_name': ConjureFieldDefinition('channelName', api_Channel),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid)
+        }
+
+    __slots__: List[str] = ['_channel_name', '_data_source_rid']
+
+    def __init__(self, channel_name: str, data_source_rid: str) -> None:
+        self._channel_name = channel_name
+        self._data_source_rid = data_source_rid
+
+    @builtins.property
+    def channel_name(self) -> str:
+        return self._channel_name
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
+
+
+timeseries_channelmetadata_api_ChannelIdentifier.__name__ = "ChannelIdentifier"
+timeseries_channelmetadata_api_ChannelIdentifier.__qualname__ = "ChannelIdentifier"
+timeseries_channelmetadata_api_ChannelIdentifier.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_ChannelMetadata(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
+            'data_type': ConjureFieldDefinition('dataType', OptionalTypeWrapper[api_SeriesDataType])
+        }
+
+    __slots__: List[str] = ['_channel_identifier', '_description', '_unit', '_data_type']
+
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", data_type: Optional["api_SeriesDataType"] = None, description: Optional[str] = None, unit: Optional[str] = None) -> None:
+        self._channel_identifier = channel_identifier
+        self._description = description
+        self._unit = unit
+        self._data_type = data_type
+
+    @builtins.property
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def unit(self) -> Optional[str]:
+        return self._unit
+
+    @builtins.property
+    def data_type(self) -> Optional["api_SeriesDataType"]:
+        return self._data_type
+
+
+timeseries_channelmetadata_api_ChannelMetadata.__name__ = "ChannelMetadata"
+timeseries_channelmetadata_api_ChannelMetadata.__qualname__ = "ChannelMetadata"
+timeseries_channelmetadata_api_ChannelMetadata.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_GetChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier)
+        }
+
+    __slots__: List[str] = ['_channel_identifier']
+
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier") -> None:
+        self._channel_identifier = channel_identifier
+
+    @builtins.property
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
+
+
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__name__ = "GetChannelMetadataRequest"
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__qualname__ = "GetChannelMetadataRequest"
+timeseries_channelmetadata_api_GetChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
+class timeseries_channelmetadata_api_UpdateChannelMetadataRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_identifier': ConjureFieldDefinition('channelIdentifier', timeseries_channelmetadata_api_ChannelIdentifier),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'unit_update': ConjureFieldDefinition('unitUpdate', OptionalTypeWrapper[timeseries_logicalseries_api_UnitUpdate])
+        }
+
+    __slots__: List[str] = ['_channel_identifier', '_description', '_unit_update']
+
+    def __init__(self, channel_identifier: "timeseries_channelmetadata_api_ChannelIdentifier", description: Optional[str] = None, unit_update: Optional["timeseries_logicalseries_api_UnitUpdate"] = None) -> None:
+        self._channel_identifier = channel_identifier
+        self._description = description
+        self._unit_update = unit_update
+
+    @builtins.property
+    def channel_identifier(self) -> "timeseries_channelmetadata_api_ChannelIdentifier":
+        return self._channel_identifier
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def unit_update(self) -> Optional["timeseries_logicalseries_api_UnitUpdate"]:
+        return self._unit_update
+
+
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__name__ = "UpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__qualname__ = "UpdateChannelMetadataRequest"
+timeseries_channelmetadata_api_UpdateChannelMetadataRequest.__module__ = "nominal_api.timeseries_channelmetadata_api"
+
+
 class timeseries_logicalseries_LogicalSeriesService(Service):
     """
     A logical series is a timeseries, represented by a channel name and a tag set.

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

@@ -1,5 +1,6 @@
 # coding=utf-8
 from .._impl import (
+    scout_video_api_Bounds as Bounds,
     scout_video_api_CreateSegment as CreateSegment,
     scout_video_api_CreateSegmentsRequest as CreateSegmentsRequest,
     scout_video_api_CreateSegmentsResponse as CreateSegmentsResponse,

nominal_api-0.582.0/nominal_api/timeseries_channelmetadata/__init__.py

@@ -0,0 +1,5 @@
+# coding=utf-8
+from .._impl import (
+    timeseries_channelmetadata_ChannelMetadataService as ChannelMetadataService,
+)
+

nominal_api-0.582.0/nominal_api/timeseries_channelmetadata_api/__init__.py

@@ -0,0 +1,12 @@
+# coding=utf-8
+from .._impl import (
+    timeseries_channelmetadata_api_BatchGetChannelMetadataRequest as BatchGetChannelMetadataRequest,
+    timeseries_channelmetadata_api_BatchGetChannelMetadataResponse as BatchGetChannelMetadataResponse,
+    timeseries_channelmetadata_api_BatchUpdateChannelMetadataRequest as BatchUpdateChannelMetadataRequest,
+    timeseries_channelmetadata_api_BatchUpdateChannelMetadataResponse as BatchUpdateChannelMetadataResponse,
+    timeseries_channelmetadata_api_ChannelIdentifier as ChannelIdentifier,
+    timeseries_channelmetadata_api_ChannelMetadata as ChannelMetadata,
+    timeseries_channelmetadata_api_GetChannelMetadataRequest as GetChannelMetadataRequest,
+    timeseries_channelmetadata_api_UpdateChannelMetadataRequest as UpdateChannelMetadataRequest,
+)
+

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

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

{nominal_api-0.580.0 → nominal_api-0.582.0}/nominal_api.egg-info/SOURCES.txt

@@ -69,6 +69,8 @@ nominal_api/storage_writer_api/__init__.py
 nominal_api/themes_api/__init__.py
 nominal_api/timeseries_archetype/__init__.py
 nominal_api/timeseries_archetype_api/__init__.py
+nominal_api/timeseries_channelmetadata/__init__.py
+nominal_api/timeseries_channelmetadata_api/__init__.py
 nominal_api/timeseries_logicalseries/__init__.py
 nominal_api/timeseries_logicalseries_api/__init__.py
 nominal_api/timeseries_seriescache/__init__.py

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

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