nominal-api 0.908.0__tar.gz → 0.910.0__tar.gz

{nominal_api-0.908.0 → nominal_api-0.910.0}/PKG-INFO

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

{nominal_api-0.908.0 → nominal_api-0.910.0}/nominal_api/__init__.py

@@ -81,5 +81,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.908.0"
+__version__ = "0.910.0"
 

{nominal_api-0.908.0 → nominal_api-0.910.0}/nominal_api/_impl.py

@@ -46912,6 +46912,60 @@ scout_compute_api_FftWindow.__qualname__ = "FftWindow"
 scout_compute_api_FftWindow.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_FilterByExpressionSeries(ConjureBeanType):
+    """Keeps points from the base series where the boolean expression evaluates to true. Only outputs timestamps 
+where all input series have an entry for that timestamp, or a value can be filled using the interpolation 
+configuration.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'base': ConjureFieldDefinition('base', scout_compute_api_LocalVariableName),
+            'inputs': ConjureFieldDefinition('inputs', Dict[scout_compute_api_LocalVariableName, scout_compute_api_NumericSeries]),
+            'expression': ConjureFieldDefinition('expression', str),
+            'interpolation_configuration': ConjureFieldDefinition('interpolationConfiguration', OptionalTypeWrapper[scout_compute_api_InterpolationConfiguration])
+        }
+
+    __slots__: List[str] = ['_base', '_inputs', '_expression', '_interpolation_configuration']
+
+    def __init__(self, base: str, expression: str, inputs: Dict[str, "scout_compute_api_NumericSeries"], interpolation_configuration: Optional["scout_compute_api_InterpolationConfiguration"] = None) -> None:
+        self._base = base
+        self._inputs = inputs
+        self._expression = expression
+        self._interpolation_configuration = interpolation_configuration
+
+    @builtins.property
+    def base(self) -> str:
+        """The variable name for the series that will be returned by this filter. The expression can filter points 
+conditional on multiple series. The base defines which series' points will be returned after applying all the filters.
+        """
+        return self._base
+
+    @builtins.property
+    def inputs(self) -> Dict[str, "scout_compute_api_NumericSeries"]:
+        """A map containing all the numeric series present in the expression.
+        """
+        return self._inputs
+
+    @builtins.property
+    def expression(self) -> str:
+        """An expression that evaluates to a boolean. For example - a > 5.
+        """
+        return self._expression
+
+    @builtins.property
+    def interpolation_configuration(self) -> Optional["scout_compute_api_InterpolationConfiguration"]:
+        """Defaults to forward fill interpolation with a 1s interpolation radius
+        """
+        return self._interpolation_configuration
+
+
+scout_compute_api_FilterByExpressionSeries.__name__ = "FilterByExpressionSeries"
+scout_compute_api_FilterByExpressionSeries.__qualname__ = "FilterByExpressionSeries"
+scout_compute_api_FilterByExpressionSeries.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_FirstPointMatchingCondition(ConjureBeanType):
     """The first point in the output range will be the first point where the condition evaluates to true.
     """
@@ -49877,6 +49931,7 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     _select1d_array_index: Optional["scout_compute_api_SelectIndexFrom1dNumericArraySeries"] = None
     _select_newest_points: Optional["scout_compute_api_SelectNewestPointsSeries"] = None
     _aggregate_under_ranges: Optional["scout_compute_api_AggregateUnderRangesSeries"] = None
+    _filter_by_expression: Optional["scout_compute_api_FilterByExpressionSeries"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -49915,7 +49970,8 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             'approximate_filter': ConjureFieldDefinition('approximateFilter', scout_compute_api_NumericApproximateFilterSeries),
             'select1d_array_index': ConjureFieldDefinition('select1dArrayIndex', scout_compute_api_SelectIndexFrom1dNumericArraySeries),
             'select_newest_points': ConjureFieldDefinition('selectNewestPoints', scout_compute_api_SelectNewestPointsSeries),
-            'aggregate_under_ranges': ConjureFieldDefinition('aggregateUnderRanges', scout_compute_api_AggregateUnderRangesSeries)
+            'aggregate_under_ranges': ConjureFieldDefinition('aggregateUnderRanges', scout_compute_api_AggregateUnderRangesSeries),
+            'filter_by_expression': ConjureFieldDefinition('filterByExpression', scout_compute_api_FilterByExpressionSeries)
         }
 
     def __init__(
@@ -49955,10 +50011,11 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             select1d_array_index: Optional["scout_compute_api_SelectIndexFrom1dNumericArraySeries"] = None,
             select_newest_points: Optional["scout_compute_api_SelectNewestPointsSeries"] = None,
             aggregate_under_ranges: Optional["scout_compute_api_AggregateUnderRangesSeries"] = None,
+            filter_by_expression: Optional["scout_compute_api_FilterByExpressionSeries"] = None,
             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) + (count_duplicate 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) + (channel is not None) + (derived 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) + (absolute_timestamp 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) + (approximate_filter is not None) + (select1d_array_index is not None) + (select_newest_points is not None) + (aggregate_under_ranges is not None) != 1:
+            if (aggregate is not None) + (arithmetic is not None) + (bit_operation is not None) + (count_duplicate 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) + (channel is not None) + (derived 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) + (absolute_timestamp 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) + (approximate_filter is not None) + (select1d_array_index is not None) + (select_newest_points is not None) + (aggregate_under_ranges is not None) + (filter_by_expression is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if aggregate is not None:
@@ -50066,6 +50123,9 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             if aggregate_under_ranges is not None:
                 self._aggregate_under_ranges = aggregate_under_ranges
                 self._type = 'aggregateUnderRanges'
+            if filter_by_expression is not None:
+                self._filter_by_expression = filter_by_expression
+                self._type = 'filterByExpression'
 
         elif type_of_union == 'aggregate':
             if aggregate is None:
@@ -50242,6 +50302,11 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._aggregate_under_ranges = aggregate_under_ranges
             self._type = 'aggregateUnderRanges'
+        elif type_of_union == 'filterByExpression':
+            if filter_by_expression is None:
+                raise ValueError('a union value must not be None')
+            self._filter_by_expression = filter_by_expression
+            self._type = 'filterByExpression'
 
     @builtins.property
     def aggregate(self) -> Optional["scout_compute_api_AggregateNumericSeries"]:
@@ -50383,6 +50448,10 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
     def aggregate_under_ranges(self) -> Optional["scout_compute_api_AggregateUnderRangesSeries"]:
         return self._aggregate_under_ranges
 
+    @builtins.property
+    def filter_by_expression(self) -> Optional["scout_compute_api_FilterByExpressionSeries"]:
+        return self._filter_by_expression
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_api_NumericSeriesVisitor):
             raise ValueError('{} is not an instance of scout_compute_api_NumericSeriesVisitor'.format(visitor.__class__.__name__))
@@ -50456,6 +50525,8 @@ class scout_compute_api_NumericSeries(ConjureUnionType):
             return visitor._select_newest_points(self.select_newest_points)
         if self._type == 'aggregateUnderRanges' and self.aggregate_under_ranges is not None:
             return visitor._aggregate_under_ranges(self.aggregate_under_ranges)
+        if self._type == 'filterByExpression' and self.filter_by_expression is not None:
+            return visitor._filter_by_expression(self.filter_by_expression)
 
 
 scout_compute_api_NumericSeries.__name__ = "NumericSeries"
@@ -50605,6 +50676,10 @@ class scout_compute_api_NumericSeriesVisitor:
     def _aggregate_under_ranges(self, aggregate_under_ranges: "scout_compute_api_AggregateUnderRangesSeries") -> Any:
         pass
 
+    @abstractmethod
+    def _filter_by_expression(self, filter_by_expression: "scout_compute_api_FilterByExpressionSeries") -> Any:
+        pass
+
 
 scout_compute_api_NumericSeriesVisitor.__name__ = "NumericSeriesVisitor"
 scout_compute_api_NumericSeriesVisitor.__qualname__ = "NumericSeriesVisitor"
@@ -59655,6 +59730,47 @@ scout_compute_resolved_api_FftNode.__qualname__ = "FftNode"
 scout_compute_resolved_api_FftNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_FilterByExpressionSeriesNode(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'base': ConjureFieldDefinition('base', scout_compute_api_LocalVariableName),
+            'inputs': ConjureFieldDefinition('inputs', Dict[scout_compute_api_LocalVariableName, scout_compute_resolved_api_NumericSeriesNode]),
+            'expression': ConjureFieldDefinition('expression', str),
+            'interpolation_configuration': ConjureFieldDefinition('interpolationConfiguration', scout_compute_resolved_api_InterpolationConfiguration)
+        }
+
+    __slots__: List[str] = ['_base', '_inputs', '_expression', '_interpolation_configuration']
+
+    def __init__(self, base: str, expression: str, inputs: Dict[str, "scout_compute_resolved_api_NumericSeriesNode"], interpolation_configuration: "scout_compute_resolved_api_InterpolationConfiguration") -> None:
+        self._base = base
+        self._inputs = inputs
+        self._expression = expression
+        self._interpolation_configuration = interpolation_configuration
+
+    @builtins.property
+    def base(self) -> str:
+        return self._base
+
+    @builtins.property
+    def inputs(self) -> Dict[str, "scout_compute_resolved_api_NumericSeriesNode"]:
+        return self._inputs
+
+    @builtins.property
+    def expression(self) -> str:
+        return self._expression
+
+    @builtins.property
+    def interpolation_configuration(self) -> "scout_compute_resolved_api_InterpolationConfiguration":
+        return self._interpolation_configuration
+
+
+scout_compute_resolved_api_FilterByExpressionSeriesNode.__name__ = "FilterByExpressionSeriesNode"
+scout_compute_resolved_api_FilterByExpressionSeriesNode.__qualname__ = "FilterByExpressionSeriesNode"
+scout_compute_resolved_api_FilterByExpressionSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_ForwardFillInterpolation(ConjureBeanType):
 
     @builtins.classmethod
@@ -60971,6 +61087,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     _absolute_timestamp: Optional["scout_compute_resolved_api_AbsoluteTimestampSeriesNode"] = None
     _newest_points: Optional["scout_compute_resolved_api_SelectNewestPointsSeriesNode"] = None
     _ranges_numeric_aggregation_to_numeric: Optional["scout_compute_resolved_api_RangesNumericAggregationToNumericSeriesNode"] = None
+    _filter_by_expression: Optional["scout_compute_resolved_api_FilterByExpressionSeriesNode"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -61006,7 +61123,8 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             'array_select': ConjureFieldDefinition('arraySelect', scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode),
             'absolute_timestamp': ConjureFieldDefinition('absoluteTimestamp', scout_compute_resolved_api_AbsoluteTimestampSeriesNode),
             'newest_points': ConjureFieldDefinition('newestPoints', scout_compute_resolved_api_SelectNewestPointsSeriesNode),
-            'ranges_numeric_aggregation_to_numeric': ConjureFieldDefinition('rangesNumericAggregationToNumeric', scout_compute_resolved_api_RangesNumericAggregationToNumericSeriesNode)
+            'ranges_numeric_aggregation_to_numeric': ConjureFieldDefinition('rangesNumericAggregationToNumeric', scout_compute_resolved_api_RangesNumericAggregationToNumericSeriesNode),
+            'filter_by_expression': ConjureFieldDefinition('filterByExpression', scout_compute_resolved_api_FilterByExpressionSeriesNode)
         }
 
     def __init__(
@@ -61043,10 +61161,11 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             absolute_timestamp: Optional["scout_compute_resolved_api_AbsoluteTimestampSeriesNode"] = None,
             newest_points: Optional["scout_compute_resolved_api_SelectNewestPointsSeriesNode"] = None,
             ranges_numeric_aggregation_to_numeric: Optional["scout_compute_resolved_api_RangesNumericAggregationToNumericSeriesNode"] = None,
+            filter_by_expression: Optional["scout_compute_resolved_api_FilterByExpressionSeriesNode"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (arithmetic is not None) + (bit_operation is not None) + (count_duplicate 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) + (threshold_filter is not None) + (array_select is not None) + (absolute_timestamp is not None) + (newest_points is not None) + (ranges_numeric_aggregation_to_numeric is not None) != 1:
+            if (arithmetic is not None) + (bit_operation is not None) + (count_duplicate 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) + (threshold_filter is not None) + (array_select is not None) + (absolute_timestamp is not None) + (newest_points is not None) + (ranges_numeric_aggregation_to_numeric is not None) + (filter_by_expression is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if arithmetic is not None:
@@ -61145,6 +61264,9 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             if ranges_numeric_aggregation_to_numeric is not None:
                 self._ranges_numeric_aggregation_to_numeric = ranges_numeric_aggregation_to_numeric
                 self._type = 'rangesNumericAggregationToNumeric'
+            if filter_by_expression is not None:
+                self._filter_by_expression = filter_by_expression
+                self._type = 'filterByExpression'
 
         elif type_of_union == 'arithmetic':
             if arithmetic is None:
@@ -61306,6 +61428,11 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._ranges_numeric_aggregation_to_numeric = ranges_numeric_aggregation_to_numeric
             self._type = 'rangesNumericAggregationToNumeric'
+        elif type_of_union == 'filterByExpression':
+            if filter_by_expression is None:
+                raise ValueError('a union value must not be None')
+            self._filter_by_expression = filter_by_expression
+            self._type = 'filterByExpression'
 
     @builtins.property
     def arithmetic(self) -> Optional["scout_compute_resolved_api_ArithmeticSeriesNode"]:
@@ -61435,6 +61562,10 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     def ranges_numeric_aggregation_to_numeric(self) -> Optional["scout_compute_resolved_api_RangesNumericAggregationToNumericSeriesNode"]:
         return self._ranges_numeric_aggregation_to_numeric
 
+    @builtins.property
+    def filter_by_expression(self) -> Optional["scout_compute_resolved_api_FilterByExpressionSeriesNode"]:
+        return self._filter_by_expression
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_compute_resolved_api_NumericSeriesNodeVisitor):
             raise ValueError('{} is not an instance of scout_compute_resolved_api_NumericSeriesNodeVisitor'.format(visitor.__class__.__name__))
@@ -61502,6 +61633,8 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             return visitor._newest_points(self.newest_points)
         if self._type == 'rangesNumericAggregationToNumeric' and self.ranges_numeric_aggregation_to_numeric is not None:
             return visitor._ranges_numeric_aggregation_to_numeric(self.ranges_numeric_aggregation_to_numeric)
+        if self._type == 'filterByExpression' and self.filter_by_expression is not None:
+            return visitor._filter_by_expression(self.filter_by_expression)
 
 
 scout_compute_resolved_api_NumericSeriesNode.__name__ = "NumericSeriesNode"
@@ -61639,6 +61772,10 @@ class scout_compute_resolved_api_NumericSeriesNodeVisitor:
     def _ranges_numeric_aggregation_to_numeric(self, ranges_numeric_aggregation_to_numeric: "scout_compute_resolved_api_RangesNumericAggregationToNumericSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _filter_by_expression(self, filter_by_expression: "scout_compute_resolved_api_FilterByExpressionSeriesNode") -> Any:
+        pass
+
 
 scout_compute_resolved_api_NumericSeriesNodeVisitor.__name__ = "NumericSeriesNodeVisitor"
 scout_compute_resolved_api_NumericSeriesNodeVisitor.__qualname__ = "NumericSeriesNodeVisitor"

{nominal_api-0.908.0 → nominal_api-0.910.0}/nominal_api/scout_compute_api/__init__.py

@@ -145,6 +145,7 @@ from .._impl import (
     scout_compute_api_ExponentialResultDetails as ExponentialResultDetails,
     scout_compute_api_Fft as Fft,
     scout_compute_api_FftWindow as FftWindow,
+    scout_compute_api_FilterByExpressionSeries as FilterByExpressionSeries,
     scout_compute_api_FirstPointMatchingCondition as FirstPointMatchingCondition,
     scout_compute_api_ForwardFillInterpolation as ForwardFillInterpolation,
     scout_compute_api_ForwardFillResampleInterpolationConfiguration as ForwardFillResampleInterpolationConfiguration,
@@ -513,6 +514,7 @@ __all__ = [
     'ExponentialResultDetails',
     'Fft',
     'FftWindow',
+    'FilterByExpressionSeries',
     'FirstPointMatchingCondition',
     'ForwardFillInterpolation',
     'ForwardFillResampleInterpolationConfiguration',

{nominal_api-0.908.0 → nominal_api-0.910.0}/nominal_api/scout_compute_resolved_api/__init__.py

@@ -46,6 +46,7 @@ from .._impl import (
     scout_compute_resolved_api_ExponentialCurve as ExponentialCurve,
     scout_compute_resolved_api_ExtremaRangesNode as ExtremaRangesNode,
     scout_compute_resolved_api_FftNode as FftNode,
+    scout_compute_resolved_api_FilterByExpressionSeriesNode as FilterByExpressionSeriesNode,
     scout_compute_resolved_api_ForwardFillInterpolation as ForwardFillInterpolation,
     scout_compute_resolved_api_ForwardFillResampleInterpolationConfiguration as ForwardFillResampleInterpolationConfiguration,
     scout_compute_resolved_api_FrequencyDomainNode as FrequencyDomainNode,
@@ -210,6 +211,7 @@ __all__ = [
     'ExponentialCurve',
     'ExtremaRangesNode',
     'FftNode',
+    'FilterByExpressionSeriesNode',
     'ForwardFillInterpolation',
     'ForwardFillResampleInterpolationConfiguration',
     'FrequencyDomainNode',

{nominal_api-0.908.0 → nominal_api-0.910.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.908.0 → nominal_api-0.910.0}/setup.py

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