nominal-api 0.851.0__py3-none-any.whl → 0.853.0__py3-none-any.whl

nominal_api/__init__.py

@@ -80,5 +80,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.17.0"
 
-__version__ = "0.851.0"
+__version__ = "0.853.0"
 

nominal_api/_impl.py

@@ -46374,24 +46374,52 @@ class scout_compute_api_Fft(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'input': ConjureFieldDefinition('input', scout_compute_api_NumericSeries)
+            'input': ConjureFieldDefinition('input', scout_compute_api_NumericSeries),
+            'window': ConjureFieldDefinition('window', OptionalTypeWrapper[scout_compute_api_FftWindow])
         }
 
-    __slots__: List[str] = ['_input']
+    __slots__: List[str] = ['_input', '_window']
 
-    def __init__(self, input: "scout_compute_api_NumericSeries") -> None:
+    def __init__(self, input: "scout_compute_api_NumericSeries", window: Optional["scout_compute_api_FftWindow"] = None) -> None:
         self._input = input
+        self._window = window
 
     @builtins.property
     def input(self) -> "scout_compute_api_NumericSeries":
         return self._input
 
+    @builtins.property
+    def window(self) -> Optional["scout_compute_api_FftWindow"]:
+        return self._window
+
 
 scout_compute_api_Fft.__name__ = "Fft"
 scout_compute_api_Fft.__qualname__ = "Fft"
 scout_compute_api_Fft.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_FftWindow(ConjureEnumType):
