nominal-api 0.595.0__tar.gz → 0.596.1__tar.gz

{nominal_api-0.595.0 → nominal_api-0.596.1}/PKG-INFO

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

{nominal_api-0.595.0 → nominal_api-0.596.1}/nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.595.0"
+__version__ = "0.596.1"
 

{nominal_api-0.595.0 → nominal_api-0.596.1}/nominal_api/_impl.py

@@ -29995,54 +29995,108 @@ class scout_compute_api_Cartesian3dBucket(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'min_x': ConjureFieldDefinition('minX', float),
-            'max_x': ConjureFieldDefinition('maxX', float),
-            'min_y': ConjureFieldDefinition('minY', float),
-            'max_y': ConjureFieldDefinition('maxY', float),
-            'min_z': ConjureFieldDefinition('minZ', float),
-            'max_z': ConjureFieldDefinition('maxZ', float),
+            'min_x': ConjureFieldDefinition('minX', OptionalTypeWrapper[float]),
+            'max_x': ConjureFieldDefinition('maxX', OptionalTypeWrapper[float]),
+            'mean_x': ConjureFieldDefinition('meanX', float),
+            'min_y': ConjureFieldDefinition('minY', OptionalTypeWrapper[float]),
+            'max_y': ConjureFieldDefinition('maxY', OptionalTypeWrapper[float]),
+            'mean_y': ConjureFieldDefinition('meanY', float),
+            'min_z': ConjureFieldDefinition('minZ', OptionalTypeWrapper[float]),
+            'max_z': ConjureFieldDefinition('maxZ', OptionalTypeWrapper[float]),
+            'mean_z': ConjureFieldDefinition('meanZ', float),
+            'min_x_point': ConjureFieldDefinition('minXPoint', scout_compute_api_Point3d),
+            'max_x_point': ConjureFieldDefinition('maxXPoint', scout_compute_api_Point3d),
+            'min_y_point': ConjureFieldDefinition('minYPoint', scout_compute_api_Point3d),
+            'max_y_point': ConjureFieldDefinition('maxYPoint', scout_compute_api_Point3d),
+            'min_z_point': ConjureFieldDefinition('minZPoint', scout_compute_api_Point3d),
+            'max_z_point': ConjureFieldDefinition('maxZPoint', scout_compute_api_Point3d),
             'min_timestamp': ConjureFieldDefinition('minTimestamp', api_Timestamp),
             'max_timestamp': ConjureFieldDefinition('maxTimestamp', api_Timestamp),
             'count': ConjureFieldDefinition('count', int)
         }
 
-    __slots__: List[str] = ['_min_x', '_max_x', '_min_y', '_max_y', '_min_z', '_max_z', '_min_timestamp', '_max_timestamp', '_count']
+    __slots__: List[str] = ['_min_x', '_max_x', '_mean_x', '_min_y', '_max_y', '_mean_y', '_min_z', '_max_z', '_mean_z', '_min_x_point', '_max_x_point', '_min_y_point', '_max_y_point', '_min_z_point', '_max_z_point', '_min_timestamp', '_max_timestamp', '_count']
 
-    def __init__(self, count: int, max_timestamp: "api_Timestamp", max_x: float, max_y: float, max_z: float, min_timestamp: "api_Timestamp", min_x: float, min_y: float, min_z: float) -> None:
+    def __init__(self, count: int, max_timestamp: "api_Timestamp", max_x_point: "scout_compute_api_Point3d", max_y_point: "scout_compute_api_Point3d", max_z_point: "scout_compute_api_Point3d", mean_x: float, mean_y: float, mean_z: float, min_timestamp: "api_Timestamp", min_x_point: "scout_compute_api_Point3d", min_y_point: "scout_compute_api_Point3d", min_z_point: "scout_compute_api_Point3d", max_x: Optional[float] = None, max_y: Optional[float] = None, max_z: Optional[float] = None, min_x: Optional[float] = None, min_y: Optional[float] = None, min_z: Optional[float] = None) -> None:
         self._min_x = min_x
         self._max_x = max_x
