nominal-api 0.757.1__tar.gz → 0.759.0__tar.gz

{nominal_api-0.757.1 → nominal_api-0.759.0}/PKG-INFO

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

{nominal_api-0.757.1 → nominal_api-0.759.0}/nominal_api/__init__.py

@@ -77,5 +77,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.757.1"
+__version__ = "0.759.0"
 

{nominal_api-0.757.1 → nominal_api-0.759.0}/nominal_api/_impl.py

@@ -15239,44 +15239,187 @@ module_ModuleVersionMetadata.__qualname__ = "ModuleVersionMetadata"
 module_ModuleVersionMetadata.__module__ = "nominal_api.module"
 
 
-class module_SearchModuleApplicationsRequest(ConjureBeanType):
+class module_SearchModuleApplicationsQuery(ConjureUnionType):
+    _module_rid: Optional[str] = None
+    _asset_rid: Optional[str] = None
+    _workspace: Optional[str] = None
+    _and_: Optional[List["module_SearchModuleApplicationsQuery"]] = None
+    _or_: Optional[List["module_SearchModuleApplicationsQuery"]] = None
+    _not_: Optional["module_SearchModuleApplicationsQuery"] = None
 
     @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'search_text': ConjureFieldDefinition('searchText', str),
-            'asset_rids': ConjureFieldDefinition('assetRids', OptionalTypeWrapper[List[scout_rids_api_AssetRid]]),
-            'module_rids': ConjureFieldDefinition('moduleRids', OptionalTypeWrapper[List[modules_api_ModuleRid]]),
-            'workspaces': ConjureFieldDefinition('workspaces', OptionalTypeWrapper[List[api_rids_WorkspaceRid]]),
-            'page_size': ConjureFieldDefinition('pageSize', int),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+            'module_rid': ConjureFieldDefinition('moduleRid', modules_api_ModuleRid),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
+            'workspace': ConjureFieldDefinition('workspace', api_rids_WorkspaceRid),
+            'and_': ConjureFieldDefinition('and', List[module_SearchModuleApplicationsQuery]),
+            'or_': ConjureFieldDefinition('or', List[module_SearchModuleApplicationsQuery]),
+            'not_': ConjureFieldDefinition('not', module_SearchModuleApplicationsQuery)
         }
 
