nominal-api 0.591.0__tar.gz → 0.592.0__tar.gz

{nominal_api-0.591.0 → nominal_api-0.592.0}/PKG-INFO

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

{nominal_api-0.591.0 → nominal_api-0.592.0}/nominal_api/__init__.py

@@ -75,5 +75,5 @@ __all__ = [
 
 __conjure_generator_version__ = "4.9.0"
 
-__version__ = "0.591.0"
+__version__ = "0.592.0"
 

{nominal_api-0.591.0 → nominal_api-0.592.0}/nominal_api/_impl.py

@@ -68174,586 +68174,29 @@ storage_deletion_api_TimeRange.__qualname__ = "TimeRange"
 storage_deletion_api_TimeRange.__module__ = "nominal_api.storage_deletion_api"
 
 
-class storage_series_api_BatchCreateOrGetResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'created_series': ConjureFieldDefinition('createdSeries', List[storage_series_api_NominalSeries]),
-            'existing_series': ConjureFieldDefinition('existingSeries', List[storage_series_api_NominalSeries])
-        }
-
-    __slots__: List[str] = ['_created_series', '_existing_series']
-
-    def __init__(self, created_series: List["storage_series_api_NominalSeries"], existing_series: List["storage_series_api_NominalSeries"]) -> None:
-        self._created_series = created_series
-        self._existing_series = existing_series
-
-    @builtins.property
-    def created_series(self) -> List["storage_series_api_NominalSeries"]:
-        return self._created_series
-
-    @builtins.property
-    def existing_series(self) -> List["storage_series_api_NominalSeries"]:
-        return self._existing_series
-
-
-storage_series_api_BatchCreateOrGetResponse.__name__ = "BatchCreateOrGetResponse"
-storage_series_api_BatchCreateOrGetResponse.__qualname__ = "BatchCreateOrGetResponse"
-storage_series_api_BatchCreateOrGetResponse.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_BatchUpdateLastTouchedAtRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'requests': ConjureFieldDefinition('requests', List[storage_series_api_UpdateLastTouchedAtRequest]),
-            'time': ConjureFieldDefinition('time', api_Timestamp)
-        }
-
-    __slots__: List[str] = ['_requests', '_time']
-
-    def __init__(self, requests: List["storage_series_api_UpdateLastTouchedAtRequest"], time: "api_Timestamp") -> None:
-        self._requests = requests
-        self._time = time
-
-    @builtins.property
-    def requests(self) -> List["storage_series_api_UpdateLastTouchedAtRequest"]:
-        return self._requests
-
-    @builtins.property
-    def time(self) -> "api_Timestamp":
-        return self._time
-
-
-storage_series_api_BatchUpdateLastTouchedAtRequest.__name__ = "BatchUpdateLastTouchedAtRequest"
-storage_series_api_BatchUpdateLastTouchedAtRequest.__qualname__ = "BatchUpdateLastTouchedAtRequest"
-storage_series_api_BatchUpdateLastTouchedAtRequest.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_CreateSeriesRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_type', '_data_source_rid', '_channel', '_tags']
-
-    def __init__(self, channel: str, data_source_rid: str, tags: Dict[str, str], type: "storage_series_api_NominalDataType") -> None:
-        self._type = type
-        self._data_source_rid = data_source_rid
-        self._channel = channel
-        self._tags = tags
-
-    @builtins.property
-    def type(self) -> "storage_series_api_NominalDataType":
-        return self._type
-
-    @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
-
-
-storage_series_api_CreateSeriesRequest.__name__ = "CreateSeriesRequest"
-storage_series_api_CreateSeriesRequest.__qualname__ = "CreateSeriesRequest"
-storage_series_api_CreateSeriesRequest.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_GetSeriesByChannelAndTagsRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_channel', '_data_source_rid', '_tags']
-
-    def __init__(self, channel: str, data_source_rid: str, tags: Dict[str, str]) -> None:
-        self._channel = channel
-        self._data_source_rid = data_source_rid
-        self._tags = tags
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
-
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        """
-        Returns a series that match this set of tags exactly.
-        """
-        return self._tags
-
-
-storage_series_api_GetSeriesByChannelAndTagsRequest.__name__ = "GetSeriesByChannelAndTagsRequest"
-storage_series_api_GetSeriesByChannelAndTagsRequest.__qualname__ = "GetSeriesByChannelAndTagsRequest"
-storage_series_api_GetSeriesByChannelAndTagsRequest.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_NominalDataType(ConjureEnumType):
-    """
-    The data types supported by Nominal's database.
-    """
-
-    DOUBLE = 'DOUBLE'
-    '''DOUBLE'''
-    STRING = 'STRING'
-    '''STRING'''
-    LOG = 'LOG'
-    '''LOG'''
-    INT64 = 'INT64'
-    '''INT64'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-storage_series_api_NominalDataType.__name__ = "NominalDataType"
-storage_series_api_NominalDataType.__qualname__ = "NominalDataType"
-storage_series_api_NominalDataType.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_NominalSeries(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'rid': ConjureFieldDefinition('rid', storage_series_api_NominalSeriesRid),
-            'type': ConjureFieldDefinition('type', storage_series_api_NominalDataType),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_rid', '_type', '_data_source_rid', '_channel', '_tags']
-
-    def __init__(self, channel: str, data_source_rid: str, rid: str, tags: Dict[str, str], type: "storage_series_api_NominalDataType") -> None:
-        self._rid = rid
-        self._type = type
-        self._data_source_rid = data_source_rid
-        self._channel = channel
-        self._tags = tags
-
-    @builtins.property
-    def rid(self) -> str:
-        return self._rid
-
-    @builtins.property
-    def type(self) -> "storage_series_api_NominalDataType":
-        return self._type
-
-    @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
-
-
-storage_series_api_NominalSeries.__name__ = "NominalSeries"
-storage_series_api_NominalSeries.__qualname__ = "NominalSeries"
-storage_series_api_NominalSeries.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_NominalSeriesService(Service):
-    """
-    Create and fetch series stored by Nominal. This service is deprecated.
-    """
-
-    def get(self, auth_header: str, rid: str) -> "storage_series_api_NominalSeries":
-        """
-        Retrieves a series for the given series RID.
-        """
-
-        _headers: Dict[str, Any] = {
-            'Accept': 'application/json',
-            'Authorization': auth_header,
-        }
-
-        _params: Dict[str, Any] = {
-        }
-
-        _path_params: Dict[str, Any] = {
-            'rid': rid,
-        }
-
-        _json: Any = None
-
-        _path = '/storage/series/v1/{rid}'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'GET',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        _decoder = ConjureDecoder()
-        return _decoder.decode(_response.json(), storage_series_api_NominalSeries, self._return_none_for_unknown_union_types)
-
-    def batch_get(self, auth_header: str, rids: List[str] = None) -> List["storage_series_api_NominalSeries"]:
-        """
-        Retrieves series for the given series RIDs.
-Excludes series that do not exist or are unauthorized. A maximum of 1000 rids can be requested.
-        """
-        rids = rids if rids is not None else []
-
-        _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(rids)
-
-        _path = '/storage/series/v1/batch-get'
-        _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(), List[storage_series_api_NominalSeries], self._return_none_for_unknown_union_types)
-
-    def batch_get_by_channel_and_tags(self, auth_header: str, request: List["storage_series_api_GetSeriesByChannelAndTagsRequest"] = None) -> List["storage_series_api_NominalSeries"]:
-        """
-        Retrieves series that match the requested data source, channel name and tags exactly.
-Omits series that do not exist or are unauthorized. A maximum of 1000 rids can be requested.
-        """
-        request = request if request is not None else []
-
-        _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 = '/storage/series/v1/batch-get-by-channel-and-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(), List[storage_series_api_NominalSeries], self._return_none_for_unknown_union_types)
-
-    def create_or_get(self, auth_header: str, request: "storage_series_api_CreateSeriesRequest") -> "storage_series_api_NominalSeries":
-        """
-        Creates a new series if it doesn't already exist.
-
-A series exists if there is already a series with the same channel name and tag values in the data source.
-Returns the series that was created or the existing series.
-        """
-
-        _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 = '/storage/series/v1'
-        _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(), storage_series_api_NominalSeries, self._return_none_for_unknown_union_types)
-
-    def batch_create_or_get(self, auth_header: str, request: List["storage_series_api_CreateSeriesRequest"] = None) -> List["storage_series_api_NominalSeries"]:
-        request = request if request is not None else []
-
-        _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 = '/storage/series/v1/batch-create'
-        _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(), List[storage_series_api_NominalSeries], self._return_none_for_unknown_union_types)
-
-    def batch_create_or_get_v2(self, auth_header: str, request: List["storage_series_api_CreateSeriesRequest"] = None) -> "storage_series_api_BatchCreateOrGetResponse":
-        """
-        Creates new series if they don't already exist.
-
-A series exists if there is already a series with the same channel name and tag values in the data source.
-Returns series that were created and any existing series.
-        """
-        request = request if request is not None else []
-
-        _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 = '/storage/series/v1/batch-create-or-get'
-        _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(), storage_series_api_BatchCreateOrGetResponse, self._return_none_for_unknown_union_types)
-
-    def update_last_touched_at(self, auth_header: str, request: "storage_series_api_BatchUpdateLastTouchedAtRequest") -> None:
-        """
-        Updates the last touched at time for series. The last touched at time represents the last time a series
-had data written 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 = '/storage/series/v1/update-last-touched'
-        _path = _path.format(**_path_params)
-
-        _response: Response = self._request(
-            'POST',
-            self._uri + _path,
-            params=_params,
-            headers=_headers,
-            json=_json)
-
-        return
-
-    def search(self, auth_header: str, request: "storage_series_api_SearchSeriesRequest") -> "storage_series_api_SearchSeriesResponse":
-        """
-        Retrieves series that match the search query.
-        """
-
-        _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 = '/storage/series/v1/search'
-        _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(), storage_series_api_SearchSeriesResponse, self._return_none_for_unknown_union_types)
-
-
-storage_series_api_NominalSeriesService.__name__ = "NominalSeriesService"
-storage_series_api_NominalSeriesService.__qualname__ = "NominalSeriesService"
-storage_series_api_NominalSeriesService.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_SearchSeriesRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_channel', '_data_source_rid', '_tags']
-
-    def __init__(self, channel: str, data_source_rid: str, tags: Dict[str, str]) -> None:
-        self._channel = channel
-        self._data_source_rid = data_source_rid
-        self._tags = tags
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-    @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
-
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        """
-        Returns all series that contain this set of tags, including those
-whose tags are a superset.
-        """
-        return self._tags
-
-
-storage_series_api_SearchSeriesRequest.__name__ = "SearchSeriesRequest"
-storage_series_api_SearchSeriesRequest.__qualname__ = "SearchSeriesRequest"
-storage_series_api_SearchSeriesRequest.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_SearchSeriesResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'series': ConjureFieldDefinition('series', List[storage_series_api_NominalSeries])
-        }
-
-    __slots__: List[str] = ['_series']
-
-    def __init__(self, series: List["storage_series_api_NominalSeries"]) -> None:
-        self._series = series
-
-    @builtins.property
-    def series(self) -> List["storage_series_api_NominalSeries"]:
-        return self._series
-
-
-storage_series_api_SearchSeriesResponse.__name__ = "SearchSeriesResponse"
-storage_series_api_SearchSeriesResponse.__qualname__ = "SearchSeriesResponse"
-storage_series_api_SearchSeriesResponse.__module__ = "nominal_api.storage_series_api"
-
-
-class storage_series_api_UpdateLastTouchedAtRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_NominalDataSourceRid),
-            'channel': ConjureFieldDefinition('channel', api_Channel),
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, api_TagValue])
-        }
-
-    __slots__: List[str] = ['_data_source_rid', '_channel', '_tags']
-
-    def __init__(self, channel: str, data_source_rid: str, tags: Dict[str, str]) -> None:
-        self._data_source_rid = data_source_rid
-        self._channel = channel
-        self._tags = tags
-
-    @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
+class storage_series_api_NominalDataType(ConjureEnumType):
+    """
+    The data types supported by Nominal's database.
+    """
 
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
+    DOUBLE = 'DOUBLE'
+    '''DOUBLE'''
+    STRING = 'STRING'
+    '''STRING'''
+    LOG = 'LOG'
+    '''LOG'''
+    INT64 = 'INT64'
+    '''INT64'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
 