+        self._mean_x = mean_x
         self._min_y = min_y
         self._max_y = max_y
+        self._mean_y = mean_y
         self._min_z = min_z
         self._max_z = max_z
+        self._mean_z = mean_z
+        self._min_x_point = min_x_point
+        self._max_x_point = max_x_point
+        self._min_y_point = min_y_point
+        self._max_y_point = max_y_point
+        self._min_z_point = min_z_point
+        self._max_z_point = max_z_point
         self._min_timestamp = min_timestamp
         self._max_timestamp = max_timestamp
         self._count = count
 
     @builtins.property
-    def min_x(self) -> float:
+    def min_x(self) -> Optional[float]:
         return self._min_x
 
     @builtins.property
-    def max_x(self) -> float:
+    def max_x(self) -> Optional[float]:
         return self._max_x
 
     @builtins.property
-    def min_y(self) -> float:
+    def mean_x(self) -> float:
+        return self._mean_x
+
+    @builtins.property
+    def min_y(self) -> Optional[float]:
         return self._min_y
 
     @builtins.property
-    def max_y(self) -> float:
+    def max_y(self) -> Optional[float]:
         return self._max_y
 
     @builtins.property
-    def min_z(self) -> float:
+    def mean_y(self) -> float:
+        return self._mean_y
+
+    @builtins.property
+    def min_z(self) -> Optional[float]:
         return self._min_z
 
     @builtins.property
-    def max_z(self) -> float:
+    def max_z(self) -> Optional[float]:
         return self._max_z
 
+    @builtins.property
+    def mean_z(self) -> float:
+        return self._mean_z
+
+    @builtins.property
+    def min_x_point(self) -> "scout_compute_api_Point3d":
+        return self._min_x_point
+
+    @builtins.property
+    def max_x_point(self) -> "scout_compute_api_Point3d":
+        return self._max_x_point
+
+    @builtins.property
+    def min_y_point(self) -> "scout_compute_api_Point3d":
+        return self._min_y_point
+
+    @builtins.property
+    def max_y_point(self) -> "scout_compute_api_Point3d":
+        return self._max_y_point
+
+    @builtins.property
+    def min_z_point(self) -> "scout_compute_api_Point3d":
+        return self._min_z_point
+
+    @builtins.property
+    def max_z_point(self) -> "scout_compute_api_Point3d":
+        return self._max_z_point
+
     @builtins.property
     def min_timestamp(self) -> "api_Timestamp":
         return self._min_timestamp
@@ -36902,6 +36956,47 @@ scout_compute_api_PersistenceWindowConfiguration.__qualname__ = "PersistenceWind
 scout_compute_api_PersistenceWindowConfiguration.__module__ = "nominal_api.scout_compute_api"
 
 
+class scout_compute_api_Point3d(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'x': ConjureFieldDefinition('x', float),
+            'y': ConjureFieldDefinition('y', float),
+            'z': ConjureFieldDefinition('z', float),
+            'timestamp': ConjureFieldDefinition('timestamp', api_Timestamp)
+        }
+
+    __slots__: List[str] = ['_x', '_y', '_z', '_timestamp']
+
+    def __init__(self, timestamp: "api_Timestamp", x: float, y: float, z: float) -> None:
+        self._x = x
+        self._y = y
+        self._z = z
+        self._timestamp = timestamp
+
+    @builtins.property
+    def x(self) -> float:
+        return self._x
+
+    @builtins.property
+    def y(self) -> float:
+        return self._y
+
+    @builtins.property
+    def z(self) -> float:
+        return self._z
+
+    @builtins.property
+    def timestamp(self) -> "api_Timestamp":
+        return self._timestamp
+
+
+scout_compute_api_Point3d.__name__ = "Point3d"
+scout_compute_api_Point3d.__qualname__ = "Point3d"
+scout_compute_api_Point3d.__module__ = "nominal_api.scout_compute_api"
+
+
 class scout_compute_api_ProductSeries(ConjureBeanType):
     """
     For every timestamp specified in the input series, outputs a value that is the product for that timestamp
@@ -68372,7 +68467,7 @@ class storage_writer_api_NominalChannelWriterService(Service):
     Write data points to Nominal data sources.
     """
 
