nominal-api 0.562.0__tar.gz → 0.564.0__tar.gz

{nominal_api-0.562.0 → nominal_api-0.564.0}/PKG-INFO

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

{nominal_api-0.562.0 → nominal_api-0.564.0}/nominal_api/__init__.py

@@ -69,5 +69,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.562.0"
+__version__ = "0.564.0"
 

{nominal_api-0.562.0 → nominal_api-0.564.0}/nominal_api/_impl.py

@@ -7356,31 +7356,24 @@ ingest_api_IngestMcapRequest.__module__ = "nominal_api.ingest_api"
 
 class ingest_api_IngestMcapResponse(ConjureBeanType):
     """
-    Returns references to the data ingested from an MCAP file, along with a rid to monitor the progress of the
-ingestion.
+    Returns references to the data ingested from an MCAP file.
     """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'outputs': ConjureFieldDefinition('outputs', List[ingest_api_McapIngestionOutput]),
-            'async_handle': ConjureFieldDefinition('asyncHandle', ingest_api_AsyncHandle)
+            'outputs': ConjureFieldDefinition('outputs', List[ingest_api_McapIngestionOutput])
         }
 
-    __slots__: List[str] = ['_outputs', '_async_handle']
+    __slots__: List[str] = ['_outputs']
 
-    def __init__(self, async_handle: "ingest_api_AsyncHandle", outputs: List["ingest_api_McapIngestionOutput"]) -> None:
+    def __init__(self, outputs: List["ingest_api_McapIngestionOutput"]) -> None:
         self._outputs = outputs
-        self._async_handle = async_handle
 
     @builtins.property
     def outputs(self) -> List["ingest_api_McapIngestionOutput"]:
         return self._outputs
 
-    @builtins.property
-    def async_handle(self) -> "ingest_api_AsyncHandle":
-        return self._async_handle
-
 
 ingest_api_IngestMcapResponse.__name__ = "IngestMcapResponse"
 ingest_api_IngestMcapResponse.__qualname__ = "IngestMcapResponse"
@@ -8205,24 +8198,18 @@ class ingest_api_IngestVideoResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid),
-            'async_handle': ConjureFieldDefinition('asyncHandle', ingest_api_AsyncHandle)
+            'video_rid': ConjureFieldDefinition('videoRid', api_rids_VideoRid)
         }
 
-    __slots__: List[str] = ['_video_rid', '_async_handle']
+    __slots__: List[str] = ['_video_rid']
 
-    def __init__(self, async_handle: "ingest_api_AsyncHandle", video_rid: str) -> None:
+    def __init__(self, video_rid: str) -> None:
         self._video_rid = video_rid
-        self._async_handle = async_handle
 
     @builtins.property
     def video_rid(self) -> str:
         return self._video_rid
 
-    @builtins.property
-    def async_handle(self) -> "ingest_api_AsyncHandle":
-        return self._async_handle
-
 
 ingest_api_IngestVideoResponse.__name__ = "IngestVideoResponse"
 ingest_api_IngestVideoResponse.__qualname__ = "IngestVideoResponse"
@@ -42822,22 +42809,20 @@ scout_compute_resolved_api_LatLongGeoNode.__qualname__ = "LatLongGeoNode"
 scout_compute_resolved_api_LatLongGeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
-class scout_compute_resolved_api_LogFilterRangesNode(ConjureBeanType):
+class scout_compute_resolved_api_LogFilterSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'input': ConjureFieldDefinition('input', scout_compute_resolved_api_LogSeriesNode),
-            'operator': ConjureFieldDefinition('operator', scout_compute_api_LogFilterOperator),
-            'persistence_window_configuration': ConjureFieldDefinition('persistenceWindowConfiguration', OptionalTypeWrapper[scout_compute_resolved_api_PersistenceWindowConfiguration])
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_LogFilterOperator)
         }
 
-    __slots__: List[str] = ['_input', '_operator', '_persistence_window_configuration']
+    __slots__: List[str] = ['_input', '_operator']
 
