nominal-api 0.540.0__py3-none-any.whl → 0.541.0__py3-none-any.whl

nominal_api/__init__.py

@@ -68,5 +68,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.540.0"
+__version__ = "0.541.0"
 

nominal_api/_impl.py

@@ -10726,105 +10726,6 @@ includes metrics for check and violation review status
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_run_api_SearchRunChannelsResponse, self._return_none_for_unknown_union_types)
 
-    def get_events(self, auth_header: str, rid: str, next_page_token: Optional[str] = None) -> "scout_run_api_GetEventsForRunPage":
-        """
-        Fetches a list of events associated with the run.
-
-Returns a maximum page size of 1000.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-            'nextPageToken': next_page_token,
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = None
-
-        _path = '/scout/v1/run/{rid}/events'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_run_api_GetEventsForRunPage, self._return_none_for_unknown_union_types)
-
-    def publish_events(self, auth_header: str, request: "scout_run_api_PublishEventsToRunRequest", rid: str) -> None:
-        """
-        Adds a set of new events to the run.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/scout/v1/run/{rid}/events'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
-    def delete_events_from_run(self, auth_header: str, request: "scout_run_api_DeleteEventsFromRunRequest", rid: str) -> None:
-        """
-        Deletes events from the run.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/scout/v1/run/{rid}/delete-events'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
     def update_run_attachment(self, auth_header: str, request: "scout_run_api_UpdateAttachmentsRequest", rid: str) -> None:
         """
         Updates the attachments associated with a run.
@@ -27603,6 +27504,64 @@ scout_compute_api_Average.__qualname__ = "Average"
 scout_compute_api_Average.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_BandPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_passband_frequency': ConjureFieldDefinition('lowPassbandFrequency', scout_compute_api_DoubleConstant),
