nominal-api 0.701.2__py3-none-any.whl → 0.703.0__py3-none-any.whl

nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.701.2"
+__version__ = "0.703.0"
 

nominal_api/_impl.py

@@ -5546,6 +5546,52 @@ event_BatchUpdateDispositionResponse.__qualname__ = "BatchUpdateDispositionRespo
 event_BatchUpdateDispositionResponse.__module__ = "nominal_api.event"
 
 
+class event_BatchUpdateEventRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', List[event_UpdateEventRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: List["event_UpdateEventRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> List["event_UpdateEventRequest"]:
+        return self._requests
+
+
+event_BatchUpdateEventRequest.__name__ = "BatchUpdateEventRequest"
+event_BatchUpdateEventRequest.__qualname__ = "BatchUpdateEventRequest"
+event_BatchUpdateEventRequest.__module__ = "nominal_api.event"
+
+
+class event_BatchUpdateEventResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'events': ConjureFieldDefinition('events', List[event_Event])
+        }
+
+    __slots__: List[str] = ['_events']
+
+    def __init__(self, events: List["event_Event"]) -> None:
+        self._events = events
+
+    @builtins.property
+    def events(self) -> List["event_Event"]:
+        return self._events
+
+
+event_BatchUpdateEventResponse.__name__ = "BatchUpdateEventResponse"
+event_BatchUpdateEventResponse.__qualname__ = "BatchUpdateEventResponse"
+event_BatchUpdateEventResponse.__module__ = "nominal_api.event"
+
+
 class event_CheckOriginMetadata(ConjureBeanType):
 
     @builtins.classmethod
@@ -6142,6 +6188,39 @@ The Event Service is responsible for creating and retrieving events for a partic
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), event_Event, self._return_none_for_unknown_union_types)
 
