nominal-api 0.623.0__py3-none-any.whl → 0.625.0__py3-none-any.whl

nominal_api/__init__.py

@@ -76,5 +76,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.623.0"
+__version__ = "0.625.0"
 

nominal_api/_impl.py

@@ -404,6 +404,35 @@ api_Property.__qualname__ = "Property"
 api_Property.__module__ = "nominal_api.api"
 
 
+class api_Range(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'start': ConjureFieldDefinition('start', api_Timestamp),
+            'end': ConjureFieldDefinition('end', api_Timestamp)
+        }
+
+    __slots__: List[str] = ['_start', '_end']
+
+    def __init__(self, end: "api_Timestamp", start: "api_Timestamp") -> None:
+        self._start = start
+        self._end = end
+
+    @builtins.property
+    def start(self) -> "api_Timestamp":
+        return self._start
+
+    @builtins.property
+    def end(self) -> "api_Timestamp":
+        return self._end
+
+
+api_Range.__name__ = "Range"
+api_Range.__qualname__ = "Range"
+api_Range.__module__ = "nominal_api.api"
+
+
 class api_SerializableError(ConjureBeanType):
     """
     A SerializableError is a representation of a ServiceException that exists to send error
@@ -4345,6 +4374,40 @@ datasource_api_GetDataScopeBoundsResponse.__qualname__ = "GetDataScopeBoundsResp
 datasource_api_GetDataScopeBoundsResponse.__module__ = "nominal_api.datasource_api"
 
 
+class datasource_api_GetTagValuesForDataSourceRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'tag_keys': ConjureFieldDefinition('tagKeys', List[api_TagName]),
+            'range': ConjureFieldDefinition('range', OptionalTypeWrapper[api_Range])
+        }
+
+    __slots__: List[str] = ['_tag_keys', '_range']
+
+    def __init__(self, tag_keys: List[str], range: Optional["api_Range"] = None) -> None:
+        self._tag_keys = tag_keys
+        self._range = range
+
+    @builtins.property
+    def tag_keys(self) -> List[str]:
+        return self._tag_keys
+
+    @builtins.property
+    def range(self) -> Optional["api_Range"]:
+        """
+        For Nominal data sources, a time range can be provided to filter tag values to those present within the 
+months spanned by the range. If left empty, this defaults to the last month. For external data sources, 
+the range must not be specified, as all tag values are returned.
+        """
+        return self._range
+
+
+datasource_api_GetTagValuesForDataSourceRequest.__name__ = "GetTagValuesForDataSourceRequest"
+datasource_api_GetTagValuesForDataSourceRequest.__qualname__ = "GetTagValuesForDataSourceRequest"
+datasource_api_GetTagValuesForDataSourceRequest.__module__ = "nominal_api.datasource_api"
+
+
 class datasource_api_IndexChannelPrefixTreeRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -11752,24 +11815,18 @@ append result for [117s, 122s].
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'subscription_id': ConjureFieldDefinition('subscriptionId', persistent_compute_api_SubscriptionId),
             'start': ConjureFieldDefinition('start', api_Timestamp),
             'end': ConjureFieldDefinition('end', api_Timestamp),
             'result': ConjureFieldDefinition('result', persistent_compute_api_ComputeNodeAppendResponse)
         }
 
-    __slots__: List[str] = ['_subscription_id', '_start', '_end', '_result']
+    __slots__: List[str] = ['_start', '_end', '_result']
 
-    def __init__(self, end: "api_Timestamp", result: "persistent_compute_api_ComputeNodeAppendResponse", start: "api_Timestamp", subscription_id: str) -> None:
-        self._subscription_id = subscription_id
+    def __init__(self, end: "api_Timestamp", result: "persistent_compute_api_ComputeNodeAppendResponse", start: "api_Timestamp") -> None:
         self._start = start
         self._end = end
         self._result = result
 
-    @builtins.property
-    def subscription_id(self) -> str:
-        return self._subscription_id
-
     @builtins.property
     def start(self) -> "api_Timestamp":
         """
@@ -11860,9 +11917,9 @@ class persistent_compute_api_ClientMessage(ConjureUnionType):
         """
         Subscribes to all of the given `StreamingComputeNodeSubscription`s. For identifying the subscriptions and
 their results a `SubscriptionId` has to be passed, which should be a unique identifier.
-If the subscription is invalid (e.g., window too big for in-memory compute or in-memory compute not
-enabled for datasource) a `ServerMessage::subscriptionError` will be sent back. Otherwise, updated results
-for the subscription will be sent periodically via `ServerMessage::subscriptionUpdate`.
+A `ServerMessage::subscriptionCreation` will be sent back for each subscription which shows whether the 
+subscription was successfully created. If it was, updated results for the subscription will be  sent 
+periodically via `ServerMessage::subscriptionUpdate`.
         """
         return self._subscribe
 
@@ -11921,7 +11978,7 @@ persistent_compute_api_ClientMessageVisitor.__module__ = "nominal_api.persistent
 
 
 class persistent_compute_api_ComputeNodeAppendResponse(ConjureUnionType):
-    """These cover the subset of the union type in `ComputeWithUnitsResponse` for which we support append result.
+    """These cover the subset of the union type in `ComputeNodeResponse` for which we support append results.
 Append results will have the same subtype as the previous full result for the same `SubscriptionId`. 
 If the subtype were to change (e.g., we start doing bucketing because data frequency increased) we will send 
 a new full result with that new type. The results will also have the same units as the previous `FullResult`.
@@ -12136,22 +12193,16 @@ class persistent_compute_api_FullResult(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'subscription_id': ConjureFieldDefinition('subscriptionId', persistent_compute_api_SubscriptionId),
-            'result': ConjureFieldDefinition('result', scout_compute_api_ComputeWithUnitsResponse)
+            'result': ConjureFieldDefinition('result', scout_compute_api_ComputeNodeResponse)
         }
 