+            'high_passband_frequency': ConjureFieldDefinition('highPassbandFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_low_passband_frequency', '_high_passband_frequency']
+
+    def __init__(self, high_passband_frequency: "scout_compute_api_DoubleConstant", low_passband_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._low_passband_frequency = low_passband_frequency
+        self._high_passband_frequency = high_passband_frequency
+
+    @builtins.property
+    def low_passband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._low_passband_frequency
+
+    @builtins.property
+    def high_passband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._high_passband_frequency
+
+
+scout_compute_api_BandPassConfiguration.__name__ = "BandPassConfiguration"
+scout_compute_api_BandPassConfiguration.__qualname__ = "BandPassConfiguration"
+scout_compute_api_BandPassConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_BandStopConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_stopband_frequency': ConjureFieldDefinition('lowStopbandFrequency', scout_compute_api_DoubleConstant),
+            'high_stopband_frequency': ConjureFieldDefinition('highStopbandFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_low_stopband_frequency', '_high_stopband_frequency']
+
+    def __init__(self, high_stopband_frequency: "scout_compute_api_DoubleConstant", low_stopband_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._low_stopband_frequency = low_stopband_frequency
+        self._high_stopband_frequency = high_stopband_frequency
+
+    @builtins.property
+    def low_stopband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._low_stopband_frequency
+
+    @builtins.property
+    def high_stopband_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._high_stopband_frequency
+
+
+scout_compute_api_BandStopConfiguration.__name__ = "BandStopConfiguration"
+scout_compute_api_BandStopConfiguration.__qualname__ = "BandStopConfiguration"
+scout_compute_api_BandStopConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_BatchComputeUnitResult(ConjureBeanType):
 
     @builtins.classmethod
@@ -31475,6 +31434,29 @@ scout_compute_api_GeoTimeBucket.__qualname__ = "GeoTimeBucket"
 scout_compute_api_GeoTimeBucket.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_HighPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._cutoff_frequency
+
+
+scout_compute_api_HighPassConfiguration.__name__ = "HighPassConfiguration"
+scout_compute_api_HighPassConfiguration.__qualname__ = "HighPassConfiguration"
+scout_compute_api_HighPassConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_Histogram(ConjureUnionType):
     _numeric: Optional["scout_compute_api_NumericHistogramNode"] = None
     _enum: Optional["scout_compute_api_EnumHistogramNode"] = None
@@ -32502,6 +32484,29 @@ scout_compute_api_LogValueFilterSeriesVisitor.__qualname__ = "LogValueFilterSeri
 scout_compute_api_LogValueFilterSeriesVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_LowPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', scout_compute_api_DoubleConstant)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: "scout_compute_api_DoubleConstant") -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> "scout_compute_api_DoubleConstant":
+        return self._cutoff_frequency
+
+
+scout_compute_api_LowPassConfiguration.__name__ = "LowPassConfiguration"
+scout_compute_api_LowPassConfiguration.__qualname__ = "LowPassConfiguration"
+scout_compute_api_LowPassConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_MaxSeries(ConjureBeanType):
     """
     For every timestamp specified in the input series, outputs a value that is the maximum for that timestamp
@@ -33312,6 +33317,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     _channel: Optional["scout_compute_api_ChannelSeries"] = None
     _resample: Optional["scout_compute_api_NumericResampleSeries"] = None
     _rolling_operation: Optional["scout_compute_api_RollingOperationSeries"] = None
+    _signal_filter: Optional["scout_compute_api_SignalFilterSeries"] = None
     _sum: Optional["scout_compute_api_SumSeries"] = None
     _scale: Optional["scout_compute_api_ScaleSeries"] = None
     _time_difference: Optional["scout_compute_api_TimeDifferenceSeries"] = None
@@ -33344,6 +33350,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             'channel': ConjureFieldDefinition('channel', scout_compute_api_ChannelSeries),
             'resample': ConjureFieldDefinition('resample', scout_compute_api_NumericResampleSeries),
             'rolling_operation': ConjureFieldDefinition('rollingOperation', scout_compute_api_RollingOperationSeries),
+            'signal_filter': ConjureFieldDefinition('signalFilter', scout_compute_api_SignalFilterSeries),
             'sum': ConjureFieldDefinition('sum', scout_compute_api_SumSeries),
             'scale': ConjureFieldDefinition('scale', scout_compute_api_ScaleSeries),
             'time_difference': ConjureFieldDefinition('timeDifference', scout_compute_api_TimeDifferenceSeries),
@@ -33376,6 +33383,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             channel: Optional["scout_compute_api_ChannelSeries"] = None,
             resample: Optional["scout_compute_api_NumericResampleSeries"] = None,
             rolling_operation: Optional["scout_compute_api_RollingOperationSeries"] = None,
+            signal_filter: Optional["scout_compute_api_SignalFilterSeries"] = None,
             sum: Optional["scout_compute_api_SumSeries"] = None,
             scale: Optional["scout_compute_api_ScaleSeries"] = None,
             time_difference: Optional["scout_compute_api_TimeDifferenceSeries"] = None,
@@ -33391,7 +33399,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (function is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) != 1:
+            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (function is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (channel is not None) + (resample is not None) + (rolling_operation is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) + (threshold_filter is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
@@ -33442,6 +33450,9 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             if rolling_operation is not None:
                 self._rolling_operation = rolling_operation
                 self._type = 'rollingOperation'
+            if signal_filter is not None:
+                self._signal_filter = signal_filter
+                self._type = 'signalFilter'
             if sum is not None:
                 self._sum = sum
                 self._type = 'sum'
@@ -33559,6 +33570,11 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._rolling_operation = rolling_operation
             self._type = 'rollingOperation'
+        elif type_of_union == 'signalFilter':
+            if signal_filter is None:
+                raise ValueError('a union value must not be None')
+            self._signal_filter = signal_filter
+            self._type = 'signalFilter'
         elif type_of_union == 'sum':
             if sum is None:
                 raise ValueError('a union value must not be None')
@@ -33684,6 +33700,10 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     def rolling_operation(self) -> Optional["scout_compute_api_RollingOperationSeries"]:
         return self._rolling_operation
 
+    @builtins.property
+    def signal_filter(self) -> Optional["scout_compute_api_SignalFilterSeries"]:
+        return self._signal_filter
+
     @builtins.property
     def sum(self) -> Optional["scout_compute_api_SumSeries"]:
         return self._sum
@@ -33767,6 +33787,8 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             return visitor._resample(self.resample)
         if self._type == 'rollingOperation' and self.rolling_operation is not None:
             return visitor._rolling_operation(self.rolling_operation)
+        if self._type == 'signalFilter' and self.signal_filter is not None:
+            return visitor._signal_filter(self.signal_filter)
         if self._type == 'sum' and self.sum is not None:
             return visitor._sum(self.sum)
         if self._type == 'scale' and self.scale is not None:
@@ -33864,6 +33886,10 @@ class scout_compute_api_NumericSeriesVisitor:
     def _rolling_operation(self, rolling_operation: "scout_compute_api_RollingOperationSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _signal_filter(self, signal_filter: "scout_compute_api_SignalFilterSeries") -> Any:
+        pass
+
     @abstractmethod
     def _sum(self, sum: "scout_compute_api_SumSeries") -> Any:
         pass
@@ -36226,6 +36252,180 @@ scout_compute_api_SetNegativeValuesToZero.__qualname__ = "SetNegativeValuesToZer
 scout_compute_api_SetNegativeValuesToZero.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_SignalFilterConfiguration(ConjureUnionType):
+    _low_pass: Optional["scout_compute_api_LowPassConfiguration"] = None
+    _high_pass: Optional["scout_compute_api_HighPassConfiguration"] = None
+    _band_pass: Optional["scout_compute_api_BandPassConfiguration"] = None
+    _band_stop: Optional["scout_compute_api_BandStopConfiguration"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_pass': ConjureFieldDefinition('lowPass', scout_compute_api_LowPassConfiguration),
+            'high_pass': ConjureFieldDefinition('highPass', scout_compute_api_HighPassConfiguration),
+            'band_pass': ConjureFieldDefinition('bandPass', scout_compute_api_BandPassConfiguration),
+            'band_stop': ConjureFieldDefinition('bandStop', scout_compute_api_BandStopConfiguration)
+        }
+
+    def __init__(
+            self,
+            low_pass: Optional["scout_compute_api_LowPassConfiguration"] = None,
+            high_pass: Optional["scout_compute_api_HighPassConfiguration"] = None,
+            band_pass: Optional["scout_compute_api_BandPassConfiguration"] = None,
+            band_stop: Optional["scout_compute_api_BandStopConfiguration"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (low_pass is not None) + (high_pass is not None) + (band_pass is not None) + (band_stop is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if low_pass is not None:
+                self._low_pass = low_pass
+                self._type = 'lowPass'
+            if high_pass is not None:
+                self._high_pass = high_pass
+                self._type = 'highPass'
+            if band_pass is not None:
+                self._band_pass = band_pass
+                self._type = 'bandPass'
+            if band_stop is not None:
+                self._band_stop = band_stop
+                self._type = 'bandStop'
+
+        elif type_of_union == 'lowPass':
+            if low_pass is None:
+                raise ValueError('a union value must not be None')
+            self._low_pass = low_pass
+            self._type = 'lowPass'
+        elif type_of_union == 'highPass':
+            if high_pass is None:
+                raise ValueError('a union value must not be None')
+            self._high_pass = high_pass
+            self._type = 'highPass'
+        elif type_of_union == 'bandPass':
+            if band_pass is None:
+                raise ValueError('a union value must not be None')
+            self._band_pass = band_pass
+            self._type = 'bandPass'
+        elif type_of_union == 'bandStop':
+            if band_stop is None:
+                raise ValueError('a union value must not be None')
+            self._band_stop = band_stop
+            self._type = 'bandStop'
+
+    @builtins.property
+    def low_pass(self) -> Optional["scout_compute_api_LowPassConfiguration"]:
+        return self._low_pass
+
+    @builtins.property
+    def high_pass(self) -> Optional["scout_compute_api_HighPassConfiguration"]:
+        return self._high_pass
+
+    @builtins.property
+    def band_pass(self) -> Optional["scout_compute_api_BandPassConfiguration"]:
+        return self._band_pass
+
+    @builtins.property
+    def band_stop(self) -> Optional["scout_compute_api_BandStopConfiguration"]:
+        return self._band_stop
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_SignalFilterConfigurationVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_SignalFilterConfigurationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'lowPass' and self.low_pass is not None:
+            return visitor._low_pass(self.low_pass)
+        if self._type == 'highPass' and self.high_pass is not None:
+            return visitor._high_pass(self.high_pass)
+        if self._type == 'bandPass' and self.band_pass is not None:
+            return visitor._band_pass(self.band_pass)
+        if self._type == 'bandStop' and self.band_stop is not None:
+            return visitor._band_stop(self.band_stop)
+
+
+scout_compute_api_SignalFilterConfiguration.__name__ = "SignalFilterConfiguration"
+scout_compute_api_SignalFilterConfiguration.__qualname__ = "SignalFilterConfiguration"
+scout_compute_api_SignalFilterConfiguration.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_SignalFilterConfigurationVisitor:
+
+    @abstractmethod
+    def _low_pass(self, low_pass: "scout_compute_api_LowPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _high_pass(self, high_pass: "scout_compute_api_HighPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_pass(self, band_pass: "scout_compute_api_BandPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_stop(self, band_stop: "scout_compute_api_BandStopConfiguration") -> Any:
+        pass
+
+
+scout_compute_api_SignalFilterConfigurationVisitor.__name__ = "SignalFilterConfigurationVisitor"
+scout_compute_api_SignalFilterConfigurationVisitor.__qualname__ = "SignalFilterConfigurationVisitor"
+scout_compute_api_SignalFilterConfigurationVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_SignalFilterSeries(ConjureBeanType):
+    """
+    Applies IIR-based signal filtering to input series. Includes low-pass, high-pass, band-pass, and band-stop
+filters. Currently supports variable-order bidirectional Butterworth filters, with fixed-size padding based
+on SciPy output.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_api_NumericSeries),
+            'signal_filter_configuration': ConjureFieldDefinition('signalFilterConfiguration', scout_compute_api_SignalFilterConfiguration),
+            'order': ConjureFieldDefinition('order', scout_compute_api_IntegerConstant),
+            'sampling_frequency': ConjureFieldDefinition('samplingFrequency', OptionalTypeWrapper[scout_compute_api_DoubleConstant])
+        }
+
+    __slots__: List[str] = ['_input', '_signal_filter_configuration', '_order', '_sampling_frequency']
+
+    def __init__(self, input: "scout_compute_api_NumericSeries", order: "scout_compute_api_IntegerConstant", signal_filter_configuration: "scout_compute_api_SignalFilterConfiguration", sampling_frequency: Optional["scout_compute_api_DoubleConstant"] = None) -> None:
+        self._input = input
+        self._signal_filter_configuration = signal_filter_configuration
+        self._order = order
+        self._sampling_frequency = sampling_frequency
+
+    @builtins.property
+    def input(self) -> "scout_compute_api_NumericSeries":
+        return self._input
+
+    @builtins.property
+    def signal_filter_configuration(self) -> "scout_compute_api_SignalFilterConfiguration":
+        """
+        Filter type and cutoff frequencies.
+        """
+        return self._signal_filter_configuration
+
+    @builtins.property
+    def order(self) -> "scout_compute_api_IntegerConstant":
+        """
+        Order of filter. Must be a positive integer, and is effectively doubled for bidirectional filters.
+        """
+        return self._order
+
+    @builtins.property
+    def sampling_frequency(self) -> Optional["scout_compute_api_DoubleConstant"]:
+        """
+        The sampling frequency of the input series. Used to calculate normalized frequency for cutoff frequencies.
+        """
+        return self._sampling_frequency
+
+
+scout_compute_api_SignalFilterSeries.__name__ = "SignalFilterSeries"
+scout_compute_api_SignalFilterSeries.__qualname__ = "SignalFilterSeries"
+scout_compute_api_SignalFilterSeries.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_StabilityDetectionRanges(ConjureBeanType):
     """
     Outputs a set of ranges where the input series is stable. For each point, the min and max are calculated over 
@@ -40681,6 +40881,64 @@ scout_compute_resolved_api_ArithmeticSeriesNode.__qualname__ = "ArithmeticSeries
 scout_compute_resolved_api_ArithmeticSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_BandPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_passband_frequency': ConjureFieldDefinition('lowPassbandFrequency', float),
+            'high_passband_frequency': ConjureFieldDefinition('highPassbandFrequency', float)
+        }
+
+    __slots__: List[str] = ['_low_passband_frequency', '_high_passband_frequency']
+
+    def __init__(self, high_passband_frequency: float, low_passband_frequency: float) -> None:
+        self._low_passband_frequency = low_passband_frequency
+        self._high_passband_frequency = high_passband_frequency
+
+    @builtins.property
+    def low_passband_frequency(self) -> float:
+        return self._low_passband_frequency
+
+    @builtins.property
+    def high_passband_frequency(self) -> float:
+        return self._high_passband_frequency
+
+
+scout_compute_resolved_api_BandPassConfiguration.__name__ = "BandPassConfiguration"
+scout_compute_resolved_api_BandPassConfiguration.__qualname__ = "BandPassConfiguration"
+scout_compute_resolved_api_BandPassConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_BandStopConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_stopband_frequency': ConjureFieldDefinition('lowStopbandFrequency', float),
+            'high_stopband_frequency': ConjureFieldDefinition('highStopbandFrequency', float)
+        }
+
+    __slots__: List[str] = ['_low_stopband_frequency', '_high_stopband_frequency']
+
+    def __init__(self, high_stopband_frequency: float, low_stopband_frequency: float) -> None:
+        self._low_stopband_frequency = low_stopband_frequency
+        self._high_stopband_frequency = high_stopband_frequency
+
+    @builtins.property
+    def low_stopband_frequency(self) -> float:
+        return self._low_stopband_frequency
+
+    @builtins.property
+    def high_stopband_frequency(self) -> float:
+        return self._high_stopband_frequency
+
+
+scout_compute_resolved_api_BandStopConfiguration.__name__ = "BandStopConfiguration"
+scout_compute_resolved_api_BandStopConfiguration.__qualname__ = "BandStopConfiguration"
+scout_compute_resolved_api_BandStopConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_BinaryArithmeticSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -41644,6 +41902,29 @@ scout_compute_resolved_api_GeoNodeTemporalSummary.__qualname__ = "GeoNodeTempora
 scout_compute_resolved_api_GeoNodeTemporalSummary.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_HighPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', float)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: float) -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> float:
+        return self._cutoff_frequency
+
+
+scout_compute_resolved_api_HighPassConfiguration.__name__ = "HighPassConfiguration"
+scout_compute_resolved_api_HighPassConfiguration.__qualname__ = "HighPassConfiguration"
+scout_compute_resolved_api_HighPassConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_HistogramNode(ConjureUnionType):
     _numeric_histogram: Optional["scout_compute_resolved_api_NumericHistogramNode"] = None
     _enum_histogram: Optional["scout_compute_resolved_api_EnumHistogramNode"] = None
@@ -41899,6 +42180,29 @@ scout_compute_resolved_api_LatLongGeoNode.__qualname__ = "LatLongGeoNode"
 scout_compute_resolved_api_LatLongGeoNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_LowPassConfiguration(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'cutoff_frequency': ConjureFieldDefinition('cutoffFrequency', float)
+        }
+
+    __slots__: List[str] = ['_cutoff_frequency']
+
+    def __init__(self, cutoff_frequency: float) -> None:
+        self._cutoff_frequency = cutoff_frequency
+
+    @builtins.property
+    def cutoff_frequency(self) -> float:
+        return self._cutoff_frequency
+
+
+scout_compute_resolved_api_LowPassConfiguration.__name__ = "LowPassConfiguration"
+scout_compute_resolved_api_LowPassConfiguration.__qualname__ = "LowPassConfiguration"
+scout_compute_resolved_api_LowPassConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_MaxSeriesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -42267,6 +42571,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     _resample: Optional["scout_compute_resolved_api_NumericResampleSeriesNode"] = None
     _rolling_operation: Optional["scout_compute_resolved_api_RollingOperationSeriesNode"] = None
     _aggregate: Optional["scout_compute_resolved_api_AggregateNumericSeriesNode"] = None
+    _signal_filter: Optional["scout_compute_resolved_api_SignalFilterSeriesNode"] = None
     _sum: Optional["scout_compute_resolved_api_SumSeriesNode"] = None
     _scale: Optional["scout_compute_resolved_api_ScaleSeriesNode"] = None
     _time_difference: Optional["scout_compute_resolved_api_TimeDifferenceSeriesNode"] = None
@@ -42296,6 +42601,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             'resample': ConjureFieldDefinition('resample', scout_compute_resolved_api_NumericResampleSeriesNode),
             'rolling_operation': ConjureFieldDefinition('rollingOperation', scout_compute_resolved_api_RollingOperationSeriesNode),
             'aggregate': ConjureFieldDefinition('aggregate', scout_compute_resolved_api_AggregateNumericSeriesNode),
+            'signal_filter': ConjureFieldDefinition('signalFilter', scout_compute_resolved_api_SignalFilterSeriesNode),
             'sum': ConjureFieldDefinition('sum', scout_compute_resolved_api_SumSeriesNode),
             'scale': ConjureFieldDefinition('scale', scout_compute_resolved_api_ScaleSeriesNode),
             'time_difference': ConjureFieldDefinition('timeDifference', scout_compute_resolved_api_TimeDifferenceSeriesNode),
@@ -42325,6 +42631,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             resample: Optional["scout_compute_resolved_api_NumericResampleSeriesNode"] = None,
             rolling_operation: Optional["scout_compute_resolved_api_RollingOperationSeriesNode"] = None,
             aggregate: Optional["scout_compute_resolved_api_AggregateNumericSeriesNode"] = None,
+            signal_filter: Optional["scout_compute_resolved_api_SignalFilterSeriesNode"] = None,
             sum: Optional["scout_compute_resolved_api_SumSeriesNode"] = None,
             scale: Optional["scout_compute_resolved_api_ScaleSeriesNode"] = None,
             time_difference: Optional["scout_compute_resolved_api_TimeDifferenceSeriesNode"] = None,
@@ -42339,7 +42646,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (resample is not None) + (rolling_operation is not None) + (aggregate is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) != 1:
+            if (arithmetic is not None) + (bit_operation is not None) + (cumulative_sum is not None) + (derivative is not None) + (integral is not None) + (max is not None) + (mean is not None) + (min is not None) + (offset is not None) + (product is not None) + (raw is not None) + (resample is not None) + (rolling_operation is not None) + (aggregate is not None) + (signal_filter is not None) + (sum is not None) + (scale is not None) + (time_difference is not None) + (time_range_filter is not None) + (time_shift is not None) + (unary_arithmetic is not None) + (binary_arithmetic is not None) + (union is not None) + (unit_conversion is not None) + (value_difference is not None) + (filter_transformation is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if arithmetic is not None:
@@ -42384,6 +42691,9 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             if aggregate is not None:
                 self._aggregate = aggregate
                 self._type = 'aggregate'
+            if signal_filter is not None:
+                self._signal_filter = signal_filter
+                self._type = 'signalFilter'
             if sum is not None:
                 self._sum = sum
                 self._type = 'sum'
@@ -42488,6 +42798,11 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._aggregate = aggregate
             self._type = 'aggregate'
+        elif type_of_union == 'signalFilter':
+            if signal_filter is None:
+                raise ValueError('a union value must not be None')
+            self._signal_filter = signal_filter
+            self._type = 'signalFilter'
         elif type_of_union == 'sum':
             if sum is None:
                 raise ValueError('a union value must not be None')
@@ -42600,6 +42915,10 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     def aggregate(self) -> Optional["scout_compute_resolved_api_AggregateNumericSeriesNode"]:
         return self._aggregate
 
+    @builtins.property
+    def signal_filter(self) -> Optional["scout_compute_resolved_api_SignalFilterSeriesNode"]:
+        return self._signal_filter
+
     @builtins.property
     def sum(self) -> Optional["scout_compute_resolved_api_SumSeriesNode"]:
         return self._sum
@@ -42675,6 +42994,8 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             return visitor._rolling_operation(self.rolling_operation)
         if self._type == 'aggregate' and self.aggregate is not None:
             return visitor._aggregate(self.aggregate)
+        if self._type == 'signalFilter' and self.signal_filter is not None:
+            return visitor._signal_filter(self.signal_filter)
         if self._type == 'sum' and self.sum is not None:
             return visitor._sum(self.sum)
         if self._type == 'scale' and self.scale is not None:
@@ -42762,6 +43083,10 @@ class scout_compute_resolved_api_NumericSeriesNodeVisitor:
     def _aggregate(self, aggregate: "scout_compute_resolved_api_AggregateNumericSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _signal_filter(self, signal_filter: "scout_compute_resolved_api_SignalFilterSeriesNode") -> Any:
+        pass
+
     @abstractmethod
     def _sum(self, sum: "scout_compute_resolved_api_SumSeriesNode") -> Any:
         pass
@@ -44047,6 +44372,181 @@ scout_compute_resolved_api_SeriesNodeVisitor.__qualname__ = "SeriesNodeVisitor"
 scout_compute_resolved_api_SeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_SignalFilterConfiguration(ConjureUnionType):
+    _low_pass: Optional["scout_compute_resolved_api_LowPassConfiguration"] = None
+    _high_pass: Optional["scout_compute_resolved_api_HighPassConfiguration"] = None
+    _band_pass: Optional["scout_compute_resolved_api_BandPassConfiguration"] = None
+    _band_stop: Optional["scout_compute_resolved_api_BandStopConfiguration"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'low_pass': ConjureFieldDefinition('lowPass', scout_compute_resolved_api_LowPassConfiguration),
+            'high_pass': ConjureFieldDefinition('highPass', scout_compute_resolved_api_HighPassConfiguration),
+            'band_pass': ConjureFieldDefinition('bandPass', scout_compute_resolved_api_BandPassConfiguration),
+            'band_stop': ConjureFieldDefinition('bandStop', scout_compute_resolved_api_BandStopConfiguration)
+        }
+
+    def __init__(
+            self,
+            low_pass: Optional["scout_compute_resolved_api_LowPassConfiguration"] = None,
+            high_pass: Optional["scout_compute_resolved_api_HighPassConfiguration"] = None,
+            band_pass: Optional["scout_compute_resolved_api_BandPassConfiguration"] = None,
+            band_stop: Optional["scout_compute_resolved_api_BandStopConfiguration"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (low_pass is not None) + (high_pass is not None) + (band_pass is not None) + (band_stop is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if low_pass is not None:
+                self._low_pass = low_pass
+                self._type = 'lowPass'
+            if high_pass is not None:
+                self._high_pass = high_pass
+                self._type = 'highPass'
+            if band_pass is not None:
+                self._band_pass = band_pass
+                self._type = 'bandPass'
+            if band_stop is not None:
+                self._band_stop = band_stop
+                self._type = 'bandStop'
+
+        elif type_of_union == 'lowPass':
+            if low_pass is None:
+                raise ValueError('a union value must not be None')
+            self._low_pass = low_pass
+            self._type = 'lowPass'
+        elif type_of_union == 'highPass':
+            if high_pass is None:
+                raise ValueError('a union value must not be None')
+            self._high_pass = high_pass
+            self._type = 'highPass'
+        elif type_of_union == 'bandPass':
+            if band_pass is None:
+                raise ValueError('a union value must not be None')
+            self._band_pass = band_pass
+            self._type = 'bandPass'
+        elif type_of_union == 'bandStop':
+            if band_stop is None:
+                raise ValueError('a union value must not be None')
+            self._band_stop = band_stop
+            self._type = 'bandStop'
+
+    @builtins.property
+    def low_pass(self) -> Optional["scout_compute_resolved_api_LowPassConfiguration"]:
+        return self._low_pass
+
+    @builtins.property
+    def high_pass(self) -> Optional["scout_compute_resolved_api_HighPassConfiguration"]:
+        return self._high_pass
+
+    @builtins.property
+    def band_pass(self) -> Optional["scout_compute_resolved_api_BandPassConfiguration"]:
+        return self._band_pass
+
+    @builtins.property
+    def band_stop(self) -> Optional["scout_compute_resolved_api_BandStopConfiguration"]:
+        return self._band_stop
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_SignalFilterConfigurationVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_SignalFilterConfigurationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'lowPass' and self.low_pass is not None:
+            return visitor._low_pass(self.low_pass)
+        if self._type == 'highPass' and self.high_pass is not None:
+            return visitor._high_pass(self.high_pass)
+        if self._type == 'bandPass' and self.band_pass is not None:
+            return visitor._band_pass(self.band_pass)
+        if self._type == 'bandStop' and self.band_stop is not None:
+            return visitor._band_stop(self.band_stop)
+
+
+scout_compute_resolved_api_SignalFilterConfiguration.__name__ = "SignalFilterConfiguration"
+scout_compute_resolved_api_SignalFilterConfiguration.__qualname__ = "SignalFilterConfiguration"
+scout_compute_resolved_api_SignalFilterConfiguration.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_SignalFilterConfigurationVisitor:
+
+    @abstractmethod
+    def _low_pass(self, low_pass: "scout_compute_resolved_api_LowPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _high_pass(self, high_pass: "scout_compute_resolved_api_HighPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_pass(self, band_pass: "scout_compute_resolved_api_BandPassConfiguration") -> Any:
+        pass
+
+    @abstractmethod
+    def _band_stop(self, band_stop: "scout_compute_resolved_api_BandStopConfiguration") -> Any:
+        pass
+
+
+scout_compute_resolved_api_SignalFilterConfigurationVisitor.__name__ = "SignalFilterConfigurationVisitor"
+scout_compute_resolved_api_SignalFilterConfigurationVisitor.__qualname__ = "SignalFilterConfigurationVisitor"
+scout_compute_resolved_api_SignalFilterConfigurationVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_SignalFilterSeriesNode(ConjureBeanType):
+    """
+    Applies IIR-based signal filtering to input series. Includes low-pass, high-pass, band-pass, and band-stop
+filters. Currently supports variable-order bidirectional Butterworth filters, with fixed-size padding based
+on SciPy output.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_NumericSeriesNode),
+            'signal_filter_configuration': ConjureFieldDefinition('signalFilterConfiguration', scout_compute_resolved_api_SignalFilterConfiguration),
+            'order': ConjureFieldDefinition('order', int),
+            'sampling_frequency': ConjureFieldDefinition('samplingFrequency', OptionalTypeWrapper[float])
+        }
+
+    __slots__: List[str] = ['_input', '_signal_filter_configuration', '_order', '_sampling_frequency']
+
+    def __init__(self, input: "scout_compute_resolved_api_NumericSeriesNode", order: int, signal_filter_configuration: "scout_compute_resolved_api_SignalFilterConfiguration", sampling_frequency: Optional[float] = None) -> None:
+        self._input = input
+        self._signal_filter_configuration = signal_filter_configuration
+        self._order = order
+        self._sampling_frequency = sampling_frequency
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._input
+
+    @builtins.property
+    def signal_filter_configuration(self) -> "scout_compute_resolved_api_SignalFilterConfiguration":
+        """
+        Configuration for the signal filter, including filter type, cutoff frequency, and order.
+        """
+        return self._signal_filter_configuration
+
+    @builtins.property
+    def order(self) -> int:
+        """
+        Order of filter. Must be a positive integer, and is effectively doubled for bidirectional filters.
+        """
+        return self._order
+
+    @builtins.property
+    def sampling_frequency(self) -> Optional[float]:
+        """
+        The sampling frequency of the input series. Used to calculate normalized frequency for cutoff frequencies.
+Defaults to number of points divided by timespan of series.
+        """
+        return self._sampling_frequency
+
+
+scout_compute_resolved_api_SignalFilterSeriesNode.__name__ = "SignalFilterSeriesNode"
+scout_compute_resolved_api_SignalFilterSeriesNode.__qualname__ = "SignalFilterSeriesNode"
+scout_compute_resolved_api_SignalFilterSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_StabilityDetectionRangesNode(ConjureBeanType):
 
     @builtins.classmethod