-    def write_batches(self, auth_header: str, request: "storage_writer_api_WriteBatchesRequest") -> None:
+    def write_batches(self, auth_header: str, request: "storage_writer_api_WriteBatchesRequestExternal") -> None:
         """
         Synchronously writes batches of records to a Nominal data source.
         """
@@ -68598,6 +68693,38 @@ If the payload is compressed, the appropriate Content-Encoding header must be in
 
         return
 
+    def write_logs(self, auth_header: str, data_source_rid: str, request: "storage_writer_api_WriteLogsRequest") -> None:
+        """
+        Synchronously writes logs to a Nominal data source.
+        """
+
+        _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 = '/storage/writer/v1/logs/{dataSourceRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
 
 storage_writer_api_NominalChannelWriterService.__name__ = "NominalChannelWriterService"
 storage_writer_api_NominalChannelWriterService.__qualname__ = "NominalChannelWriterService"
@@ -68605,6 +68732,8 @@ storage_writer_api_NominalChannelWriterService.__module__ = "nominal_api.storage
 
 
 class storage_writer_api_Points(ConjureUnionType):
+    """Points for internal API for directly writing points which supports all points types.
+Logs specifically are supported externally via a separate endpoint."""
     _string: Optional[List["storage_writer_api_StringPoint"]] = None
     _double: Optional[List["storage_writer_api_DoublePoint"]] = None
     _log: Optional[List["storage_writer_api_LogPoint"]] = None
@@ -68675,9 +68804,6 @@ class storage_writer_api_Points(ConjureUnionType):
 
     @builtins.property
     def log(self) -> Optional[List["storage_writer_api_LogPoint"]]:
-        """
-        Log points are not yet supported. Sending log points will result in an error.
-        """
         return self._log
 
     @builtins.property
@@ -68726,6 +68852,104 @@ storage_writer_api_PointsVisitor.__qualname__ = "PointsVisitor"
 storage_writer_api_PointsVisitor.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_PointsExternal(ConjureUnionType):