-    __slots__: List[str] = ['_subscription_id', '_result']
+    __slots__: List[str] = ['_result']
 
-    def __init__(self, result: "scout_compute_api_ComputeWithUnitsResponse", subscription_id: str) -> None:
-        self._subscription_id = subscription_id
+    def __init__(self, result: "scout_compute_api_ComputeNodeResponse") -> None:
         self._result = result
 
     @builtins.property
-    def subscription_id(self) -> str:
-        return self._subscription_id
-
-    @builtins.property
-    def result(self) -> "scout_compute_api_ComputeWithUnitsResponse":
+    def result(self) -> "scout_compute_api_ComputeNodeResponse":
         return self._result
 
 
@@ -12160,6 +12211,83 @@ persistent_compute_api_FullResult.__qualname__ = "FullResult"
 persistent_compute_api_FullResult.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_HealthMessage(ConjureUnionType):
+    _ping: Optional["persistent_compute_api_Ping"] = None
+    _pong: Optional["persistent_compute_api_Pong"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'ping': ConjureFieldDefinition('ping', persistent_compute_api_Ping),
+            'pong': ConjureFieldDefinition('pong', persistent_compute_api_Pong)
+        }
+
+    def __init__(
+            self,
+            ping: Optional["persistent_compute_api_Ping"] = None,
+            pong: Optional["persistent_compute_api_Pong"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (ping is not None) + (pong is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if ping is not None:
+                self._ping = ping
+                self._type = 'ping'
+            if pong is not None:
+                self._pong = pong
+                self._type = 'pong'
+
+        elif type_of_union == 'ping':
+            if ping is None:
+                raise ValueError('a union value must not be None')
+            self._ping = ping
+            self._type = 'ping'
+        elif type_of_union == 'pong':
+            if pong is None:
+                raise ValueError('a union value must not be None')
+            self._pong = pong
+            self._type = 'pong'
+
+    @builtins.property
+    def ping(self) -> Optional["persistent_compute_api_Ping"]:
+        return self._ping
+
+    @builtins.property
+    def pong(self) -> Optional["persistent_compute_api_Pong"]:
+        return self._pong
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, persistent_compute_api_HealthMessageVisitor):
+            raise ValueError('{} is not an instance of persistent_compute_api_HealthMessageVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'ping' and self.ping is not None:
+            return visitor._ping(self.ping)
+        if self._type == 'pong' and self.pong is not None:
+            return visitor._pong(self.pong)
+
+
+persistent_compute_api_HealthMessage.__name__ = "HealthMessage"
+persistent_compute_api_HealthMessage.__qualname__ = "HealthMessage"
+persistent_compute_api_HealthMessage.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_HealthMessageVisitor:
+
+    @abstractmethod
+    def _ping(self, ping: "persistent_compute_api_Ping") -> Any:
+        pass
+
+    @abstractmethod
+    def _pong(self, pong: "persistent_compute_api_Pong") -> Any:
+        pass
+
+
+persistent_compute_api_HealthMessageVisitor.__name__ = "HealthMessageVisitor"
+persistent_compute_api_HealthMessageVisitor.__qualname__ = "HealthMessageVisitor"
+persistent_compute_api_HealthMessageVisitor.__module__ = "nominal_api.persistent_compute_api"
+
+
 class persistent_compute_api_Ping(ConjureBeanType):
     """
     A ping can be sent by both client and server to keep the connection open and check that it is still working.
@@ -12219,93 +12347,76 @@ persistent_compute_api_Pong.__module__ = "nominal_api.persistent_compute_api"
 
 
 class persistent_compute_api_ServerMessage(ConjureUnionType):
-    _subscription_update: Optional["persistent_compute_api_SubscriptionUpdate"] = None
-    _subscription_error: Optional["persistent_compute_api_SubscriptionError"] = None
-    _ping: Optional["persistent_compute_api_Ping"] = None
-    _pong: Optional["persistent_compute_api_Pong"] = None
+    _subscription_update: Optional["persistent_compute_api_SubscriptionUpdateMessage"] = None
+    _subscription_creation: Optional["persistent_compute_api_SubscriptionCreationMessage"] = None
+    _health: Optional["persistent_compute_api_HealthMessage"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'subscription_update': ConjureFieldDefinition('subscriptionUpdate', persistent_compute_api_SubscriptionUpdate),
-            'subscription_error': ConjureFieldDefinition('subscriptionError', persistent_compute_api_SubscriptionError),
-            'ping': ConjureFieldDefinition('ping', persistent_compute_api_Ping),
-            'pong': ConjureFieldDefinition('pong', persistent_compute_api_Pong)
+            'subscription_update': ConjureFieldDefinition('subscriptionUpdate', persistent_compute_api_SubscriptionUpdateMessage),
+            'subscription_creation': ConjureFieldDefinition('subscriptionCreation', persistent_compute_api_SubscriptionCreationMessage),
+            'health': ConjureFieldDefinition('health', persistent_compute_api_HealthMessage)
         }
 
     def __init__(
             self,
-            subscription_update: Optional["persistent_compute_api_SubscriptionUpdate"] = None,
-            subscription_error: Optional["persistent_compute_api_SubscriptionError"] = None,
-            ping: Optional["persistent_compute_api_Ping"] = None,
-            pong: Optional["persistent_compute_api_Pong"] = None,
+            subscription_update: Optional["persistent_compute_api_SubscriptionUpdateMessage"] = None,
+            subscription_creation: Optional["persistent_compute_api_SubscriptionCreationMessage"] = None,
+            health: Optional["persistent_compute_api_HealthMessage"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (subscription_update is not None) + (subscription_error is not None) + (ping is not None) + (pong is not None) != 1:
+            if (subscription_update is not None) + (subscription_creation is not None) + (health is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if subscription_update is not None:
                 self._subscription_update = subscription_update
                 self._type = 'subscriptionUpdate'
-            if subscription_error is not None:
-                self._subscription_error = subscription_error
-                self._type = 'subscriptionError'
-            if ping is not None:
-                self._ping = ping
-                self._type = 'ping'
-            if pong is not None:
-                self._pong = pong
-                self._type = 'pong'
+            if subscription_creation is not None:
+                self._subscription_creation = subscription_creation
+                self._type = 'subscriptionCreation'
+            if health is not None:
+                self._health = health
+                self._type = 'health'
 
         elif type_of_union == 'subscriptionUpdate':
             if subscription_update is None:
                 raise ValueError('a union value must not be None')
             self._subscription_update = subscription_update
             self._type = 'subscriptionUpdate'
-        elif type_of_union == 'subscriptionError':
-            if subscription_error is None:
+        elif type_of_union == 'subscriptionCreation':
+            if subscription_creation is None:
                 raise ValueError('a union value must not be None')
-            self._subscription_error = subscription_error
-            self._type = 'subscriptionError'
-        elif type_of_union == 'ping':
-            if ping is None:
+            self._subscription_creation = subscription_creation
+            self._type = 'subscriptionCreation'
+        elif type_of_union == 'health':
+            if health is None:
                 raise ValueError('a union value must not be None')
-            self._ping = ping
-            self._type = 'ping'
-        elif type_of_union == 'pong':
-            if pong is None:
-                raise ValueError('a union value must not be None')
-            self._pong = pong
-            self._type = 'pong'
+            self._health = health
+            self._type = 'health'
 
     @builtins.property
-    def subscription_update(self) -> Optional["persistent_compute_api_SubscriptionUpdate"]:
+    def subscription_update(self) -> Optional["persistent_compute_api_SubscriptionUpdateMessage"]:
         return self._subscription_update
 
     @builtins.property
-    def subscription_error(self) -> Optional["persistent_compute_api_SubscriptionError"]:
-        return self._subscription_error
-
-    @builtins.property
-    def ping(self) -> Optional["persistent_compute_api_Ping"]:
-        return self._ping
+    def subscription_creation(self) -> Optional["persistent_compute_api_SubscriptionCreationMessage"]:
+        return self._subscription_creation
 
     @builtins.property
-    def pong(self) -> Optional["persistent_compute_api_Pong"]:
-        return self._pong
+    def health(self) -> Optional["persistent_compute_api_HealthMessage"]:
+        return self._health
 
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, persistent_compute_api_ServerMessageVisitor):
             raise ValueError('{} is not an instance of persistent_compute_api_ServerMessageVisitor'.format(visitor.__class__.__name__))
         if self._type == 'subscriptionUpdate' and self.subscription_update is not None:
             return visitor._subscription_update(self.subscription_update)
-        if self._type == 'subscriptionError' and self.subscription_error is not None:
-            return visitor._subscription_error(self.subscription_error)
-        if self._type == 'ping' and self.ping is not None:
-            return visitor._ping(self.ping)
-        if self._type == 'pong' and self.pong is not None:
-            return visitor._pong(self.pong)
+        if self._type == 'subscriptionCreation' and self.subscription_creation is not None:
+            return visitor._subscription_creation(self.subscription_creation)
+        if self._type == 'health' and self.health is not None:
+            return visitor._health(self.health)
 
 
 persistent_compute_api_ServerMessage.__name__ = "ServerMessage"
@@ -12316,19 +12427,15 @@ persistent_compute_api_ServerMessage.__module__ = "nominal_api.persistent_comput
 class persistent_compute_api_ServerMessageVisitor:
 
     @abstractmethod
-    def _subscription_update(self, subscription_update: "persistent_compute_api_SubscriptionUpdate") -> Any:
+    def _subscription_update(self, subscription_update: "persistent_compute_api_SubscriptionUpdateMessage") -> Any:
         pass
 
     @abstractmethod
-    def _subscription_error(self, subscription_error: "persistent_compute_api_SubscriptionError") -> Any:
+    def _subscription_creation(self, subscription_creation: "persistent_compute_api_SubscriptionCreationMessage") -> Any:
         pass
 
     @abstractmethod
-    def _ping(self, ping: "persistent_compute_api_Ping") -> Any:
-        pass
-
-    @abstractmethod
-    def _pong(self, pong: "persistent_compute_api_Pong") -> Any:
+    def _health(self, health: "persistent_compute_api_HealthMessage") -> Any:
         pass
 
 
@@ -12405,30 +12512,100 @@ persistent_compute_api_StreamingComputeNodeSubscription.__qualname__ = "Streamin
 persistent_compute_api_StreamingComputeNodeSubscription.__module__ = "nominal_api.persistent_compute_api"
 
 
-class persistent_compute_api_SubscriptionError(ConjureBeanType):
+class persistent_compute_api_SubscriptionCreation(ConjureUnionType):
+    _success: Optional["persistent_compute_api_SubscriptionCreationSuccess"] = None
+    _error: Optional["persistent_compute_api_SubscriptionCreationError"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'success': ConjureFieldDefinition('success', persistent_compute_api_SubscriptionCreationSuccess),
+            'error': ConjureFieldDefinition('error', persistent_compute_api_SubscriptionCreationError)
+        }
+
+    def __init__(
+            self,
+            success: Optional["persistent_compute_api_SubscriptionCreationSuccess"] = None,
+            error: Optional["persistent_compute_api_SubscriptionCreationError"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (success is not None) + (error is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if success is not None:
+                self._success = success
+                self._type = 'success'
+            if error is not None:
+                self._error = error
+                self._type = 'error'
+
+        elif type_of_union == 'success':
+            if success is None:
+                raise ValueError('a union value must not be None')
+            self._success = success
+            self._type = 'success'
+        elif type_of_union == 'error':
+            if error is None:
+                raise ValueError('a union value must not be None')
+            self._error = error
+            self._type = 'error'
+
+    @builtins.property
+    def success(self) -> Optional["persistent_compute_api_SubscriptionCreationSuccess"]:
+        return self._success
+
+    @builtins.property
+    def error(self) -> Optional["persistent_compute_api_SubscriptionCreationError"]:
+        return self._error
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, persistent_compute_api_SubscriptionCreationVisitor):
+            raise ValueError('{} is not an instance of persistent_compute_api_SubscriptionCreationVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'success' and self.success is not None:
+            return visitor._success(self.success)
+        if self._type == 'error' and self.error is not None:
+            return visitor._error(self.error)
+
+
+persistent_compute_api_SubscriptionCreation.__name__ = "SubscriptionCreation"
+persistent_compute_api_SubscriptionCreation.__qualname__ = "SubscriptionCreation"
+persistent_compute_api_SubscriptionCreation.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_SubscriptionCreationVisitor:
+
+    @abstractmethod
+    def _success(self, success: "persistent_compute_api_SubscriptionCreationSuccess") -> Any:
+        pass
+
+    @abstractmethod
+    def _error(self, error: "persistent_compute_api_SubscriptionCreationError") -> Any:
+        pass
+
+
+persistent_compute_api_SubscriptionCreationVisitor.__name__ = "SubscriptionCreationVisitor"
+persistent_compute_api_SubscriptionCreationVisitor.__qualname__ = "SubscriptionCreationVisitor"
+persistent_compute_api_SubscriptionCreationVisitor.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_SubscriptionCreationError(ConjureBeanType):
     """
-    This will be sent if there is an error while creating or updating a subscription. Note: This won't 
-automatically cancel the subscription. The client will have to call `ClientMessage::unsubscribe` to do that
-if warranted.
+    This will be sent if there is an error while creating a subscription. This means that the subscription was
+never created and the client will have to re-try creating it if warranted.
     """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'subscription_id': ConjureFieldDefinition('subscriptionId', persistent_compute_api_SubscriptionId),
             'serializable_error': ConjureFieldDefinition('serializableError', api_SerializableError)
         }
 
-    __slots__: List[str] = ['_subscription_id', '_serializable_error']
+    __slots__: List[str] = ['_serializable_error']
 
-    def __init__(self, serializable_error: "api_SerializableError", subscription_id: str) -> None:
-        self._subscription_id = subscription_id
+    def __init__(self, serializable_error: "api_SerializableError") -> None:
         self._serializable_error = serializable_error
 
-    @builtins.property
-    def subscription_id(self) -> str:
-        return self._subscription_id
-
     @builtins.property
     def serializable_error(self) -> "api_SerializableError":
         """
@@ -12437,9 +12614,64 @@ if warranted.
         return self._serializable_error
 
 
-persistent_compute_api_SubscriptionError.__name__ = "SubscriptionError"
-persistent_compute_api_SubscriptionError.__qualname__ = "SubscriptionError"
-persistent_compute_api_SubscriptionError.__module__ = "nominal_api.persistent_compute_api"
+persistent_compute_api_SubscriptionCreationError.__name__ = "SubscriptionCreationError"
+persistent_compute_api_SubscriptionCreationError.__qualname__ = "SubscriptionCreationError"
+persistent_compute_api_SubscriptionCreationError.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_SubscriptionCreationMessage(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'subscription_id': ConjureFieldDefinition('subscriptionId', persistent_compute_api_SubscriptionId),
+            'creation': ConjureFieldDefinition('creation', persistent_compute_api_SubscriptionCreation)
+        }
+
+    __slots__: List[str] = ['_subscription_id', '_creation']
+
+    def __init__(self, creation: "persistent_compute_api_SubscriptionCreation", subscription_id: str) -> None:
+        self._subscription_id = subscription_id
+        self._creation = creation
+
+    @builtins.property
+    def subscription_id(self) -> str:
+        return self._subscription_id
+
+    @builtins.property
+    def creation(self) -> "persistent_compute_api_SubscriptionCreation":
+        return self._creation
+
+
+persistent_compute_api_SubscriptionCreationMessage.__name__ = "SubscriptionCreationMessage"
+persistent_compute_api_SubscriptionCreationMessage.__qualname__ = "SubscriptionCreationMessage"
+persistent_compute_api_SubscriptionCreationMessage.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_SubscriptionCreationSuccess(ConjureBeanType):
+    """
+    Will be returned once a subscriptions has been successfully created.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'unit_result': ConjureFieldDefinition('unitResult', scout_compute_api_ComputeUnitResult)
+        }
+
+    __slots__: List[str] = ['_unit_result']
+
+    def __init__(self, unit_result: "scout_compute_api_ComputeUnitResult") -> None:
+        self._unit_result = unit_result
+
+    @builtins.property
+    def unit_result(self) -> "scout_compute_api_ComputeUnitResult":
+        return self._unit_result
+
+
+persistent_compute_api_SubscriptionCreationSuccess.__name__ = "SubscriptionCreationSuccess"
+persistent_compute_api_SubscriptionCreationSuccess.__qualname__ = "SubscriptionCreationSuccess"
+persistent_compute_api_SubscriptionCreationSuccess.__module__ = "nominal_api.persistent_compute_api"
 
 
 class persistent_compute_api_SubscriptionOptions(ConjureBeanType):
@@ -12486,22 +12718,25 @@ persistent_compute_api_SubscriptionOptions.__module__ = "nominal_api.persistent_
 class persistent_compute_api_SubscriptionUpdate(ConjureUnionType):
     _full: Optional["persistent_compute_api_FullResult"] = None
     _append: Optional["persistent_compute_api_AppendResult"] = None
+    _error: Optional["persistent_compute_api_SubscriptionUpdateError"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'full': ConjureFieldDefinition('full', persistent_compute_api_FullResult),
-            'append': ConjureFieldDefinition('append', persistent_compute_api_AppendResult)
+            'append': ConjureFieldDefinition('append', persistent_compute_api_AppendResult),
+            'error': ConjureFieldDefinition('error', persistent_compute_api_SubscriptionUpdateError)
         }
 
     def __init__(
             self,
             full: Optional["persistent_compute_api_FullResult"] = None,
             append: Optional["persistent_compute_api_AppendResult"] = None,
+            error: Optional["persistent_compute_api_SubscriptionUpdateError"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (full is not None) + (append is not None) != 1:
+            if (full is not None) + (append is not None) + (error is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if full is not None:
@@ -12510,6 +12745,9 @@ class persistent_compute_api_SubscriptionUpdate(ConjureUnionType):
             if append is not None:
                 self._append = append
                 self._type = 'append'
+            if error is not None:
+                self._error = error
+                self._type = 'error'
 
         elif type_of_union == 'full':
             if full is None:
@@ -12521,6 +12759,11 @@ class persistent_compute_api_SubscriptionUpdate(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._append = append
             self._type = 'append'
+        elif type_of_union == 'error':
+            if error is None:
+                raise ValueError('a union value must not be None')
+            self._error = error
+            self._type = 'error'
 
     @builtins.property
     def full(self) -> Optional["persistent_compute_api_FullResult"]:
@@ -12530,6 +12773,10 @@ class persistent_compute_api_SubscriptionUpdate(ConjureUnionType):
     def append(self) -> Optional["persistent_compute_api_AppendResult"]:
         return self._append
 
+    @builtins.property
+    def error(self) -> Optional["persistent_compute_api_SubscriptionUpdateError"]:
+        return self._error
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, persistent_compute_api_SubscriptionUpdateVisitor):
             raise ValueError('{} is not an instance of persistent_compute_api_SubscriptionUpdateVisitor'.format(visitor.__class__.__name__))
@@ -12537,6 +12784,8 @@ class persistent_compute_api_SubscriptionUpdate(ConjureUnionType):
             return visitor._full(self.full)
         if self._type == 'append' and self.append is not None:
             return visitor._append(self.append)
+        if self._type == 'error' and self.error is not None:
+            return visitor._error(self.error)
 
 
 persistent_compute_api_SubscriptionUpdate.__name__ = "SubscriptionUpdate"
@@ -12554,12 +12803,75 @@ class persistent_compute_api_SubscriptionUpdateVisitor:
     def _append(self, append: "persistent_compute_api_AppendResult") -> Any:
         pass
 
+    @abstractmethod
+    def _error(self, error: "persistent_compute_api_SubscriptionUpdateError") -> Any:
+        pass
+
 
 persistent_compute_api_SubscriptionUpdateVisitor.__name__ = "SubscriptionUpdateVisitor"
 persistent_compute_api_SubscriptionUpdateVisitor.__qualname__ = "SubscriptionUpdateVisitor"
 persistent_compute_api_SubscriptionUpdateVisitor.__module__ = "nominal_api.persistent_compute_api"
 
 
+class persistent_compute_api_SubscriptionUpdateError(ConjureBeanType):
+    """
+    This will be sent if there is an error while updating a subscription. Note: This won't automatically cancel 
+the subscription. The client will have to call `ClientMessage::unsubscribe` to do that if warranted.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'serializable_error': ConjureFieldDefinition('serializableError', api_SerializableError)
+        }
+
+    __slots__: List[str] = ['_serializable_error']
+
+    def __init__(self, serializable_error: "api_SerializableError") -> None:
+        self._serializable_error = serializable_error
+
+    @builtins.property
+    def serializable_error(self) -> "api_SerializableError":
+        """
+        A serialized version of the error. Should match the errors defined below.
+        """
+        return self._serializable_error
+
+
+persistent_compute_api_SubscriptionUpdateError.__name__ = "SubscriptionUpdateError"
+persistent_compute_api_SubscriptionUpdateError.__qualname__ = "SubscriptionUpdateError"
+persistent_compute_api_SubscriptionUpdateError.__module__ = "nominal_api.persistent_compute_api"
+
+
+class persistent_compute_api_SubscriptionUpdateMessage(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'subscription_id': ConjureFieldDefinition('subscriptionId', persistent_compute_api_SubscriptionId),
+            'update': ConjureFieldDefinition('update', persistent_compute_api_SubscriptionUpdate)
+        }
+
+    __slots__: List[str] = ['_subscription_id', '_update']
+
+    def __init__(self, subscription_id: str, update: "persistent_compute_api_SubscriptionUpdate") -> None:
+        self._subscription_id = subscription_id
+        self._update = update
+
+    @builtins.property
+    def subscription_id(self) -> str:
+        return self._subscription_id
+
+    @builtins.property
+    def update(self) -> "persistent_compute_api_SubscriptionUpdate":
+        return self._update
+
+
+persistent_compute_api_SubscriptionUpdateMessage.__name__ = "SubscriptionUpdateMessage"
+persistent_compute_api_SubscriptionUpdateMessage.__qualname__ = "SubscriptionUpdateMessage"
+persistent_compute_api_SubscriptionUpdateMessage.__module__ = "nominal_api.persistent_compute_api"
+
+
 class scout_InternalVersioningService(Service):
     """
     These endpoints are not intended to be used directly by clients, since
@@ -56461,6 +56773,42 @@ in the same order as requests.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), datasource_api_BatchGetDataScopeBoundsResponse, self._return_none_for_unknown_union_types)
 
+    def get_tag_values_for_data_source(self, auth_header: str, data_source_rid: str, request: "datasource_api_GetTagValuesForDataSourceRequest") -> Dict[str, List[str]]:
+        """
+        Returns available tag values for a given data source for a set of tag keys. For Nominal data sources, a time 
+range can be provided to filter tag values to those present within the months spanned by the range. If no
+time range is provided, this defaults to the last month. For external data sources, the range must not be 
+specified, as all tag values are returned.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'dataSourceRid': data_source_rid,
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/data-source/v1/data-sources/{dataSourceRid}/get-tags'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), Dict[api_TagName, List[api_TagValue]], self._return_none_for_unknown_union_types)
+
 
 scout_datasource_DataSourceService.__name__ = "DataSourceService"
 scout_datasource_DataSourceService.__qualname__ = "DataSourceService"
@@ -56989,7 +57337,7 @@ class scout_datasource_connection_api_Connection(ConjureBeanType):
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'connection_details': ConjureFieldDefinition('connectionDetails', scout_datasource_connection_api_ConnectionDetails),
             'required_tag_names': ConjureFieldDefinition('requiredTagNames', List[api_TagName]),
-            'available_tag_values': ConjureFieldDefinition('availableTagValues', Dict[api_TagName, List[api_TagValue]]),
+            'available_tag_values': ConjureFieldDefinition('availableTagValues', OptionalTypeWrapper[Dict[api_TagName, List[api_TagValue]]]),
             'metadata': ConjureFieldDefinition('metadata', Dict[str, str]),
             'scraping': ConjureFieldDefinition('scraping', OptionalTypeWrapper[scout_datasource_connection_api_ScrapingConfig]),
             'should_scrape': ConjureFieldDefinition('shouldScrape', bool),
@@ -57000,7 +57348,7 @@ class scout_datasource_connection_api_Connection(ConjureBeanType):
 
     __slots__: List[str] = ['_rid', '_display_name', '_description', '_connection_details', '_required_tag_names', '_available_tag_values', '_metadata', '_scraping', '_should_scrape', '_limits', '_connection_status', '_is_archived']
 
-    def __init__(self, available_tag_values: Dict[str, List[str]], connection_details: "scout_datasource_connection_api_ConnectionDetails", connection_status: "scout_datasource_connection_api_ConnectionStatus", display_name: str, is_archived: bool, metadata: Dict[str, str], required_tag_names: List[str], rid: str, should_scrape: bool, description: Optional[str] = None, limits: Optional["scout_datasource_connection_api_LimitsConfig"] = None, scraping: Optional["scout_datasource_connection_api_ScrapingConfig"] = None) -> None:
+    def __init__(self, connection_details: "scout_datasource_connection_api_ConnectionDetails", connection_status: "scout_datasource_connection_api_ConnectionStatus", display_name: str, is_archived: bool, metadata: Dict[str, str], required_tag_names: List[str], rid: str, should_scrape: bool, available_tag_values: Optional[Dict[str, List[str]]] = None, description: Optional[str] = None, limits: Optional["scout_datasource_connection_api_LimitsConfig"] = None, scraping: Optional["scout_datasource_connection_api_ScrapingConfig"] = None) -> None:
         self._rid = rid
         self._display_name = display_name
         self._description = description
@@ -57042,7 +57390,10 @@ rather than strictly required.
         return self._required_tag_names
 
     @builtins.property
-    def available_tag_values(self) -> Dict[str, List[str]]:
+    def available_tag_values(self) -> Optional[Dict[str, List[str]]]:
+        """
+        Deprecated, use the getAvailableTagsForConnection endpoint instead
+        """
         return self._available_tag_values
 
     @builtins.property
@@ -59210,101 +59561,12 @@ quick access within search pages throughout the application for themselves.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_favorites_api_FavoritesListResponse, self._return_none_for_unknown_union_types)
 
-    def update_favorites(self, auth_header: str, request: "scout_favorites_api_SetFavoritesListRequest") -> "scout_favorites_api_FavoritesListResponse":
-        """
-        Update the user's favorited resources.
-This will use the org's default workspace if the user has access to it.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/scout/v2/favorites'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'PUT',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_favorites_api_FavoritesListResponse, self._return_none_for_unknown_union_types)
-
-    def list_favorites(self, auth_header: str, request: "scout_favorites_api_DeprecatedListFavoritesRequest") -> "scout_favorites_api_FavoritesListResponse":
-        """
-        Retrieves all the user's favorites with filtering options on the resource types to include.
-This will use the org's default workspace if the user has access to it.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Content-Type': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-        }
-
-        _json: Any = ConjureEncoder().default(request)
-
-        _path = '/scout/v2/favorites/list'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), scout_favorites_api_FavoritesListResponse, self._return_none_for_unknown_union_types)
-
 
 scout_favorites_FavoritesService.__name__ = "FavoritesService"
 scout_favorites_FavoritesService.__qualname__ = "FavoritesService"
 scout_favorites_FavoritesService.__module__ = "nominal_api.scout_favorites"
 
 