@@ -56803,29 +57303,6 @@ scout_run_api_DataSourceType.__qualname__ = "DataSourceType"
 scout_run_api_DataSourceType.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_DeleteEventsFromRunRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'events': ConjureFieldDefinition('events', List[event_EventRid])
-        }
-
-    __slots__: List[str] = ['_events']
-
-    def __init__(self, events: List[str]) -> None:
-        self._events = events
-
-    @builtins.property
-    def events(self) -> List[str]:
-        return self._events
-
-
-scout_run_api_DeleteEventsFromRunRequest.__name__ = "DeleteEventsFromRunRequest"
-scout_run_api_DeleteEventsFromRunRequest.__qualname__ = "DeleteEventsFromRunRequest"
-scout_run_api_DeleteEventsFromRunRequest.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_Duration(ConjureBeanType):
 
     @builtins.classmethod
@@ -56861,35 +57338,6 @@ scout_run_api_Duration.__qualname__ = "Duration"
 scout_run_api_Duration.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_GetEventsForRunPage(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'events': ConjureFieldDefinition('events', List[event_EventRid]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[scout_api_Token])
-        }
-
-    __slots__: List[str] = ['_events', '_next_page_token']
-
-    def __init__(self, events: List[str], next_page_token: Optional[str] = None) -> None:
-        self._events = events
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def events(self) -> List[str]:
-        return self._events
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-
-scout_run_api_GetEventsForRunPage.__name__ = "GetEventsForRunPage"
-scout_run_api_GetEventsForRunPage.__qualname__ = "GetEventsForRunPage"
-scout_run_api_GetEventsForRunPage.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_GetRunByIdRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -57035,29 +57483,6 @@ scout_run_api_Property.__qualname__ = "Property"
 scout_run_api_Property.__module__ = "nominal_api.scout_run_api"
 
 
