nominal-api 0.508.0__tar.gz → 0.510.0__tar.gz

{nominal_api-0.508.0 → nominal_api-0.510.0}/PKG-INFO

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

{nominal_api-0.508.0 → nominal_api-0.510.0}/nominal_api/__init__.py

@@ -67,5 +67,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.508.0"
+__version__ = "0.510.0"
 

{nominal_api-0.508.0 → nominal_api-0.510.0}/nominal_api/_impl.py

@@ -26293,6 +26293,52 @@ scout_compute_api_BatchComputeUnitsRequest.__qualname__ = "BatchComputeUnitsRequ
 scout_compute_api_BatchComputeUnitsRequest.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_BatchComputeWithUnitsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'requests': ConjureFieldDefinition('requests', List[scout_compute_api_ComputeNodeRequest])
+        }
+
+    __slots__: List[str] = ['_requests']
+
+    def __init__(self, requests: List["scout_compute_api_ComputeNodeRequest"]) -> None:
+        self._requests = requests
+
+    @builtins.property
+    def requests(self) -> List["scout_compute_api_ComputeNodeRequest"]:
+        return self._requests
+
+
+scout_compute_api_BatchComputeWithUnitsRequest.__name__ = "BatchComputeWithUnitsRequest"
+scout_compute_api_BatchComputeWithUnitsRequest.__qualname__ = "BatchComputeWithUnitsRequest"
+scout_compute_api_BatchComputeWithUnitsRequest.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_BatchComputeWithUnitsResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'results': ConjureFieldDefinition('results', List[scout_compute_api_ComputeWithUnitsResult])
+        }
+
+    __slots__: List[str] = ['_results']
+
+    def __init__(self, results: List["scout_compute_api_ComputeWithUnitsResult"]) -> None:
+        self._results = results
+
+    @builtins.property
+    def results(self) -> List["scout_compute_api_ComputeWithUnitsResult"]:
+        return self._results
+
+
+scout_compute_api_BatchComputeWithUnitsResponse.__name__ = "BatchComputeWithUnitsResponse"
+scout_compute_api_BatchComputeWithUnitsResponse.__qualname__ = "BatchComputeWithUnitsResponse"
+scout_compute_api_BatchComputeWithUnitsResponse.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_BinaryArithmeticOperation(ConjureEnumType):
 
     ATAN2 = 'ATAN2'
@@ -27772,6 +27818,83 @@ scout_compute_api_ComputeNodeResponseVisitor.__qualname__ = "ComputeNodeResponse
 scout_compute_api_ComputeNodeResponseVisitor.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ComputeNodeResult(ConjureUnionType):
+    _success: Optional["scout_compute_api_ComputeNodeResponse"] = None
+    _error: Optional["scout_compute_api_ErrorResult"] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'success': ConjureFieldDefinition('success', scout_compute_api_ComputeNodeResponse),
+            'error': ConjureFieldDefinition('error', scout_compute_api_ErrorResult)
+        }
+
+    def __init__(
+            self,
+            success: Optional["scout_compute_api_ComputeNodeResponse"] = None,
+            error: Optional["scout_compute_api_ErrorResult"] = 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["scout_compute_api_ComputeNodeResponse"]:
+        return self._success
+
+    @builtins.property
+    def error(self) -> Optional["scout_compute_api_ErrorResult"]:
+        return self._error
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_compute_api_ComputeNodeResultVisitor):
+            raise ValueError('{} is not an instance of scout_compute_api_ComputeNodeResultVisitor'.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)
+
+
+scout_compute_api_ComputeNodeResult.__name__ = "ComputeNodeResult"
+scout_compute_api_ComputeNodeResult.__qualname__ = "ComputeNodeResult"
+scout_compute_api_ComputeNodeResult.__module__ = "nominal_api.scout_compute_api"
+
+
+class scout_compute_api_ComputeNodeResultVisitor:
+
+    @abstractmethod
+    def _success(self, success: "scout_compute_api_ComputeNodeResponse") -> Any:
+        pass
+
+    @abstractmethod
+    def _error(self, error: "scout_compute_api_ErrorResult") -> Any:
+        pass
+
+
+scout_compute_api_ComputeNodeResultVisitor.__name__ = "ComputeNodeResultVisitor"
+scout_compute_api_ComputeNodeResultVisitor.__qualname__ = "ComputeNodeResultVisitor"
+scout_compute_api_ComputeNodeResultVisitor.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ComputeNodeWithContext(ConjureBeanType):
 
     @builtins.classmethod
