nominal-api 0.752.0__py3-none-any.whl → 0.753.0__py3-none-any.whl

nominal_api/__init__.py

@@ -77,5 +77,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.752.0"
+__version__ = "0.753.0"
 

nominal_api/_impl.py

@@ -9190,6 +9190,8 @@ class ingest_api_FileOutputFormat(ConjureEnumType):
     '''CSV'''
     PARQUET_TAR = 'PARQUET_TAR'
     '''PARQUET_TAR'''
+    AVRO_STREAM = 'AVRO_STREAM'
+    '''AVRO_STREAM'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -37521,17 +37523,19 @@ class scout_compute_api_AssetChannel(ConjureBeanType):
             'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_compute_api_StringConstant),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
             'additional_tags': ConjureFieldDefinition('additionalTags', Dict[str, scout_compute_api_StringConstant]),
+            'additional_tag_filters': ConjureFieldDefinition('additionalTagFilters', OptionalTypeWrapper[scout_compute_api_TagFilters]),
             'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[str]),
             'group_by_tags': ConjureFieldDefinition('groupByTags', OptionalTypeWrapper[scout_compute_api_StringSetConstant])
         }
 
-    __slots__: List[str] = ['_asset_rid', '_data_scope_name', '_channel', '_additional_tags', '_tags_to_group_by', '_group_by_tags']
+    __slots__: List[str] = ['_asset_rid', '_data_scope_name', '_channel', '_additional_tags', '_additional_tag_filters', '_tags_to_group_by', '_group_by_tags']
 
-    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], asset_rid: "scout_compute_api_StringConstant", channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", tags_to_group_by: List[str], group_by_tags: Optional["scout_compute_api_StringSetConstant"] = None) -> None:
+    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], asset_rid: "scout_compute_api_StringConstant", channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", tags_to_group_by: List[str], additional_tag_filters: Optional["scout_compute_api_TagFilters"] = None, group_by_tags: Optional["scout_compute_api_StringSetConstant"] = None) -> None:
         self._asset_rid = asset_rid
         self._data_scope_name = data_scope_name
         self._channel = channel
         self._additional_tags = additional_tags
+        self._additional_tag_filters = additional_tag_filters
         self._tags_to_group_by = tags_to_group_by
         self._group_by_tags = group_by_tags
 
@@ -37551,11 +37555,15 @@ class scout_compute_api_AssetChannel(ConjureBeanType):
 
     @builtins.property
     def additional_tags(self) -> Dict[str, "scout_compute_api_StringConstant"]:
+        return self._additional_tags
+
+    @builtins.property
+    def additional_tag_filters(self) -> Optional["scout_compute_api_TagFilters"]:
         """Tags to filter the channel by, in addition to tag filters defined for a given Asset data scope. Throws on 
 collisions with tag keys already defined for the given Asset data scope. Only returns points that match 
 both sets of tag filters. For log series, include arg filters here in addition to tag filters.
         """
-        return self._additional_tags
+        return self._additional_tag_filters
 
     @builtins.property
     def tags_to_group_by(self) -> List[str]:
@@ -40931,16 +40939,18 @@ class scout_compute_api_DataSourceChannel(ConjureBeanType):
             'data_source_rid': ConjureFieldDefinition('dataSourceRid', scout_compute_api_StringConstant),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
             'tags': ConjureFieldDefinition('tags', Dict[str, scout_compute_api_StringConstant]),
+            'tag_filters': ConjureFieldDefinition('tagFilters', OptionalTypeWrapper[scout_compute_api_TagFilters]),
             'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[str]),
             'group_by_tags': ConjureFieldDefinition('groupByTags', OptionalTypeWrapper[scout_compute_api_StringSetConstant])
         }
 
-    __slots__: List[str] = ['_data_source_rid', '_channel', '_tags', '_tags_to_group_by', '_group_by_tags']
+    __slots__: List[str] = ['_data_source_rid', '_channel', '_tags', '_tag_filters', '_tags_to_group_by', '_group_by_tags']
 
-    def __init__(self, channel: "scout_compute_api_StringConstant", data_source_rid: "scout_compute_api_StringConstant", tags: Dict[str, "scout_compute_api_StringConstant"], tags_to_group_by: List[str], group_by_tags: Optional["scout_compute_api_StringSetConstant"] = None) -> None:
+    def __init__(self, channel: "scout_compute_api_StringConstant", data_source_rid: "scout_compute_api_StringConstant", tags: Dict[str, "scout_compute_api_StringConstant"], tags_to_group_by: List[str], group_by_tags: Optional["scout_compute_api_StringSetConstant"] = None, tag_filters: Optional["scout_compute_api_TagFilters"] = None) -> None:
         self._data_source_rid = data_source_rid
         self._channel = channel
         self._tags = tags
+        self._tag_filters = tag_filters
         self._tags_to_group_by = tags_to_group_by
         self._group_by_tags = group_by_tags
 
@@ -40954,11 +40964,15 @@ class scout_compute_api_DataSourceChannel(ConjureBeanType):
 
     @builtins.property
     def tags(self) -> Dict[str, "scout_compute_api_StringConstant"]:
-        """Tags to filter the channel by. Only returns points from the channel with matching tag values for the 
-provided tag keys. For log series, include arg filters here in addition to tag filters.
-        """
         return self._tags
 
+    @builtins.property
+    def tag_filters(self) -> Optional["scout_compute_api_TagFilters"]:
+        """Tags to filter the channel by. Only returns points from the channel where tag values match the provided
+expression. For log series, include arg filters here in addition to tag filters.
+        """
+        return self._tag_filters
+
     @builtins.property
     def tags_to_group_by(self) -> List[str]:
         return self._tags_to_group_by
@@ -47955,17 +47969,19 @@ class scout_compute_api_RunChannel(ConjureBeanType):
             'data_scope_name': ConjureFieldDefinition('dataScopeName', scout_compute_api_StringConstant),
             'channel': ConjureFieldDefinition('channel', scout_compute_api_StringConstant),
             'additional_tags': ConjureFieldDefinition('additionalTags', Dict[str, scout_compute_api_StringConstant]),
+            'additional_tag_filters': ConjureFieldDefinition('additionalTagFilters', OptionalTypeWrapper[scout_compute_api_TagFilters]),
             'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[str]),
             'group_by_tags': ConjureFieldDefinition('groupByTags', OptionalTypeWrapper[scout_compute_api_StringSetConstant])
         }
 
-    __slots__: List[str] = ['_run_rid', '_data_scope_name', '_channel', '_additional_tags', '_tags_to_group_by', '_group_by_tags']
+    __slots__: List[str] = ['_run_rid', '_data_scope_name', '_channel', '_additional_tags', '_additional_tag_filters', '_tags_to_group_by', '_group_by_tags']
 
-    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", run_rid: "scout_compute_api_StringConstant", tags_to_group_by: List[str], group_by_tags: Optional["scout_compute_api_StringSetConstant"] = None) -> None:
+    def __init__(self, additional_tags: Dict[str, "scout_compute_api_StringConstant"], channel: "scout_compute_api_StringConstant", data_scope_name: "scout_compute_api_StringConstant", run_rid: "scout_compute_api_StringConstant", tags_to_group_by: List[str], additional_tag_filters: Optional["scout_compute_api_TagFilters"] = None, group_by_tags: Optional["scout_compute_api_StringSetConstant"] = None) -> None:
         self._run_rid = run_rid
         self._data_scope_name = data_scope_name
         self._channel = channel
         self._additional_tags = additional_tags
+        self._additional_tag_filters = additional_tag_filters
         self._tags_to_group_by = tags_to_group_by
         self._group_by_tags = group_by_tags
 
@@ -47985,11 +48001,15 @@ class scout_compute_api_RunChannel(ConjureBeanType):
 
     @builtins.property
     def additional_tags(self) -> Dict[str, "scout_compute_api_StringConstant"]:
+        return self._additional_tags
+
+    @builtins.property
+    def additional_tag_filters(self) -> Optional["scout_compute_api_TagFilters"]:
         """Tags to filter the channel by, in addition to tag filters defined for a given Run data scope. Throws on 
 collisions with tag keys already defined for the given Run data scope. Only returns points that match 
 both sets of tag filters. For log series, include arg filters here in addition to tag filters.
         """
-        return self._additional_tags
+        return self._additional_tag_filters
 
     @builtins.property
     def tags_to_group_by(self) -> List[str]:
@@ -49519,6 +49539,166 @@ scout_compute_api_SummarizeSeries.__qualname__ = "SummarizeSeries"
 scout_compute_api_SummarizeSeries.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_TagFilter(ConjureBeanType):
+    """A filter on a single tag key and set of values. For an IN operator, the tag key must match at least one of the
+values in the set. For a NOT_IN operator, it must not match any of the values in the set.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'key': ConjureFieldDefinition('key', scout_compute_api_StringConstant),
+            'values': ConjureFieldDefinition('values', List[scout_compute_api_StringConstant]),
+            'operator': ConjureFieldDefinition('operator', scout_compute_api_TagFilterOperator)
+        }
+
+    __slots__: List[str] = ['_key', '_values', '_operator']
+
+    def __init__(self, key: "scout_compute_api_StringConstant", operator: "scout_compute_api_TagFilterOperator", values: List["scout_compute_api_StringConstant"]) -> None:
+        self._key = key
+        self._values = values
+        self._operator = operator
+
+    @builtins.property
+    def key(self) -> "scout_compute_api_StringConstant":
+        return self._key
+
+    @builtins.property
+    def values(self) -> List["scout_compute_api_StringConstant"]:
+        return self._values
+
+    @builtins.property
+    def operator(self) -> "scout_compute_api_TagFilterOperator":
+        return self._operator
+
+
+scout_compute_api_TagFilter.__name__ = "TagFilter"
+scout_compute_api_TagFilter.__qualname__ = "TagFilter"
+scout_compute_api_TagFilter.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_TagFilterOperator(ConjureEnumType):
+
+    IN = 'IN'
+    '''IN'''
+    NOT_IN = 'NOT_IN'
+    '''NOT_IN'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_compute_api_TagFilterOperator.__name__ = "TagFilterOperator"
+scout_compute_api_TagFilterOperator.__qualname__ = "TagFilterOperator"
+scout_compute_api_TagFilterOperator.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_TagFilterValidationErrorType(ConjureEnumType):
+
+    BOTH_TAGS_AND_TAG_FILTERS_PROVIDED = 'BOTH_TAGS_AND_TAG_FILTERS_PROVIDED'
+    '''BOTH_TAGS_AND_TAG_FILTERS_PROVIDED'''
+    EMPTY_FILTER_LIST = 'EMPTY_FILTER_LIST'
+    '''EMPTY_FILTER_LIST'''
+    EMPTY_TAG_VALUE_SET = 'EMPTY_TAG_VALUE_SET'
+    '''EMPTY_TAG_VALUE_SET'''
+    NESTED_AND_OPERATIONS = 'NESTED_AND_OPERATIONS'
+    '''NESTED_AND_OPERATIONS'''
+    DUPLICATE_TAG_KEY = 'DUPLICATE_TAG_KEY'
+    '''DUPLICATE_TAG_KEY'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_compute_api_TagFilterValidationErrorType.__name__ = "TagFilterValidationErrorType"
+scout_compute_api_TagFilterValidationErrorType.__qualname__ = "TagFilterValidationErrorType"
+scout_compute_api_TagFilterValidationErrorType.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_TagFilters(ConjureUnionType):
+    """A set of tag filters to apply to a channel. Allows for combining filters on multiple tag keys, but throws if
+any one tag key is specified in more than one filter.
+    """
+    _single: Optional["scout_compute_api_TagFilter"] = None
+    _and_: Optional[List["scout_compute_api_TagFilters"]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'single': ConjureFieldDefinition('single', scout_compute_api_TagFilter),
+            'and_': ConjureFieldDefinition('and', List[scout_compute_api_TagFilters])
+        }
+
+    def __init__(
+            self,
+            single: Optional["scout_compute_api_TagFilter"] = None,
+            and_: Optional[List["scout_compute_api_TagFilters"]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (single is not None) + (and_ is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if single is not None:
+                self._single = single
+                self._type = 'single'
+            if and_ is not None:
+                self._and_ = and_
+                self._type = 'and'
+
+        elif type_of_union == 'single':
+            if single is None:
+                raise ValueError('a union value must not be None')
+            self._single = single
+            self._type = 'single'
+        elif type_of_union == 'and':
+            if and_ is None:
+                raise ValueError('a union value must not be None')
+            self._and_ = and_
+            self._type = 'and'
+
+    @builtins.property
+    def single(self) -> Optional["scout_compute_api_TagFilter"]:
+        return self._single
+
+    @builtins.property
+    def and_(self) -> Optional[List["scout_compute_api_TagFilters"]]:
+        return self._and_
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_TagFiltersVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_TagFiltersVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'single' and self.single is not None:
+            return visitor._single(self.single)
+        if self._type == 'and' and self.and_ is not None:
+            return visitor._and(self.and_)
+
+
+scout_compute_api_TagFilters.__name__ = "TagFilters"
+scout_compute_api_TagFilters.__qualname__ = "TagFilters"
+scout_compute_api_TagFilters.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_TagFiltersVisitor:
+
+    @abstractmethod
+    def _single(self, single: "scout_compute_api_TagFilter") -> Any:
+        pass
+
+    @abstractmethod
+    def _and(self, and_: List["scout_compute_api_TagFilters"]) -> Any:
+        pass
+
+
+scout_compute_api_TagFiltersVisitor.__name__ = "TagFiltersVisitor"
+scout_compute_api_TagFiltersVisitor.__qualname__ = "TagFiltersVisitor"
+scout_compute_api_TagFiltersVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_Threshold(ConjureUnionType):
     _absolute: Optional["scout_compute_api_AbsoluteThreshold"] = None
     _percentage: Optional["scout_compute_api_PercentageThreshold"] = None
@@ -53232,14 +53412,14 @@ class scout_compute_resolved_api_ClickHouseSeriesResolutionDetails(ConjureBeanTy
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'channel': ConjureFieldDefinition('channel', api_Channel),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'tags': ConjureFieldDefinition('tags', OptionalTypeWrapper[scout_compute_resolved_api_TagFilters]),
             'tags_to_group_by': ConjureFieldDefinition('tagsToGroupBy', List[api_TagName]),
             'org_rid': ConjureFieldDefinition('orgRid', authentication_api_OrgRid)
         }
 
     __slots__: List[str] = ['_channel', '_tags', '_tags_to_group_by', '_org_rid']
 
-    def __init__(self, channel: str, org_rid: str, tags: Dict[str, str], tags_to_group_by: List[str]) -> None:
+    def __init__(self, channel: str, org_rid: str, tags_to_group_by: List[str], tags: Optional["scout_compute_resolved_api_TagFilters"] = None) -> None:
         self._channel = channel
         self._tags = tags
         self._tags_to_group_by = tags_to_group_by
@@ -53250,7 +53430,7 @@ class scout_compute_resolved_api_ClickHouseSeriesResolutionDetails(ConjureBeanTy
         return self._channel
 
     @builtins.property
-    def tags(self) -> Dict[str, str]:
+    def tags(self) -> Optional["scout_compute_resolved_api_TagFilters"]:
         return self._tags
 
     @builtins.property
@@ -58386,6 +58566,136 @@ scout_compute_resolved_api_SummarizeSeriesNode.__qualname__ = "SummarizeSeriesNo
 scout_compute_resolved_api_SummarizeSeriesNode.__module__ = "nominal_api.scout_compute_resolved_api"
 
 
+class scout_compute_resolved_api_TagFilter(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'key': ConjureFieldDefinition('key', api_TagName),
+            'values': ConjureFieldDefinition('values', List[api_TagValue]),
+            'operator': ConjureFieldDefinition('operator', scout_compute_resolved_api_TagFilterOperator)
+        }
+
+    __slots__: List[str] = ['_key', '_values', '_operator']
+
+    def __init__(self, key: str, operator: "scout_compute_resolved_api_TagFilterOperator", values: List[str]) -> None:
+        self._key = key
+        self._values = values
+        self._operator = operator
+
+    @builtins.property
+    def key(self) -> str:
+        return self._key
+
+    @builtins.property
+    def values(self) -> List[str]:
+        return self._values
+
+    @builtins.property
+    def operator(self) -> "scout_compute_resolved_api_TagFilterOperator":
+        return self._operator
+
+
+scout_compute_resolved_api_TagFilter.__name__ = "TagFilter"
+scout_compute_resolved_api_TagFilter.__qualname__ = "TagFilter"
+scout_compute_resolved_api_TagFilter.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_TagFilterOperator(ConjureEnumType):
+
+    IN = 'IN'
+    '''IN'''
+    NOT_IN = 'NOT_IN'
+    '''NOT_IN'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_compute_resolved_api_TagFilterOperator.__name__ = "TagFilterOperator"
+scout_compute_resolved_api_TagFilterOperator.__qualname__ = "TagFilterOperator"
+scout_compute_resolved_api_TagFilterOperator.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_TagFilters(ConjureUnionType):
+    _single: Optional["scout_compute_resolved_api_TagFilter"] = None
+    _and_: Optional[List["scout_compute_resolved_api_TagFilters"]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'single': ConjureFieldDefinition('single', scout_compute_resolved_api_TagFilter),
+            'and_': ConjureFieldDefinition('and', List[scout_compute_resolved_api_TagFilters])
+        }
+
+    def __init__(
+            self,
+            single: Optional["scout_compute_resolved_api_TagFilter"] = None,
+            and_: Optional[List["scout_compute_resolved_api_TagFilters"]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (single is not None) + (and_ is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if single is not None:
+                self._single = single
+                self._type = 'single'
+            if and_ is not None:
+                self._and_ = and_
+                self._type = 'and'
+
+        elif type_of_union == 'single':
+            if single is None:
+                raise ValueError('a union value must not be None')
+            self._single = single
+            self._type = 'single'
+        elif type_of_union == 'and':
+            if and_ is None:
+                raise ValueError('a union value must not be None')
+            self._and_ = and_
+            self._type = 'and'
+
+    @builtins.property
+    def single(self) -> Optional["scout_compute_resolved_api_TagFilter"]:
+        return self._single
+
+    @builtins.property
+    def and_(self) -> Optional[List["scout_compute_resolved_api_TagFilters"]]:
+        return self._and_
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_resolved_api_TagFiltersVisitor):
+            raise ValueError('{} is not an instance of scout_compute_resolved_api_TagFiltersVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'single' and self.single is not None:
+            return visitor._single(self.single)
+        if self._type == 'and' and self.and_ is not None:
+            return visitor._and(self.and_)
+
+
+scout_compute_resolved_api_TagFilters.__name__ = "TagFilters"
+scout_compute_resolved_api_TagFilters.__qualname__ = "TagFilters"
+scout_compute_resolved_api_TagFilters.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
+class scout_compute_resolved_api_TagFiltersVisitor:
+
+    @abstractmethod
+    def _single(self, single: "scout_compute_resolved_api_TagFilter") -> Any:
+        pass
+
+    @abstractmethod
+    def _and(self, and_: List["scout_compute_resolved_api_TagFilters"]) -> Any:
+        pass
+
+
+scout_compute_resolved_api_TagFiltersVisitor.__name__ = "TagFiltersVisitor"
+scout_compute_resolved_api_TagFiltersVisitor.__qualname__ = "TagFiltersVisitor"
+scout_compute_resolved_api_TagFiltersVisitor.__module__ = "nominal_api.scout_compute_resolved_api"
+
+
 class scout_compute_resolved_api_Threshold(ConjureUnionType):
     _absolute: Optional["scout_compute_resolved_api_AbsoluteThreshold"] = None
     _percentage: Optional["scout_compute_resolved_api_PercentageThreshold"] = None

nominal_api/scout_compute_api/__init__.py

@@ -297,6 +297,11 @@ from .._impl import (
     scout_compute_api_SummarizeGeo as SummarizeGeo,
     scout_compute_api_SummarizeRanges as SummarizeRanges,
     scout_compute_api_SummarizeSeries as SummarizeSeries,
+    scout_compute_api_TagFilter as TagFilter,
+    scout_compute_api_TagFilterOperator as TagFilterOperator,
+    scout_compute_api_TagFilterValidationErrorType as TagFilterValidationErrorType,
+    scout_compute_api_TagFilters as TagFilters,
+    scout_compute_api_TagFiltersVisitor as TagFiltersVisitor,
     scout_compute_api_Threshold as Threshold,
     scout_compute_api_ThresholdOperator as ThresholdOperator,
     scout_compute_api_ThresholdVisitor as ThresholdVisitor,
@@ -624,6 +629,11 @@ __all__ = [
     'SummarizeGeo',
     'SummarizeRanges',
     'SummarizeSeries',
+    'TagFilter',
+    'TagFilterOperator',
+    'TagFilterValidationErrorType',
+    'TagFilters',
+    'TagFiltersVisitor',
     'Threshold',
     'ThresholdVisitor',
     'ThresholdOperator',

nominal_api/scout_compute_resolved_api/__init__.py

@@ -135,6 +135,10 @@ from .._impl import (
     scout_compute_resolved_api_SummarizeGeoNode as SummarizeGeoNode,
     scout_compute_resolved_api_SummarizeRangesNode as SummarizeRangesNode,
     scout_compute_resolved_api_SummarizeSeriesNode as SummarizeSeriesNode,
+    scout_compute_resolved_api_TagFilter as TagFilter,
+    scout_compute_resolved_api_TagFilterOperator as TagFilterOperator,
+    scout_compute_resolved_api_TagFilters as TagFilters,
+    scout_compute_resolved_api_TagFiltersVisitor as TagFiltersVisitor,
     scout_compute_resolved_api_Threshold as Threshold,
     scout_compute_resolved_api_ThresholdVisitor as ThresholdVisitor,
     scout_compute_resolved_api_ThresholdingRangesNode as ThresholdingRangesNode,
@@ -285,6 +289,10 @@ __all__ = [
     'SummarizeGeoNode',
     'SummarizeRangesNode',
     'SummarizeSeriesNode',
+    'TagFilter',
+    'TagFilterOperator',
+    'TagFilters',
+    'TagFiltersVisitor',
     'Threshold',
     'ThresholdVisitor',
     'ThresholdingRangesNode',

{nominal_api-0.752.0.dist-info → nominal_api-0.753.0.dist-info}/METADATA

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

{nominal_api-0.752.0.dist-info → nominal_api-0.753.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=Y8_3G7wdD4kyWS5wNkAqiADoO9K1huGkyJinXRYUCmU,1989
-nominal_api/_impl.py,sha256=nSwZUJrlgpZqcBPkuHR9p69WbRJmvlB8o-Wvl9FK9eU,3392878
+nominal_api/__init__.py,sha256=E6-Zr3eQZ0NEXPwk58S-C4XuwEz0fqxORgAkUMtoLpI,1989
+nominal_api/_impl.py,sha256=TL0rMs2UWJPg799z2r155xJgAPX-4xJ90p9I6IyUjYs,3404959
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=PMREKP7UhxJ1_gHkrlJET46qlDHksKMm6-woR1p6WnU,1970
 nominal_api/api_ids/__init__.py,sha256=sxqN5dMk6bOx0SKOd0ANG3_kmx1VtdSVotzEGn_q6sE,114
@@ -32,9 +32,9 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=iVeUjPTlbpQ3vlQkQjHr
 nominal_api/scout_checks_api/__init__.py,sha256=sxTv9ZL2rnXCaR7wVRNafqIPIzBbIPDGiJdYAr-VSV0,7317
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=RpTvc8WqNxOuDSXWs-xV3MSSFIoIy8Fj3eaIDCVygvU,6215
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=y5SlDoXvskyTKjg2O8o3cBhGSN-KA7iVlVjyy3vb3Co,652
-nominal_api/scout_compute_api/__init__.py,sha256=IrFVrR6TLpDyM2oILBBewPuWH4dIIlcG2JwPSy8VkGk,29464
+nominal_api/scout_compute_api/__init__.py,sha256=4ny8oqPQRJOp9RSNTHVB2mgmAMihasntrphVFeYlBco,29887
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=JrZKbt1ulYECTdUSkXn6On22Alu_cPUBjCRWTN3ctxk,5041
-nominal_api/scout_compute_resolved_api/__init__.py,sha256=xUnUtOCWuwM1e4wC6hBg2vuaGjAgm2lXTSsxFZXQW4o,15751
+nominal_api/scout_compute_resolved_api/__init__.py,sha256=BW4jT78H0_xrK1BP6anvZQxTNUE6Xv_pAIinJup7eWY,16090
 nominal_api/scout_dataexport_api/__init__.py,sha256=CF2vuo8kUXLJ4B7w95STrU0UMoBGuziacH5Eo3uxYf4,2068
 nominal_api/scout_datareview_api/__init__.py,sha256=kTDvcuav5bBm3IPhvmDrBTYyVD26iQVkyzdZnu75omE,11695
 nominal_api/scout_datasource/__init__.py,sha256=Z1Msu1Daf8GlLuM3w5imyB-6DhTNZojxI6xpH1sSvhM,141
@@ -74,7 +74,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=BwdqHLq_98LOsRV14JA3
 nominal_api/timeseries_seriescache/__init__.py,sha256=hL5hN8jKLEGE_fDiZzdASmWIrRjU6tncpmDeuc_47P4,150
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=USBxFmNnVFdnhTPLvWi3UgsvBZ4Iz4ycNgBTi10F-zI,1603
 nominal_api/upload_api/__init__.py,sha256=7-XXuZUqKPV4AMWvxNpZPZ5vBun4x-AomXj3Vol_BN4,123
-nominal_api-0.752.0.dist-info/METADATA,sha256=gGg5vDfDpmR4ao9U25r-aImr6kVaXI0XkmoFY7FxwEA,199
-nominal_api-0.752.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nominal_api-0.752.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.752.0.dist-info/RECORD,,
+nominal_api-0.753.0.dist-info/METADATA,sha256=VGvDRyy3jvWgddsy3vKnMNR8lmgTrSrvRwnmLWmaeV4,199
+nominal_api-0.753.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nominal_api-0.753.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.753.0.dist-info/RECORD,,