-class scout_favorites_api_DeprecatedListFavoritesRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'resource_types': ConjureFieldDefinition('resourceTypes', OptionalTypeWrapper[List[scout_favorites_api_ResourceType]])
-        }
-
-    __slots__: List[str] = ['_resource_types']
-
-    def __init__(self, resource_types: Optional[List["scout_favorites_api_ResourceType"]] = None) -> None:
-        self._resource_types = resource_types
-
-    @builtins.property
-    def resource_types(self) -> Optional[List["scout_favorites_api_ResourceType"]]:
-        return self._resource_types
-
-
-scout_favorites_api_DeprecatedListFavoritesRequest.__name__ = "DeprecatedListFavoritesRequest"
-scout_favorites_api_DeprecatedListFavoritesRequest.__qualname__ = "DeprecatedListFavoritesRequest"
-scout_favorites_api_DeprecatedListFavoritesRequest.__module__ = "nominal_api.scout_favorites_api"
-
-
 class scout_favorites_api_FavoriteResource(ConjureUnionType):
     _asset: Optional[str] = None
     _run: Optional[str] = None

nominal_api/api/__init__.py

@@ -22,6 +22,7 @@ from .._impl import (
     api_Property as Property,
     api_PropertyName as PropertyName,
     api_PropertyValue as PropertyValue,
+    api_Range as Range,
     api_S3Path as S3Path,
     api_SerializableError as SerializableError,
     api_SeriesArchetypeRid as SeriesArchetypeRid,

nominal_api/datasource_api/__init__.py

@@ -17,6 +17,7 @@ from .._impl import (
     datasource_api_GetAvailableTagsForChannelResponse as GetAvailableTagsForChannelResponse,
     datasource_api_GetDataScopeBoundsRequest as GetDataScopeBoundsRequest,
     datasource_api_GetDataScopeBoundsResponse as GetDataScopeBoundsResponse,
+    datasource_api_GetTagValuesForDataSourceRequest as GetTagValuesForDataSourceRequest,
     datasource_api_IndexChannelPrefixTreeRequest as IndexChannelPrefixTreeRequest,
     datasource_api_SearchChannelsRequest as SearchChannelsRequest,
     datasource_api_SearchChannelsResponse as SearchChannelsResponse,

nominal_api/persistent_compute_api/__init__.py

@@ -6,6 +6,8 @@ from .._impl import (
     persistent_compute_api_ComputeNodeAppendResponse as ComputeNodeAppendResponse,
     persistent_compute_api_ComputeNodeAppendResponseVisitor as ComputeNodeAppendResponseVisitor,
     persistent_compute_api_FullResult as FullResult,
+    persistent_compute_api_HealthMessage as HealthMessage,
+    persistent_compute_api_HealthMessageVisitor as HealthMessageVisitor,
     persistent_compute_api_Milliseconds as Milliseconds,
     persistent_compute_api_Ping as Ping,
     persistent_compute_api_Pong as Pong,
@@ -13,10 +15,16 @@ from .._impl import (
     persistent_compute_api_ServerMessageVisitor as ServerMessageVisitor,
     persistent_compute_api_StreamingComputeNodeRequest as StreamingComputeNodeRequest,
     persistent_compute_api_StreamingComputeNodeSubscription as StreamingComputeNodeSubscription,
-    persistent_compute_api_SubscriptionError as SubscriptionError,
+    persistent_compute_api_SubscriptionCreation as SubscriptionCreation,
+    persistent_compute_api_SubscriptionCreationError as SubscriptionCreationError,
+    persistent_compute_api_SubscriptionCreationMessage as SubscriptionCreationMessage,
+    persistent_compute_api_SubscriptionCreationSuccess as SubscriptionCreationSuccess,
+    persistent_compute_api_SubscriptionCreationVisitor as SubscriptionCreationVisitor,
     persistent_compute_api_SubscriptionId as SubscriptionId,
     persistent_compute_api_SubscriptionOptions as SubscriptionOptions,
     persistent_compute_api_SubscriptionUpdate as SubscriptionUpdate,
+    persistent_compute_api_SubscriptionUpdateError as SubscriptionUpdateError,
+    persistent_compute_api_SubscriptionUpdateMessage as SubscriptionUpdateMessage,
     persistent_compute_api_SubscriptionUpdateVisitor as SubscriptionUpdateVisitor,
 )
 

nominal_api/scout_favorites_api/__init__.py

@@ -1,6 +1,5 @@
 # coding=utf-8
 from .._impl import (
-    scout_favorites_api_DeprecatedListFavoritesRequest as DeprecatedListFavoritesRequest,
     scout_favorites_api_FavoriteResource as FavoriteResource,
     scout_favorites_api_FavoriteResourceVisitor as FavoriteResourceVisitor,
     scout_favorites_api_FavoritesListResponse as FavoritesListResponse,

{nominal_api-0.623.0.dist-info → nominal_api-0.625.0.dist-info}/METADATA

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

{nominal_api-0.623.0.dist-info → nominal_api-0.625.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-nominal_api/__init__.py,sha256=0G-zmhqQ_3xFeqfbtuSRQnzBTz8w4Z9k3tithBihh9M,1995
-nominal_api/_impl.py,sha256=4SPkC1z2YVLR5yVTKHgJrp6fCY-ij0n01_RUhH6yv-w,2992953
+nominal_api/__init__.py,sha256=1jB8LoHK2esww0ZdWjOh83WJuQgcQ7hFuoisU9N8-64,1995
+nominal_api/_impl.py,sha256=Jq-jFqwQaz9E4LSegTSByQn1WFPF_IB3LSJQL3QKazE,3003501
 nominal_api/py.typed,sha256=eoZ6GfifbqhMLNzjlqRDVil-yyBkOmVN9ujSgJWNBlY,15
-nominal_api/api/__init__.py,sha256=f6fvZACzXUPSIN-H855AjAYLwmisy_VrHy4Ie2HXiNE,1270
+nominal_api/api/__init__.py,sha256=1oJPOuAMfV2uClPUW8Ie1nj2Y6j81TDpedcc3yUFTe0,1294
 nominal_api/api_ids/__init__.py,sha256=CAtt44XgNZEEUDv-BbEbYtuxQ8y1wqSZU-STjBYdZv8,80
 nominal_api/api_rids/__init__.py,sha256=qerno2fgGWLfokoSdCarKSXg2jDjTJpz45Wv8PnqI6Q,500
 nominal_api/attachments_api/__init__.py,sha256=eQBE8xVTFDaTItCZv-WJSZqSStpgdai192n23pmVeeQ,634
@@ -10,14 +10,14 @@ nominal_api/authorization/__init__.py,sha256=F6JRzi_O0vr5jgwPbDlQMHLLKpCzyc9u5DY
 nominal_api/comments_api/__init__.py,sha256=bt24EdmTY513nKMrWMCsfYV0XmX7VKQgOFH4I4tKWy4,860
 nominal_api/connect_download/__init__.py,sha256=kYpjIjuFHA3uix70bJ5gV9-7BmDcJZAcm_e3MeMVSSQ,83
 nominal_api/datasource/__init__.py,sha256=C2lvxiWYnZRjaMKL2sY9_bfgZezBpK39A3VtgSASgRI,134
-nominal_api/datasource_api/__init__.py,sha256=5TddGrr5x6bZdVun00Zb_BwwcQtP35Yvn1DSxZ6QZmI,2074
+nominal_api/datasource_api/__init__.py,sha256=-0v4FGK22kyCALrJ-LRcwJ-QHDUnFCBqj_LkpEt_rgs,2163
 nominal_api/datasource_logset/__init__.py,sha256=H3fNxqyYC490MwvdWbt5BwhgWQUev7uieaLz5hUbZDc,94
 nominal_api/datasource_logset_api/__init__.py,sha256=JyjO1tQmG-HZ7kYMi8lSfeaaYddBZdCMIyqc0IUJfWo,1006
 nominal_api/datasource_pagination_api/__init__.py,sha256=3GO8TAUavOe6dUEitOhje74aSZHjTKVI5N1MNuct1lI,212
 nominal_api/event/__init__.py,sha256=YUhvDFXtyAn08WNd7Xwnybz3PtflvtTcIOaunRS5-1I,836
 nominal_api/ingest_api/__init__.py,sha256=jpxmJO0dzcCEIv5iM7xvziQEs1x92XLTm-LmbHxtii4,6953
 nominal_api/ingest_workflow_api/__init__.py,sha256=1oJO78YCmXFkfN5LY7x0gOJwtijrOcXD8Sl0GJCOyrk,1352
-nominal_api/persistent_compute_api/__init__.py,sha256=ovp4TsiVPGgCFjHVo4L9s0xSr0t7lV6GRSn6-8m3wBE,1268
+nominal_api/persistent_compute_api/__init__.py,sha256=9X56Ar01aw8PUC7rVVZ2A9Vny0QIXaJPWJtjjCY4IWg,1912
 nominal_api/scout/__init__.py,sha256=ip3XK_9jJKAoFiCifUVMTpDMiUE4mWIdGzMDu7LASus,324
 nominal_api/scout_api/__init__.py,sha256=biO4DEygbGcLwM6Dg2VuvMra3A5EW6NBjukbIemXoG8,178
 nominal_api/scout_asset_api/__init__.py,sha256=Ph-KlW-ki0JRejYQZDvbZ2jRzNAttVBux27lcEj7--Q,1910
@@ -41,7 +41,7 @@ nominal_api/scout_datasource_connection/__init__.py,sha256=he1CCSqMBwRWnzovWCeYP
 nominal_api/scout_datasource_connection_api/__init__.py,sha256=uZDDTsvvsr_7LfkHwEIfPnV9MsHoxmoTL95e37bZ_nE,4984
 nominal_api/scout_datasource_connection_api_influx/__init__.py,sha256=PeUZYnCR7Iq92bRuygtWly-HaZ-G1MfqShxJmamiTWA,99
 nominal_api/scout_favorites/__init__.py,sha256=qiOvaWVVl3O7tXZIq_NrCWFcMx-Q-H5sA_NpIc4TFVU,98
-nominal_api/scout_favorites_api/__init__.py,sha256=gwJVcakw17C6U_dFSbHDVw1AMvz6AyiXXD374rHdt0Q,470
+nominal_api/scout_favorites_api/__init__.py,sha256=VOsTMNCQTHYxdYRzRlvEyli5b7Lo2BEnSNcWT2HA9uY,380
 nominal_api/scout_integrations_api/__init__.py,sha256=8iXeDLEbgMYEZz0dEZsvUj7v9JkuaaTdxkzS-ld8E0U,1432
 nominal_api/scout_internal_search_api/__init__.py,sha256=CF2YYZXkl95YkEgCbhqXSdAQ4ayPDDOJiCcyoFKOaA8,520
 nominal_api/scout_jobs_api/__init__.py,sha256=_2ETRUShk1pestGAKzHwc69S-ililQRD4Y9JLD5qqZ4,146
@@ -73,7 +73,7 @@ nominal_api/timeseries_logicalseries_api/__init__.py,sha256=Q9iZHurmyDsJIFbUg-Eb
 nominal_api/timeseries_seriescache/__init__.py,sha256=tFCkNuyrVMgtj-HIl1pOYPJHaL2VikI4C_x97bX_Lcs,109
 nominal_api/timeseries_seriescache_api/__init__.py,sha256=U9EhlqdF9qzD1O9al0vcvcdgS_C5lq-lN3Kmr0K3g84,1191
 nominal_api/upload_api/__init__.py,sha256=ZMudWMSqCrNozohbHaJKuxJnT9Edepe7nxxXMz_pT9k,87
-nominal_api-0.623.0.dist-info/METADATA,sha256=YBLiL8d0hhZd6AX8fcM0Qkt6uZiPEqOgvCV8Yx7mtAs,199
-nominal_api-0.623.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-nominal_api-0.623.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
-nominal_api-0.623.0.dist-info/RECORD,,
+nominal_api-0.625.0.dist-info/METADATA,sha256=ZXo6H9Ssw4miirmImDttwuvrFjGUGOYOqpUe359MGcQ,199
+nominal_api-0.625.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+nominal_api-0.625.0.dist-info/top_level.txt,sha256=gI1ZdNJbuHcJZeKtCzzBXsEtpU1GX6XJKs6ksi_gCRA,12
+nominal_api-0.625.0.dist-info/RECORD,,