-    __slots__: List[str] = ['_search_text', '_asset_rids', '_module_rids', '_workspaces', '_page_size', '_next_page_token']
+    def __init__(
+            self,
+            module_rid: Optional[str] = None,
+            asset_rid: Optional[str] = None,
+            workspace: Optional[str] = None,
+            and_: Optional[List["module_SearchModuleApplicationsQuery"]] = None,
+            or_: Optional[List["module_SearchModuleApplicationsQuery"]] = None,
+            not_: Optional["module_SearchModuleApplicationsQuery"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (module_rid is not None) + (asset_rid is not None) + (workspace is not None) + (and_ is not None) + (or_ is not None) + (not_ is not None) != 1:
+                raise ValueError('a union must contain a single member')
 
-    def __init__(self, page_size: int, search_text: str, asset_rids: Optional[List[str]] = None, module_rids: Optional[List[str]] = None, next_page_token: Optional[str] = None, workspaces: Optional[List[str]] = None) -> None:
-        self._search_text = search_text
-        self._asset_rids = asset_rids
-        self._module_rids = module_rids
-        self._workspaces = workspaces
-        self._page_size = page_size
-        self._next_page_token = next_page_token
+            if module_rid is not None:
+                self._module_rid = module_rid
+                self._type = 'moduleRid'
+            if asset_rid is not None:
+                self._asset_rid = asset_rid
+                self._type = 'assetRid'
+            if workspace is not None:
+                self._workspace = workspace
+                self._type = 'workspace'
+            if and_ is not None:
+                self._and_ = and_
+                self._type = 'and'
+            if or_ is not None:
+                self._or_ = or_
+                self._type = 'or'
+            if not_ is not None:
+                self._not_ = not_
+                self._type = 'not'
+
+        elif type_of_union == 'moduleRid':
+            if module_rid is None:
+                raise ValueError('a union value must not be None')
+            self._module_rid = module_rid
+            self._type = 'moduleRid'
+        elif type_of_union == 'assetRid':
+            if asset_rid is None:
+                raise ValueError('a union value must not be None')
+            self._asset_rid = asset_rid
+            self._type = 'assetRid'
+        elif type_of_union == 'workspace':
+            if workspace is None:
+                raise ValueError('a union value must not be None')
+            self._workspace = workspace
+            self._type = 'workspace'
+        elif type_of_union == 'and':
+            if and_ is None:
+                raise ValueError('a union value must not be None')
+            self._and_ = and_
+            self._type = 'and'
+        elif type_of_union == 'or':
+            if or_ is None:
+                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'
 
     @builtins.property
-    def search_text(self) -> str:
-        return self._search_text
+    def module_rid(self) -> Optional[str]:
+        return self._module_rid
 
     @builtins.property
-    def asset_rids(self) -> Optional[List[str]]:
-        return self._asset_rids
+    def asset_rid(self) -> Optional[str]:
+        return self._asset_rid
 
     @builtins.property
-    def module_rids(self) -> Optional[List[str]]:
-        return self._module_rids
+    def workspace(self) -> Optional[str]:
+        return self._workspace
 
     @builtins.property
-    def workspaces(self) -> Optional[List[str]]:
-        return self._workspaces
+    def and_(self) -> Optional[List["module_SearchModuleApplicationsQuery"]]:
+        return self._and_
+
+    @builtins.property
+    def or_(self) -> Optional[List["module_SearchModuleApplicationsQuery"]]:
+        return self._or_
+
+    @builtins.property
+    def not_(self) -> Optional["module_SearchModuleApplicationsQuery"]:
+        return self._not_
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, module_SearchModuleApplicationsQueryVisitor):
+            raise ValueError('{} is not an instance of module_SearchModuleApplicationsQueryVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'moduleRid' and self.module_rid is not None:
+            return visitor._module_rid(self.module_rid)
+        if self._type == 'assetRid' and self.asset_rid is not None:
+            return visitor._asset_rid(self.asset_rid)
+        if self._type == 'workspace' and self.workspace is not None:
+            return visitor._workspace(self.workspace)
+        if self._type == 'and' and self.and_ is not None:
+            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_)
+
+
+module_SearchModuleApplicationsQuery.__name__ = "SearchModuleApplicationsQuery"
+module_SearchModuleApplicationsQuery.__qualname__ = "SearchModuleApplicationsQuery"
+module_SearchModuleApplicationsQuery.__module__ = "nominal_api.module"
+
+
+class module_SearchModuleApplicationsQueryVisitor:
+
+    @abstractmethod
+    def _module_rid(self, module_rid: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _asset_rid(self, asset_rid: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _workspace(self, workspace: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _and(self, and_: List["module_SearchModuleApplicationsQuery"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _or(self, or_: List["module_SearchModuleApplicationsQuery"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _not(self, not_: "module_SearchModuleApplicationsQuery") -> Any:
+        pass
+
+
+module_SearchModuleApplicationsQueryVisitor.__name__ = "SearchModuleApplicationsQueryVisitor"
+module_SearchModuleApplicationsQueryVisitor.__qualname__ = "SearchModuleApplicationsQueryVisitor"
+module_SearchModuleApplicationsQueryVisitor.__module__ = "nominal_api.module"
+
+
+class module_SearchModuleApplicationsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'query': ConjureFieldDefinition('query', module_SearchModuleApplicationsQuery),
+            'page_size': ConjureFieldDefinition('pageSize', int),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_query', '_page_size', '_next_page_token']
+
+    def __init__(self, page_size: int, query: "module_SearchModuleApplicationsQuery", next_page_token: Optional[str] = None) -> None:
+        self._query = query
+        self._page_size = page_size
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def query(self) -> "module_SearchModuleApplicationsQuery":
+        return self._query
 
     @builtins.property
     def page_size(self) -> int:
@@ -15509,21 +15652,29 @@ class module_SearchModulesRequest(ConjureBeanType):
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'query': ConjureFieldDefinition('query', module_SearchModulesQuery),
+            'sort': ConjureFieldDefinition('sort', OptionalTypeWrapper[module_SearchModulesSortOptions]),
             'page_size': ConjureFieldDefinition('pageSize', int),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
+            'archived_statuses': ConjureFieldDefinition('archivedStatuses', OptionalTypeWrapper[List[api_ArchivedStatus]])
         }
 
-    __slots__: List[str] = ['_query', '_page_size', '_next_page_token']
+    __slots__: List[str] = ['_query', '_sort', '_page_size', '_next_page_token', '_archived_statuses']
 
-    def __init__(self, page_size: int, query: "module_SearchModulesQuery", next_page_token: Optional[str] = None) -> None:
+    def __init__(self, page_size: int, query: "module_SearchModulesQuery", archived_statuses: Optional[List["api_ArchivedStatus"]] = None, next_page_token: Optional[str] = None, sort: Optional["module_SearchModulesSortOptions"] = None) -> None:
         self._query = query
+        self._sort = sort
         self._page_size = page_size
         self._next_page_token = next_page_token
+        self._archived_statuses = archived_statuses
 
     @builtins.property
     def query(self) -> "module_SearchModulesQuery":
         return self._query
 
+    @builtins.property
+    def sort(self) -> Optional["module_SearchModulesSortOptions"]:
+        return self._sort
+
     @builtins.property
     def page_size(self) -> int:
         return self._page_size
@@ -15532,6 +15683,12 @@ class module_SearchModulesRequest(ConjureBeanType):
     def next_page_token(self) -> Optional[str]:
         return self._next_page_token
 
+    @builtins.property
+    def archived_statuses(self) -> Optional[List["api_ArchivedStatus"]]:
+        """Default search status is NOT_ARCHIVED if none are provided. Allows for including archived modules in search.
+        """
+        return self._archived_statuses
+
 
 module_SearchModulesRequest.__name__ = "SearchModulesRequest"
 module_SearchModulesRequest.__qualname__ = "SearchModulesRequest"
@@ -15567,6 +15724,57 @@ module_SearchModulesResponse.__qualname__ = "SearchModulesResponse"
 module_SearchModulesResponse.__module__ = "nominal_api.module"
 
 
+class module_SearchModulesSortField(ConjureEnumType):
+
+    NAME = 'NAME'
+    '''NAME'''
+    LAST_UPDATED_AT = 'LAST_UPDATED_AT'
+    '''LAST_UPDATED_AT'''
+    CREATED_AT = 'CREATED_AT'
+    '''CREATED_AT'''
+    ARCHIVED_AT = 'ARCHIVED_AT'
+    '''ARCHIVED_AT'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+module_SearchModulesSortField.__name__ = "SearchModulesSortField"
+module_SearchModulesSortField.__qualname__ = "SearchModulesSortField"
+module_SearchModulesSortField.__module__ = "nominal_api.module"
+
+
+class module_SearchModulesSortOptions(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'is_descending': ConjureFieldDefinition('isDescending', bool),
+            'field': ConjureFieldDefinition('field', module_SearchModulesSortField)
+        }
+
+    __slots__: List[str] = ['_is_descending', '_field']
+
+    def __init__(self, field: "module_SearchModulesSortField", is_descending: bool) -> None:
+        self._is_descending = is_descending
+        self._field = field
+
+    @builtins.property
+    def is_descending(self) -> bool:
+        return self._is_descending
+
+    @builtins.property
+    def field(self) -> "module_SearchModulesSortField":
+        return self._field
+
+
+module_SearchModulesSortOptions.__name__ = "SearchModulesSortOptions"
+module_SearchModulesSortOptions.__qualname__ = "SearchModulesSortOptions"
+module_SearchModulesSortOptions.__module__ = "nominal_api.module"
+
+
 class module_SemanticVersion(ConjureBeanType):
 
     @builtins.classmethod
@@ -55443,6 +55651,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     _unit_conversion: Optional["scout_compute_resolved_api_UnitConversionSeriesNode"] = None
     _value_difference: Optional["scout_compute_resolved_api_ValueDifferenceSeriesNode"] = None
     _filter_transformation: Optional["scout_compute_resolved_api_NumericFilterTransformationSeriesNode"] = None
+    _threshold_filter: Optional["scout_compute_resolved_api_NumericThresholdFilterSeriesNode"] = None
     _array_select: Optional["scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode"] = None
     _absolute_timestamp: Optional["scout_compute_resolved_api_AbsoluteTimestampSeriesNode"] = None
 
@@ -55476,6 +55685,7 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             'unit_conversion': ConjureFieldDefinition('unitConversion', scout_compute_resolved_api_UnitConversionSeriesNode),
             'value_difference': ConjureFieldDefinition('valueDifference', scout_compute_resolved_api_ValueDifferenceSeriesNode),
             'filter_transformation': ConjureFieldDefinition('filterTransformation', scout_compute_resolved_api_NumericFilterTransformationSeriesNode),
+            'threshold_filter': ConjureFieldDefinition('thresholdFilter', scout_compute_resolved_api_NumericThresholdFilterSeriesNode),
             'array_select': ConjureFieldDefinition('arraySelect', scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode),
             'absolute_timestamp': ConjureFieldDefinition('absoluteTimestamp', scout_compute_resolved_api_AbsoluteTimestampSeriesNode)
         }
@@ -55509,12 +55719,13 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             unit_conversion: Optional["scout_compute_resolved_api_UnitConversionSeriesNode"] = None,
             value_difference: Optional["scout_compute_resolved_api_ValueDifferenceSeriesNode"] = None,
             filter_transformation: Optional["scout_compute_resolved_api_NumericFilterTransformationSeriesNode"] = None,
+            threshold_filter: Optional["scout_compute_resolved_api_NumericThresholdFilterSeriesNode"] = None,
             array_select: Optional["scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode"] = None,
             absolute_timestamp: Optional["scout_compute_resolved_api_AbsoluteTimestampSeriesNode"] = 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) + (array_select is not None) + (absolute_timestamp 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) != 1:
                 raise ValueError('a union must contain a single member')
 
             if arithmetic is not None:
@@ -55598,6 +55809,9 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             if filter_transformation is not None:
                 self._filter_transformation = filter_transformation
                 self._type = 'filterTransformation'
+            if threshold_filter is not None:
+                self._threshold_filter = threshold_filter
+                self._type = 'thresholdFilter'
             if array_select is not None:
                 self._array_select = array_select
                 self._type = 'arraySelect'
@@ -55740,6 +55954,11 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._filter_transformation = filter_transformation
             self._type = 'filterTransformation'
+        elif type_of_union == 'thresholdFilter':
+            if threshold_filter is None:
+                raise ValueError('a union value must not be None')
+            self._threshold_filter = threshold_filter
+            self._type = 'thresholdFilter'
         elif type_of_union == 'arraySelect':
             if array_select is None:
                 raise ValueError('a union value must not be None')
@@ -55859,6 +56078,10 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
     def filter_transformation(self) -> Optional["scout_compute_resolved_api_NumericFilterTransformationSeriesNode"]:
         return self._filter_transformation
 
+    @builtins.property
+    def threshold_filter(self) -> Optional["scout_compute_resolved_api_NumericThresholdFilterSeriesNode"]:
+        return self._threshold_filter
+
     @builtins.property
     def array_select(self) -> Optional["scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode"]:
         return self._array_select
@@ -55924,6 +56147,8 @@ class scout_compute_resolved_api_NumericSeriesNode(ConjureUnionType):
             return visitor._value_difference(self.value_difference)
         if self._type == 'filterTransformation' and self.filter_transformation is not None:
             return visitor._filter_transformation(self.filter_transformation)
+        if self._type == 'thresholdFilter' and self.threshold_filter is not None:
+            return visitor._threshold_filter(self.threshold_filter)
         if self._type == 'arraySelect' and self.array_select is not None:
             return visitor._array_select(self.array_select)
         if self._type == 'absoluteTimestamp' and self.absolute_timestamp is not None:
@@ -56045,6 +56270,10 @@ class scout_compute_resolved_api_NumericSeriesNodeVisitor:
     def _filter_transformation(self, filter_transformation: "scout_compute_resolved_api_NumericFilterTransformationSeriesNode") -> Any:
         pass
 
+    @abstractmethod
+    def _threshold_filter(self, threshold_filter: "scout_compute_resolved_api_NumericThresholdFilterSeriesNode") -> Any:
+        pass
+
     @abstractmethod
     def _array_select(self, array_select: "scout_compute_resolved_api_SelectIndexFromNumericArraySeriesNode") -> Any:
         pass
@@ -56059,6 +56288,44 @@ scout_compute_resolved_api_NumericSeriesNodeVisitor.__qualname__ = "NumericSerie
 scout_compute_resolved_api_NumericSeriesNodeVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_NumericThresholdFilterSeriesNode(ConjureBeanType):
+    """Even though this could be implementing using a filter transformation, handling it alone gives
+easier pushdown instead of indirecting through ranges nodes
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'input': ConjureFieldDefinition('input', scout_compute_resolved_api_NumericSeriesNode),
+            'threshold': ConjureFieldDefinition('threshold', float),
+            'threshold_operator': ConjureFieldDefinition('thresholdOperator', scout_compute_api_ThresholdOperator)
+        }
+
+    __slots__: List[str] = ['_input', '_threshold', '_threshold_operator']
+
+    def __init__(self, input: "scout_compute_resolved_api_NumericSeriesNode", threshold: float, threshold_operator: "scout_compute_api_ThresholdOperator") -> None:
+        self._input = input
+        self._threshold = threshold
+        self._threshold_operator = threshold_operator
+
+    @builtins.property
+    def input(self) -> "scout_compute_resolved_api_NumericSeriesNode":
+        return self._input
+
+    @builtins.property
+    def threshold(self) -> float:
+        return self._threshold
+
+    @builtins.property
+    def threshold_operator(self) -> "scout_compute_api_ThresholdOperator":
+        return self._threshold_operator
+
+
+scout_compute_resolved_api_NumericThresholdFilterSeriesNode.__name__ = "NumericThresholdFilterSeriesNode"
+scout_compute_resolved_api_NumericThresholdFilterSeriesNode.__qualname__ = "NumericThresholdFilterSeriesNode"
+scout_compute_resolved_api_NumericThresholdFilterSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_NumericTimeRangeFilterSeriesNode(ConjureBeanType):
 
     @builtins.classmethod

{nominal_api-0.757.1 → nominal_api-0.759.0}/nominal_api/module/__init__.py

@@ -27,12 +27,16 @@ from .._impl import (
     module_ModuleVersionDefinition as ModuleVersionDefinition,
     module_ModuleVersionMetadata as ModuleVersionMetadata,
     module_ParameterName as ParameterName,
+    module_SearchModuleApplicationsQuery as SearchModuleApplicationsQuery,
+    module_SearchModuleApplicationsQueryVisitor as SearchModuleApplicationsQueryVisitor,
     module_SearchModuleApplicationsRequest as SearchModuleApplicationsRequest,
     module_SearchModuleApplicationsResponse as SearchModuleApplicationsResponse,
     module_SearchModulesQuery as SearchModulesQuery,
     module_SearchModulesQueryVisitor as SearchModulesQueryVisitor,
     module_SearchModulesRequest as SearchModulesRequest,
     module_SearchModulesResponse as SearchModulesResponse,
+    module_SearchModulesSortField as SearchModulesSortField,
+    module_SearchModulesSortOptions as SearchModulesSortOptions,
     module_SemanticVersion as SemanticVersion,
     module_UnapplyModuleRequest as UnapplyModuleRequest,
     module_UnapplyModuleResponse as UnapplyModuleResponse,
@@ -68,12 +72,16 @@ __all__ = [
     'ModuleVersionDefinition',
     'ModuleVersionMetadata',
     'ParameterName',
+    'SearchModuleApplicationsQuery',
+    'SearchModuleApplicationsQueryVisitor',
     'SearchModuleApplicationsRequest',
     'SearchModuleApplicationsResponse',
     'SearchModulesQuery',
     'SearchModulesQueryVisitor',
     'SearchModulesRequest',
     'SearchModulesResponse',
+    'SearchModulesSortField',
+    'SearchModulesSortOptions',
     'SemanticVersion',
     'UnapplyModuleRequest',
     'UnapplyModuleResponse',

{nominal_api-0.757.1 → nominal_api-0.759.0}/nominal_api/scout_compute_resolved_api/__init__.py

@@ -85,6 +85,7 @@ from .._impl import (
     scout_compute_resolved_api_NumericResampleSeriesNode as NumericResampleSeriesNode,
     scout_compute_resolved_api_NumericSeriesNode as NumericSeriesNode,
     scout_compute_resolved_api_NumericSeriesNodeVisitor as NumericSeriesNodeVisitor,
+    scout_compute_resolved_api_NumericThresholdFilterSeriesNode as NumericThresholdFilterSeriesNode,
     scout_compute_resolved_api_NumericTimeRangeFilterSeriesNode as NumericTimeRangeFilterSeriesNode,
     scout_compute_resolved_api_NumericTimeShiftSeriesNode as NumericTimeShiftSeriesNode,
     scout_compute_resolved_api_NumericUnionSeriesNode as NumericUnionSeriesNode,
@@ -239,6 +240,7 @@ __all__ = [
     'NumericResampleSeriesNode',
     'NumericSeriesNode',
     'NumericSeriesNodeVisitor',
+    'NumericThresholdFilterSeriesNode',
     'NumericTimeRangeFilterSeriesNode',
     'NumericTimeShiftSeriesNode',
     'NumericUnionSeriesNode',

{nominal_api-0.757.1 → nominal_api-0.759.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.757.1 → nominal_api-0.759.0}/setup.py

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