+
+    BLACKMAN = 'BLACKMAN'
+    '''BLACKMAN'''
+    HANN = 'HANN'
+    '''HANN'''
+    HAMMING = 'HAMMING'
+    '''HAMMING'''
+    RECT = 'RECT'
+    '''RECT'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+scout_compute_api_FftWindow.__name__ = "FftWindow"
+scout_compute_api_FftWindow.__qualname__ = "FftWindow"
+scout_compute_api_FftWindow.__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.
     """
@@ -50615,12 +50643,12 @@ scout_compute_api_Periodogram.__module__ = "nominal_api.scout_compute_api"
 
 class scout_compute_api_PeriodogramMethod(ConjureEnumType):
 
+    WELCH_BLACKMAN = 'WELCH_BLACKMAN'
+    '''WELCH_BLACKMAN'''
     WELCH_HANN = 'WELCH_HANN'
     '''WELCH_HANN'''
     WELCH_HAMMING = 'WELCH_HAMMING'
     '''WELCH_HAMMING'''
-    WELCH_BLACKMAN = 'WELCH_BLACKMAN'
-    '''WELCH_BLACKMAN'''
     WELCH_RECT = 'WELCH_RECT'
     '''WELCH_RECT'''
     UNKNOWN = 'UNKNOWN'
@@ -69788,6 +69816,155 @@ scout_datasource_connection_ConnectionService.__qualname__ = "ConnectionService"
 scout_datasource_connection_ConnectionService.__module__ = "nominal_api.scout_datasource_connection"
 
 
+class scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig.__name__ = "AllChannelsConnectionsScrapingConfig"
+scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig.__qualname__ = "AllChannelsConnectionsScrapingConfig"
+scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig.__module__ = "nominal_api.scout_datasource_connection_api"
+
+
+class scout_datasource_connection_api_ApiConnectionDetails(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'api_uri': ConjureFieldDefinition('apiUri', str),
+            'token_secret_rid': ConjureFieldDefinition('tokenSecretRid', scout_datasource_connection_api_SecretRid)
+        }
+
+    __slots__: List[str] = ['_api_uri', '_token_secret_rid']
+
+    def __init__(self, api_uri: str, token_secret_rid: str) -> None:
+        self._api_uri = api_uri
+        self._token_secret_rid = token_secret_rid
+
+    @builtins.property
+    def api_uri(self) -> str:
+        """The URI to connect to hit the endpoints specified in the spec.
+        """
+        return self._api_uri
+
+    @builtins.property
+    def token_secret_rid(self) -> str:
+        """Secret Rid of token secret stored in Secrets Service.
+        """
+        return self._token_secret_rid
+
+
+scout_datasource_connection_api_ApiConnectionDetails.__name__ = "ApiConnectionDetails"
+scout_datasource_connection_api_ApiConnectionDetails.__qualname__ = "ApiConnectionDetails"
+scout_datasource_connection_api_ApiConnectionDetails.__module__ = "nominal_api.scout_datasource_connection_api"
+
+
+class scout_datasource_connection_api_ApiScrapingConfig(ConjureUnionType):
+    """This config is used to scrape data from an external connections service.
+    """
+    _all_channels: Optional["scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig"] = None
+    _channel_allow_list: Optional["scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig"] = None
+    _channel_block_list: Optional["scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'all_channels': ConjureFieldDefinition('allChannels', scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig),
+            'channel_allow_list': ConjureFieldDefinition('channelAllowList', scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig),
+            'channel_block_list': ConjureFieldDefinition('channelBlockList', scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig)
+        }
+
+    def __init__(
+            self,
+            all_channels: Optional["scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig"] = None,
+            channel_allow_list: Optional["scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig"] = None,
+            channel_block_list: Optional["scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (all_channels is not None) + (channel_allow_list is not None) + (channel_block_list is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if all_channels is not None:
+                self._all_channels = all_channels
+                self._type = 'allChannels'
+            if channel_allow_list is not None:
+                self._channel_allow_list = channel_allow_list
+                self._type = 'channelAllowList'
+            if channel_block_list is not None:
+                self._channel_block_list = channel_block_list
+                self._type = 'channelBlockList'
+
+        elif type_of_union == 'allChannels':
+            if all_channels is None:
+                raise ValueError('a union value must not be None')
+            self._all_channels = all_channels
+            self._type = 'allChannels'
+        elif type_of_union == 'channelAllowList':
+            if channel_allow_list is None:
+                raise ValueError('a union value must not be None')
+            self._channel_allow_list = channel_allow_list
+            self._type = 'channelAllowList'
+        elif type_of_union == 'channelBlockList':
+            if channel_block_list is None:
+                raise ValueError('a union value must not be None')
+            self._channel_block_list = channel_block_list
+            self._type = 'channelBlockList'
+
+    @builtins.property
+    def all_channels(self) -> Optional["scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig"]:
+        return self._all_channels
+
+    @builtins.property
+    def channel_allow_list(self) -> Optional["scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig"]:
+        return self._channel_allow_list
+
+    @builtins.property
+    def channel_block_list(self) -> Optional["scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig"]:
+        return self._channel_block_list
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_datasource_connection_api_ApiScrapingConfigVisitor):
+            raise ValueError('{} is not an instance of scout_datasource_connection_api_ApiScrapingConfigVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'allChannels' and self.all_channels is not None:
+            return visitor._all_channels(self.all_channels)
+        if self._type == 'channelAllowList' and self.channel_allow_list is not None:
+            return visitor._channel_allow_list(self.channel_allow_list)
+        if self._type == 'channelBlockList' and self.channel_block_list is not None:
+            return visitor._channel_block_list(self.channel_block_list)
+
+
+scout_datasource_connection_api_ApiScrapingConfig.__name__ = "ApiScrapingConfig"
+scout_datasource_connection_api_ApiScrapingConfig.__qualname__ = "ApiScrapingConfig"
+scout_datasource_connection_api_ApiScrapingConfig.__module__ = "nominal_api.scout_datasource_connection_api"
+
+
+class scout_datasource_connection_api_ApiScrapingConfigVisitor:
+
+    @abstractmethod
+    def _all_channels(self, all_channels: "scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig") -> Any:
+        pass
+
+    @abstractmethod
+    def _channel_allow_list(self, channel_allow_list: "scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig") -> Any:
+        pass
+
+    @abstractmethod
+    def _channel_block_list(self, channel_block_list: "scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig") -> Any:
+        pass
+
+
+scout_datasource_connection_api_ApiScrapingConfigVisitor.__name__ = "ApiScrapingConfigVisitor"
+scout_datasource_connection_api_ApiScrapingConfigVisitor.__qualname__ = "ApiScrapingConfigVisitor"
+scout_datasource_connection_api_ApiScrapingConfigVisitor.__module__ = "nominal_api.scout_datasource_connection_api"
+
+
 class scout_datasource_connection_api_BigQueryChannelNameComponent(ConjureBeanType):
 
     @builtins.classmethod
@@ -69938,6 +70115,56 @@ scout_datasource_connection_api_BigQueryScrapingConfig.__qualname__ = "BigQueryS
 scout_datasource_connection_api_BigQueryScrapingConfig.__module__ = "nominal_api.scout_datasource_connection_api"
 
 
+class scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_allow_list': ConjureFieldDefinition('channelAllowList', List[api_Channel])
+        }
+
+    __slots__: List[str] = ['_channel_allow_list']
+
+    def __init__(self, channel_allow_list: List[str]) -> None:
+        self._channel_allow_list = channel_allow_list
+
+    @builtins.property
+    def channel_allow_list(self) -> List[str]:
+        """Only channels in this set will be scraped. Must not be empty.
+        """
+        return self._channel_allow_list
+
+
+scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig.__name__ = "ChannelAllowListConnectionsScrapingConfig"
+scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig.__qualname__ = "ChannelAllowListConnectionsScrapingConfig"
+scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig.__module__ = "nominal_api.scout_datasource_connection_api"
+
+
+class scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel_block_list': ConjureFieldDefinition('channelBlockList', List[api_Channel])
+        }
+
+    __slots__: List[str] = ['_channel_block_list']
+
+    def __init__(self, channel_block_list: List[str]) -> None:
+        self._channel_block_list = channel_block_list
+
+    @builtins.property
+    def channel_block_list(self) -> List[str]:
+        """Only channels not in this set will be scraped. Must not be empty.
+        """
+        return self._channel_block_list
+
+
+scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig.__name__ = "ChannelBlockListConnectionsScrapingConfig"
+scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig.__qualname__ = "ChannelBlockListConnectionsScrapingConfig"
+scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig.__module__ = "nominal_api.scout_datasource_connection_api"
+
+
 class scout_datasource_connection_api_Connection(ConjureBeanType):
 
     @builtins.classmethod
@@ -70038,6 +70265,7 @@ class scout_datasource_connection_api_ConnectionDetails(ConjureUnionType):
     _timestream: Optional["scout_datasource_connection_api_TimestreamConnectionDetails"] = None
     _visual_crossing: Optional["scout_datasource_connection_api_VisualCrossingConnectionDetails"] = None
     _big_query: Optional["scout_datasource_connection_api_BigQueryConnectionDetails"] = None
+    _api: Optional["scout_datasource_connection_api_ApiConnectionDetails"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -70048,7 +70276,8 @@ class scout_datasource_connection_api_ConnectionDetails(ConjureUnionType):
             'nominal': ConjureFieldDefinition('nominal', scout_datasource_connection_api_NominalConnectionDetails),
             'timestream': ConjureFieldDefinition('timestream', scout_datasource_connection_api_TimestreamConnectionDetails),
             'visual_crossing': ConjureFieldDefinition('visualCrossing', scout_datasource_connection_api_VisualCrossingConnectionDetails),
-            'big_query': ConjureFieldDefinition('bigQuery', scout_datasource_connection_api_BigQueryConnectionDetails)
+            'big_query': ConjureFieldDefinition('bigQuery', scout_datasource_connection_api_BigQueryConnectionDetails),
+            'api': ConjureFieldDefinition('api', scout_datasource_connection_api_ApiConnectionDetails)
         }
 
     def __init__(
@@ -70060,10 +70289,11 @@ class scout_datasource_connection_api_ConnectionDetails(ConjureUnionType):
             timestream: Optional["scout_datasource_connection_api_TimestreamConnectionDetails"] = None,
             visual_crossing: Optional["scout_datasource_connection_api_VisualCrossingConnectionDetails"] = None,
             big_query: Optional["scout_datasource_connection_api_BigQueryConnectionDetails"] = None,
+            api: Optional["scout_datasource_connection_api_ApiConnectionDetails"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (timescale is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) != 1:
+            if (timescale is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) + (api is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if timescale is not None:
@@ -70087,6 +70317,9 @@ class scout_datasource_connection_api_ConnectionDetails(ConjureUnionType):
             if big_query is not None:
                 self._big_query = big_query
                 self._type = 'bigQuery'
+            if api is not None:
+                self._api = api
+                self._type = 'api'
 
         elif type_of_union == 'timescale':
             if timescale is None:
@@ -70123,6 +70356,11 @@ class scout_datasource_connection_api_ConnectionDetails(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._big_query = big_query
             self._type = 'bigQuery'
+        elif type_of_union == 'api':
+            if api is None:
+                raise ValueError('a union value must not be None')
+            self._api = api
+            self._type = 'api'
 
     @builtins.property
     def timescale(self) -> Optional["scout_datasource_connection_api_TimescaleConnectionDetails"]:
@@ -70152,6 +70390,10 @@ class scout_datasource_connection_api_ConnectionDetails(ConjureUnionType):
     def big_query(self) -> Optional["scout_datasource_connection_api_BigQueryConnectionDetails"]:
         return self._big_query
 
+    @builtins.property
+    def api(self) -> Optional["scout_datasource_connection_api_ApiConnectionDetails"]:
+        return self._api
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_datasource_connection_api_ConnectionDetailsVisitor):
             raise ValueError('{} is not an instance of scout_datasource_connection_api_ConnectionDetailsVisitor'.format(visitor.__class__.__name__))
@@ -70169,6 +70411,8 @@ class scout_datasource_connection_api_ConnectionDetails(ConjureUnionType):
             return visitor._visual_crossing(self.visual_crossing)
         if self._type == 'bigQuery' and self.big_query is not None:
             return visitor._big_query(self.big_query)
+        if self._type == 'api' and self.api is not None:
+            return visitor._api(self.api)
 
 
 scout_datasource_connection_api_ConnectionDetails.__name__ = "ConnectionDetails"
@@ -70206,6 +70450,10 @@ class scout_datasource_connection_api_ConnectionDetailsVisitor:
     def _big_query(self, big_query: "scout_datasource_connection_api_BigQueryConnectionDetails") -> Any:
         pass
 
+    @abstractmethod
+    def _api(self, api: "scout_datasource_connection_api_ApiConnectionDetails") -> Any:
+        pass
+
 
 scout_datasource_connection_api_ConnectionDetailsVisitor.__name__ = "ConnectionDetailsVisitor"
 scout_datasource_connection_api_ConnectionDetailsVisitor.__qualname__ = "ConnectionDetailsVisitor"
@@ -71234,6 +71482,7 @@ class scout_datasource_connection_api_ScrapingConfig(ConjureUnionType):
     _timescale: Optional["scout_datasource_connection_api_PivotedTimescaleScrapingConfig"] = None
     _visual_crossing: Optional["scout_datasource_connection_api_VisualCrossingScrapingConfig"] = None
     _big_query: Optional["scout_datasource_connection_api_BigQueryScrapingConfig"] = None
+    _api: Optional["scout_datasource_connection_api_ApiScrapingConfig"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -71243,7 +71492,8 @@ class scout_datasource_connection_api_ScrapingConfig(ConjureUnionType):
             'timestream': ConjureFieldDefinition('timestream', scout_datasource_connection_api_TimestreamScrapingConfig),
             'timescale': ConjureFieldDefinition('timescale', scout_datasource_connection_api_PivotedTimescaleScrapingConfig),
             'visual_crossing': ConjureFieldDefinition('visualCrossing', scout_datasource_connection_api_VisualCrossingScrapingConfig),
-            'big_query': ConjureFieldDefinition('bigQuery', scout_datasource_connection_api_BigQueryScrapingConfig)
+            'big_query': ConjureFieldDefinition('bigQuery', scout_datasource_connection_api_BigQueryScrapingConfig),
+            'api': ConjureFieldDefinition('api', scout_datasource_connection_api_ApiScrapingConfig)
         }
 
     def __init__(
@@ -71254,10 +71504,11 @@ class scout_datasource_connection_api_ScrapingConfig(ConjureUnionType):
             timescale: Optional["scout_datasource_connection_api_PivotedTimescaleScrapingConfig"] = None,
             visual_crossing: Optional["scout_datasource_connection_api_VisualCrossingScrapingConfig"] = None,
             big_query: Optional["scout_datasource_connection_api_BigQueryScrapingConfig"] = None,
+            api: Optional["scout_datasource_connection_api_ApiScrapingConfig"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (influx is not None) + (nominal is not None) + (timestream is not None) + (timescale is not None) + (visual_crossing is not None) + (big_query is not None) != 1:
+            if (influx is not None) + (nominal is not None) + (timestream is not None) + (timescale is not None) + (visual_crossing is not None) + (big_query is not None) + (api is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if influx is not None:
@@ -71278,6 +71529,9 @@ class scout_datasource_connection_api_ScrapingConfig(ConjureUnionType):
             if big_query is not None:
                 self._big_query = big_query
                 self._type = 'bigQuery'
+            if api is not None:
+                self._api = api
+                self._type = 'api'
 
         elif type_of_union == 'influx':
             if influx is None:
@@ -71309,6 +71563,11 @@ class scout_datasource_connection_api_ScrapingConfig(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._big_query = big_query
             self._type = 'bigQuery'
+        elif type_of_union == 'api':
+            if api is None:
+                raise ValueError('a union value must not be None')
+            self._api = api
+            self._type = 'api'
 
     @builtins.property
     def influx(self) -> Optional["scout_datasource_connection_api_InfluxScrapingConfig"]:
@@ -71334,6 +71593,10 @@ class scout_datasource_connection_api_ScrapingConfig(ConjureUnionType):
     def big_query(self) -> Optional["scout_datasource_connection_api_BigQueryScrapingConfig"]:
         return self._big_query
 
+    @builtins.property
+    def api(self) -> Optional["scout_datasource_connection_api_ApiScrapingConfig"]:
+        return self._api
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_datasource_connection_api_ScrapingConfigVisitor):
             raise ValueError('{} is not an instance of scout_datasource_connection_api_ScrapingConfigVisitor'.format(visitor.__class__.__name__))
@@ -71349,6 +71612,8 @@ class scout_datasource_connection_api_ScrapingConfig(ConjureUnionType):
             return visitor._visual_crossing(self.visual_crossing)
         if self._type == 'bigQuery' and self.big_query is not None:
             return visitor._big_query(self.big_query)
+        if self._type == 'api' and self.api is not None:
+            return visitor._api(self.api)
 
 
 scout_datasource_connection_api_ScrapingConfig.__name__ = "ScrapingConfig"
@@ -71382,6 +71647,10 @@ class scout_datasource_connection_api_ScrapingConfigVisitor:
     def _big_query(self, big_query: "scout_datasource_connection_api_BigQueryScrapingConfig") -> Any:
         pass
 
+    @abstractmethod
+    def _api(self, api: "scout_datasource_connection_api_ApiScrapingConfig") -> Any:
+        pass
+
 
 scout_datasource_connection_api_ScrapingConfigVisitor.__name__ = "ScrapingConfigVisitor"
 scout_datasource_connection_api_ScrapingConfigVisitor.__qualname__ = "ScrapingConfigVisitor"
@@ -72119,6 +72388,7 @@ class scout_favorites_api_FavoriteResource(ConjureUnionType):
     _notebook: Optional[str] = None
     _notebook_template: Optional[str] = None
     _checklist: Optional[str] = None
+    _saved_view: Optional[str] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -72127,7 +72397,8 @@ class scout_favorites_api_FavoriteResource(ConjureUnionType):
             'run': ConjureFieldDefinition('run', scout_run_api_RunRid),
             'notebook': ConjureFieldDefinition('notebook', scout_rids_api_NotebookRid),
             'notebook_template': ConjureFieldDefinition('notebookTemplate', scout_rids_api_TemplateRid),
-            'checklist': ConjureFieldDefinition('checklist', scout_rids_api_ChecklistRid)
+            'checklist': ConjureFieldDefinition('checklist', scout_rids_api_ChecklistRid),
+            'saved_view': ConjureFieldDefinition('savedView', scout_rids_api_SavedViewRid)
         }
 
     def __init__(
@@ -72137,10 +72408,11 @@ class scout_favorites_api_FavoriteResource(ConjureUnionType):
             notebook: Optional[str] = None,
             notebook_template: Optional[str] = None,
             checklist: Optional[str] = None,
+            saved_view: Optional[str] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (asset is not None) + (run is not None) + (notebook is not None) + (notebook_template is not None) + (checklist is not None) != 1:
+            if (asset is not None) + (run is not None) + (notebook is not None) + (notebook_template is not None) + (checklist is not None) + (saved_view is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if asset is not None:
@@ -72158,6 +72430,9 @@ class scout_favorites_api_FavoriteResource(ConjureUnionType):
             if checklist is not None:
                 self._checklist = checklist
                 self._type = 'checklist'
+            if saved_view is not None:
+                self._saved_view = saved_view
+                self._type = 'savedView'
 
         elif type_of_union == 'asset':
             if asset is None:
@@ -72184,6 +72459,11 @@ class scout_favorites_api_FavoriteResource(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._checklist = checklist
             self._type = 'checklist'
+        elif type_of_union == 'savedView':
+            if saved_view is None:
+                raise ValueError('a union value must not be None')
+            self._saved_view = saved_view
+            self._type = 'savedView'
 
     @builtins.property
     def asset(self) -> Optional[str]:
@@ -72205,6 +72485,10 @@ class scout_favorites_api_FavoriteResource(ConjureUnionType):
     def checklist(self) -> Optional[str]:
         return self._checklist
 
+    @builtins.property
+    def saved_view(self) -> Optional[str]:
+        return self._saved_view
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_favorites_api_FavoriteResourceVisitor):
             raise ValueError('{} is not an instance of scout_favorites_api_FavoriteResourceVisitor'.format(visitor.__class__.__name__))
@@ -72218,6 +72502,8 @@ class scout_favorites_api_FavoriteResource(ConjureUnionType):
             return visitor._notebook_template(self.notebook_template)
         if self._type == 'checklist' and self.checklist is not None:
             return visitor._checklist(self.checklist)
+        if self._type == 'savedView' and self.saved_view is not None:
+            return visitor._saved_view(self.saved_view)
 
 
 scout_favorites_api_FavoriteResource.__name__ = "FavoriteResource"
@@ -72247,6 +72533,10 @@ class scout_favorites_api_FavoriteResourceVisitor:
     def _checklist(self, checklist: str) -> Any:
         pass
 
+    @abstractmethod
+    def _saved_view(self, saved_view: str) -> Any:
+        pass
+
 
 scout_favorites_api_FavoriteResourceVisitor.__name__ = "FavoriteResourceVisitor"
 scout_favorites_api_FavoriteResourceVisitor.__qualname__ = "FavoriteResourceVisitor"
@@ -72288,6 +72578,8 @@ class scout_favorites_api_ResourceType(ConjureEnumType):
     '''NOTEBOOK_TEMPLATE'''
     CHECKLIST = 'CHECKLIST'
     '''CHECKLIST'''
+    SAVED_VIEW = 'SAVED_VIEW'
+    '''SAVED_VIEW'''
     UNKNOWN = 'UNKNOWN'
     '''UNKNOWN'''
 
@@ -89704,6 +89996,35 @@ timeseries_archetype_SeriesArchetypeService.__qualname__ = "SeriesArchetypeServi
 timeseries_archetype_SeriesArchetypeService.__module__ = "nominal_api.timeseries_archetype"
 
 
+class timeseries_archetype_api_ApiLocatorTemplate(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_ApiType)
+        }
+
+    __slots__: List[str] = ['_channel', '_type']
+
+    def __init__(self, channel: str, type: "timeseries_logicalseries_api_ApiType") -> None:
+        self._channel = channel
+        self._type = type
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_ApiType":
+        return self._type
+
+
+timeseries_archetype_api_ApiLocatorTemplate.__name__ = "ApiLocatorTemplate"
+timeseries_archetype_api_ApiLocatorTemplate.__qualname__ = "ApiLocatorTemplate"
+timeseries_archetype_api_ApiLocatorTemplate.__module__ = "nominal_api.timeseries_archetype_api"
+
+
 class timeseries_archetype_api_BatchCreateSeriesArchetypeRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -90073,6 +90394,7 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
     _timestream: Optional["timeseries_archetype_api_TimestreamLocatorTemplate"] = None
     _visual_crossing: Optional["timeseries_archetype_api_VisualCrossingLocatorTemplate"] = None
     _big_query: Optional["timeseries_archetype_api_BigQueryLocatorTemplate"] = None
+    _api: Optional["timeseries_archetype_api_ApiLocatorTemplate"] = None
     _csv: Optional["timeseries_archetype_api_CsvLocatorTemplate"] = None
     _csv_v2: Optional["timeseries_archetype_api_CsvLocatorV2Template"] = None
 
@@ -90086,6 +90408,7 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             'timestream': ConjureFieldDefinition('timestream', timeseries_archetype_api_TimestreamLocatorTemplate),
             'visual_crossing': ConjureFieldDefinition('visualCrossing', timeseries_archetype_api_VisualCrossingLocatorTemplate),
             'big_query': ConjureFieldDefinition('bigQuery', timeseries_archetype_api_BigQueryLocatorTemplate),
+            'api': ConjureFieldDefinition('api', timeseries_archetype_api_ApiLocatorTemplate),
             'csv': ConjureFieldDefinition('csv', timeseries_archetype_api_CsvLocatorTemplate),
             'csv_v2': ConjureFieldDefinition('csvV2', timeseries_archetype_api_CsvLocatorV2Template)
         }
@@ -90099,12 +90422,13 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             timestream: Optional["timeseries_archetype_api_TimestreamLocatorTemplate"] = None,
             visual_crossing: Optional["timeseries_archetype_api_VisualCrossingLocatorTemplate"] = None,
             big_query: Optional["timeseries_archetype_api_BigQueryLocatorTemplate"] = None,
+            api: Optional["timeseries_archetype_api_ApiLocatorTemplate"] = None,
             csv: Optional["timeseries_archetype_api_CsvLocatorTemplate"] = None,
             csv_v2: Optional["timeseries_archetype_api_CsvLocatorV2Template"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (timescale_db is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) + (csv is not None) + (csv_v2 is not None) != 1:
+            if (timescale_db is not None) + (influx is not None) + (influx1 is not None) + (nominal is not None) + (timestream is not None) + (visual_crossing is not None) + (big_query is not None) + (api is not None) + (csv is not None) + (csv_v2 is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if timescale_db is not None:
@@ -90128,6 +90452,9 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             if big_query is not None:
                 self._big_query = big_query
                 self._type = 'bigQuery'
+            if api is not None:
+                self._api = api
+                self._type = 'api'
             if csv is not None:
                 self._csv = csv
                 self._type = 'csv'
@@ -90170,6 +90497,11 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._big_query = big_query
             self._type = 'bigQuery'
+        elif type_of_union == 'api':
+            if api is None:
+                raise ValueError('a union value must not be None')
+            self._api = api
+            self._type = 'api'
         elif type_of_union == 'csv':
             if csv is None:
                 raise ValueError('a union value must not be None')
@@ -90209,6 +90541,10 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
     def big_query(self) -> Optional["timeseries_archetype_api_BigQueryLocatorTemplate"]:
         return self._big_query
 
+    @builtins.property
+    def api(self) -> Optional["timeseries_archetype_api_ApiLocatorTemplate"]:
+        return self._api
+
     @builtins.property
     def csv(self) -> Optional["timeseries_archetype_api_CsvLocatorTemplate"]:
         return self._csv
@@ -90234,6 +90570,8 @@ class timeseries_archetype_api_LocatorTemplate(ConjureUnionType):
             return visitor._visual_crossing(self.visual_crossing)
         if self._type == 'bigQuery' and self.big_query is not None:
             return visitor._big_query(self.big_query)
+        if self._type == 'api' and self.api is not None:
+            return visitor._api(self.api)
         if self._type == 'csv' and self.csv is not None:
             return visitor._csv(self.csv)
         if self._type == 'csvV2' and self.csv_v2 is not None:
@@ -90275,6 +90613,10 @@ class timeseries_archetype_api_LocatorTemplateVisitor:
     def _big_query(self, big_query: "timeseries_archetype_api_BigQueryLocatorTemplate") -> Any:
         pass
 
+    @abstractmethod
+    def _api(self, api: "timeseries_archetype_api_ApiLocatorTemplate") -> Any:
+        pass
+
     @abstractmethod
     def _csv(self, csv: "timeseries_archetype_api_CsvLocatorTemplate") -> Any:
         pass
@@ -91078,6 +91420,61 @@ timeseries_logicalseries_LogicalSeriesService.__qualname__ = "LogicalSeriesServi
 timeseries_logicalseries_LogicalSeriesService.__module__ = "nominal_api.timeseries_logicalseries"
 
 
+class timeseries_logicalseries_api_ApiLocator(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'type': ConjureFieldDefinition('type', timeseries_logicalseries_api_ApiType)
+        }
+
+    __slots__: List[str] = ['_channel', '_tags', '_type']
+
+    def __init__(self, channel: str, tags: Dict[str, str], type: "timeseries_logicalseries_api_ApiType") -> None:
+        self._channel = channel
+        self._tags = tags
+        self._type = type
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+    @builtins.property
+    def type(self) -> "timeseries_logicalseries_api_ApiType":
+        return self._type
+
+
+timeseries_logicalseries_api_ApiLocator.__name__ = "ApiLocator"
+timeseries_logicalseries_api_ApiLocator.__qualname__ = "ApiLocator"
+timeseries_logicalseries_api_ApiLocator.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
+class timeseries_logicalseries_api_ApiType(ConjureEnumType):
+
+    DOUBLE = 'DOUBLE'
+    '''DOUBLE'''
+    STRING = 'STRING'
+    '''STRING'''
+    INT64 = 'INT64'
+    '''INT64'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+timeseries_logicalseries_api_ApiType.__name__ = "ApiType"
+timeseries_logicalseries_api_ApiType.__qualname__ = "ApiType"
+timeseries_logicalseries_api_ApiType.__module__ = "nominal_api.timeseries_logicalseries_api"
+
+
 class timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -91659,6 +92056,7 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
     _timestream_locator: Optional["timeseries_logicalseries_api_TimestreamLocator"] = None
     _visual_crossing_locator: Optional["timeseries_logicalseries_api_VisualCrossingLocator"] = None
     _big_query_locator: Optional["timeseries_logicalseries_api_BigQueryLocator"] = None