@@ -27908,6 +28031,39 @@ are returned.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_compute_api_ComputeUnitResult, self._return_none_for_unknown_union_types)
 
+    def batch_compute_with_units(self, auth_header: str, request: "scout_compute_api_BatchComputeWithUnitsRequest") -> "scout_compute_api_BatchComputeWithUnitsResponse":
+        """
+        Computes the output of compute graphs specified by BatchComputeNodeRequest. Results are returned in the same
+order as the request.
+        """
+
+        _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 = '/compute/v2/compute/batch'
+        _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_compute_api_BatchComputeWithUnitsResponse, self._return_none_for_unknown_union_types)
+
     def batch_compute_units(self, auth_header: str, request: "scout_compute_api_BatchComputeUnitsRequest") -> "scout_compute_api_BatchComputeUnitResult":
         """
         Same as computeUnits, however this endpoint functions on a batch of requests for wire efficiency purposes. An
@@ -28119,6 +28275,35 @@ scout_compute_api_ComputeWithUnitsResponse.__qualname__ = "ComputeWithUnitsRespo
 scout_compute_api_ComputeWithUnitsResponse.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_ComputeWithUnitsResult(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'compute_result': ConjureFieldDefinition('computeResult', scout_compute_api_ComputeNodeResult),
+            'unit_result': ConjureFieldDefinition('unitResult', scout_compute_api_ComputeUnitResult)
+        }
+
+    __slots__: List[str] = ['_compute_result', '_unit_result']
+
+    def __init__(self, compute_result: "scout_compute_api_ComputeNodeResult", unit_result: "scout_compute_api_ComputeUnitResult") -> None:
+        self._compute_result = compute_result
+        self._unit_result = unit_result
+
+    @builtins.property
+    def compute_result(self) -> "scout_compute_api_ComputeNodeResult":
+        return self._compute_result
+
+    @builtins.property
+    def unit_result(self) -> "scout_compute_api_ComputeUnitResult":
+        return self._unit_result
+
+
+scout_compute_api_ComputeWithUnitsResult.__name__ = "ComputeWithUnitsResult"
+scout_compute_api_ComputeWithUnitsResult.__qualname__ = "ComputeWithUnitsResult"
+scout_compute_api_ComputeWithUnitsResult.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_Context(ConjureBeanType):
 
     @builtins.classmethod
@@ -32140,16 +32325,16 @@ class scout_compute_api_ParameterizedComputeNodeResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'results': ConjureFieldDefinition('results', List[scout_compute_api_ParameterizedComputeNodeResult])
+            'results': ConjureFieldDefinition('results', List[scout_compute_api_ComputeNodeResult])
         }
 
     __slots__: List[str] = ['_results']
 
-    def __init__(self, results: List["scout_compute_api_ParameterizedComputeNodeResult"]) -> None:
+    def __init__(self, results: List["scout_compute_api_ComputeNodeResult"]) -> None:
         self._results = results
 
     @builtins.property
-    def results(self) -> List["scout_compute_api_ParameterizedComputeNodeResult"]:
+    def results(self) -> List["scout_compute_api_ComputeNodeResult"]:
         return self._results
 
 
@@ -32158,83 +32343,6 @@ scout_compute_api_ParameterizedComputeNodeResponse.__qualname__ = "Parameterized
 scout_compute_api_ParameterizedComputeNodeResponse.__module__ = "nominal_api.scout_compute_api"
 
 
-class scout_compute_api_ParameterizedComputeNodeResult(ConjureUnionType):
-    _success: Optional["scout_compute_api_ComputeNodeResponse"] = None
-    _error: Optional["scout_compute_api_ErrorResult"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'success': ConjureFieldDefinition('success', scout_compute_api_ComputeNodeResponse),
-            'error': ConjureFieldDefinition('error', scout_compute_api_ErrorResult)
-        }
-
-    def __init__(
-            self,
-            success: Optional["scout_compute_api_ComputeNodeResponse"] = None,
-            error: Optional["scout_compute_api_ErrorResult"] = 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["scout_compute_api_ComputeNodeResponse"]:
-        return self._success
-
-    @builtins.property
-    def error(self) -> Optional["scout_compute_api_ErrorResult"]:
-        return self._error
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_compute_api_ParameterizedComputeNodeResultVisitor):
-            raise ValueError('{} is not an instance of scout_compute_api_ParameterizedComputeNodeResultVisitor'.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)
-
-
-scout_compute_api_ParameterizedComputeNodeResult.__name__ = "ParameterizedComputeNodeResult"
-scout_compute_api_ParameterizedComputeNodeResult.__qualname__ = "ParameterizedComputeNodeResult"
-scout_compute_api_ParameterizedComputeNodeResult.__module__ = "nominal_api.scout_compute_api"
-
-
-class scout_compute_api_ParameterizedComputeNodeResultVisitor:
-
-    @abstractmethod
-    def _success(self, success: "scout_compute_api_ComputeNodeResponse") -> Any:
-        pass
-
-    @abstractmethod
-    def _error(self, error: "scout_compute_api_ErrorResult") -> Any:
-        pass
-
-
-scout_compute_api_ParameterizedComputeNodeResultVisitor.__name__ = "ParameterizedComputeNodeResultVisitor"
-scout_compute_api_ParameterizedComputeNodeResultVisitor.__qualname__ = "ParameterizedComputeNodeResultVisitor"
-scout_compute_api_ParameterizedComputeNodeResultVisitor.__module__ = "nominal_api.scout_compute_api"
-
-
 class scout_compute_api_ParameterizedContext(ConjureBeanType):
 
     @builtins.classmethod

{nominal_api-0.508.0 → nominal_api-0.510.0}/nominal_api/scout_compute_api/__init__.py

@@ -10,6 +10,8 @@ from .._impl import (
     scout_compute_api_Average as Average,
     scout_compute_api_BatchComputeUnitResult as BatchComputeUnitResult,
     scout_compute_api_BatchComputeUnitsRequest as BatchComputeUnitsRequest,
+    scout_compute_api_BatchComputeWithUnitsRequest as BatchComputeWithUnitsRequest,
+    scout_compute_api_BatchComputeWithUnitsResponse as BatchComputeWithUnitsResponse,
     scout_compute_api_BinaryArithmeticOperation as BinaryArithmeticOperation,
     scout_compute_api_BinaryArithmeticSeries as BinaryArithmeticSeries,
     scout_compute_api_BitAndFunction as BitAndFunction,
@@ -39,6 +41,8 @@ from .._impl import (
     scout_compute_api_ComputeNodeRequest as ComputeNodeRequest,
     scout_compute_api_ComputeNodeResponse as ComputeNodeResponse,
     scout_compute_api_ComputeNodeResponseVisitor as ComputeNodeResponseVisitor,
+    scout_compute_api_ComputeNodeResult as ComputeNodeResult,
+    scout_compute_api_ComputeNodeResultVisitor as ComputeNodeResultVisitor,
     scout_compute_api_ComputeNodeVisitor as ComputeNodeVisitor,
     scout_compute_api_ComputeNodeWithContext as ComputeNodeWithContext,
     scout_compute_api_ComputeService as ComputeService,
@@ -47,6 +51,7 @@ from .._impl import (
     scout_compute_api_ComputeUnitsRequest as ComputeUnitsRequest,
     scout_compute_api_ComputeWithUnitsRequest as ComputeWithUnitsRequest,
     scout_compute_api_ComputeWithUnitsResponse as ComputeWithUnitsResponse,
+    scout_compute_api_ComputeWithUnitsResult as ComputeWithUnitsResult,
     scout_compute_api_Context as Context,
     scout_compute_api_Count as Count,
     scout_compute_api_CumulativeSumSeries as CumulativeSumSeries,
@@ -152,8 +157,6 @@ from .._impl import (
     scout_compute_api_ParameterInput as ParameterInput,
     scout_compute_api_ParameterizedComputeNodeRequest as ParameterizedComputeNodeRequest,
     scout_compute_api_ParameterizedComputeNodeResponse as ParameterizedComputeNodeResponse,
-    scout_compute_api_ParameterizedComputeNodeResult as ParameterizedComputeNodeResult,
-    scout_compute_api_ParameterizedComputeNodeResultVisitor as ParameterizedComputeNodeResultVisitor,
     scout_compute_api_ParameterizedContext as ParameterizedContext,
     scout_compute_api_PeakRanges as PeakRanges,
     scout_compute_api_PeakType as PeakType,

{nominal_api-0.508.0 → nominal_api-0.510.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.508.0 → nominal_api-0.510.0}/setup.py

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