-    @builtins.property
-    def tags(self) -> Dict[str, str]:
-        return self._tags
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
 
 
-storage_series_api_UpdateLastTouchedAtRequest.__name__ = "UpdateLastTouchedAtRequest"
-storage_series_api_UpdateLastTouchedAtRequest.__qualname__ = "UpdateLastTouchedAtRequest"
-storage_series_api_UpdateLastTouchedAtRequest.__module__ = "nominal_api.storage_series_api"
+storage_series_api_NominalDataType.__name__ = "NominalDataType"
+storage_series_api_NominalDataType.__qualname__ = "NominalDataType"
+storage_series_api_NominalDataType.__module__ = "nominal_api.storage_series_api"
 
 
 class storage_writer_api_DirectNominalChannelWriterService(Service):
@@ -71610,39 +71053,6 @@ if the channel + datasource + tag cannot be resolved into a logical series rid.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), timeseries_logicalseries_api_BatchResolveSeriesResponse, self._return_none_for_unknown_union_types)
 
-    def get_suggested_tags(self, auth_header: str, request: "timeseries_logicalseries_api_GetSuggestedTagsRequest") -> "timeseries_logicalseries_api_GetSuggestedTagsResponse":
-        """
-        Returns suggested tags given a channel, datasource, and the existing tags by reading series archetypes,
-external datasources, and other tagged channels.
-        """
-
-        _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 = '/timeseries/logical-series/v1/get-suggested-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(), timeseries_logicalseries_api_GetSuggestedTagsResponse, self._return_none_for_unknown_union_types)
-
 
 timeseries_logicalseries_LogicalSeriesService.__name__ = "LogicalSeriesService"
 timeseries_logicalseries_LogicalSeriesService.__qualname__ = "LogicalSeriesService"