+    _api_locator: Optional["timeseries_logicalseries_api_ApiLocator"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -91671,7 +92069,8 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             'nominal_locator': ConjureFieldDefinition('nominalLocator', timeseries_logicalseries_api_NominalLocator),
             'timestream_locator': ConjureFieldDefinition('timestreamLocator', timeseries_logicalseries_api_TimestreamLocator),
             'visual_crossing_locator': ConjureFieldDefinition('visualCrossingLocator', timeseries_logicalseries_api_VisualCrossingLocator),
-            'big_query_locator': ConjureFieldDefinition('bigQueryLocator', timeseries_logicalseries_api_BigQueryLocator)
+            'big_query_locator': ConjureFieldDefinition('bigQueryLocator', timeseries_logicalseries_api_BigQueryLocator),
+            'api_locator': ConjureFieldDefinition('apiLocator', timeseries_logicalseries_api_ApiLocator)
         }
 
     def __init__(
@@ -91685,10 +92084,11 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             timestream_locator: Optional["timeseries_logicalseries_api_TimestreamLocator"] = None,
             visual_crossing_locator: Optional["timeseries_logicalseries_api_VisualCrossingLocator"] = None,
             big_query_locator: Optional["timeseries_logicalseries_api_BigQueryLocator"] = None,
+            api_locator: Optional["timeseries_logicalseries_api_ApiLocator"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (csv_locator is not None) + (csv_v2 is not None) + (timescale_db_locator is not None) + (influx_locator is not None) + (influx1_locator is not None) + (nominal_locator is not None) + (timestream_locator is not None) + (visual_crossing_locator is not None) + (big_query_locator is not None) != 1:
+            if (csv_locator is not None) + (csv_v2 is not None) + (timescale_db_locator is not None) + (influx_locator is not None) + (influx1_locator is not None) + (nominal_locator is not None) + (timestream_locator is not None) + (visual_crossing_locator is not None) + (big_query_locator is not None) + (api_locator is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if csv_locator is not None:
@@ -91718,6 +92118,9 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             if big_query_locator is not None:
                 self._big_query_locator = big_query_locator
                 self._type = 'bigQueryLocator'
+            if api_locator is not None:
+                self._api_locator = api_locator
+                self._type = 'apiLocator'
 
         elif type_of_union == 'csvLocator':
             if csv_locator is None:
@@ -91764,6 +92167,11 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._big_query_locator = big_query_locator
             self._type = 'bigQueryLocator'
+        elif type_of_union == 'apiLocator':
+            if api_locator is None:
+                raise ValueError('a union value must not be None')
+            self._api_locator = api_locator
+            self._type = 'apiLocator'
 
     @builtins.property
     def csv_locator(self) -> Optional["timeseries_logicalseries_api_CsvLocator"]:
@@ -91801,6 +92209,10 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
     def big_query_locator(self) -> Optional["timeseries_logicalseries_api_BigQueryLocator"]:
         return self._big_query_locator
 
+    @builtins.property
+    def api_locator(self) -> Optional["timeseries_logicalseries_api_ApiLocator"]:
+        return self._api_locator
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, timeseries_logicalseries_api_LocatorVisitor):
             raise ValueError('{} is not an instance of timeseries_logicalseries_api_LocatorVisitor'.format(visitor.__class__.__name__))
@@ -91822,6 +92234,8 @@ class timeseries_logicalseries_api_Locator(ConjureUnionType):
             return visitor._visual_crossing_locator(self.visual_crossing_locator)
         if self._type == 'bigQueryLocator' and self.big_query_locator is not None:
             return visitor._big_query_locator(self.big_query_locator)
+        if self._type == 'apiLocator' and self.api_locator is not None:
+            return visitor._api_locator(self.api_locator)
 
 
 timeseries_logicalseries_api_Locator.__name__ = "Locator"
@@ -91867,6 +92281,10 @@ class timeseries_logicalseries_api_LocatorVisitor:
     def _big_query_locator(self, big_query_locator: "timeseries_logicalseries_api_BigQueryLocator") -> Any:
         pass
 
+    @abstractmethod
+    def _api_locator(self, api_locator: "timeseries_logicalseries_api_ApiLocator") -> Any:
+        pass
+
 
 timeseries_logicalseries_api_LocatorVisitor.__name__ = "LocatorVisitor"
 timeseries_logicalseries_api_LocatorVisitor.__qualname__ = "LocatorVisitor"

nominal_api/scout_compute_api/__init__.py

@@ -139,6 +139,7 @@ from .._impl import (
     scout_compute_api_ExponentialCurve as ExponentialCurve,
     scout_compute_api_ExponentialResultDetails as ExponentialResultDetails,
     scout_compute_api_Fft as Fft,
+    scout_compute_api_FftWindow as FftWindow,
     scout_compute_api_FirstPointMatchingCondition as FirstPointMatchingCondition,
     scout_compute_api_ForwardFillInterpolation as ForwardFillInterpolation,
     scout_compute_api_ForwardFillResampleInterpolationConfiguration as ForwardFillResampleInterpolationConfiguration,
@@ -492,6 +493,7 @@ __all__ = [
     'ExponentialCurve',
     'ExponentialResultDetails',
     'Fft',
+    'FftWindow',
     'FirstPointMatchingCondition',
     'ForwardFillInterpolation',
     'ForwardFillResampleInterpolationConfiguration',

nominal_api/scout_datasource_connection_api/__init__.py

@@ -1,9 +1,15 @@
 # coding=utf-8
 from .._impl import (
+    scout_datasource_connection_api_AllChannelsConnectionsScrapingConfig as AllChannelsConnectionsScrapingConfig,
+    scout_datasource_connection_api_ApiConnectionDetails as ApiConnectionDetails,
+    scout_datasource_connection_api_ApiScrapingConfig as ApiScrapingConfig,
+    scout_datasource_connection_api_ApiScrapingConfigVisitor as ApiScrapingConfigVisitor,
     scout_datasource_connection_api_BigQueryChannelNameComponent as BigQueryChannelNameComponent,
     scout_datasource_connection_api_BigQueryConnectionDetails as BigQueryConnectionDetails,
     scout_datasource_connection_api_BigQueryScrapingConfig as BigQueryScrapingConfig,
     scout_datasource_connection_api_BucketName as BucketName,
+    scout_datasource_connection_api_ChannelAllowListConnectionsScrapingConfig as ChannelAllowListConnectionsScrapingConfig,
+    scout_datasource_connection_api_ChannelBlockListConnectionsScrapingConfig as ChannelBlockListConnectionsScrapingConfig,
     scout_datasource_connection_api_ColumnName as ColumnName,
     scout_datasource_connection_api_Connection as Connection,
     scout_datasource_connection_api_ConnectionDetails as ConnectionDetails,
@@ -61,10 +67,16 @@ from .._impl import (
 )
 
 __all__ = [
+    'AllChannelsConnectionsScrapingConfig',
+    'ApiConnectionDetails',
+    'ApiScrapingConfig',
+    'ApiScrapingConfigVisitor',
     'BigQueryChannelNameComponent',
     'BigQueryConnectionDetails',
     'BigQueryScrapingConfig',
     'BucketName',
+    'ChannelAllowListConnectionsScrapingConfig',
+    'ChannelBlockListConnectionsScrapingConfig',
     'ColumnName',
     'Connection',
     'ConnectionDetails',

nominal_api/timeseries_archetype_api/__init__.py

@@ -1,5 +1,6 @@
 # coding=utf-8
 from .._impl import (
+    timeseries_archetype_api_ApiLocatorTemplate as ApiLocatorTemplate,
     timeseries_archetype_api_BatchCreateSeriesArchetypeRequest as BatchCreateSeriesArchetypeRequest,
     timeseries_archetype_api_BatchGetSeriesArchetypeRequest as BatchGetSeriesArchetypeRequest,
     timeseries_archetype_api_BatchGetSeriesArchetypeResponse as BatchGetSeriesArchetypeResponse,
@@ -21,6 +22,7 @@ from .._impl import (
 )
 
 __all__ = [
+    'ApiLocatorTemplate',
     'BatchCreateSeriesArchetypeRequest',
     'BatchGetSeriesArchetypeRequest',
     'BatchGetSeriesArchetypeResponse',

nominal_api/timeseries_logicalseries_api/__init__.py

@@ -1,5 +1,7 @@
 # coding=utf-8
 from .._impl import (
+    timeseries_logicalseries_api_ApiLocator as ApiLocator,
+    timeseries_logicalseries_api_ApiType as ApiType,
     timeseries_logicalseries_api_AttributeName as AttributeName,
     timeseries_logicalseries_api_BatchCreateLogicalSeriesRequest as BatchCreateLogicalSeriesRequest,
     timeseries_logicalseries_api_BatchCreateLogicalSeriesResponse as BatchCreateLogicalSeriesResponse,
@@ -50,6 +52,8 @@ from .._impl import (
 )
 
 __all__ = [
+    'ApiLocator',
+    'ApiType',
     'AttributeName',
     'BatchCreateLogicalSeriesRequest',
     'BatchCreateLogicalSeriesResponse',

{nominal_api-0.851.0.dist-info → nominal_api-0.853.0.dist-info}/METADATA

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

{nominal_api-0.851.0.dist-info → nominal_api-0.853.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
-nominal_api/__init__.py,sha256=spY9qlBJIoRQF-L7btlyCRtXRgiwy2xTPNnFszS8328,2064
-nominal_api/_impl.py,sha256=9UC8pZBYlAru1NMVdnsxYqqNvCkV7T98hlLolL5u_mI,3687225
+nominal_api/__init__.py,sha256=qhqTUUFKQ_8FM70D2_jvyQsyYGVcuHNQWfTBCseF7zU,2064
+nominal_api/_impl.py,sha256=NTXTP80X8Jk-qIPH-m6nebX4kOJpE4ub7rWynOwRpxg,3704879
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
 nominal_api/api/__init__.py,sha256=ZiGjcYwIBCrZR5pPqyqX2ggRJmVcSlOCazMtF2xCZzw,2171
 nominal_api/api_ids/__init__.py,sha256=sxqN5dMk6bOx0SKOd0ANG3_kmx1VtdSVotzEGn_q6sE,114
@@ -33,14 +33,14 @@ nominal_api/scout_checklistexecution_api/__init__.py,sha256=iVeUjPTlbpQ3vlQkQjHr
 nominal_api/scout_checks_api/__init__.py,sha256=uCmiNrVwLDlkg8YnpP-uZr9nFFFN52sM644Qo6YNy3k,6972
 nominal_api/scout_comparisonnotebook_api/__init__.py,sha256=F5cQo_KqeTpFwqKBDV-iEjrND7xQgkycC1yocpxq1Qk,6277
 nominal_api/scout_comparisonrun_api/__init__.py,sha256=y5SlDoXvskyTKjg2O8o3cBhGSN-KA7iVlVjyy3vb3Co,652
-nominal_api/scout_compute_api/__init__.py,sha256=WKNq2EBWK-r5N4eykzvOujqeyjoj38rGfA-P8CTuosU,31783
+nominal_api/scout_compute_api/__init__.py,sha256=sJFk1Ko5Qs6WpTSTlRVgEZsELblYjEkwTgK14S-Tubw,31846
 nominal_api/scout_compute_api_deprecated/__init__.py,sha256=JrZKbt1ulYECTdUSkXn6On22Alu_cPUBjCRWTN3ctxk,5041
 nominal_api/scout_compute_resolved_api/__init__.py,sha256=wHZ-fvDaqCCoO3BRPjCF0ZktxVpCT203fa0bSs3fwz4,16741
 nominal_api/scout_dataexport_api/__init__.py,sha256=CF2vuo8kUXLJ4B7w95STrU0UMoBGuziacH5Eo3uxYf4,2068
 nominal_api/scout_datareview_api/__init__.py,sha256=ITQR6pdPseU9vS2bKDeleafiBhurtHmcHeKz_6J8Ab8,12229
 nominal_api/scout_datasource/__init__.py,sha256=Z1Msu1Daf8GlLuM3w5imyB-6DhTNZojxI6xpH1sSvhM,141
 nominal_api/scout_datasource_connection/__init__.py,sha256=vT-OJYR5a--THheuxH1T1n553ZHp8pwsWBVzB7qvuKs,285
-nominal_api/scout_datasource_connection_api/__init__.py,sha256=qsgop-L20mSfE0yxlgtqPkcj_S-AJLm9V-75jqdASFQ,6717
+nominal_api/scout_datasource_connection_api/__init__.py,sha256=TxvP0xKyJD9TH644OnmapA_L-b27l9ZTouPvzDmmsc4,7554
 nominal_api/scout_datasource_connection_api_influx/__init__.py,sha256=jAVVZomYEPl87gSskLU7f0fwWNUa0YItwgBNBc9ryK4,127
 nominal_api/scout_favorites/__init__.py,sha256=XtBItmJSZTsgyO5fOR1AElMf1MAZwEkKlL5jtIaivXk,137
 nominal_api/scout_favorites_api/__init__.py,sha256=93jNrOFPbdZFg_AfXVnwYGLvpARa4WgLZ8fo0Xg0efc,530
@@ -69,15 +69,15 @@ nominal_api/storage_series_api/__init__.py,sha256=wq6d_C7M31wVt9CM-bw0DtOBfcrPyv
 nominal_api/storage_writer_api/__init__.py,sha256=a6EGXk7GgDraTFLYRdJTi4baAYtuRsEX7xrKQTYRydo,2587
 nominal_api/themes_api/__init__.py,sha256=5GNGZfslPuTthUYl179XRDS_jR0nrmTi8Z-aiFQZHyU,1415
 nominal_api/timeseries_archetype/__init__.py,sha256=sZdZCA3nTyv0rF4YHaAZTw4kglrNREcsYTMjjl85hWY,160
-nominal_api/timeseries_archetype_api/__init__.py,sha256=xd51luqmUAPR5gn1vVWx6Kzw1EU6rzfit7iK8vYlkB8,2137
+nominal_api/timeseries_archetype_api/__init__.py,sha256=A9rI1AKAgExODQRabJIvWW0S1W6ZxLiTLrMEsWZg41w,2234
 nominal_api/timeseries_channelmetadata/__init__.py,sha256=K5rQ2FnPxUJJ-763HWInYu0tRfnOyf1V9H232SyliD4,166
 nominal_api/timeseries_channelmetadata_api/__init__.py,sha256=cnW4lnburn1z58pMO1inqf7DCqbxcTivQmEMCEtqtvQ,1086
 nominal_api/timeseries_logicalseries/__init__.py,sha256=8GyG6TLiwCUsfooVx8fotkILjCFwsqiDmy9LmSb-OrY,158
-nominal_api/timeseries_logicalseries_api/__init__.py,sha256=BwdqHLq_98LOsRV14JA39RGFSsnpS6Rh4ZPBwJRZ5yc,4565
+nominal_api/timeseries_logicalseries_api/__init__.py,sha256=lDuOWyLpdVBI9aoN6ujwU_cGS18i9QrPZFYsoDerhvM,4710
 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.851.0.dist-info/METADATA,sha256=EbQwEqtPmP6j7gjps9bg6Wkyxo26G3O5m9llG0W7mJ8,199
-nominal_api-0.851.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nominal_api-0.851.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.851.0.dist-info/RECORD,,
+nominal_api-0.853.0.dist-info/METADATA,sha256=taz1AfP5c7KTM-zAhWTDitgMEZLd_4-Aq_H6IyXa1tA,199
+nominal_api-0.853.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nominal_api-0.853.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.853.0.dist-info/RECORD,,