+    def batch_update_event(self, auth_header: str, request: "event_BatchUpdateEventRequest") -> "event_BatchUpdateEventResponse":
+        """
+        Updates the fields of an event specified by each request in the batch.
+Empty fields in the UpdateEventRequest are left unchanged.
+        """
+
+        _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 = '/event/v1/events/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(), event_BatchUpdateEventResponse, self._return_none_for_unknown_union_types)
+
     def batch_update_disposition(self, auth_header: str, request: "event_BatchUpdateDispositionRequest") -> "event_BatchUpdateDispositionResponse":
         """
         Updates the disposition of an event.
@@ -6494,6 +6573,7 @@ class event_HistogramFilterQuery(ConjureUnionType):
     _property: Optional["api_Property"] = None
     _and_: Optional[List["event_HistogramFilterQuery"]] = None
     _or_: Optional[List["event_HistogramFilterQuery"]] = None
+    _not_: Optional["event_HistogramFilterQuery"] = None
     _workspace: Optional[str] = None
 
     @builtins.classmethod
@@ -6514,6 +6594,7 @@ class event_HistogramFilterQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_Property),
             'and_': ConjureFieldDefinition('and', List[event_HistogramFilterQuery]),
             'or_': ConjureFieldDefinition('or', List[event_HistogramFilterQuery]),
+            'not_': ConjureFieldDefinition('not', event_HistogramFilterQuery),
             'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
@@ -6534,11 +6615,12 @@ class event_HistogramFilterQuery(ConjureUnionType):
             property: Optional["api_Property"] = None,
             and_: Optional[List["event_HistogramFilterQuery"]] = None,
             or_: Optional[List["event_HistogramFilterQuery"]] = None,
+            not_: Optional["event_HistogramFilterQuery"] = None,
             workspace: Optional[str] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (search_text is not None) + (asset is not None) + (template is not None) + (workbook is not None) + (data_review is not None) + (origin_type is not None) + (data_review_check is not None) + (disposition_status is not None) + (priority is not None) + (assignee is not None) + (event_type is not None) + (label is not None) + (property is not None) + (and_ is not None) + (or_ is not None) + (workspace is not None) != 1:
+            if (search_text is not None) + (asset is not None) + (template is not None) + (workbook is not None) + (data_review is not None) + (origin_type is not None) + (data_review_check is not None) + (disposition_status is not None) + (priority is not None) + (assignee is not None) + (event_type is not None) + (label is not None) + (property is not None) + (and_ is not None) + (or_ is not None) + (not_ is not None) + (workspace is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if search_text is not None:
@@ -6586,6 +6668,9 @@ class event_HistogramFilterQuery(ConjureUnionType):
             if or_ is not None:
                 self._or_ = or_
                 self._type = 'or'
+            if not_ is not None:
+                self._not_ = not_
+                self._type = 'not'
             if workspace is not None:
                 self._workspace = workspace
                 self._type = 'workspace'
@@ -6665,6 +6750,11 @@ class event_HistogramFilterQuery(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._or_ = or_
             self._type = 'or'
+        elif type_of_union == 'not':
+            if not_ is None:
+                raise ValueError('a union value must not be None')
+            self._not_ = not_
+            self._type = 'not'
         elif type_of_union == 'workspace':
             if workspace is None:
                 raise ValueError('a union value must not be None')
@@ -6731,6 +6821,10 @@ class event_HistogramFilterQuery(ConjureUnionType):
     def or_(self) -> Optional[List["event_HistogramFilterQuery"]]:
         return self._or_
 
+    @builtins.property
+    def not_(self) -> Optional["event_HistogramFilterQuery"]:
+        return self._not_
+
     @builtins.property
     def workspace(self) -> Optional[str]:
         return self._workspace
@@ -6768,6 +6862,8 @@ class event_HistogramFilterQuery(ConjureUnionType):
             return visitor._and(self.and_)
         if self._type == 'or' and self.or_ is not None:
             return visitor._or(self.or_)
+        if self._type == 'not' and self.not_ is not None:
+            return visitor._not(self.not_)
         if self._type == 'workspace' and self.workspace is not None:
             return visitor._workspace(self.workspace)
 
@@ -6839,6 +6935,10 @@ class event_HistogramFilterQueryVisitor:
     def _or(self, or_: List["event_HistogramFilterQuery"]) -> Any:
         pass
 
+    @abstractmethod
+    def _not(self, not_: "event_HistogramFilterQuery") -> Any:
+        pass
+
     @abstractmethod
     def _workspace(self, workspace: str) -> Any:
         pass
@@ -6971,6 +7071,7 @@ class event_SearchQuery(ConjureUnionType):
     _property: Optional["api_Property"] = None
     _and_: Optional[List["event_SearchQuery"]] = None
     _or_: Optional[List["event_SearchQuery"]] = None
+    _not_: Optional["event_SearchQuery"] = None
     _workspace: Optional[str] = None
 
     @builtins.classmethod
@@ -6993,6 +7094,7 @@ class event_SearchQuery(ConjureUnionType):
             'property': ConjureFieldDefinition('property', api_Property),
             'and_': ConjureFieldDefinition('and', List[event_SearchQuery]),
             'or_': ConjureFieldDefinition('or', List[event_SearchQuery]),
+            'not_': ConjureFieldDefinition('not', event_SearchQuery),
             'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid)
         }
 
@@ -7015,11 +7117,12 @@ class event_SearchQuery(ConjureUnionType):
             property: Optional["api_Property"] = None,
             and_: Optional[List["event_SearchQuery"]] = None,
             or_: Optional[List["event_SearchQuery"]] = None,
+            not_: Optional["event_SearchQuery"] = None,
             workspace: Optional[str] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (search_text is not None) + (after is not None) + (before is not None) + (asset is not None) + (template is not None) + (workbook is not None) + (data_review is not None) + (origin_type is not None) + (data_review_check is not None) + (disposition_status is not None) + (priority is not None) + (assignee is not None) + (event_type is not None) + (label is not None) + (property is not None) + (and_ is not None) + (or_ is not None) + (workspace is not None) != 1:
+            if (search_text is not None) + (after is not None) + (before is not None) + (asset is not None) + (template is not None) + (workbook is not None) + (data_review is not None) + (origin_type is not None) + (data_review_check is not None) + (disposition_status is not None) + (priority is not None) + (assignee is not None) + (event_type is not None) + (label is not None) + (property is not None) + (and_ is not None) + (or_ is not None) + (not_ is not None) + (workspace is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if search_text is not None:
@@ -7073,6 +7176,9 @@ class event_SearchQuery(ConjureUnionType):
             if or_ is not None:
                 self._or_ = or_
                 self._type = 'or'
+            if not_ is not None:
+                self._not_ = not_
+                self._type = 'not'
             if workspace is not None:
                 self._workspace = workspace
                 self._type = 'workspace'
@@ -7162,6 +7268,11 @@ class event_SearchQuery(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._or_ = or_
             self._type = 'or'
+        elif type_of_union == 'not':
+            if not_ is None:
+                raise ValueError('a union value must not be None')
+            self._not_ = not_
+            self._type = 'not'
         elif type_of_union == 'workspace':
             if workspace is None:
                 raise ValueError('a union value must not be None')
@@ -7242,6 +7353,10 @@ class event_SearchQuery(ConjureUnionType):
     def or_(self) -> Optional[List["event_SearchQuery"]]:
         return self._or_
 
+    @builtins.property
+    def not_(self) -> Optional["event_SearchQuery"]:
+        return self._not_
+
     @builtins.property
     def workspace(self) -> Optional[str]:
         return self._workspace
@@ -7283,6 +7398,8 @@ class event_SearchQuery(ConjureUnionType):
             return visitor._and(self.and_)
         if self._type == 'or' and self.or_ is not None:
             return visitor._or(self.or_)
+        if self._type == 'not' and self.not_ is not None:
+            return visitor._not(self.not_)
         if self._type == 'workspace' and self.workspace is not None:
             return visitor._workspace(self.workspace)
 
@@ -7362,6 +7479,10 @@ class event_SearchQueryVisitor:
     def _or(self, or_: List["event_SearchQuery"]) -> Any:
         pass
 
+    @abstractmethod
+    def _not(self, not_: "event_SearchQuery") -> Any:
+        pass
+
     @abstractmethod
     def _workspace(self, workspace: str) -> Any:
         pass
@@ -7568,6 +7689,81 @@ event_UpdateEvent.__qualname__ = "UpdateEvent"
 event_UpdateEvent.__module__ = "nominal_api.event"
 
 
+class event_UpdateEventRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rid': ConjureFieldDefinition('rid', api_rids_EventRid),
+            'asset_rids': ConjureFieldDefinition('assetRids', OptionalTypeWrapper[List[scout_rids_api_AssetRid]]),
+            'timestamp': ConjureFieldDefinition('timestamp', OptionalTypeWrapper[api_Timestamp]),
+            'duration': ConjureFieldDefinition('duration', OptionalTypeWrapper[scout_run_api_Duration]),
+            'name': ConjureFieldDefinition('name', OptionalTypeWrapper[str]),
+            'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
+            'type': ConjureFieldDefinition('type', OptionalTypeWrapper[event_EventType]),
+            'labels': ConjureFieldDefinition('labels', OptionalTypeWrapper[List[api_Label]]),
+            'properties': ConjureFieldDefinition('properties', OptionalTypeWrapper[Dict[api_PropertyName, api_PropertyValue]])
+        }
+
+    __slots__: List[str] = ['_rid', '_asset_rids', '_timestamp', '_duration', '_name', '_description', '_type', '_labels', '_properties']
+
+    def __init__(self, rid: str, asset_rids: Optional[List[str]] = None, description: Optional[str] = None, duration: Optional["scout_run_api_Duration"] = None, labels: Optional[List[str]] = None, name: Optional[str] = None, properties: Optional[Dict[str, str]] = None, timestamp: Optional["api_Timestamp"] = None, type: Optional["event_EventType"] = None) -> None:
+        self._rid = rid
+        self._asset_rids = asset_rids
+        self._timestamp = timestamp
+        self._duration = duration
+        self._name = name
+        self._description = description
+        self._type = type
+        self._labels = labels
+        self._properties = properties
+
+    @builtins.property
+    def rid(self) -> str:
+        return self._rid
+
+    @builtins.property
+    def asset_rids(self) -> Optional[List[str]]:
+        """
+        If provided, will replace the existing asset rids.
+If provided, must contain at least one asset rid.
+        """
+        return self._asset_rids
+
+    @builtins.property
+    def timestamp(self) -> Optional["api_Timestamp"]:
+        return self._timestamp
+
+    @builtins.property
+    def duration(self) -> Optional["scout_run_api_Duration"]:
+        return self._duration
+
+    @builtins.property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @builtins.property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @builtins.property
+    def type(self) -> Optional["event_EventType"]:
+        return self._type
+
+    @builtins.property
+    def labels(self) -> Optional[List[str]]:
+        return self._labels
+
+    @builtins.property
+    def properties(self) -> Optional[Dict[str, str]]:
+        return self._properties
+
+
+event_UpdateEventRequest.__name__ = "UpdateEventRequest"
+event_UpdateEventRequest.__qualname__ = "UpdateEventRequest"
+event_UpdateEventRequest.__module__ = "nominal_api.event"
+
+
 class event_WorkbookEventOrigin(ConjureBeanType):
 
     @builtins.classmethod
@@ -38680,6 +38876,44 @@ scout_compute_api_DurationConstantVisitor.__qualname__ = "DurationConstantVisito
 scout_compute_api_DurationConstantVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_DurationFilterRanges(ConjureBeanType):
+    """
+    Filters a list of ranges down to only those satisfying a threshold condition on the range's duration.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_RangeSeries),
+            'threshold': ConjureFieldDefinition('threshold', scout_compute_api_DurationConstant),
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_ThresholdOperator)
+        }
+
+    __slots__: List[str] = ['_input', '_threshold', '_operator']
+
+    def __init__(self, input: "scout_compute_api_RangeSeries", operator: "scout_compute_api_ThresholdOperator", threshold: "scout_compute_api_DurationConstant") -> None:
+        self._input = input
+        self._threshold = threshold
+        self._operator = operator
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_RangeSeries":
+        return self._input
+
+    @builtins.property
+    def threshold(self) -> "scout_compute_api_DurationConstant":
+        return self._threshold
+
+    @builtins.property
+    def operator(self) -> "scout_compute_api_ThresholdOperator":
+        return self._operator
+
+
+scout_compute_api_DurationFilterRanges.__name__ = "DurationFilterRanges"
+scout_compute_api_DurationFilterRanges.__qualname__ = "DurationFilterRanges"
+scout_compute_api_DurationFilterRanges.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_EnumAggregationFunction(ConjureEnumType):
 
     MIN = 'MIN'