-    def __init__(self, input: "scout_compute_resolved_api_LogSeriesNode", operator: "scout_compute_api_LogFilterOperator", persistence_window_configuration: Optional["scout_compute_resolved_api_PersistenceWindowConfiguration"] = None) -> None:
+    def __init__(self, input: "scout_compute_resolved_api_LogSeriesNode", operator: "scout_compute_api_LogFilterOperator") -> None:
         self._input = input
         self._operator = operator
-        self._persistence_window_configuration = persistence_window_configuration
 
     @builtins.property
     def input(self) -> "scout_compute_resolved_api_LogSeriesNode":
@@ -42847,52 +42832,16 @@ class scout_compute_resolved_api_LogFilterRangesNode(ConjureBeanType):
     def operator(self) -> "scout_compute_api_LogFilterOperator":
         return self._operator
 
-    @builtins.property
-    def persistence_window_configuration(self) -> Optional["scout_compute_resolved_api_PersistenceWindowConfiguration"]:
-        return self._persistence_window_configuration
-
-
-scout_compute_resolved_api_LogFilterRangesNode.__name__ = "LogFilterRangesNode"
-scout_compute_resolved_api_LogFilterRangesNode.__qualname__ = "LogFilterRangesNode"
-scout_compute_resolved_api_LogFilterRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
-
-
-class scout_compute_resolved_api_LogFilterTransformationSeriesNode(ConjureBeanType):
-    """
-    Outputs the values of the log plot value within the ranges specified by a ranges node
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_LogSeriesNode),
-            'filter': ConjureFieldDefinition('filter', scout_compute_resolved_api_RangesNode)
-        }
-
-    __slots__: List[str] = ['_input', '_filter']
-
-    def __init__(self, filter: "scout_compute_resolved_api_RangesNode", input: "scout_compute_resolved_api_LogSeriesNode") -> None:
-        self._input = input
-        self._filter = filter
-
-    @builtins.property
-    def input(self) -> "scout_compute_resolved_api_LogSeriesNode":
-        return self._input
-
-    @builtins.property
-    def filter(self) -> "scout_compute_resolved_api_RangesNode":
-        return self._filter
 
-
-scout_compute_resolved_api_LogFilterTransformationSeriesNode.__name__ = "LogFilterTransformationSeriesNode"
-scout_compute_resolved_api_LogFilterTransformationSeriesNode.__qualname__ = "LogFilterTransformationSeriesNode"
-scout_compute_resolved_api_LogFilterTransformationSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+scout_compute_resolved_api_LogFilterSeriesNode.__name__ = "LogFilterSeriesNode"
+scout_compute_resolved_api_LogFilterSeriesNode.__qualname__ = "LogFilterSeriesNode"
+scout_compute_resolved_api_LogFilterSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
 class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
     _raw: Optional["scout_compute_resolved_api_RawLogSeriesNode"] = None
     _union: Optional["scout_compute_resolved_api_LogUnionSeriesNode"] = None
-    _filter_transformation: Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"] = None
+    _filter: Optional["scout_compute_resolved_api_LogFilterSeriesNode"] = None
     _time_shift: Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"] = None
 
     @builtins.classmethod
@@ -42900,7 +42849,7 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
         return {
             'raw': ConjureFieldDefinition('raw', scout_compute_resolved_api_RawLogSeriesNode),
             'union': ConjureFieldDefinition('union', scout_compute_resolved_api_LogUnionSeriesNode),
-            'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_LogFilterTransformationSeriesNode),
+            'filter': ConjureFieldDefinition('filter', scout_compute_resolved_api_LogFilterSeriesNode),
             'time_shift': ConjureFieldDefinition('timeShift', scout_compute_resolved_api_LogTimeShiftSeriesNode)
         }
 
@@ -42908,12 +42857,12 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
             self,
             raw: Optional["scout_compute_resolved_api_RawLogSeriesNode"] = None,
             union: Optional["scout_compute_resolved_api_LogUnionSeriesNode"] = None,
-            filter_transformation: Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"] = None,
+            filter: Optional["scout_compute_resolved_api_LogFilterSeriesNode"] = None,
             time_shift: Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (raw is not None) + (union is not None) + (filter_transformation is not None) + (time_shift is not None) != 1:
+            if (raw is not None) + (union is not None) + (filter is not None) + (time_shift is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if raw is not None:
@@ -42922,9 +42871,9 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
             if union is not None:
                 self._union = union
                 self._type = 'union'
-            if filter_transformation is not None:
-                self._filter_transformation = filter_transformation
-                self._type = 'filterTransformation'
+            if filter is not None:
+                self._filter = filter
+                self._type = 'filter'
             if time_shift is not None:
                 self._time_shift = time_shift
                 self._type = 'timeShift'
@@ -42939,11 +42888,11 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._union = union
             self._type = 'union'
-        elif type_of_union == 'filterTransformation':
-            if filter_transformation is None:
+        elif type_of_union == 'filter':
+            if filter is None:
                 raise ValueError('a union value must not be None')
-            self._filter_transformation = filter_transformation
-            self._type = 'filterTransformation'
+            self._filter = filter
+            self._type = 'filter'
         elif type_of_union == 'timeShift':
             if time_shift is None:
                 raise ValueError('a union value must not be None')
@@ -42959,8 +42908,8 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
         return self._union
 
     @builtins.property
-    def filter_transformation(self) -> Optional["scout_compute_resolved_api_LogFilterTransformationSeriesNode"]:
-        return self._filter_transformation
+    def filter(self) -> Optional["scout_compute_resolved_api_LogFilterSeriesNode"]:
+        return self._filter
 
     @builtins.property
     def time_shift(self) -> Optional["scout_compute_resolved_api_LogTimeShiftSeriesNode"]:
@@ -42973,8 +42922,8 @@ class scout_compute_resolved_api_LogSeriesNode(ConjureUnionType):
             return visitor._raw(self.raw)
         if self._type == 'union' and self.union is not None:
             return visitor._union(self.union)
-        if self._type == 'filterTransformation' and self.filter_transformation is not None:
-            return visitor._filter_transformation(self.filter_transformation)
+        if self._type == 'filter' and self.filter is not None:
+            return visitor._filter(self.filter)
         if self._type == 'timeShift' and self.time_shift is not None:
             return visitor._time_shift(self.time_shift)
 
@@ -42995,7 +42944,7 @@ class scout_compute_resolved_api_LogSeriesNodeVisitor:
         pass
 
     @abstractmethod
-    def _filter_transformation(self, filter_transformation: "scout_compute_resolved_api_LogFilterTransformationSeriesNode") -> Any:
+    def _filter(self, filter: "scout_compute_resolved_api_LogFilterSeriesNode") -> Any:
         pass
 
     @abstractmethod
@@ -44281,7 +44230,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     _enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None
     _extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None
     _intersect_range: Optional["scout_compute_resolved_api_IntersectRangesNode"] = None
-    _log_filter: Optional["scout_compute_resolved_api_LogFilterRangesNode"] = None
     _min_max_threshold: Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"] = None
     _not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None
     _on_change: Optional["scout_compute_resolved_api_OnChangeRangesNode"] = None
@@ -44299,7 +44247,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_resolved_api_EnumFilterRangesNode),
             'extrema': ConjureFieldDefinition('extrema', scout_compute_resolved_api_ExtremaRangesNode),
             'intersect_range': ConjureFieldDefinition('intersectRange', scout_compute_resolved_api_IntersectRangesNode),
-            'log_filter': ConjureFieldDefinition('logFilter', scout_compute_resolved_api_LogFilterRangesNode),
             'min_max_threshold': ConjureFieldDefinition('minMaxThreshold', scout_compute_resolved_api_MinMaxThresholdRangesNode),
             'not_': ConjureFieldDefinition('not', scout_compute_resolved_api_NotRangesNode),
             'on_change': ConjureFieldDefinition('onChange', scout_compute_resolved_api_OnChangeRangesNode),
@@ -44317,7 +44264,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None,
             extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None,
             intersect_range: Optional["scout_compute_resolved_api_IntersectRangesNode"] = None,
-            log_filter: Optional["scout_compute_resolved_api_LogFilterRangesNode"] = None,
             min_max_threshold: Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"] = None,
             not_: Optional["scout_compute_resolved_api_NotRangesNode"] = None,
             on_change: Optional["scout_compute_resolved_api_OnChangeRangesNode"] = None,
@@ -44330,7 +44276,7 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (log_filter is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (range_numeric_aggregation is not None) + (series_crossover_ranges_node is not None) + (stale_range is not None) + (stability_detection is not None) + (threshold is not None) + (union_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if enum_equality is not None:
@@ -44345,9 +44291,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             if intersect_range is not None:
                 self._intersect_range = intersect_range
                 self._type = 'intersectRange'
-            if log_filter is not None:
-                self._log_filter = log_filter
-                self._type = 'logFilter'
             if min_max_threshold is not None:
                 self._min_max_threshold = min_max_threshold
                 self._type = 'minMaxThreshold'
@@ -44396,11 +44339,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._intersect_range = intersect_range
             self._type = 'intersectRange'
-        elif type_of_union == 'logFilter':
-            if log_filter is None:
-                raise ValueError('a union value must not be None')
-            self._log_filter = log_filter
-            self._type = 'logFilter'
         elif type_of_union == 'minMaxThreshold':
             if min_max_threshold is None:
                 raise ValueError('a union value must not be None')
@@ -44463,10 +44401,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     def intersect_range(self) -> Optional["scout_compute_resolved_api_IntersectRangesNode"]:
         return self._intersect_range
 
-    @builtins.property
-    def log_filter(self) -> Optional["scout_compute_resolved_api_LogFilterRangesNode"]:
-        return self._log_filter
-
     @builtins.property
     def min_max_threshold(self) -> Optional["scout_compute_resolved_api_MinMaxThresholdRangesNode"]:
         return self._min_max_threshold
@@ -44514,8 +44448,6 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             return visitor._extrema(self.extrema)
         if self._type == 'intersectRange' and self.intersect_range is not None:
             return visitor._intersect_range(self.intersect_range)
-        if self._type == 'logFilter' and self.log_filter is not None:
-            return visitor._log_filter(self.log_filter)
         if self._type == 'minMaxThreshold' and self.min_max_threshold is not None:
             return visitor._min_max_threshold(self.min_max_threshold)
         if self._type == 'not' and self.not_ is not None:
@@ -44559,10 +44491,6 @@ class scout_compute_resolved_api_RangesNodeVisitor:
     def _intersect_range(self, intersect_range: "scout_compute_resolved_api_IntersectRangesNode") -> Any:
         pass
 
-    @abstractmethod
-    def _log_filter(self, log_filter: "scout_compute_resolved_api_LogFilterRangesNode") -> Any:
-        pass
-
     @abstractmethod
     def _min_max_threshold(self, min_max_threshold: "scout_compute_resolved_api_MinMaxThresholdRangesNode") -> Any:
         pass
@@ -61883,6 +61811,41 @@ class scout_video_VideoSegmentService(Service):
 at the segment-level.
     """
 