@@ -71855,26 +71265,6 @@ timeseries_logicalseries_api_BigQueryType.__qualname__ = "BigQueryType"
 timeseries_logicalseries_api_BigQueryType.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_logicalseries_api_Confidence(ConjureEnumType):
-
-    LOW = 'LOW'
-    '''LOW'''
-    MEDIUM = 'MEDIUM'
-    '''MEDIUM'''
-    HIGH = 'HIGH'
-    '''HIGH'''
-    UNKNOWN = 'UNKNOWN'
-    '''UNKNOWN'''
-
-    def __reduce_ex__(self, proto):
-        return self.__class__, (self.name,)
-
-
-timeseries_logicalseries_api_Confidence.__name__ = "Confidence"
-timeseries_logicalseries_api_Confidence.__qualname__ = "Confidence"
-timeseries_logicalseries_api_Confidence.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
 class timeseries_logicalseries_api_Context(ConjureBeanType):
 
     @builtins.classmethod
@@ -72100,70 +71490,6 @@ timeseries_logicalseries_api_CsvLocatorV2.__qualname__ = "CsvLocatorV2"
 timeseries_logicalseries_api_CsvLocatorV2.__module__ = "nominal_api.timeseries_logicalseries_api"
 
 
-class timeseries_logicalseries_api_GetSuggestedTagsRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'current_tags': ConjureFieldDefinition('currentTags', Dict[api_TagName, api_TagValue]),
-            'data_source_rid': ConjureFieldDefinition('dataSourceRid', api_rids_DataSourceRid),
-            'channel': ConjureFieldDefinition('channel', api_Channel)
-        }
-
-    __slots__: List[str] = ['_current_tags', '_data_source_rid', '_channel']
-
-    def __init__(self, channel: str, current_tags: Dict[str, str], data_source_rid: str) -> None:
-        self._current_tags = current_tags
-        self._data_source_rid = data_source_rid
-        self._channel = channel
-
-    @builtins.property
-    def current_tags(self) -> Dict[str, str]:
-        return self._current_tags
-
-    @builtins.property
-    def data_source_rid(self) -> str:
-        return self._data_source_rid
-
-    @builtins.property
-    def channel(self) -> str:
-        return self._channel
-
-
-timeseries_logicalseries_api_GetSuggestedTagsRequest.__name__ = "GetSuggestedTagsRequest"
-timeseries_logicalseries_api_GetSuggestedTagsRequest.__qualname__ = "GetSuggestedTagsRequest"
-timeseries_logicalseries_api_GetSuggestedTagsRequest.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
-class timeseries_logicalseries_api_GetSuggestedTagsResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'tags': ConjureFieldDefinition('tags', Dict[api_TagName, List[api_TagValue]]),
-            'confidence': ConjureFieldDefinition('confidence', timeseries_logicalseries_api_Confidence)
-        }
-
-    __slots__: List[str] = ['_tags', '_confidence']
-
-    def __init__(self, confidence: "timeseries_logicalseries_api_Confidence", tags: Dict[str, List[str]]) -> None:
-        self._tags = tags
-        self._confidence = confidence
-
-    @builtins.property
-    def tags(self) -> Dict[str, List[str]]:
-        return self._tags
-
-    @builtins.property
-    def confidence(self) -> "timeseries_logicalseries_api_Confidence":
-        return self._confidence
-
-
-timeseries_logicalseries_api_GetSuggestedTagsResponse.__name__ = "GetSuggestedTagsResponse"
-timeseries_logicalseries_api_GetSuggestedTagsResponse.__qualname__ = "GetSuggestedTagsResponse"
-timeseries_logicalseries_api_GetSuggestedTagsResponse.__module__ = "nominal_api.timeseries_logicalseries_api"
-
-
 class timeseries_logicalseries_api_Influx1Locator(ConjureBeanType):
 
     @builtins.classmethod