-class scout_run_api_PublishEventsToRunRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'events': ConjureFieldDefinition('events', List[event_EventRid])
-        }
-
-    __slots__: List[str] = ['_events']
-
-    def __init__(self, events: List[str]) -> None:
-        self._events = events
-
-    @builtins.property
-    def events(self) -> List[str]:
-        return self._events
-
-
-scout_run_api_PublishEventsToRunRequest.__name__ = "PublishEventsToRunRequest"
-scout_run_api_PublishEventsToRunRequest.__qualname__ = "PublishEventsToRunRequest"
-scout_run_api_PublishEventsToRunRequest.__module__ = "nominal_api.scout_run_api"
-
-
 class scout_run_api_RefNameAndType(ConjureBeanType):
     """
     Scoped to the org-level, intended to help the frontend
@@ -62869,17 +63294,19 @@ class storage_datasource_api_NominalDataSource(ConjureBeanType):
             'id': ConjureFieldDefinition('id', storage_datasource_api_NominalDataSourceId),
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'data_last_written_at': ConjureFieldDefinition('dataLastWrittenAt', OptionalTypeWrapper[str]),
-            'granularity': ConjureFieldDefinition('granularity', api_Granularity)
+            'granularity': ConjureFieldDefinition('granularity', api_Granularity),
+            'in_memory_streaming_enabled': ConjureFieldDefinition('inMemoryStreamingEnabled', OptionalTypeWrapper[bool])
         }
 
-    __slots__: List[str] = ['_rid', '_id', '_description', '_data_last_written_at', '_granularity']
+    __slots__: List[str] = ['_rid', '_id', '_description', '_data_last_written_at', '_granularity', '_in_memory_streaming_enabled']
 
-    def __init__(self, granularity: "api_Granularity", id: str, rid: str, data_last_written_at: Optional[str] = None, description: Optional[str] = None) -> None:
+    def __init__(self, granularity: "api_Granularity", id: str, rid: str, data_last_written_at: Optional[str] = None, description: Optional[str] = None, in_memory_streaming_enabled: Optional[bool] = None) -> None:
         self._rid = rid
         self._id = id
         self._description = description
         self._data_last_written_at = data_last_written_at
         self._granularity = granularity
+        self._in_memory_streaming_enabled = in_memory_streaming_enabled
 
     @builtins.property
     def rid(self) -> str:
@@ -62905,6 +63332,10 @@ Will be accurate to within 1 minute.
     def granularity(self) -> "api_Granularity":
         return self._granularity
 
+    @builtins.property
+    def in_memory_streaming_enabled(self) -> Optional[bool]:
+        return self._in_memory_streaming_enabled
+
 
 storage_datasource_api_NominalDataSource.__name__ = "NominalDataSource"
 storage_datasource_api_NominalDataSource.__qualname__ = "NominalDataSource"

nominal_api/scout_compute_api/__init__.py

@@ -8,6 +8,8 @@ from .._impl import (
     scout_compute_api_ArithmeticSeries as ArithmeticSeries,
     scout_compute_api_AssetChannel as AssetChannel,
     scout_compute_api_Average as Average,
+    scout_compute_api_BandPassConfiguration as BandPassConfiguration,
+    scout_compute_api_BandStopConfiguration as BandStopConfiguration,
     scout_compute_api_BatchComputeUnitResult as BatchComputeUnitResult,
     scout_compute_api_BatchComputeUnitsRequest as BatchComputeUnitsRequest,
     scout_compute_api_BatchComputeWithUnitsRequest as BatchComputeWithUnitsRequest,
@@ -107,6 +109,7 @@ from .._impl import (
     scout_compute_api_GeoSummaryStrategyVisitor as GeoSummaryStrategyVisitor,
     scout_compute_api_GeoTemporalSummary as GeoTemporalSummary,
     scout_compute_api_GeoTimeBucket as GeoTimeBucket,
+    scout_compute_api_HighPassConfiguration as HighPassConfiguration,
     scout_compute_api_Histogram as Histogram,
     scout_compute_api_HistogramChannelCount as HistogramChannelCount,
     scout_compute_api_HistogramVisitor as HistogramVisitor,
@@ -135,6 +138,7 @@ from .._impl import (
     scout_compute_api_LogUnionSeries as LogUnionSeries,
     scout_compute_api_LogValueFilterSeries as LogValueFilterSeries,
     scout_compute_api_LogValueFilterSeriesVisitor as LogValueFilterSeriesVisitor,
+    scout_compute_api_LowPassConfiguration as LowPassConfiguration,
     scout_compute_api_MaxSeries as MaxSeries,
     scout_compute_api_Maximum as Maximum,
     scout_compute_api_MeanSeries as MeanSeries,
@@ -209,6 +213,9 @@ from .._impl import (
     scout_compute_api_SeriesSpec as SeriesSpec,
     scout_compute_api_SeriesVisitor as SeriesVisitor,
     scout_compute_api_SetNegativeValuesToZero as SetNegativeValuesToZero,
+    scout_compute_api_SignalFilterConfiguration as SignalFilterConfiguration,
+    scout_compute_api_SignalFilterConfigurationVisitor as SignalFilterConfigurationVisitor,
+    scout_compute_api_SignalFilterSeries as SignalFilterSeries,
     scout_compute_api_StabilityDetectionRanges as StabilityDetectionRanges,
     scout_compute_api_StabilityWindowConfiguration as StabilityWindowConfiguration,
     scout_compute_api_StaleRanges as StaleRanges,

nominal_api/scout_compute_resolved_api/__init__.py

@@ -4,6 +4,8 @@ from .._impl import (
     scout_compute_resolved_api_AggregateEnumSeriesNode as AggregateEnumSeriesNode,
     scout_compute_resolved_api_AggregateNumericSeriesNode as AggregateNumericSeriesNode,
     scout_compute_resolved_api_ArithmeticSeriesNode as ArithmeticSeriesNode,
+    scout_compute_resolved_api_BandPassConfiguration as BandPassConfiguration,
+    scout_compute_resolved_api_BandStopConfiguration as BandStopConfiguration,
     scout_compute_resolved_api_BinaryArithmeticSeriesNode as BinaryArithmeticSeriesNode,
     scout_compute_resolved_api_BitOperationSeriesNode as BitOperationSeriesNode,
     scout_compute_resolved_api_CartesianBounds as CartesianBounds,
@@ -32,6 +34,7 @@ from .._impl import (
     scout_compute_resolved_api_GeoNodeSummaryStrategyVisitor as GeoNodeSummaryStrategyVisitor,
     scout_compute_resolved_api_GeoNodeTemporalSummary as GeoNodeTemporalSummary,
     scout_compute_resolved_api_GeoNodeVisitor as GeoNodeVisitor,
+    scout_compute_resolved_api_HighPassConfiguration as HighPassConfiguration,
     scout_compute_resolved_api_HistogramNode as HistogramNode,
     scout_compute_resolved_api_HistogramNodeVisitor as HistogramNodeVisitor,
     scout_compute_resolved_api_IntegralSeriesNode as IntegralSeriesNode,
@@ -40,6 +43,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_LowPassConfiguration as LowPassConfiguration,
     scout_compute_resolved_api_MaxSeriesNode as MaxSeriesNode,
     scout_compute_resolved_api_MeanSeriesNode as MeanSeriesNode,
     scout_compute_resolved_api_MinMaxThresholdRangesNode as MinMaxThresholdRangesNode,
@@ -80,6 +84,9 @@ from .._impl import (
     scout_compute_resolved_api_SeriesCrossoverRangesNode as SeriesCrossoverRangesNode,
     scout_compute_resolved_api_SeriesNode as SeriesNode,
     scout_compute_resolved_api_SeriesNodeVisitor as SeriesNodeVisitor,
+    scout_compute_resolved_api_SignalFilterConfiguration as SignalFilterConfiguration,
+    scout_compute_resolved_api_SignalFilterConfigurationVisitor as SignalFilterConfigurationVisitor,
+    scout_compute_resolved_api_SignalFilterSeriesNode as SignalFilterSeriesNode,
     scout_compute_resolved_api_StabilityDetectionRangesNode as StabilityDetectionRangesNode,
     scout_compute_resolved_api_StaleRangesNode as StaleRangesNode,
     scout_compute_resolved_api_SumSeriesNode as SumSeriesNode,

nominal_api/scout_run_api/__init__.py

@@ -14,9 +14,7 @@ from .._impl import (
     scout_run_api_DataSourceSeriesTag as DataSourceSeriesTag,
     scout_run_api_DataSourceType as DataSourceType,
     scout_run_api_DataSourceVisitor as DataSourceVisitor,
-    scout_run_api_DeleteEventsFromRunRequest as DeleteEventsFromRunRequest,
     scout_run_api_Duration as Duration,
-    scout_run_api_GetEventsForRunPage as GetEventsForRunPage,
     scout_run_api_GetRunByIdRequest as GetRunByIdRequest,
     scout_run_api_GetRunsByAssetRequest as GetRunsByAssetRequest,
     scout_run_api_GetRunsByAssetResponse as GetRunsByAssetResponse,
@@ -26,7 +24,6 @@ from .._impl import (
     scout_run_api_Property as Property,
     scout_run_api_PropertyName as PropertyName,
     scout_run_api_PropertyValue as PropertyValue,
-    scout_run_api_PublishEventsToRunRequest as PublishEventsToRunRequest,
     scout_run_api_RefNameAndType as RefNameAndType,
     scout_run_api_Run as Run,
     scout_run_api_RunDataReviewEvaluationStatus as RunDataReviewEvaluationStatus,

{nominal_api-0.540.0.dist-info → nominal_api-0.541.0.dist-info}/METADATA

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

{nominal_api-0.540.0.dist-info → nominal_api-0.541.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=PgTMWZrSjdtP3Ira9hG2bMy7Qdz6N5XzwHZSc3xDXuc,1762
-nominal_api/_impl.py,sha256=6DO_xexkB3gQLyqfog5kXBFedWdBdddSQkC7H1cI8fE,2647850
+nominal_api/__init__.py,sha256=GV6Kh5nkfkljdeaz5y5FFGpLlKbbPlU7QraBV4fJ--E,1762
+nominal_api/_impl.py,sha256=ylUEy1vbtjNF0PJ3saL3r6FMgQKS5xBby7MU3sDxeCQ,2669686
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=CaUmWhW0zcP8jVWFQEgj-lpoBi-Unm0wBd2s9dPeWmo,656
 nominal_api/api_rids/__init__.py,sha256=p7dKiMV692oGtYStr5FZJEJNg3YbF7scJK1WFMpBiW0,298
@@ -28,10 +28,10 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=PfMFzie0xO5d5WSpB3bE
 nominal_api/scout_checks_api/__init__.py,sha256=RJH7HsXjUhItC11V9C-hfv6lkIfiSXyxnB8slUpaT2g,5203
 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=2hkEtKIcCTMCiG4pM8tOe4JOXnod3xZFLlP6nsJmjpE,15746
+nominal_api/scout_compute_api/__init__.py,sha256=LTyWkvP0El00HnyM_CFI1NpGJgStubKck8mAP9P05fQ,16258
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=RggSfc6C1VR1-kNXPWybpfw3hZbkQ1gvxEisFZCHdnM,3732
 nominal_api/scout_compute_representation_api/__init__.py,sha256=FezODo7sI8m6tDhPPK_gZX1qXImi4O3TUprDoNUuWpk,1672
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=k9LeUYDDFbNRNjpFh1F6SBzZ4rKaSVaoGLRCn6QXQHU,7584
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=LdYWUd7eFPhJMIADnVZwXYu1wNLj8tvwmUHqKMZC19s,8167
 nominal_api/scout_dataexport_api/__init__.py,sha256=pWRQdQJOObD0jITRYLw3AxeDJSrJQqAdFZACxULqA4o,1487
 nominal_api/scout_datareview_api/__init__.py,sha256=CxPVFirxckwj_cVSmqCI5X-4EDfp7iGp11o3VvmSNX0,8519
 nominal_api/scout_datasource/__init__.py,sha256=1NWMrEx-JOEb4Pmd2oAqcpSmQB3g3lxgxFenWEtcF2M,101
@@ -46,7 +46,7 @@ nominal_api/scout_metadata/__init__.py,sha256=GIhWKJL2XSMB0iGaKfcGgmPHuvGWWmkK4l
 nominal_api/scout_notebook_api/__init__.py,sha256=QW0vg8ZrAmuctjnNLxTnqtwyQoX-H9MOkHlLWioe5AA,1230
 nominal_api/scout_plotting/__init__.py,sha256=m6u3y7R70mo3ugaCp_-fwlS8_tDwrsq1l5ElOTY0TBc,91
 nominal_api/scout_rids_api/__init__.py,sha256=YH_6EVOA2sJQH81wYb2sx500wrEBXF-Xij76Bl946MY,1174
-nominal_api/scout_run_api/__init__.py,sha256=bJ6rYRRtdBiHnSrMg64vD0kWqqQh0mo6pw8kS_VN69g,2980
+nominal_api/scout_run_api/__init__.py,sha256=c4I7gob0WYcnf1Ra5wBhizc5uLSu6z4EMwGT___vuKk,2768
 nominal_api/scout_template_api/__init__.py,sha256=bsu8qPiZ4gf67G5iFvwsfkqEKJRZ7L5Wyg6qcFyogO0,1037
 nominal_api/scout_units_api/__init__.py,sha256=KxRDScfumX__0ncWJftGvgApn_LBTfnIBAvnaBrcA5A,368
 nominal_api/scout_versioning_api/__init__.py,sha256=Sf4T4t0rZXNRIZgkqLBN3yh0sAnrxiuzaTfDQVVkyO4,1323
@@ -65,7 +65,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=wr83ByQTVVPOGvbB_KWL
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=YLixotb-W-adYR6t_RBsJDwoHttppkOBesoaXERwhVs,1240
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.540.0.dist-info/METADATA,sha256=BuGm9tNrGHFj_0__l8Igv8Mplwf6qeoMx2GNETWLX38,199
-nominal_api-0.540.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nominal_api-0.540.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.540.0.dist-info/RECORD,,
+nominal_api-0.541.0.dist-info/METADATA,sha256=hfVZrRBLAhDo0stwDEPXYWR7VbhQNKbjESF6QzkyNw8,199
+nominal_api-0.541.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nominal_api-0.541.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.541.0.dist-info/RECORD,,