+    def get_segment_data(self, auth_header: str, segment_rid: str, video_rid: str) -> Any:
+        """
+        Retrieves the raw bytes of a video segment. The data will be returned as a transport stream.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/octet-stream',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'videoRid': video_rid,
+            'segmentRid': segment_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/video/v1/videos/{videoRid}/segments/{segmentRid}'
+        _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
+
     def create_segments(self, auth_header: str, request: "scout_video_api_CreateSegmentsRequest", video_rid: str) -> "scout_video_api_CreateSegmentsResponse":
 
         _headers: Dict[str, Any] = {
@@ -62305,36 +62268,6 @@ links to all of the segments in the video in sequential order.
         _raw.decode_content = True
         return _raw
 
-    def update_target_duration(self, auth_header: str, request: "scout_video_api_UpdateTargetDurationRequest", video_rid: str) -> "scout_video_api_UpdateTargetDurationResponse":
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'videoRid': video_rid,
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/video/v1/videos/{videoRid}/target-duration'
-        _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_UpdateTargetDurationResponse, self._return_none_for_unknown_union_types)
-
     def get_segment_summaries(self, auth_header: str, video_rid: str) -> List["scout_video_api_SegmentSummary"]:
         """
         Returns the min and max absolute and media timestamps for each segment in a video. To be used during 