@@ -72524,12 +71850,12 @@ class timeseries_logicalseries_api_LogicalSeries(ConjureBeanType):
             'description': ConjureFieldDefinition('description', OptionalTypeWrapper[str]),
             'unit': ConjureFieldDefinition('unit', OptionalTypeWrapper[api_Unit]),
             'series_data_type': ConjureFieldDefinition('seriesDataType', OptionalTypeWrapper[api_SeriesDataType]),
-            'granularity': ConjureFieldDefinition('granularity', api_Granularity)
+            'granularity': ConjureFieldDefinition('granularity', OptionalTypeWrapper[api_Granularity])
         }
 
     __slots__: List[str] = ['_rid', '_data_source_rid', '_locator', '_time_locator', '_channel', '_description', '_unit', '_series_data_type', '_granularity']
 
-    def __init__(self, channel: str, data_source_rid: str, granularity: "api_Granularity", locator: "timeseries_logicalseries_api_Locator", rid: str, description: Optional[str] = None, series_data_type: Optional["api_SeriesDataType"] = None, time_locator: Optional["timeseries_logicalseries_api_Locator"] = None, unit: Optional[str] = None) -> None:
+    def __init__(self, channel: str, data_source_rid: str, locator: "timeseries_logicalseries_api_Locator", rid: str, description: Optional[str] = None, granularity: Optional["api_Granularity"] = None, series_data_type: Optional["api_SeriesDataType"] = None, time_locator: Optional["timeseries_logicalseries_api_Locator"] = None, unit: Optional[str] = None) -> None:
         self._rid = rid
         self._data_source_rid = data_source_rid
         self._locator = locator
