nominal-api 0.624.0__tar.gz → 0.626.0__tar.gz

{nominal_api-0.624.0 → nominal_api-0.626.0}/PKG-INFO

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

{nominal_api-0.624.0 → nominal_api-0.626.0}/nominal_api/__init__.py

@@ -76,5 +76,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.624.0"
+__version__ = "0.626.0"
 

{nominal_api-0.624.0 → nominal_api-0.626.0}/nominal_api/_impl.py

@@ -4784,10 +4784,6 @@ class datasource_logset_LogSetService(Service):
     """
 
     def create(self, auth_header: str, request: "datasource_logset_api_CreateLogSetRequest") -> "datasource_logset_api_LogSetMetadata":
-        """
-        Creates a log set, to which logs can be attached using `attach-and-finalize`. The logs within a logset are
-not searchable until the logset is finalized.
-        """
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -4817,9 +4813,6 @@ not searchable until the logset is finalized.
         return _decoder.decode(_response.json(), datasource_logset_api_LogSetMetadata, self._return_none_for_unknown_union_types)
 
     def attach_logs_and_finalize(self, auth_header: str, log_set_rid: str, request: "datasource_logset_api_AttachLogsAndFinalizeRequest") -> "datasource_logset_api_LogSetMetadata":
-        """
-        A logset is not considered readable until it has been finalized. Once finalized, the logset is immutable.
-        """
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -4850,9 +4843,6 @@ not searchable until the logset is finalized.
         return _decoder.decode(_response.json(), datasource_logset_api_LogSetMetadata, self._return_none_for_unknown_union_types)
 
     def get_log_set_metadata(self, auth_header: str, log_set_rid: str) -> "datasource_logset_api_LogSetMetadata":
-        """
-        Returns metadata about a log set.
-        """
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -4882,9 +4872,6 @@ not searchable until the logset is finalized.
         return _decoder.decode(_response.json(), datasource_logset_api_LogSetMetadata, self._return_none_for_unknown_union_types)
 
     def batch_get_log_set_metadata(self, auth_header: str, request: List[str] = None) -> List["datasource_logset_api_LogSetMetadata"]:
-        """
-        Returns metadata about a set of log sets.
-        """
         request = request if request is not None else []
 
         _headers: Dict[str, Any] = {
@@ -4915,9 +4902,6 @@ not searchable until the logset is finalized.
         return _decoder.decode(_response.json(), List[datasource_logset_api_LogSetMetadata], self._return_none_for_unknown_union_types)
 
     def search_log_sets(self, auth_header: str, request: "datasource_logset_api_SearchLogSetsRequest") -> "datasource_logset_api_SearchLogSetsResponse":
-        """
-        Searches all visible log sets based on log set metadata.
-        """
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -4947,9 +4931,6 @@ not searchable until the logset is finalized.
         return _decoder.decode(_response.json(), datasource_logset_api_SearchLogSetsResponse, self._return_none_for_unknown_union_types)
 
     def search_logs(self, auth_header: str, log_set_rid: str, request: "datasource_logset_api_SearchLogsRequest") -> "datasource_logset_api_SearchLogsResponse":
-        """
-        Searches logs within a single log set.
-        """
 
         _headers: Dict[str, Any] = {
             'Accept': 'application/json',
@@ -11815,24 +11796,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":
         """
@@ -11923,9 +11898,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
 
@@ -11984,7 +11959,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`.
@@ -12199,22 +12174,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
 
 
@@ -12223,6 +12192,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.
@@ -12282,93 +12328,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
+    def subscription_creation(self) -> Optional["persistent_compute_api_SubscriptionCreationMessage"]:
+        return self._subscription_creation
 
     @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 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"
@@ -12379,19 +12408,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:
-        pass
-
-    @abstractmethod
-    def _subscription_error(self, subscription_error: "persistent_compute_api_SubscriptionError") -> Any:
+    def _subscription_update(self, subscription_update: "persistent_compute_api_SubscriptionUpdateMessage") -> Any:
         pass
 
     @abstractmethod
-    def _ping(self, ping: "persistent_compute_api_Ping") -> Any:
+    def _subscription_creation(self, subscription_creation: "persistent_compute_api_SubscriptionCreationMessage") -> Any:
         pass
 
     @abstractmethod
-    def _pong(self, pong: "persistent_compute_api_Pong") -> Any:
+    def _health(self, health: "persistent_compute_api_HealthMessage") -> Any:
         pass
 
 
@@ -12468,30 +12493,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":
         """
@@ -12500,9 +12595,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):
@@ -12549,22 +12699,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:
@@ -12573,6 +12726,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:
@@ -12584,6 +12740,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"]:
@@ -12593,6 +12754,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__))
@@ -12600,6 +12765,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"
@@ -12617,12 +12784,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
@@ -59312,101 +59542,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-0.624.0 → nominal_api-0.626.0}/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-0.624.0 → nominal_api-0.626.0}/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.624.0 → nominal_api-0.626.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.624.0 → nominal_api-0.626.0}/setup.py

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