@@ -63428,48 +63361,33 @@ class scout_video_api_SegmentTimestamps(ConjureUnionType):
 be frame-mapped. Without a frame-timestamp mapping manifest file, a list of absolute timestamps will be
 automatically assigned to each segment based on media timestamps.. Otherwise, media timestamps will be
 extracted and mapped to those in the provided manifest."""
-    _timestamps: Optional[List["api_Timestamp"]] = None
     _timestamp_mappings: Optional["scout_video_api_TimestampMappings"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
             'timestamp_mappings': ConjureFieldDefinition('timestampMappings', scout_video_api_TimestampMappings)
         }
 
     def __init__(
             self,
-            timestamps: Optional[List["api_Timestamp"]] = None,
             timestamp_mappings: Optional["scout_video_api_TimestampMappings"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (timestamps is not None) + (timestamp_mappings is not None) != 1:
+            if (timestamp_mappings is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
-            if timestamps is not None:
-                self._timestamps = timestamps
-                self._type = 'timestamps'
             if timestamp_mappings is not None:
                 self._timestamp_mappings = timestamp_mappings
                 self._type = 'timestampMappings'
 
-        elif type_of_union == 'timestamps':
-            if timestamps is None:
-                raise ValueError('a union value must not be None')
-            self._timestamps = timestamps
-            self._type = 'timestamps'
         elif type_of_union == 'timestampMappings':
             if timestamp_mappings is None:
                 raise ValueError('a union value must not be None')
             self._timestamp_mappings = timestamp_mappings
             self._type = 'timestampMappings'
 
-    @builtins.property
-    def timestamps(self) -> Optional[List["api_Timestamp"]]:
-        return self._timestamps
-
     @builtins.property
     def timestamp_mappings(self) -> Optional["scout_video_api_TimestampMappings"]:
         return self._timestamp_mappings
@@ -63477,8 +63395,6 @@ extracted and mapped to those in the provided manifest."""
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_video_api_SegmentTimestampsVisitor):
             raise ValueError('{} is not an instance of scout_video_api_SegmentTimestampsVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'timestamps' and self.timestamps is not None:
-            return visitor._timestamps(self.timestamps)
         if self._type == 'timestampMappings' and self.timestamp_mappings is not None:
             return visitor._timestamp_mappings(self.timestamp_mappings)
 
@@ -63490,10 +63406,6 @@ scout_video_api_SegmentTimestamps.__module__ = "nominal_api.scout_video_api"
 
 class scout_video_api_SegmentTimestampsVisitor:
 
-    @abstractmethod
-    def _timestamps(self, timestamps: List["api_Timestamp"]) -> Any:
-        pass
-
     @abstractmethod
     def _timestamp_mappings(self, timestamp_mappings: "scout_video_api_TimestampMappings") -> Any:
         pass
@@ -63719,60 +63631,6 @@ scout_video_api_UpdateIngestStatusRequest.__qualname__ = "UpdateIngestStatusRequ
 scout_video_api_UpdateIngestStatusRequest.__module__ = "nominal_api.scout_video_api"
 
 
-class scout_video_api_UpdateTargetDurationRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'target_duration_seconds': ConjureFieldDefinition('targetDurationSeconds', float)
-        }
-
-    __slots__: List[str] = ['_target_duration_seconds']
-
-    def __init__(self, target_duration_seconds: float) -> None:
-        self._target_duration_seconds = target_duration_seconds
-
-    @builtins.property
-    def target_duration_seconds(self) -> float:
-        """
-        A value used to construct the HLS playlist which must be greater than or equal to the durations of all
-the segments within a video, when rounded to the nearest integer.
-        """
-        return self._target_duration_seconds
-
-
-scout_video_api_UpdateTargetDurationRequest.__name__ = "UpdateTargetDurationRequest"
-scout_video_api_UpdateTargetDurationRequest.__qualname__ = "UpdateTargetDurationRequest"
-scout_video_api_UpdateTargetDurationRequest.__module__ = "nominal_api.scout_video_api"
-
-
-class scout_video_api_UpdateTargetDurationResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'target_duration_seconds': ConjureFieldDefinition('targetDurationSeconds', float)
-        }
-
-    __slots__: List[str] = ['_target_duration_seconds']
-
-    def __init__(self, target_duration_seconds: float) -> None:
-        self._target_duration_seconds = target_duration_seconds
-
-    @builtins.property
-    def target_duration_seconds(self) -> float:
-        """
-        If the video already has a target duration, then the returned target duration will be the max of the one
-sent in the request and the existing target duration.
-        """
-        return self._target_duration_seconds
-
-
-scout_video_api_UpdateTargetDurationResponse.__name__ = "UpdateTargetDurationResponse"
-scout_video_api_UpdateTargetDurationResponse.__qualname__ = "UpdateTargetDurationResponse"
-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.
@@ -64462,28 +64320,19 @@ class scout_video_api_VideoOriginMetadata(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'video_sources': ConjureFieldDefinition('videoSources', List[api_Handle]),
-            'video_sources_original_handles': ConjureFieldDefinition('videoSourcesOriginalHandles', OptionalTypeWrapper[List[api_Handle]]),
             'timestamp_manifest': ConjureFieldDefinition('timestampManifest', scout_video_api_VideoTimestampManifest)
         }
 