+    _string: Optional[List["storage_writer_api_StringPoint"]] = None
+    _double: Optional[List["storage_writer_api_DoublePoint"]] = None
+    _int_: Optional[List["storage_writer_api_IntPoint"]] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'string': ConjureFieldDefinition('string', List[storage_writer_api_StringPoint]),
+            'double': ConjureFieldDefinition('double', List[storage_writer_api_DoublePoint]),
+            'int_': ConjureFieldDefinition('int', List[storage_writer_api_IntPoint])
+        }
+
+    def __init__(
+            self,
+            string: Optional[List["storage_writer_api_StringPoint"]] = None,
+            double: Optional[List["storage_writer_api_DoublePoint"]] = None,
+            int_: Optional[List["storage_writer_api_IntPoint"]] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (string is not None) + (double is not None) + (int_ is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if string is not None:
+                self._string = string
+                self._type = 'string'
+            if double is not None:
+                self._double = double
+                self._type = 'double'
+            if int_ is not None:
+                self._int_ = int_
+                self._type = 'int'
+
+        elif type_of_union == 'string':
+            if string is None:
+                raise ValueError('a union value must not be None')
+            self._string = string
+            self._type = 'string'
+        elif type_of_union == 'double':
+            if double is None:
+                raise ValueError('a union value must not be None')
+            self._double = double
+            self._type = 'double'
+        elif type_of_union == 'int':
+            if int_ is None:
+                raise ValueError('a union value must not be None')
+            self._int_ = int_
+            self._type = 'int'
+
+    @builtins.property
+    def string(self) -> Optional[List["storage_writer_api_StringPoint"]]:
+        return self._string
+
+    @builtins.property
+    def double(self) -> Optional[List["storage_writer_api_DoublePoint"]]:
+        return self._double
+
+    @builtins.property
+    def int_(self) -> Optional[List["storage_writer_api_IntPoint"]]:
+        return self._int_
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, storage_writer_api_PointsExternalVisitor):
+            raise ValueError('{} is not an instance of storage_writer_api_PointsExternalVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'string' and self.string is not None:
+            return visitor._string(self.string)
+        if self._type == 'double' and self.double is not None:
+            return visitor._double(self.double)
+        if self._type == 'int' and self.int_ is not None:
+            return visitor._int(self.int_)
+
+
+storage_writer_api_PointsExternal.__name__ = "PointsExternal"
+storage_writer_api_PointsExternal.__qualname__ = "PointsExternal"
+storage_writer_api_PointsExternal.__module__ = "nominal_api.storage_writer_api"
+
+
+class storage_writer_api_PointsExternalVisitor:
+
+    @abstractmethod
+    def _string(self, string: List["storage_writer_api_StringPoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _double(self, double: List["storage_writer_api_DoublePoint"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _int(self, int_: List["storage_writer_api_IntPoint"]) -> Any:
+        pass
+
+
+storage_writer_api_PointsExternalVisitor.__name__ = "PointsExternalVisitor"
+storage_writer_api_PointsExternalVisitor.__qualname__ = "PointsExternalVisitor"
+storage_writer_api_PointsExternalVisitor.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_RecordsBatch(ConjureBeanType):
 
     @builtins.classmethod
@@ -68761,6 +68985,41 @@ storage_writer_api_RecordsBatch.__qualname__ = "RecordsBatch"
 storage_writer_api_RecordsBatch.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_RecordsBatchExternal(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'channel': ConjureFieldDefinition('channel', api_Channel),
+            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue]),
+            'points': ConjureFieldDefinition('points', storage_writer_api_PointsExternal)
+        }
+
+    __slots__: List[str] = ['_channel', '_tags', '_points']
+
+    def __init__(self, channel: str, points: "storage_writer_api_PointsExternal", tags: Dict[str, str]) -> None:
+        self._channel = channel
+        self._tags = tags
+        self._points = points
+
+    @builtins.property
+    def channel(self) -> str:
+        return self._channel
+
+    @builtins.property
+    def tags(self) -> Dict[str, str]:
+        return self._tags
+
+    @builtins.property
+    def points(self) -> "storage_writer_api_PointsExternal":
+        return self._points
+
+
+storage_writer_api_RecordsBatchExternal.__name__ = "RecordsBatchExternal"
+storage_writer_api_RecordsBatchExternal.__qualname__ = "RecordsBatchExternal"
+storage_writer_api_RecordsBatchExternal.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_StringPoint(ConjureBeanType):
 
     @builtins.classmethod
@@ -68865,10 +69124,8 @@ class storage_writer_api_WriteBatchesRequest(ConjureBeanType):
     @builtins.property
     def asynchronous_insert(self) -> Optional[bool]:
         """
-        Should typically be set to false.
-If enabled, the server handles batching of requests. Request latency will be slower, but
-overall throughput will be faster if requests are sent in parallel.
-Defaults to false if not specified.
+        Defaults to true if not specified. If enabled, the server handles batching of requests. Request latency
+will be slower, but overall throughput will be faster if requests are sent in parallel.
         """
         return self._asynchronous_insert
 
@@ -68878,6 +69135,68 @@ storage_writer_api_WriteBatchesRequest.__qualname__ = "WriteBatchesRequest"
 storage_writer_api_WriteBatchesRequest.__module__ = "nominal_api.storage_writer_api"
 
 
+class storage_writer_api_WriteBatchesRequestExternal(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'batches': ConjureFieldDefinition('batches', List[storage_writer_api_RecordsBatchExternal]),
+            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
+            'asynchronous_insert': ConjureFieldDefinition('asynchronousInsert', OptionalTypeWrapper[bool])
+        }
+
+    __slots__: List[str] = ['_batches', '_data_source_rid', '_asynchronous_insert']
+
+    def __init__(self, batches: List["storage_writer_api_RecordsBatchExternal"], data_source_rid: str, asynchronous_insert: Optional[bool] = None) -> None:
+        self._batches = batches
+        self._data_source_rid = data_source_rid
+        self._asynchronous_insert = asynchronous_insert
+
+    @builtins.property
+    def batches(self) -> List["storage_writer_api_RecordsBatchExternal"]:
+        return self._batches
+
+    @builtins.property
+    def data_source_rid(self) -> str:
+        return self._data_source_rid
+
+    @builtins.property
+    def asynchronous_insert(self) -> Optional[bool]:
+        """
+        Defaults to true if not specified. If enabled, the server handles batching of requests. Request latency
+will be slower, but overall throughput will be faster if requests are sent in parallel.
+        """
+        return self._asynchronous_insert
+
+
+storage_writer_api_WriteBatchesRequestExternal.__name__ = "WriteBatchesRequestExternal"
+storage_writer_api_WriteBatchesRequestExternal.__qualname__ = "WriteBatchesRequestExternal"
+storage_writer_api_WriteBatchesRequestExternal.__module__ = "nominal_api.storage_writer_api"
+
+
+class storage_writer_api_WriteLogsRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'logs': ConjureFieldDefinition('logs', List[storage_writer_api_LogPoint])
+        }
+
+    __slots__: List[str] = ['_logs']
+
+    def __init__(self, logs: List["storage_writer_api_LogPoint"]) -> None:
+        self._logs = logs
+
+    @builtins.property
+    def logs(self) -> List["storage_writer_api_LogPoint"]:
+        return self._logs
+
+
+storage_writer_api_WriteLogsRequest.__name__ = "WriteLogsRequest"
+storage_writer_api_WriteLogsRequest.__qualname__ = "WriteLogsRequest"
+storage_writer_api_WriteLogsRequest.__module__ = "nominal_api.storage_writer_api"
+
+
 class storage_writer_api_WriteTelegrafBatchesRequest(ConjureBeanType):
 
     @builtins.classmethod

{nominal_api-0.595.0 → nominal_api-0.596.1}/nominal_api/scout_compute_api/__init__.py

@@ -199,6 +199,7 @@ from .._impl import (
     scout_compute_api_PeakType as PeakType,
     scout_compute_api_PercentageThreshold as PercentageThreshold,
     scout_compute_api_PersistenceWindowConfiguration as PersistenceWindowConfiguration,
+    scout_compute_api_Point3d as Point3d,
     scout_compute_api_ProductSeries as ProductSeries,
     scout_compute_api_Range as Range,
     scout_compute_api_RangeAggregation as RangeAggregation,

{nominal_api-0.595.0 → nominal_api-0.596.1}/nominal_api/storage_writer_api/__init__.py

@@ -9,11 +9,16 @@ from .._impl import (
     storage_writer_api_MeasurementName as MeasurementName,
     storage_writer_api_NominalChannelWriterService as NominalChannelWriterService,
     storage_writer_api_Points as Points,
+    storage_writer_api_PointsExternal as PointsExternal,
+    storage_writer_api_PointsExternalVisitor as PointsExternalVisitor,
     storage_writer_api_PointsVisitor as PointsVisitor,
     storage_writer_api_RecordsBatch as RecordsBatch,
+    storage_writer_api_RecordsBatchExternal as RecordsBatchExternal,
     storage_writer_api_StringPoint as StringPoint,
     storage_writer_api_TelegrafMetric as TelegrafMetric,
     storage_writer_api_WriteBatchesRequest as WriteBatchesRequest,
+    storage_writer_api_WriteBatchesRequestExternal as WriteBatchesRequestExternal,
+    storage_writer_api_WriteLogsRequest as WriteLogsRequest,
     storage_writer_api_WriteTelegrafBatchesRequest as WriteTelegrafBatchesRequest,
 )
 

{nominal_api-0.595.0 → nominal_api-0.596.1}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.595.0 → nominal_api-0.596.1}/setup.py

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