@@ -44119,6 +44353,7 @@ scout_compute_api_RangeMap.__module__ = "nominal_api.scout_compute_api"
 
 class scout_compute_api_RangeSeries(ConjureUnionType):
     _approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None
+    _duration_filter: Optional["scout_compute_api_DurationFilterRanges"] = None
     _enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None
     _enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None
     _function: Optional["scout_compute_api_RangesFunction"] = None
@@ -44141,6 +44376,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'approximate_threshold': ConjureFieldDefinition('approximateThreshold', scout_compute_api_ApproximateThresholdRanges),
+            'duration_filter': ConjureFieldDefinition('durationFilter', scout_compute_api_DurationFilterRanges),
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_api_EnumFilterRanges),
             'enum_series_equality_ranges_node': ConjureFieldDefinition('enumSeriesEqualityRangesNode', scout_compute_api_EnumSeriesEqualityRanges),
             'function': ConjureFieldDefinition('function', scout_compute_api_RangesFunction),
@@ -44163,6 +44399,7 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def __init__(
             self,
             approximate_threshold: Optional["scout_compute_api_ApproximateThresholdRanges"] = None,
+            duration_filter: Optional["scout_compute_api_DurationFilterRanges"] = None,
             enum_filter: Optional["scout_compute_api_EnumFilterRanges"] = None,
             enum_series_equality_ranges_node: Optional["scout_compute_api_EnumSeriesEqualityRanges"] = None,
             function: Optional["scout_compute_api_RangesFunction"] = None,
@@ -44183,12 +44420,15 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (approximate_threshold is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (function is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
+            if (approximate_threshold is not None) + (duration_filter is not None) + (enum_filter is not None) + (enum_series_equality_ranges_node is not None) + (function is not None) + (intersect_range is not None) + (literal_ranges is not None) + (min_max_threshold is not None) + (not_ is not None) + (on_change is not None) + (peak is not None) + (range_numeric_aggregation is not None) + (raw is not None) + (series_crossover_ranges_node is not None) + (series_equality_ranges_node is not None) + (stability_detection is not None) + (stale_range is not None) + (threshold is not None) + (union_range is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if approximate_threshold is not None:
                 self._approximate_threshold = approximate_threshold
                 self._type = 'approximateThreshold'
+            if duration_filter is not None:
+                self._duration_filter = duration_filter
+                self._type = 'durationFilter'
             if enum_filter is not None:
                 self._enum_filter = enum_filter
                 self._type = 'enumFilter'
@@ -44246,6 +44486,11 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._approximate_threshold = approximate_threshold
             self._type = 'approximateThreshold'
+        elif type_of_union == 'durationFilter':
+            if duration_filter is None:
+                raise ValueError('a union value must not be None')
+            self._duration_filter = duration_filter
+            self._type = 'durationFilter'
         elif type_of_union == 'enumFilter':
             if enum_filter is None:
                 raise ValueError('a union value must not be None')
@@ -44336,6 +44581,10 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
     def approximate_threshold(self) -> Optional["scout_compute_api_ApproximateThresholdRanges"]:
         return self._approximate_threshold
 
+    @builtins.property
+    def duration_filter(self) -> Optional["scout_compute_api_DurationFilterRanges"]:
+        return self._duration_filter
+
     @builtins.property
     def enum_filter(self) -> Optional["scout_compute_api_EnumFilterRanges"]:
         return self._enum_filter
@@ -44415,6 +44664,8 @@ class scout_compute_api_RangeSeries(ConjureUnionType):
             raise ValueError('{} is not an instance of scout_compute_api_RangeSeriesVisitor'.format(visitor.__class__.__name__))
         if self._type == 'approximateThreshold' and self.approximate_threshold is not None:
             return visitor._approximate_threshold(self.approximate_threshold)
+        if self._type == 'durationFilter' and self.duration_filter is not None:
+            return visitor._duration_filter(self.duration_filter)
         if self._type == 'enumFilter' and self.enum_filter is not None:
             return visitor._enum_filter(self.enum_filter)
         if self._type == 'enumSeriesEqualityRangesNode' and self.enum_series_equality_ranges_node is not None:
@@ -44462,6 +44713,10 @@ class scout_compute_api_RangeSeriesVisitor:
     def _approximate_threshold(self, approximate_threshold: "scout_compute_api_ApproximateThresholdRanges") -> Any:
         pass
 
+    @abstractmethod
+    def _duration_filter(self, duration_filter: "scout_compute_api_DurationFilterRanges") -> Any:
+        pass
+
     @abstractmethod
     def _enum_filter(self, enum_filter: "scout_compute_api_EnumFilterRanges") -> Any:
         pass
@@ -50669,6 +50924,41 @@ scout_compute_resolved_api_DerivativeSeriesNode.__qualname__ = "DerivativeSeries
 scout_compute_resolved_api_DerivativeSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_DurationFilterRangesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_RangesNode),
+            'threshold': ConjureFieldDefinition('threshold', scout_run_api_Duration),
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_ThresholdOperator)
+        }
+
+    __slots__: List[str] = ['_input', '_threshold', '_operator']
+
+    def __init__(self, input: "scout_compute_resolved_api_RangesNode", operator: "scout_compute_api_ThresholdOperator", threshold: "scout_run_api_Duration") -> None:
+        self._input = input
+        self._threshold = threshold
+        self._operator = operator
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_RangesNode":
+        return self._input
+
+    @builtins.property
+    def threshold(self) -> "scout_run_api_Duration":
+        return self._threshold
+
+    @builtins.property
+    def operator(self) -> "scout_compute_api_ThresholdOperator":
+        return self._operator
+
+
+scout_compute_resolved_api_DurationFilterRangesNode.__name__ = "DurationFilterRangesNode"
+scout_compute_resolved_api_DurationFilterRangesNode.__qualname__ = "DurationFilterRangesNode"
+scout_compute_resolved_api_DurationFilterRangesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_EnumCountDuplicateSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -53348,6 +53638,7 @@ scout_compute_resolved_api_RangeMap.__module__ = "nominal_api.scout_compute_reso
 
 
 class scout_compute_resolved_api_RangesNode(ConjureUnionType):
+    _duration_filter: Optional["scout_compute_resolved_api_DurationFilterRangesNode"] = None
     _enum_equality: Optional["scout_compute_resolved_api_EnumEqualityRangesNode"] = None
     _enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None
     _extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None
@@ -53366,6 +53657,7 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
+            'duration_filter': ConjureFieldDefinition('durationFilter', scout_compute_resolved_api_DurationFilterRangesNode),
             'enum_equality': ConjureFieldDefinition('enumEquality', scout_compute_resolved_api_EnumEqualityRangesNode),
             'enum_filter': ConjureFieldDefinition('enumFilter', scout_compute_resolved_api_EnumFilterRangesNode),
             'extrema': ConjureFieldDefinition('extrema', scout_compute_resolved_api_ExtremaRangesNode),
@@ -53384,6 +53676,7 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
 
     def __init__(
             self,
+            duration_filter: Optional["scout_compute_resolved_api_DurationFilterRangesNode"] = None,
             enum_equality: Optional["scout_compute_resolved_api_EnumEqualityRangesNode"] = None,
             enum_filter: Optional["scout_compute_resolved_api_EnumFilterRangesNode"] = None,
             extrema: Optional["scout_compute_resolved_api_ExtremaRangesNode"] = None,
@@ -53401,9 +53694,12 @@ 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) + (literal_ranges 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 (duration_filter is not None) + (enum_equality is not None) + (enum_filter is not None) + (extrema is not None) + (intersect_range is not None) + (literal_ranges 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 duration_filter is not None:
+                self._duration_filter = duration_filter
+                self._type = 'durationFilter'
             if enum_equality is not None:
                 self._enum_equality = enum_equality
                 self._type = 'enumEquality'
@@ -53447,6 +53743,11 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
                 self._union_range = union_range
                 self._type = 'unionRange'
 
+        elif type_of_union == 'durationFilter':
+            if duration_filter is None:
+                raise ValueError('a union value must not be None')
+            self._duration_filter = duration_filter
+            self._type = 'durationFilter'
         elif type_of_union == 'enumEquality':
             if enum_equality is None:
                 raise ValueError('a union value must not be None')
@@ -53518,6 +53819,10 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
             self._union_range = union_range
             self._type = 'unionRange'
 
+    @builtins.property
+    def duration_filter(self) -> Optional["scout_compute_resolved_api_DurationFilterRangesNode"]:
+        return self._duration_filter
+
     @builtins.property
     def enum_equality(self) -> Optional["scout_compute_resolved_api_EnumEqualityRangesNode"]:
         return self._enum_equality
@@ -53577,6 +53882,8 @@ class scout_compute_resolved_api_RangesNode(ConjureUnionType):
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_RangesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_RangesNodeVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'durationFilter' and self.duration_filter is not None:
+            return visitor._duration_filter(self.duration_filter)
         if self._type == 'enumEquality' and self.enum_equality is not None:
             return visitor._enum_equality(self.enum_equality)
         if self._type == 'enumFilter' and self.enum_filter is not None:
@@ -53614,6 +53921,10 @@ scout_compute_resolved_api_RangesNode.__module__ = "nominal_api.scout_compute_re
 
 class scout_compute_resolved_api_RangesNodeVisitor:
 
+    @abstractmethod
+    def _duration_filter(self, duration_filter: "scout_compute_resolved_api_DurationFilterRangesNode") -> Any:
+        pass
+
     @abstractmethod
     def _enum_equality(self, enum_equality: "scout_compute_resolved_api_EnumEqualityRangesNode") -> Any:
         pass
@@ -75094,12 +75405,12 @@ class scout_workbookcommon_api_EventReference(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'event_uuid': ConjureFieldDefinition('eventUuid', OptionalTypeWrapper[str]),
-            'rid': ConjureFieldDefinition('rid', OptionalTypeWrapper[api_rids_EventRid])
+            'rid': ConjureFieldDefinition('rid', api_rids_EventRid)
         }
 
     __slots__: List[str] = ['_event_uuid', '_rid']
 
-    def __init__(self, event_uuid: Optional[str] = None, rid: Optional[str] = None) -> None:
+    def __init__(self, rid: str, event_uuid: Optional[str] = None) -> None:
         self._event_uuid = event_uuid
         self._rid = rid
 
@@ -75108,9 +75419,9 @@ class scout_workbookcommon_api_EventReference(ConjureBeanType):
         return self._event_uuid
 
     @builtins.property
-    def rid(self) -> Optional[str]:
+    def rid(self) -> str:
         """
-        The event's unique identifier. This will soon be a required field.
+        The event's unique identifier.
         """
         return self._rid
 
@@ -77002,6 +77313,163 @@ storage_writer_api_ArrayPointsVisitor.__qualname__ = "ArrayPointsVisitor"
 storage_writer_api_ArrayPointsVisitor.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_ColumnBatch(ConjureBeanType):
+    """
+    Batch of data to stream for a single channel with their associated timestamps.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'timestamps': ConjureFieldDefinition('timestamps', List[api_Timestamp]),
+            'values': ConjureFieldDefinition('values', storage_writer_api_ColumnValues)
+        }
+
+    __slots__: List[str] = ['_channel', '_tags', '_timestamps', '_values']
+
+    def __init__(self, channel: str, tags: Dict[str, str], timestamps: List["api_Timestamp"], values: "storage_writer_api_ColumnValues") -> None:
+        self._channel = channel
+        self._tags = tags
+        self._timestamps = timestamps
+        self._values = values
+
+    @builtins.property
+    def channel(self) -> str:
+        """
+        Channel within nominal to stream data to.
+        """
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        """
+        Mapping of key-value pairs to provide as tags to all points within the batch
+        """
+        return self._tags
+
+    @builtins.property
+    def timestamps(self) -> List["api_Timestamp"]:
+        """
+        List of timestamp values that correspond to the provided list of column values. The number of timestamps
+provided MUST match the number of columnar values provided, otherwise a 400 error will be returned.
+        """
+        return self._timestamps
+
+    @builtins.property
+    def values(self) -> "storage_writer_api_ColumnValues":
+        """
+        List of timeseries values that should be ingested to a single channel. The number of columnar values
+provided MUST match the number of timestamps provided, otherwise a 400 error will be returned.
+        """
+        return self._values
+
+
+storage_writer_api_ColumnBatch.__name__ = "ColumnBatch"
+storage_writer_api_ColumnBatch.__qualname__ = "ColumnBatch"
+storage_writer_api_ColumnBatch.__module__ = "nominal_api.storage_writer_api"
+
+
+class storage_writer_api_ColumnValues(ConjureUnionType):
+    """List of values that correspond to subsequent values to ingest from a single channel."""
+    _strings: Optional[List[str]] = None
+    _doubles: Optional[List[float]] = None
+    _ints: Optional[List[int]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'strings': ConjureFieldDefinition('strings', List[str]),
+            'doubles': ConjureFieldDefinition('doubles', List[float]),
+            'ints': ConjureFieldDefinition('ints', List[int])
+        }
+
+    def __init__(
+            self,
+            strings: Optional[List[str]] = None,
+            doubles: Optional[List[float]] = None,
+            ints: Optional[List[int]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (strings is not None) + (doubles is not None) + (ints is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if strings is not None:
+                self._strings = strings
+                self._type = 'strings'
+            if doubles is not None:
+                self._doubles = doubles
+                self._type = 'doubles'
+            if ints is not None:
+                self._ints = ints
+                self._type = 'ints'
+
+        elif type_of_union == 'strings':
+            if strings is None:
+                raise ValueError('a union value must not be None')
+            self._strings = strings
+            self._type = 'strings'
+        elif type_of_union == 'doubles':
+            if doubles is None:
+                raise ValueError('a union value must not be None')
+            self._doubles = doubles
+            self._type = 'doubles'
+        elif type_of_union == 'ints':
+            if ints is None:
+                raise ValueError('a union value must not be None')
+            self._ints = ints
+            self._type = 'ints'
+
+    @builtins.property
+    def strings(self) -> Optional[List[str]]:
+        return self._strings
+
+    @builtins.property
+    def doubles(self) -> Optional[List[float]]:
+        return self._doubles
+
+    @builtins.property
+    def ints(self) -> Optional[List[int]]:
+        return self._ints
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, storage_writer_api_ColumnValuesVisitor):
+            raise ValueError('{} is not an instance of storage_writer_api_ColumnValuesVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'strings' and self.strings is not None:
+            return visitor._strings(self.strings)
+        if self._type == 'doubles' and self.doubles is not None:
+            return visitor._doubles(self.doubles)
+        if self._type == 'ints' and self.ints is not None:
+            return visitor._ints(self.ints)
+
+
+storage_writer_api_ColumnValues.__name__ = "ColumnValues"
+storage_writer_api_ColumnValues.__qualname__ = "ColumnValues"
+storage_writer_api_ColumnValues.__module__ = "nominal_api.storage_writer_api"
+
+
+class storage_writer_api_ColumnValuesVisitor:
+
+    @abstractmethod
+    def _strings(self, strings: List[str]) -> Any:
+        pass
+
+    @abstractmethod
+    def _doubles(self, doubles: List[float]) -> Any:
+        pass
+
+    @abstractmethod
+    def _ints(self, ints: List[int]) -> Any:
+        pass
+
+
+storage_writer_api_ColumnValuesVisitor.__name__ = "ColumnValuesVisitor"
+storage_writer_api_ColumnValuesVisitor.__qualname__ = "ColumnValuesVisitor"
+storage_writer_api_ColumnValuesVisitor.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_DirectNominalChannelWriterService(Service):
     """
     Writes data points directly to Nominal's managed database offering.
@@ -77229,6 +77697,42 @@ class storage_writer_api_NominalChannelWriterService(Service):
 
         return
 
+    def write_column_batches(self, auth_header: str, request: "storage_writer_api_WriteColumnBatchesRequest") -> None:
+        """
+        Synchronously writes batches of columns of data to a Nominal data source.
+
+This is a column-major variant of writeBatches (which is row-major) to optimize serialization and compression
+time for client applications streaming large numbers of points from a single column at a time. This has the
+tradeoff of slightly larger sizes post-gzipping of requests, so should be used in the particular case where
+the main bottleneck is in encoding columnar data into the row-based format found in writeBatches.
+        """
+
+        _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 = '/storage/writer/v1/columnar'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
     def write_telegraf_batches(self, auth_header: str, data_source_rid: str, request: "storage_writer_api_WriteTelegrafBatchesRequest") -> None:
         """
         Synchronously writes batches of records to a Nominal data source.
@@ -77955,6 +78459,41 @@ storage_writer_api_WriteBatchesRequestExternal.__qualname__ = "WriteBatchesReque
 storage_writer_api_WriteBatchesRequestExternal.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_WriteColumnBatchesRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'batches': ConjureFieldDefinition('batches', List[storage_writer_api_ColumnBatch]),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceOrDatasetRid)
+        }
+
+    __slots__: List[str] = ['_batches', '_data_source_rid']
+
+    def __init__(self, batches: List["storage_writer_api_ColumnBatch"], data_source_rid: str) -> None:
+        self._batches = batches
+        self._data_source_rid = data_source_rid
+
+    @builtins.property
+    def batches(self) -> List["storage_writer_api_ColumnBatch"]:
+        """
+        Batches of columnar data to stream to Nominal. Each channel's data are provided as a column batch.
+        """
+        return self._batches
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        """
+        RID of the datasource (e.g., for a Connection) or dataset to stream data into.
+        """
+        return self._data_source_rid
+
+
+storage_writer_api_WriteColumnBatchesRequest.__name__ = "WriteColumnBatchesRequest"
+storage_writer_api_WriteColumnBatchesRequest.__qualname__ = "WriteColumnBatchesRequest"
+storage_writer_api_WriteColumnBatchesRequest.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_WriteLogsRequest(ConjureBeanType):
 
     @builtins.classmethod

nominal_api/event/__init__.py

@@ -4,6 +4,8 @@ from .._impl import (
     event_ArchiveEvent as ArchiveEvent,
     event_BatchUpdateDispositionRequest as BatchUpdateDispositionRequest,
     event_BatchUpdateDispositionResponse as BatchUpdateDispositionResponse,
+    event_BatchUpdateEventRequest as BatchUpdateEventRequest,
+    event_BatchUpdateEventResponse as BatchUpdateEventResponse,
     event_CheckOriginMetadata as CheckOriginMetadata,
     event_CreateEvent as CreateEvent,
     event_DataReviewEventOrigin as DataReviewEventOrigin,
@@ -30,6 +32,7 @@ from .._impl import (
     event_TemplateEventOrigin as TemplateEventOrigin,
     event_UpdateDispositionRequest as UpdateDispositionRequest,
     event_UpdateEvent as UpdateEvent,
+    event_UpdateEventRequest as UpdateEventRequest,
     event_WorkbookEventOrigin as WorkbookEventOrigin,
 )
 

nominal_api/scout_compute_api/__init__.py

@@ -86,6 +86,7 @@ from .._impl import (
     scout_compute_api_DriverSeries3d as DriverSeries3d,
     scout_compute_api_DurationConstant as DurationConstant,
     scout_compute_api_DurationConstantVisitor as DurationConstantVisitor,
+    scout_compute_api_DurationFilterRanges as DurationFilterRanges,
     scout_compute_api_EnumAggregationFunction as EnumAggregationFunction,
     scout_compute_api_EnumBucket as EnumBucket,
     scout_compute_api_EnumCountDuplicateSeries as EnumCountDuplicateSeries,

nominal_api/scout_compute_resolved_api/__init__.py

@@ -24,6 +24,7 @@ from .._impl import (
     scout_compute_resolved_api_CurveFitPlotTypeNode as CurveFitPlotTypeNode,
     scout_compute_resolved_api_CurveFitPlotTypeNodeVisitor as CurveFitPlotTypeNodeVisitor,
     scout_compute_resolved_api_DerivativeSeriesNode as DerivativeSeriesNode,
+    scout_compute_resolved_api_DurationFilterRangesNode as DurationFilterRangesNode,
     scout_compute_resolved_api_EnumCountDuplicateSeriesNode as EnumCountDuplicateSeriesNode,
     scout_compute_resolved_api_EnumEqualityRangesNode as EnumEqualityRangesNode,
     scout_compute_resolved_api_EnumFilterRangesNode as EnumFilterRangesNode,

nominal_api/storage_writer_api/__init__.py

@@ -2,6 +2,9 @@
 from .._impl import (
     storage_writer_api_ArrayPoints as ArrayPoints,
     storage_writer_api_ArrayPointsVisitor as ArrayPointsVisitor,
+    storage_writer_api_ColumnBatch as ColumnBatch,
+    storage_writer_api_ColumnValues as ColumnValues,
+    storage_writer_api_ColumnValuesVisitor as ColumnValuesVisitor,
     storage_writer_api_DirectNominalChannelWriterService as DirectNominalChannelWriterService,
     storage_writer_api_DoubleArrayPoint as DoubleArrayPoint,
     storage_writer_api_DoublePoint as DoublePoint,
@@ -22,6 +25,7 @@ from .._impl import (
     storage_writer_api_TelegrafMetric as TelegrafMetric,
     storage_writer_api_WriteBatchesRequest as WriteBatchesRequest,
     storage_writer_api_WriteBatchesRequestExternal as WriteBatchesRequestExternal,
+    storage_writer_api_WriteColumnBatchesRequest as WriteColumnBatchesRequest,
     storage_writer_api_WriteLogsRequest as WriteLogsRequest,
     storage_writer_api_WriteTelegrafBatchesRequest as WriteTelegrafBatchesRequest,
 )

{nominal_api-0.701.2.dist-info → nominal_api-0.703.0.dist-info}/METADATA

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

{nominal_api-0.701.2.dist-info → nominal_api-0.703.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=8IpugkJAJv5cJkgSPZJpYUJ_eyCMRF2wgJVVzEd7uwQ,1955
-nominal_api/_impl.py,sha256=0Gml0qjPHdhVAHhC6D63fRJTdG_CljP2RiMlspQ0_M4,3205926
+nominal_api/__init__.py,sha256=WOjXRrnGry8pj2oj5gmJqM3Xh6sbtmeY91YStK6f1kk,1955
+nominal_api/_impl.py,sha256=1LunadUC805ktmWRGX8mBu4pMpMRhOaRx5TLnWbgX3s,3226636
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=1oJPOuAMfV2uClPUW8Ie1nj2Y6j81TDpedcc3yUFTe0,1294
 nominal_api/api_ids/__init__.py,sha256=CAtt44XgNZEEUDv-BbEbYtuxQ8y1wqSZU-STjBYdZv8,80
@@ -14,7 +14,7 @@ nominal_api/datasource_api/__init__.py,sha256=-0v4FGK22kyCALrJ-LRcwJ-QHDUnFCBqj_
 nominal_api/datasource_logset/__init__.py,sha256=H3fNxqyYC490MwvdWbt5BwhgWQUev7uieaLz5hUbZDc,94
 nominal_api/datasource_logset_api/__init__.py,sha256=JyjO1tQmG-HZ7kYMi8lSfeaaYddBZdCMIyqc0IUJfWo,1006
 nominal_api/datasource_pagination_api/__init__.py,sha256=3GO8TAUavOe6dUEitOhje74aSZHjTKVI5N1MNuct1lI,212
-nominal_api/event/__init__.py,sha256=zcrM1UbIi-nnXmuns9Q-yyXRuTJY2SfJe2yYrJ7U-Dw,1602
+nominal_api/event/__init__.py,sha256=Kpvbh_YSNgVS2zHwYT9efLdS9GkPrYCUuyafPsMEJgE,1780
 nominal_api/ingest_api/__init__.py,sha256=pX6SuqdKC9Um0Rko2-EE04LyjOpaN8jAYDezl3LGAPw,7491
 nominal_api/ingest_workflow_api/__init__.py,sha256=Xvz7jXoK5k_zEWzGnMB9EB942T-yCpX3CNHq-rqewlg,2094
 nominal_api/persistent_compute_api/__init__.py,sha256=ThraDBJyYB5nFrbB6FZZpDoVAmsq8GAibiK0nu63MVA,2050
@@ -30,9 +30,9 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=1_nOnCSWn7bniSvTfskQ
 nominal_api/scout_checks_api/__init__.py,sha256=cNCQHBX38YqQv2qJMXwqUhjpCbayA3R9FqMmtKwzA3U,5160
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=8BL5jE9NDxqCj9DyvZWSPhq6zw2J7xp6aLsl3x9rpyw,4530
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=1LCXQe64tDqqeMQixW8PI-R_edSz7F5X0x2_ufEuC8M,480
-nominal_api/scout_compute_api/__init__.py,sha256=hqFzmHW1b58r3otIul1aUb_Qr0mL4QzO0Jq-GA9A9qU,19868
+nominal_api/scout_compute_api/__init__.py,sha256=TFM96QwZOqvbkI1qa0BX7S7Iw0sRfo_t1lBg-QOoDmM,19936
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=RggSfc6C1VR1-kNXPWybpfw3hZbkQ1gvxEisFZCHdnM,3732
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=LJFZQR1u_EQbZLzLGWMQVS8sEsKsFSmsITrlYGI5JsA,10801
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=vw310PtjaDwccDihR26-5AkuLFZ-ZMxG-tZpbQYde_4,10886
 nominal_api/scout_dataexport_api/__init__.py,sha256=pWRQdQJOObD0jITRYLw3AxeDJSrJQqAdFZACxULqA4o,1487
 nominal_api/scout_datareview_api/__init__.py,sha256=sdD3rdI65ZlVWXHRwk2sAranMypVdStq090U0UOOwuY,8320
 nominal_api/scout_datasource/__init__.py,sha256=1NWMrEx-JOEb4Pmd2oAqcpSmQB3g3lxgxFenWEtcF2M,101
@@ -61,7 +61,7 @@ nominal_api/security_api_workspace/__init__.py,sha256=W-TKCfSPTZ5XvLP0xFhkjCLKUW
 nominal_api/storage_datasource_api/__init__.py,sha256=jh_OZE_b4nBNAvnyenBjw8aGZOnvIXR6qvUKd31fXOk,445
 nominal_api/storage_deletion_api/__init__.py,sha256=2bIuAU0tcnT_8lqae0fcII4R45A_RzfV0y_E-vTkpSQ,267
 nominal_api/storage_series_api/__init__.py,sha256=F2ctWx8yqb4-JtfHkLzCq74njNEpGwr69b9fWQp9UAQ,99
-nominal_api/storage_writer_api/__init__.py,sha256=gGXpDRA9WJYYZ6F6dujahrgmWIZ337gUl2X7TQryFgE,1488
+nominal_api/storage_writer_api/__init__.py,sha256=TmSnKSsv_ubvxN__SlDxSyAH9XierKm_7k50AB4vgZM,1738
 nominal_api/themes_api/__init__.py,sha256=w-G93T5f6_2zSSUi-ffyUHxH8QA_2oI9jM7YBSMFpwY,924
 nominal_api/timeseries_archetype/__init__.py,sha256=eKdgdZoOcZg_9pmec6J86NlgQdhxhi1282WUAFxghJ8,115
 nominal_api/timeseries_archetype_api/__init__.py,sha256=IREibRlChT9ugCAkeMKm7RiAChsKV4KJZ-DcKkVLC_U,1396
@@ -72,7 +72,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=Q9iZHurmyDsJIFbUg-Eb
 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.701.2.dist-info/METADATA,sha256=rkMgd37o9VHOoktH4lhJBVZ77xXrZCm4SASROynQ5Cs,199
-nominal_api-0.701.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nominal_api-0.701.2.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.701.2.dist-info/RECORD,,
+nominal_api-0.703.0.dist-info/METADATA,sha256=LM52vVlig9wlHicdyWxsgJbu8Nr0bRr47eBuvBtcusk,199
+nominal_api-0.703.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nominal_api-0.703.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.703.0.dist-info/RECORD,,