-    __slots__: List[str] = ['_video_sources', '_video_sources_original_handles', '_timestamp_manifest']
+    __slots__: List[str] = ['_video_sources', '_timestamp_manifest']
 
-    def __init__(self, timestamp_manifest: "scout_video_api_VideoTimestampManifest", video_sources: List["api_Handle"], video_sources_original_handles: Optional[List["api_Handle"]] = None) -> None:
+    def __init__(self, timestamp_manifest: "scout_video_api_VideoTimestampManifest", video_sources: List["api_Handle"]) -> None:
         self._video_sources = video_sources
-        self._video_sources_original_handles = video_sources_original_handles
         self._timestamp_manifest = timestamp_manifest
 
     @builtins.property
     def video_sources(self) -> List["api_Handle"]:
         return self._video_sources
 
-    @builtins.property
-    def video_sources_original_handles(self) -> Optional[List["api_Handle"]]:
-        """
-        Will be present if the handles were copied from a different bucket to the Nominal bucket.
-        """
-        return self._video_sources_original_handles
-
     @builtins.property
     def timestamp_manifest(self) -> "scout_video_api_VideoTimestampManifest":
         return self._timestamp_manifest

{nominal_api-0.562.0 → nominal_api-0.564.0}/nominal_api/scout_compute_resolved_api/__init__.py

@@ -44,8 +44,7 @@ from .._impl import (
     scout_compute_resolved_api_IntersectRangesNode as IntersectRangesNode,
     scout_compute_resolved_api_LatLongBounds as LatLongBounds,
     scout_compute_resolved_api_LatLongGeoNode as LatLongGeoNode,
-    scout_compute_resolved_api_LogFilterRangesNode as LogFilterRangesNode,
-    scout_compute_resolved_api_LogFilterTransformationSeriesNode as LogFilterTransformationSeriesNode,
+    scout_compute_resolved_api_LogFilterSeriesNode as LogFilterSeriesNode,
     scout_compute_resolved_api_LogSeriesNode as LogSeriesNode,
     scout_compute_resolved_api_LogSeriesNodeVisitor as LogSeriesNodeVisitor,
     scout_compute_resolved_api_LogTimeShiftSeriesNode as LogTimeShiftSeriesNode,

{nominal_api-0.562.0 → nominal_api-0.564.0}/nominal_api/scout_video_api/__init__.py

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

{nominal_api-0.562.0 → nominal_api-0.564.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.562.0 → nominal_api-0.564.0}/setup.py

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