@@ -72576,7 +71902,7 @@ class timeseries_logicalseries_api_LogicalSeries(ConjureBeanType):
         return self._series_data_type
 
     @builtins.property
-    def granularity(self) -> "api_Granularity":
+    def granularity(self) -> Optional["api_Granularity"]:
         """
         Time granularity of the series. If omitted, defaults to nanoseconds.
         """
@@ -74209,8 +73535,6 @@ scout_rids_api_Version = int
 
 scout_versioning_api_BranchName = str
 
-storage_series_api_NominalSeriesRid = str
-
 storage_writer_api_MeasurementName = str
 
 storage_datasource_api_NominalDataSourceId = str

nominal_api-0.592.0/nominal_api/storage_series_api/__init__.py

@@ -0,0 +1,5 @@
+# coding=utf-8
+from .._impl import (
+    storage_series_api_NominalDataType as NominalDataType,
+)
+

{nominal_api-0.591.0 → nominal_api-0.592.0}/nominal_api/timeseries_logicalseries_api/__init__.py

@@ -11,7 +11,6 @@ from .._impl import (
     timeseries_logicalseries_api_BigQueryType as BigQueryType,
     timeseries_logicalseries_api_BucketName as BucketName,
     timeseries_logicalseries_api_ColumnName as ColumnName,
-    timeseries_logicalseries_api_Confidence as Confidence,
     timeseries_logicalseries_api_Context as Context,
     timeseries_logicalseries_api_ContextProperty as ContextProperty,
     timeseries_logicalseries_api_ContextPropertyVisitor as ContextPropertyVisitor,
@@ -21,8 +20,6 @@ from .._impl import (
     timeseries_logicalseries_api_DatabaseName as DatabaseName,
     timeseries_logicalseries_api_DatasetName as DatasetName,
     timeseries_logicalseries_api_FieldName as FieldName,
-    timeseries_logicalseries_api_GetSuggestedTagsRequest as GetSuggestedTagsRequest,
-    timeseries_logicalseries_api_GetSuggestedTagsResponse as GetSuggestedTagsResponse,
     timeseries_logicalseries_api_Influx1Locator as Influx1Locator,
     timeseries_logicalseries_api_Influx2Locator as Influx2Locator,
     timeseries_logicalseries_api_InfluxType as InfluxType,

{nominal_api-0.591.0 → nominal_api-0.592.0}/nominal_api.egg-info/PKG-INFO

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

{nominal_api-0.591.0 → nominal_api-0.592.0}/setup.py

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

nominal_api-0.591.0/nominal_api/storage_series_api/__init__.py

@@ -1,15 +0,0 @@
-# coding=utf-8
-from .._impl import (
-    storage_series_api_BatchCreateOrGetResponse as BatchCreateOrGetResponse,
-    storage_series_api_BatchUpdateLastTouchedAtRequest as BatchUpdateLastTouchedAtRequest,
-    storage_series_api_CreateSeriesRequest as CreateSeriesRequest,
-    storage_series_api_GetSeriesByChannelAndTagsRequest as GetSeriesByChannelAndTagsRequest,
-    storage_series_api_NominalDataType as NominalDataType,
-    storage_series_api_NominalSeries as NominalSeries,
-    storage_series_api_NominalSeriesRid as NominalSeriesRid,
-    storage_series_api_NominalSeriesService as NominalSeriesService,
-    storage_series_api_SearchSeriesRequest as SearchSeriesRequest,
-    storage_series_api_SearchSeriesResponse as SearchSeriesResponse,
-    storage_series_api_UpdateLastTouchedAtRequest as UpdateLastTouchedAtRequest,
-)
-